Changeset 6644 for trunk/src

Timestamp:

Sep 5, 2001, 2:05:03 PM (24 years ago)

Author:

bird

Message:

Added $Id:$ keyword.

Location:

trunk/src

Files:

• avifil32/api.c (modified) (2 diffs)
• avifil32/comentry.c (modified) (4 diffs)
• comctl32/animate.c (modified) (38 diffs)
• comctl32/comboex.c (modified) (75 diffs)
• comctl32/comctl32.c (modified) (33 diffs)
• comctl32/comctl32undoc.c (modified) (73 diffs)
• comctl32/datetime.c (modified) (42 diffs)
• comctl32/flatsb.c (modified) (15 diffs)
• comctl32/imagelist.c (modified) (109 diffs)
• comctl32/initcomctl32.cpp (modified) (4 diffs)
• comctl32/initterm.cpp (modified) (2 diffs)
• comctl32/listview.c (modified) (1 diff)
• comctl32/monthcal.c (modified) (94 diffs)
• comctl32/pager.c (modified) (43 diffs)
• comctl32/rebar.c (modified) (123 diffs)
• comctl32/status.c (modified) (51 diffs)
• comctl32/tab.c (modified) (105 diffs)
• comctl32/toolbar.c (modified) (144 diffs)

trunk/src/avifil32/api.c

@@ -1 @@
-/*
+/* $Id: api.c,v 1.2 2001-09-05 12:00:53 bird Exp $
+ *
  * Copyright 1999 Marcus Meissner
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
@@ -22 +23 @@
 
 /***********************************************************************
- *              AVIFileInit (AVIFILE.100)
- *              AVIFileInit (AVIFIL32.@)
+ *      AVIFileInit (AVIFILE.100)
+ *      AVIFileInit (AVIFIL32.@)
  */
 void WINAPI AVIFileInit(void)
 {
-        TRACE("()\n");
-        if ( AVIFILE_data.dwAVIFileRef == 0 )
-        {
-                if ( FAILED(CoInitialize(NULL)) )
-                        AVIFILE_data.fInitCOM = FALSE;
-                else
-                        AVIFILE_data.fInitCOM = TRUE;
-        }
-        AVIFILE_data.dwAVIFileRef ++;
-}
-
-/***********************************************************************
- *              AVIFileExit (AVIFILE.101)
- *              AVIFileExit (AVIFIL32.@)
+    TRACE("()\n");
+    if ( AVIFILE_data.dwAVIFileRef == 0 )
+    {
+        if ( FAILED(CoInitialize(NULL)) )
+            AVIFILE_data.fInitCOM = FALSE;
+        else
+            AVIFILE_data.fInitCOM = TRUE;
+    }
+    AVIFILE_data.dwAVIFileRef ++;
+}
+
+/***********************************************************************
+ *      AVIFileExit (AVIFILE.101)
+ *      AVIFileExit (AVIFIL32.@)
  */
 void WINAPI AVIFileExit(void)
 {
-        TRACE("()\n");
-        if ( AVIFILE_data.dwAVIFileRef == 0 )
-        {
-                ERR( "unexpected AVIFileExit()\n" );
-                return;
-        }
-
-        AVIFILE_data.dwAVIFileRef --;
-        if ( AVIFILE_data.dwAVIFileRef == 0 )
-        {
-                if ( AVIFILE_data.fInitCOM )
-                {
-                        CoUninitialize();
-                        AVIFILE_data.fInitCOM = FALSE;
-                }
-        }
-}
-
-/***********************************************************************
- *              AVIFileAddRef (AVIFIL32.@)
+    TRACE("()\n");
+    if ( AVIFILE_data.dwAVIFileRef == 0 )
+    {
+        ERR( "unexpected AVIFileExit()\n" );
+        return;
+    }
+
+    AVIFILE_data.dwAVIFileRef --;
+    if ( AVIFILE_data.dwAVIFileRef == 0 )
+    {
+        if ( AVIFILE_data.fInitCOM )
+        {
+            CoUninitialize();
+            AVIFILE_data.fInitCOM = FALSE;
+        }
+    }
+}
+
+/***********************************************************************
+ *      AVIFileAddRef (AVIFIL32.@)
  */
 ULONG WINAPI AVIFileAddRef(PAVIFILE pfile)
 {
-        return IAVIFile_AddRef( pfile );
-}
-
-/***********************************************************************
- *              AVIFileRelease (AVIFILE.141)
- *              AVIFileRelease (AVIFIL32.@)
+    return IAVIFile_AddRef( pfile );
+}
+
+/***********************************************************************
+ *      AVIFileRelease (AVIFILE.141)
+ *      AVIFileRelease (AVIFIL32.@)
  */
 ULONG WINAPI AVIFileRelease(PAVIFILE pfile)
 {
-        return IAVIFile_Release( pfile );
-}
-
-/***********************************************************************
- *              AVIFileOpen  (AVIFILE.102)
- *              AVIFileOpenA (AVIFIL32.@)
+    return IAVIFile_Release( pfile );
+}
+
+/***********************************************************************
+ *      AVIFileOpen  (AVIFILE.102)
+ *      AVIFileOpenA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileOpenA(
-        PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler )
-{
-        WCHAR*  pwsz;
-        HRESULT hr;
-
-        TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
-        pwsz = AVIFILE_strdupAtoW( szFile );
-        if ( pwsz == NULL )
-                return AVIERR_MEMORY;
-        hr = AVIFileOpenW(ppfile,pwsz,uMode,lpHandler);
-        HeapFree( AVIFILE_data.hHeap, 0, pwsz );
-        return hr;
-}
-
-/***********************************************************************
- *              AVIFileOpenW (AVIFIL32.@)
+    PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler )
+{
+    WCHAR*  pwsz;
+    HRESULT hr;
+
+    TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
+    pwsz = AVIFILE_strdupAtoW( szFile );
+    if ( pwsz == NULL )
+        return AVIERR_MEMORY;
+    hr = AVIFileOpenW(ppfile,pwsz,uMode,lpHandler);
+    HeapFree( AVIFILE_data.hHeap, 0, pwsz );
+    return hr;
+}
+
+/***********************************************************************
+ *      AVIFileOpenW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileOpenW(
-        PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler )
-{
-        HRESULT hr;
-        IClassFactory*  pcf;
-        CLSID   clsRIFF;
-
-        TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
-        *ppfile = (PAVIFILE)NULL;
-
-        if ( lpHandler == NULL )
-        {
-                /* FIXME - check RIFF type and get a handler from registry
-                 *         if IAVIFile::Open is worked...
-                 */
-                memcpy( &clsRIFF, &CLSID_AVIFile, sizeof(CLSID) );
-                lpHandler = &clsRIFF;
-        }
-
-        /*
-         * FIXME - MS says IAVIFile::Open will be called,
-         *         but no such method in vfw.h... why????
-         */
-        if ( !IsEqualGUID( lpHandler, &CLSID_AVIFile ) )
-                return REGDB_E_CLASSNOTREG;
-
-        hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
-                                       &IID_IClassFactory,(void**)&pcf);
-        if ( hr != S_OK )
-                return hr;
-
-        hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIFile,
-                                           (void**)ppfile );
-        IClassFactory_Release( pcf );
-
-        if ( hr == S_OK )
-        {
-                /* FIXME??? */
-                hr = AVIFILE_IAVIFile_Open( *ppfile, szFile, uMode );
-                if ( hr != S_OK )
-                {
-                        IAVIFile_Release( (*ppfile) );
-                        *ppfile = NULL;
-                }
-        }
-
-        return hr;
-}
-
-/***********************************************************************
- *              AVIFileInfoW (AVIFIL32.@)
+    PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler )
+{
+    HRESULT hr;
+    IClassFactory*  pcf;
+    CLSID   clsRIFF;
+
+    TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
+    *ppfile = (PAVIFILE)NULL;
+
+    if ( lpHandler == NULL )
+    {
+        /* FIXME - check RIFF type and get a handler from registry
+         *         if IAVIFile::Open is worked...
+         */
+        memcpy( &clsRIFF, &CLSID_AVIFile, sizeof(CLSID) );
+        lpHandler = &clsRIFF;
+    }
+
+    /*
+     * FIXME - MS says IAVIFile::Open will be called,
+     *         but no such method in vfw.h... why????
+     */
+    if ( !IsEqualGUID( lpHandler, &CLSID_AVIFile ) )
+        return REGDB_E_CLASSNOTREG;
+
+    hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
+                       &IID_IClassFactory,(void**)&pcf);
+    if ( hr != S_OK )
+        return hr;
+
+    hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIFile,
+                       (void**)ppfile );
+    IClassFactory_Release( pcf );
+
+    if ( hr == S_OK )
+    {
+        /* FIXME??? */
+        hr = AVIFILE_IAVIFile_Open( *ppfile, szFile, uMode );
+        if ( hr != S_OK )
+        {
+            IAVIFile_Release( (*ppfile) );
+            *ppfile = NULL;
+        }
+    }
+
+    return hr;
+}
+
+/***********************************************************************
+ *      AVIFileInfoW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile,AVIFILEINFOW* pfi,LONG lSize)
 {
-        return IAVIFile_Info( pfile, pfi, lSize );
-}
-
-/***********************************************************************
- *              AVIFileInfo  (AVIFIL32.@)
- *              AVIFileInfoA (AVIFIL32.@)
+    return IAVIFile_Info( pfile, pfi, lSize );
+}
+
+/***********************************************************************
+ *      AVIFileInfo  (AVIFIL32.@)
+ *      AVIFileInfoA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile,AVIFILEINFOA* pfi,LONG lSize)
 {
-        AVIFILEINFOW    fiw;
-        HRESULT         hr;
-
-        if ( lSize < sizeof(AVIFILEINFOA) )
-                return AVIERR_BADSIZE;
-        hr = AVIFileInfoW( pfile, &fiw, sizeof(AVIFILEINFOW) );
-        if ( hr != S_OK )
-                return hr;
-        memcpy( pfi,&fiw,sizeof(AVIFILEINFOA) );
-        AVIFILE_strncpyWtoA( pfi->szFileType, fiw.szFileType,
-                             sizeof(pfi->szFileType) );
-        pfi->szFileType[sizeof(pfi->szFileType)-1] = 0;
-
-        return S_OK;
-}
-
-/***********************************************************************
- *              AVIFileGetStream (AVIFILE.143)
- *              AVIFileGetStream (AVIFIL32.@)
+    AVIFILEINFOW    fiw;
+    HRESULT     hr;
+
+    if ( lSize < sizeof(AVIFILEINFOA) )
+        return AVIERR_BADSIZE;
+    hr = AVIFileInfoW( pfile, &fiw, sizeof(AVIFILEINFOW) );
+    if ( hr != S_OK )
+        return hr;
+    memcpy( pfi,&fiw,sizeof(AVIFILEINFOA) );
+    AVIFILE_strncpyWtoA( pfi->szFileType, fiw.szFileType,
+                 sizeof(pfi->szFileType) );
+    pfi->szFileType[sizeof(pfi->szFileType)-1] = 0;
+
+    return S_OK;
+}
+
+/***********************************************************************
+ *      AVIFileGetStream (AVIFILE.143)
+ *      AVIFileGetStream (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile,PAVISTREAM* pas,DWORD fccType,LONG lParam)
 {
-        return IAVIFile_GetStream(pfile,pas,fccType,lParam);
-}
-
-/***********************************************************************
- *              AVIFileCreateStreamW (AVIFIL32.@)
+    return IAVIFile_GetStream(pfile,pas,fccType,lParam);
+}
+
+/***********************************************************************
+ *      AVIFileCreateStreamW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOW* pasi)
 {
-        return IAVIFile_CreateStream(pfile,ppas,pasi);
-}
-
-/***********************************************************************
- *              AVIFileCreateStreamA (AVIFIL32.@)
+    return IAVIFile_CreateStream(pfile,ppas,pasi);
+}
+
+/***********************************************************************
+ *      AVIFileCreateStreamA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOA* pasi)
 {
-        AVISTREAMINFOW  siw;
-        HRESULT         hr;
-
-        memcpy( &siw,pasi,sizeof(AVISTREAMINFOA) );
-        AVIFILE_strncpyAtoW( siw.szName, pasi->szName,
-                sizeof(siw.szName)/sizeof(siw.szName[0]) );
-        siw.szName[sizeof(siw.szName)/sizeof(siw.szName[0])-1] = 0;
-
-        hr = AVIFileCreateStreamW(pfile,ppas,&siw);
-
-        return hr;
-}
-
-/***********************************************************************
- *              AVIFileWriteData (AVIFIL32.@)
+    AVISTREAMINFOW  siw;
+    HRESULT     hr;
+
+    memcpy( &siw,pasi,sizeof(AVISTREAMINFOA) );
+    AVIFILE_strncpyAtoW( siw.szName, pasi->szName,
+        sizeof(siw.szName)/sizeof(siw.szName[0]) );
+    siw.szName[sizeof(siw.szName)/sizeof(siw.szName[0])-1] = 0;
+
+    hr = AVIFileCreateStreamW(pfile,ppas,&siw);
+
+    return hr;
+}
+
+/***********************************************************************
+ *      AVIFileWriteData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileWriteData(
-        PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
-{
-        return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
-}
-
-/***********************************************************************
- *              AVIFileReadData (AVIFIL32.@)
+    PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
+{
+    return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
+}
+
+/***********************************************************************
+ *      AVIFileReadData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileReadData(
-        PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
-{
-        return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
-}
-
-/***********************************************************************
- *              AVIFileEndRecord (AVIFIL32.@)
+    PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
+{
+    return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
+}
+
+/***********************************************************************
+ *      AVIFileEndRecord (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileEndRecord( PAVIFILE pfile )
 {
-        return IAVIFile_EndRecord( pfile );
-}
-
-/***********************************************************************
- *              AVIStreamAddRef (AVIFIL32.@)
+    return IAVIFile_EndRecord( pfile );
+}
+
+/***********************************************************************
+ *      AVIStreamAddRef (AVIFIL32.@)
  */
 ULONG WINAPI AVIStreamAddRef(PAVISTREAM pas)
 {
-        return IAVIStream_Release(pas);
-}
-
-/***********************************************************************
- *              AVIStreamRelease (AVIFIL32.@)
+    return IAVIStream_Release(pas);
+}
+
+/***********************************************************************
+ *      AVIStreamRelease (AVIFIL32.@)
  */
 ULONG WINAPI AVIStreamRelease(PAVISTREAM pas)
 {
-        return IAVIStream_Release(pas);
-}
-
-/***********************************************************************
- *              AVIStreamInfoW (AVIFIL32.@)
+    return IAVIStream_Release(pas);
+}
+
+/***********************************************************************
+ *      AVIStreamInfoW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamInfoW(PAVISTREAM pas,AVISTREAMINFOW* psi,LONG lSize)
 {
-        return IAVIStream_Info(pas,psi,lSize);
-}
-
-/***********************************************************************
- *              AVIStreamInfo  (AVIFIL32.@)
- *              AVIStreamInfoA (AVIFIL32.@)
+    return IAVIStream_Info(pas,psi,lSize);
+}
+
+/***********************************************************************
+ *      AVIStreamInfo  (AVIFIL32.@)
+ *      AVIStreamInfoA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamInfoA(PAVISTREAM pas,AVISTREAMINFOA* psi,LONG lSize)
 {
-        AVISTREAMINFOW  siw;
-        HRESULT         hr;
-
-        if (lSize < sizeof(AVISTREAMINFOA))
-                return AVIERR_BADSIZE;
-        hr = AVIStreamInfoW(pas,&siw,sizeof(AVISTREAMINFOW));
-        if ( hr != S_OK )
-                return hr;
-        memcpy( psi,&siw,sizeof(AVIFILEINFOA) );
-        AVIFILE_strncpyWtoA( psi->szName, siw.szName, sizeof(psi->szName) );
-        psi->szName[sizeof(psi->szName)-1] = 0;
-
-        return hr;
-}
-
-/***********************************************************************
- *              AVIStreamFindSample (AVIFIL32.@)
+    AVISTREAMINFOW  siw;
+    HRESULT     hr;
+
+    if (lSize < sizeof(AVISTREAMINFOA))
+        return AVIERR_BADSIZE;
+    hr = AVIStreamInfoW(pas,&siw,sizeof(AVISTREAMINFOW));
+    if ( hr != S_OK )
+        return hr;
+    memcpy( psi,&siw,sizeof(AVIFILEINFOA) );
+    AVIFILE_strncpyWtoA( psi->szName, siw.szName, sizeof(psi->szName) );
+    psi->szName[sizeof(psi->szName)-1] = 0;
+
+    return hr;
+}
+
+/***********************************************************************
+ *      AVIStreamFindSample (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamFindSample(PAVISTREAM pas,LONG lPos,LONG lFlags)
 {
-        return IAVIStream_FindSample(pas,lPos,lFlags);
-}
-
-/***********************************************************************
- *              AVIStreamReadFormat (AVIFIL32.@)
+    return IAVIStream_FindSample(pas,lPos,lFlags);
+}
+
+/***********************************************************************
+ *      AVIStreamReadFormat (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG *formatsize) {
-        return IAVIStream_ReadFormat(pas,pos,format,formatsize);
-}
-
-/***********************************************************************
- *              AVIStreamSetFormat (AVIFIL32.@)
+    return IAVIStream_ReadFormat(pas,pos,format,formatsize);
+}
+
+/***********************************************************************
+ *      AVIStreamSetFormat (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG formatsize) {
-        return IAVIStream_SetFormat(pas,pos,format,formatsize);
-}
-
-/***********************************************************************
- *              AVIStreamReadData (AVIFIL32.@)
+    return IAVIStream_SetFormat(pas,pos,format,formatsize);
+}
+
+/***********************************************************************
+ *      AVIStreamReadData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamReadData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG *lpread) {
-        return IAVIStream_ReadData(pas,fcc,lp,lpread);
-}
-
-/***********************************************************************
- *              AVIStreamWriteData (AVIFIL32.@)
+    return IAVIStream_ReadData(pas,fcc,lp,lpread);
+}
+
+/***********************************************************************
+ *      AVIStreamWriteData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamWriteData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG size) {
-        return IAVIStream_WriteData(pas,fcc,lp,size);
-}
-
-/***********************************************************************
- *              AVIStreamRead (AVIFIL32.@)
+    return IAVIStream_WriteData(pas,fcc,lp,size);
+}
+
+/***********************************************************************
+ *      AVIStreamRead (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamRead(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread)
 {
-        return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
-}
-
-/***********************************************************************
- *              AVIStreamWrite (AVIFIL32.@)
+    return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
+}
+
+/***********************************************************************
+ *      AVIStreamWrite (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamWrite(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
-        return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
-}
-
-
-/***********************************************************************
- *              AVIStreamStart (AVIFIL32.@)
+    return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
+}
+
+
+/***********************************************************************
+ *      AVIStreamStart (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamStart(PAVISTREAM pas)
 {
-        AVISTREAMINFOW  si;
-        HRESULT                 hr;
-
-        hr = IAVIStream_Info(pas,&si,sizeof(si));
-        if (hr != S_OK)
-                return -1;
-        return (LONG)si.dwStart;
-}
-
-/***********************************************************************
- *              AVIStreamLength (AVIFIL32.@)
+    AVISTREAMINFOW  si;
+    HRESULT         hr;
+
+    hr = IAVIStream_Info(pas,&si,sizeof(si));
+    if (hr != S_OK)
+        return -1;
+    return (LONG)si.dwStart;
+}
+
+/***********************************************************************
+ *      AVIStreamLength (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamLength(PAVISTREAM pas)
 {
-        AVISTREAMINFOW  si;
-        HRESULT                 hr;
-
-        hr = IAVIStream_Info(pas,&si,sizeof(si));
-        if (hr != S_OK)
-                return -1;
-        return (LONG)si.dwLength;
-}
-
-/***********************************************************************
- *              AVIStreamTimeToSample (AVIFIL32.@)
+    AVISTREAMINFOW  si;
+    HRESULT         hr;
+
+    hr = IAVIStream_Info(pas,&si,sizeof(si));
+    if (hr != S_OK)
+        return -1;
+    return (LONG)si.dwLength;
+}
+
+/***********************************************************************
+ *      AVIStreamTimeToSample (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pas,LONG lTime)
 {
-        AVISTREAMINFOW  si;
-        HRESULT                 hr;
-
-        hr = IAVIStream_Info(pas,&si,sizeof(si));
-        if (hr != S_OK)
-                return -1;
-
-        /* I am too lazy... */
-        FIXME("(%p,%ld)",pas,lTime);
-        return (LONG)-1L;
-}
-
-/***********************************************************************
- *              AVIStreamSampleToTime (AVIFIL32.@)
+    AVISTREAMINFOW  si;
+    HRESULT         hr;
+
+    hr = IAVIStream_Info(pas,&si,sizeof(si));
+    if (hr != S_OK)
+        return -1;
+
+    /* I am too lazy... */
+    FIXME("(%p,%ld)",pas,lTime);
+    return (LONG)-1L;
+}
+
+/***********************************************************************
+ *      AVIStreamSampleToTime (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pas,LONG lSample)
 {
-        AVISTREAMINFOW  si;
-        HRESULT                 hr;
-
-        hr = IAVIStream_Info(pas,&si,sizeof(si));
-        if (hr != S_OK)
-                return -1;
-
-        /* I am too lazy... */
-        FIXME("(%p,%ld)",pas,lSample);
-        return (LONG)-1L;
-}
-
-/***********************************************************************
- *              AVIStreamBeginStreaming (AVIFIL32.@)
+    AVISTREAMINFOW  si;
+    HRESULT         hr;
+
+    hr = IAVIStream_Info(pas,&si,sizeof(si));
+    if (hr != S_OK)
+        return -1;
+
+    /* I am too lazy... */
+    FIXME("(%p,%ld)",pas,lSample);
+    return (LONG)-1L;
+}
+
+/***********************************************************************
+ *      AVIStreamBeginStreaming (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamBeginStreaming(PAVISTREAM pas,LONG lStart,LONG lEnd,LONG lRate)
 {
-        FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
-        return E_FAIL;
-}
-
-/***********************************************************************
- *              AVIStreamEndStreaming (AVIFIL32.@)
+    FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
+    return E_FAIL;
+}
+
+/***********************************************************************
+ *      AVIStreamEndStreaming (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamEndStreaming(PAVISTREAM pas)
 {
-        FIXME("(%p)->(),stub!\n",pas);
-        return E_FAIL;
-}
-
-/***********************************************************************
- *              AVIStreamGetFrameOpen (AVIFIL32.@)
+    FIXME("(%p)->(),stub!\n",pas);
+    return E_FAIL;
+}
+
+/***********************************************************************
+ *      AVIStreamGetFrameOpen (AVIFIL32.@)
  */
 PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pas,LPBITMAPINFOHEADER pbi)
 {
-        IGetFrame*      pgf;
-        HRESULT         hr;
-        AVISTREAMINFOW  si;
-
-        FIXME("(%p,%p)\n",pas,pbi);
-
-        hr = IAVIStream_Info(pas,&si,sizeof(si));
-        if (hr != S_OK)
-                return NULL;
-
-        hr = AVIFILE_CreateIGetFrame((void**)&pgf,pas,pbi);
-        if ( hr != S_OK )
-                return NULL;
-        hr = IGetFrame_Begin( pgf, si.dwStart, si.dwLength, 1000 );
-        if ( hr != S_OK )
-        {
-                IGetFrame_Release( pgf );
-                return NULL;
-        }
-
-        return pgf;
-}
-
-/***********************************************************************
- *              AVIStreamGetFrame (AVIFIL32.@)
+    IGetFrame*  pgf;
+    HRESULT     hr;
+    AVISTREAMINFOW  si;
+
+    FIXME("(%p,%p)\n",pas,pbi);
+
+    hr = IAVIStream_Info(pas,&si,sizeof(si));
+    if (hr != S_OK)
+        return NULL;
+
+    hr = AVIFILE_CreateIGetFrame((void**)&pgf,pas,pbi);
+    if ( hr != S_OK )
+        return NULL;
+    hr = IGetFrame_Begin( pgf, si.dwStart, si.dwLength, 1000 );
+    if ( hr != S_OK )
+    {
+        IGetFrame_Release( pgf );
+        return NULL;
+    }
+
+    return pgf;
+}
+
+/***********************************************************************
+ *      AVIStreamGetFrame (AVIFIL32.@)
  */
 LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pgf, LONG lPos)
 {
-        return IGetFrame_GetFrame(pgf,lPos);
-}
-
-/***********************************************************************
- *              AVIStreamGetFrameClose (AVIFIL32.@)
+    return IGetFrame_GetFrame(pgf,lPos);
+}
+
+/***********************************************************************
+ *      AVIStreamGetFrameClose (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pgf)
 {
-        return IGetFrame_End(pgf);
-}
-
-/***********************************************************************
- *              AVIStreamOpenFromFileA (AVIFIL32.@)
+    return IGetFrame_End(pgf);
+}
+
+/***********************************************************************
+ *      AVIStreamOpenFromFileA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM* ppas, LPCSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
 {
-        WCHAR*  pwsz;
-        HRESULT hr;
-
-        pwsz = AVIFILE_strdupAtoW( szFile );
-        if ( pwsz == NULL )
-                return AVIERR_MEMORY;
-        hr = AVIStreamOpenFromFileW(ppas,pwsz,fccType,lParam,uMode,lpHandler);
-        HeapFree( AVIFILE_data.hHeap, 0, pwsz );
-        return hr;
-}
-
-/***********************************************************************
- *              AVIStreamOpenFromFileW (AVIFIL32.@)
+    WCHAR*  pwsz;
+    HRESULT hr;
+
+    pwsz = AVIFILE_strdupAtoW( szFile );
+    if ( pwsz == NULL )
+        return AVIERR_MEMORY;
+    hr = AVIStreamOpenFromFileW(ppas,pwsz,fccType,lParam,uMode,lpHandler);
+    HeapFree( AVIFILE_data.hHeap, 0, pwsz );
+    return hr;
+}
+
+/***********************************************************************
+ *      AVIStreamOpenFromFileW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM* ppas, LPCWSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
 {
-        HRESULT hr;
-        PAVIFILE        paf;
-        AVIFILEINFOW    fi;
-
-        *ppas = NULL;
-        hr = AVIFileOpenW(&paf,szFile,uMode,lpHandler);
-        if ( hr != S_OK )
-                return hr;
-        hr = AVIFileInfoW(paf,&fi,sizeof(AVIFILEINFOW));
-        if ( hr == S_OK )
-                hr = AVIFileGetStream(paf,ppas,fccType,lParam);
-
-        IAVIFile_Release(paf);
-
-        return hr;
-}
-
-/***********************************************************************
- *              AVIStreamCreate (AVIFIL32.@)
+    HRESULT hr;
+    PAVIFILE    paf;
+    AVIFILEINFOW    fi;
+
+    *ppas = NULL;
+    hr = AVIFileOpenW(&paf,szFile,uMode,lpHandler);
+    if ( hr != S_OK )
+        return hr;
+    hr = AVIFileInfoW(paf,&fi,sizeof(AVIFILEINFOW));
+    if ( hr == S_OK )
+        hr = AVIFileGetStream(paf,ppas,fccType,lParam);
+
+    IAVIFile_Release(paf);
+
+    return hr;
+}
+
+/***********************************************************************
+ *      AVIStreamCreate (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamCreate(PAVISTREAM* ppas, LONG lParam1, LONG lParam2, CLSID* lpHandler)
 {
-        HRESULT hr;
-        IClassFactory*  pcf;
-
-        *ppas = NULL;
-
-        if ( lpHandler == NULL )
-        {
-                hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
-                                               &IID_IClassFactory,(void**)&pcf);
-        }
-        else
-        {
-                if ( !AVIFILE_data.fInitCOM )
-                        return E_UNEXPECTED;
-                hr = CoGetClassObject(lpHandler,CLSCTX_INPROC_SERVER,
-                                      NULL,&IID_IClassFactory,(void**)&pcf);
-        }
-        if ( hr != S_OK )
-                return hr;
-
-        hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIStream,
-                                           (void**)ppas );
-        IClassFactory_Release( pcf );
-
-        if ( hr == S_OK )
-        {
-                hr = IAVIStream_Create((*ppas),lParam1,lParam2);
-                if ( hr != S_OK )
-                {
-                        IAVIStream_Release((*ppas));
-                        *ppas = NULL;
-                }
-        }
-
-        return hr;
-}
-
-/***********************************************************************
- *              AVIMakeCompressedStream (AVIFIL32.@)
+    HRESULT hr;
+    IClassFactory*  pcf;
+
+    *ppas = NULL;
+
+    if ( lpHandler == NULL )
+    {
+        hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
+                           &IID_IClassFactory,(void**)&pcf);
+    }
+    else
+    {
+        if ( !AVIFILE_data.fInitCOM )
+            return E_UNEXPECTED;
+        hr = CoGetClassObject(lpHandler,CLSCTX_INPROC_SERVER,
+                      NULL,&IID_IClassFactory,(void**)&pcf);
+    }
+    if ( hr != S_OK )
+        return hr;
+
+    hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIStream,
+                       (void**)ppas );
+    IClassFactory_Release( pcf );
+
+    if ( hr == S_OK )
+    {
+        hr = IAVIStream_Create((*ppas),lParam1,lParam2);
+        if ( hr != S_OK )
+        {
+            IAVIStream_Release((*ppas));
+            *ppas = NULL;
+        }
+    }
+
+    return hr;
+}
+
+/***********************************************************************
+ *      AVIMakeCompressedStream (AVIFIL32.@)
  */
 HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *aco,CLSID *pclsidHandler)
 {
-        FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
-        return E_FAIL;
-}
-
+    FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
+    return E_FAIL;
+}
+

trunk/src/avifil32/comentry.c

@@ -1 @@
-/*
+/* $Id: comentry.c,v 1.2 2001-09-05 12:00:53 bird Exp $
+ *
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
  */
@@ -27 +28 @@
 static ICOM_VTABLE(IClassFactory) iclassfact =
 {
-        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
-        IClassFactory_fnQueryInterface,
-        IClassFactory_fnAddRef,
-        IClassFactory_fnRelease,
-        IClassFactory_fnCreateInstance,
-        IClassFactory_fnLockServer
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    IClassFactory_fnQueryInterface,
+    IClassFactory_fnAddRef,
+    IClassFactory_fnRelease,
+    IClassFactory_fnCreateInstance,
+    IClassFactory_fnLockServer
 };
 
 typedef struct
 {
-        /* IUnknown fields */
-        ICOM_VFIELD(IClassFactory);
-        DWORD   ref;
+    /* IUnknown fields */
+    ICOM_VFIELD(IClassFactory);
+    DWORD   ref;
 } IClassFactoryImpl;
 
@@ -49 +50 @@
 IClassFactory_fnQueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
 {
-        ICOM_THIS(IClassFactoryImpl,iface);
+    ICOM_THIS(IClassFactoryImpl,iface);
 
-        TRACE("(%p)->(%p,%p)\n",This,riid,ppobj);
-        if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) ||
-             ( IsEqualGUID( &IID_IClassFactory, riid ) ) )
-        {
-                *ppobj = iface;
-                IClassFactory_AddRef(iface);
-                return S_OK;
-        }
+    TRACE("(%p)->(%p,%p)\n",This,riid,ppobj);
+    if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) ||
+         ( IsEqualGUID( &IID_IClassFactory, riid ) ) )
+    {
+        *ppobj = iface;
+        IClassFactory_AddRef(iface);
+        return S_OK;
+    }
 
-        return E_NOINTERFACE;
+    return E_NOINTERFACE;
 }
 
 static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface)
 {
-        ICOM_THIS(IClassFactoryImpl,iface);
+    ICOM_THIS(IClassFactoryImpl,iface);
 
-        TRACE("(%p)->()\n",This);
-        if ( (This->ref) == 0 )
-                AVIFILE_data.dwClassObjRef ++;
+    TRACE("(%p)->()\n",This);
+    if ( (This->ref) == 0 )
+        AVIFILE_data.dwClassObjRef ++;
 
-        return ++(This->ref);
+    return ++(This->ref);
 }
 
 static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface)
 {
-        ICOM_THIS(IClassFactoryImpl,iface);
+    ICOM_THIS(IClassFactoryImpl,iface);
 
-        TRACE("(%p)->()\n",This);
-        if ( (--(This->ref)) > 0 )
-                return This->ref;
+    TRACE("(%p)->()\n",This);
+    if ( (--(This->ref)) > 0 )
+        return This->ref;
 
-        AVIFILE_data.dwClassObjRef --;
-        return 0;
+    AVIFILE_data.dwClassObjRef --;
+    return 0;
 }
 
@@ -90 +91 @@
     /*ICOM_THIS(IClassFactoryImpl,iface);*/
 
-        *ppobj = NULL;
-        if ( pOuter != NULL )
-                return E_FAIL;
+    *ppobj = NULL;
+    if ( pOuter != NULL )
+        return E_FAIL;
 
-        if ( IsEqualGUID( &IID_IAVIFile, riid ) )
-                return AVIFILE_CreateIAVIFile(ppobj);
-        if ( IsEqualGUID( &IID_IAVIStream, riid ) )
-                return AVIFILE_CreateIAVIStream(ppobj);
+    if ( IsEqualGUID( &IID_IAVIFile, riid ) )
+        return AVIFILE_CreateIAVIFile(ppobj);
+    if ( IsEqualGUID( &IID_IAVIStream, riid ) )
+        return AVIFILE_CreateIAVIStream(ppobj);
 
-        return E_NOINTERFACE;
+    return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface,BOOL dolock)
 {
-        ICOM_THIS(IClassFactoryImpl,iface);
-        HRESULT hr;
+    ICOM_THIS(IClassFactoryImpl,iface);
+    HRESULT hr;
 
-        FIXME("(%p)->(%d),stub!\n",This,dolock);
-        if (dolock)
-                hr = IClassFactory_AddRef(iface);
-        else
-                hr = IClassFactory_Release(iface);
+    FIXME("(%p)->(%d),stub!\n",This,dolock);
+    if (dolock)
+        hr = IClassFactory_AddRef(iface);
+    else
+        hr = IClassFactory_Release(iface);
 
-        return hr;
+    return hr;
 }
 
 
 /***********************************************************************
- *              DllGetClassObject (AVIFIL32.@)
+ *      DllGetClassObject (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFILE_DllGetClassObject(const CLSID* pclsid,const IID* piid,void** ppv)
 {
-        *ppv = NULL;
-        if ( IsEqualCLSID( &IID_IClassFactory, piid ) )
-        {
-                *ppv = (LPVOID)&AVIFILE_GlobalCF;
-                IClassFactory_AddRef((IClassFactory*)*ppv);
-                return S_OK;
-        }
+    *ppv = NULL;
+    if ( IsEqualCLSID( &IID_IClassFactory, piid ) )
+    {
+        *ppv = (LPVOID)&AVIFILE_GlobalCF;
+        IClassFactory_AddRef((IClassFactory*)*ppv);
+        return S_OK;
+    }
 
-        return CLASS_E_CLASSNOTAVAILABLE;
+    return CLASS_E_CLASSNOTAVAILABLE;
 }
 
 /*****************************************************************************
- *              DllCanUnloadNow (AVIFIL32.@)
+ *      DllCanUnloadNow (AVIFIL32.@)
  */
 DWORD WINAPI AVIFILE_DllCanUnloadNow(void)
 {
-        return ( AVIFILE_data.dwClassObjRef == 0 ) ? S_OK : S_FALSE;
+    return ( AVIFILE_data.dwClassObjRef == 0 ) ? S_OK : S_FALSE;
 }
 

trunk/src/comctl32/animate.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
+/* $Id: animate.c,v 1.14 2001-09-05 12:04:56 bird Exp $ */
 /*
  * Animation control
  *
  * Copyright 1998, 1999 Eric Kohl
- *                 1999 Eric Pouech
+ *         1999 Eric Pouech
  *
  * NOTES
@@ -33 +34 @@
 #endif
    /* reference to input stream (file or resource) */
-   HGLOBAL              hRes;
-   HMMIO                hMMio;  /* handle to mmio stream */
-   HWND                 hWnd;
+   HGLOBAL      hRes;
+   HMMIO        hMMio;  /* handle to mmio stream */
+   HWND         hWnd;
    /* information on the loaded AVI file */
-   MainAVIHeader        mah;
-   AVIStreamHeader      ash;
-   LPBITMAPINFOHEADER   inbih;
-   LPDWORD              lpIndex;
+   MainAVIHeader    mah;
+   AVIStreamHeader  ash;
+   LPBITMAPINFOHEADER   inbih;
+   LPDWORD      lpIndex;
    /* data for the decompressor */
-   HIC                  hic;
-   LPBITMAPINFOHEADER   outbih;
-   LPVOID               indata;
-   LPVOID               outdata;
+   HIC          hic;
+   LPBITMAPINFOHEADER   outbih;
+   LPVOID       indata;
+   LPVOID       outdata;
    /* data for the background mechanism */
-   CRITICAL_SECTION     cs;
-   HANDLE               hThread;
-   UINT                 uTimer;
+   CRITICAL_SECTION cs;
+   HANDLE       hThread;
+   UINT         uTimer;
    /* data for playing the file */
-   int                  nFromFrame;
-   int                  nToFrame;
-   int                  nLoop;
-   int                  currFrame;
+   int          nFromFrame;
+   int          nToFrame;
+   int          nLoop;
+   int          currFrame;
    /* tranparency info*/
-   COLORREF             transparentColor;   
-   HBRUSH               hbrushBG;
-   HBITMAP              hbmPrevFrame;
+   COLORREF             transparentColor;
+   HBRUSH               hbrushBG;
+   HBITMAP              hbmPrevFrame;
 } ANIMATE_INFO;
 
 #define ANIMATE_GetInfoPtr(hWnd) ((ANIMATE_INFO *)GetWindowLongA(hWnd, 0))
-#define ANIMATE_COLOR_NONE      0xffffffff
+#define ANIMATE_COLOR_NONE      0xffffffff
 
 static void ANIMATE_Notify(ANIMATE_INFO* infoPtr, UINT notif)
 {
-    SendMessageA(GetParent(infoPtr->hWnd), WM_COMMAND, 
-                 MAKEWPARAM(GetDlgCtrlID(infoPtr->hWnd), notif), 
-                 (LPARAM)infoPtr->hWnd);
+    SendMessageA(GetParent(infoPtr->hWnd), WM_COMMAND,
+         MAKEWPARAM(GetDlgCtrlID(infoPtr->hWnd), notif),
+         (LPARAM)infoPtr->hWnd);
 }
 
@@ -77 +78 @@
 #endif
 {
-    HRSRC       hrsrc;
-    MMIOINFO    mminfo;
-    LPVOID      lpAvi;
-    
+    HRSRC   hrsrc;
+    MMIOINFO    mminfo;
+    LPVOID  lpAvi;
+
 #ifdef __WIN32OS2__
     if (unicode)
@@ -90 +91 @@
 #endif
     if (!hrsrc)
-        return FALSE;
-    
+    return FALSE;
+
     infoPtr->hRes = LoadResource(hInst, hrsrc);
     if (!infoPtr->hRes)
-        return FALSE;
-    
+    return FALSE;
+
     lpAvi = LockResource(infoPtr->hRes);
     if (!lpAvi)
-        return FALSE;
-    
+    return FALSE;
+
     memset(&mminfo, 0, sizeof(mminfo));
     mminfo.fccIOProc = FOURCC_MEM;
@@ -106 +107 @@
     infoPtr->hMMio = mmioOpenA(NULL, &mminfo, MMIO_READ);
     if (!infoPtr->hMMio) {
-        GlobalFree((HGLOBAL)lpAvi);
-        return FALSE;
+    GlobalFree((HGLOBAL)lpAvi);
+    return FALSE;
     }
 
@@ -127 +128 @@
 #else
     infoPtr->hMMio = mmioOpenA((LPSTR)lpName, NULL,
-                               MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
+                   MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 #endif
     if (!infoPtr->hMMio)
-        return FALSE;
-    
+    return FALSE;
+
     return TRUE;
 }
@@ -141 +142 @@
 
     /* should stop playing */
-    if (infoPtr->hThread) 
+    if (infoPtr->hThread)
     {
         if (!TerminateThread(infoPtr->hThread,0))
             WARN("could not destroy animation thread!\n");
-            infoPtr->hThread = 0;
+        infoPtr->hThread = 0;
     }
     if (infoPtr->uTimer) {
-        KillTimer(infoPtr->hWnd, infoPtr->uTimer);
-        infoPtr->uTimer = 0;
+    KillTimer(infoPtr->hWnd, infoPtr->uTimer);
+    infoPtr->uTimer = 0;
     }
 
@@ -163 +164 @@
 {
     if (infoPtr->hMMio) {
-        ANIMATE_DoStop(infoPtr);
-        mmioClose(infoPtr->hMMio, 0);
-        if (infoPtr->hRes) {
-            FreeResource(infoPtr->hRes);
-            infoPtr->hRes = 0;
-        }
-        if (infoPtr->lpIndex) {
-            HeapFree(GetProcessHeap(), 0, infoPtr->lpIndex);
-            infoPtr->lpIndex = NULL;
-        }
-        if (infoPtr->hic) {
-            ICClose(infoPtr->hic);
-            infoPtr->hic = 0;
-        }
-        if (infoPtr->inbih) {
-            HeapFree(GetProcessHeap(), 0, infoPtr->inbih);
-            infoPtr->inbih = NULL;
-        }
-        if (infoPtr->outbih) {
-            HeapFree(GetProcessHeap(), 0, infoPtr->outbih);
-            infoPtr->outbih = NULL;
-        }
+    ANIMATE_DoStop(infoPtr);
+    mmioClose(infoPtr->hMMio, 0);
+    if (infoPtr->hRes) {
+        FreeResource(infoPtr->hRes);
+        infoPtr->hRes = 0;
+    }
+    if (infoPtr->lpIndex) {
+        HeapFree(GetProcessHeap(), 0, infoPtr->lpIndex);
+        infoPtr->lpIndex = NULL;
+    }
+    if (infoPtr->hic) {
+        ICClose(infoPtr->hic);
+        infoPtr->hic = 0;
+    }
+    if (infoPtr->inbih) {
+        HeapFree(GetProcessHeap(), 0, infoPtr->inbih);
+        infoPtr->inbih = NULL;
+    }
+    if (infoPtr->outbih) {
+        HeapFree(GetProcessHeap(), 0, infoPtr->outbih);
+        infoPtr->outbih = NULL;
+    }
         if( infoPtr->indata )
         {
-        HeapFree(GetProcessHeap(), 0, infoPtr->indata);
+    HeapFree(GetProcessHeap(), 0, infoPtr->indata);
             infoPtr->indata = NULL;
         }
-        if( infoPtr->outdata )
+        if( infoPtr->outdata )
         {
-        HeapFree(GetProcessHeap(), 0, infoPtr->outdata);
+    HeapFree(GetProcessHeap(), 0, infoPtr->outdata);
             infoPtr->outdata = NULL;
         }
-        if( infoPtr->hbmPrevFrame )
+        if( infoPtr->hbmPrevFrame )
         {
-            DeleteObject(infoPtr->hbmPrevFrame);
+        DeleteObject(infoPtr->hbmPrevFrame);
             infoPtr->hbmPrevFrame = 0;
         }
-        infoPtr->indata = infoPtr->outdata = NULL;
-        infoPtr->hWnd = 0;
-        infoPtr->hMMio = 0;
-        
-        memset(&infoPtr->mah, 0, sizeof(infoPtr->mah));
-        memset(&infoPtr->ash, 0, sizeof(infoPtr->ash));
-        infoPtr->nFromFrame = infoPtr->nToFrame = infoPtr->nLoop = infoPtr->currFrame = 0;
-    }
-    infoPtr->transparentColor = ANIMATE_COLOR_NONE;    
+    infoPtr->indata = infoPtr->outdata = NULL;
+    infoPtr->hWnd = 0;
+    infoPtr->hMMio = 0;
+
+    memset(&infoPtr->mah, 0, sizeof(infoPtr->mah));
+    memset(&infoPtr->ash, 0, sizeof(infoPtr->ash));
+    infoPtr->nFromFrame = infoPtr->nToFrame = infoPtr->nLoop = infoPtr->currFrame = 0;
+    }
+    infoPtr->transparentColor = ANIMATE_COLOR_NONE;
 }
 
 static void ANIMATE_TransparentBlt(ANIMATE_INFO* infoPtr, HDC hdcDest, HDC hdcSource)
-{       
+{
     HDC hdcMask;
     HBITMAP hbmMask;
-    HBITMAP hbmOld;            
-    
+    HBITMAP hbmOld;
+
     /* create a transparency mask */
     hdcMask = CreateCompatibleDC(hdcDest);
-    hbmMask = CreateBitmap(infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, 1,1,NULL);   
-    hbmOld = SelectObject(hdcMask, hbmMask);             
+    hbmMask = CreateBitmap(infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, 1,1,NULL);
+    hbmOld = SelectObject(hdcMask, hbmMask);
 
     SetBkColor(hdcSource,infoPtr->transparentColor);
     BitBlt(hdcMask,0,0,infoPtr->inbih->biWidth, infoPtr->inbih->biHeight,hdcSource,0,0,SRCCOPY);
-            
+
     /* mask the source bitmap */
-    SetBkColor(hdcSource, RGB(0,0,0));          
-    SetTextColor(hdcSource, RGB(255,255,255)); 
+    SetBkColor(hdcSource, RGB(0,0,0));
+    SetTextColor(hdcSource, RGB(255,255,255));
     BitBlt(hdcSource, 0, 0, infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, hdcMask, 0, 0, SRCAND);
 
     /* mask the destination bitmap */
-    SetBkColor(hdcDest, RGB(255,255,255));   
-    SetTextColor(hdcDest, RGB(0,0,0));         
+    SetBkColor(hdcDest, RGB(255,255,255));
+    SetTextColor(hdcDest, RGB(0,0,0));
     BitBlt(hdcDest, 0, 0, infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, hdcMask, 0, 0, SRCAND);
 
@@ -258 +259 @@
 
     if (!hDC || !infoPtr->inbih)
-        return TRUE;
+    return TRUE;
 
     if (infoPtr->hic )
@@ -266 +267 @@
 
         nWidth = infoPtr->outbih->biWidth;
-        nHeight = infoPtr->outbih->biHeight;  
+        nHeight = infoPtr->outbih->biHeight;
     } else
-    {  
+    {
         pBitmapData = infoPtr->indata;
         pBitmapInfo = (LPBITMAPINFO)infoPtr->inbih;
 
         nWidth = infoPtr->inbih->biWidth;
-        nHeight = infoPtr->inbih->biHeight;  
-    }  
+        nHeight = infoPtr->inbih->biHeight;
+    }
 
     if(!infoPtr->hbmPrevFrame)
@@ -281 +282 @@
     }
 
-    SetDIBits(hDC, infoPtr->hbmPrevFrame, 0, nHeight, pBitmapData, (LPBITMAPINFO)pBitmapInfo, DIB_RGB_COLORS); 
-    
+    SetDIBits(hDC, infoPtr->hbmPrevFrame, 0, nHeight, pBitmapData, (LPBITMAPINFO)pBitmapInfo, DIB_RGB_COLORS);
+
     hdcMem = CreateCompatibleDC(hDC);
     hbmOld = SelectObject(hdcMem, infoPtr->hbmPrevFrame);
 
-    /* 
-     * we need to get the transparent color even without ACS_TRANSPARENT, 
+    /*
+     * we need to get the transparent color even without ACS_TRANSPARENT,
      * because the style can be changed later on and the color should always
-     * be obtained in the first frame 
+     * be obtained in the first frame
      */
     if(infoPtr->transparentColor == ANIMATE_COLOR_NONE)
     {
         infoPtr->transparentColor = GetPixel(hdcMem,0,0);
-    } 
-
-    if(GetWindowLongA(infoPtr->hWnd, GWL_STYLE) & ACS_TRANSPARENT) 
-    { 
+    }
+
+    if(GetWindowLongA(infoPtr->hWnd, GWL_STYLE) & ACS_TRANSPARENT)
+    {
         HDC hdcFinal = CreateCompatibleDC(hDC);
         HBITMAP hbmFinal = CreateCompatibleBitmap(hDC,nWidth, nHeight);
         HBITMAP hbmOld2 = SelectObject(hdcFinal, hbmFinal);
         RECT rect;
-        
+
         rect.left = 0;
         rect.top = 0;
         rect.right = nWidth;
         rect.bottom = nHeight;
-        
+
         if(!infoPtr->hbrushBG)
             infoPtr->hbrushBG = GetCurrentObject(hDC, OBJ_BRUSH);
@@ -320 +321 @@
         infoPtr->hbmPrevFrame = hbmFinal;
          }
-    
-    if (GetWindowLongA(infoPtr->hWnd, GWL_STYLE) & ACS_CENTER) 
-    {
-       RECT rect;   
+
+    if (GetWindowLongA(infoPtr->hWnd, GWL_STYLE) & ACS_CENTER)
+    {
+       RECT rect;
 
        GetWindowRect(infoPtr->hWnd, &rect);
-       nOffsetX = ((rect.right - rect.left) - nWidth)/2; 
-       nOffsetY = ((rect.bottom - rect.top) - nHeight)/2;  
-    }
-    BitBlt(hDC, nOffsetX, nOffsetY, nWidth, nHeight, hdcMem, 0, 0, SRCCOPY);    
+       nOffsetX = ((rect.right - rect.left) - nWidth)/2;
+       nOffsetY = ((rect.bottom - rect.top) - nHeight)/2;
+    }
+    BitBlt(hDC, nOffsetX, nOffsetY, nWidth, nHeight, hdcMem, 0, 0, SRCCOPY);
 
     SelectObject(hdcMem, hbmOld);
@@ -338 +339 @@
 static LRESULT ANIMATE_DrawFrame(ANIMATE_INFO* infoPtr)
 {
-    HDC         hDC;
+    HDC     hDC;
 
     TRACE("Drawing frame %d (loop %d)\n", infoPtr->currFrame, infoPtr->nLoop);
@@ -346 +347 @@
     mmioSeek(infoPtr->hMMio, infoPtr->lpIndex[infoPtr->currFrame], SEEK_SET);
     mmioRead(infoPtr->hMMio, infoPtr->indata, infoPtr->ash.dwSuggestedBufferSize);
-    
+
     if (infoPtr->hic &&
-        ICDecompress(infoPtr->hic, 0, infoPtr->inbih, infoPtr->indata, 
-                     infoPtr->outbih, infoPtr->outdata) != ICERR_OK) {
-        LeaveCriticalSection(&infoPtr->cs);
-        WARN("Decompression error\n");
-        return FALSE;
+    ICDecompress(infoPtr->hic, 0, infoPtr->inbih, infoPtr->indata,
+             infoPtr->outbih, infoPtr->outdata) != ICERR_OK) {
+    LeaveCriticalSection(&infoPtr->cs);
+    WARN("Decompression error\n");
+    return FALSE;
     }
 
     if ((hDC = GetDC(infoPtr->hWnd)) != 0) {
-        ANIMATE_PaintFrame(infoPtr, hDC);
-        ReleaseDC(infoPtr->hWnd, hDC);
+    ANIMATE_PaintFrame(infoPtr, hDC);
+    ReleaseDC(infoPtr->hWnd, hDC);
     }
 
     if (infoPtr->currFrame++ >= infoPtr->nToFrame) {
-        infoPtr->currFrame = infoPtr->nFromFrame;
-        if (infoPtr->nLoop != -1) {
-            if (--infoPtr->nLoop == 0) {
-                ANIMATE_DoStop(infoPtr);
-            }
-        }
+    infoPtr->currFrame = infoPtr->nFromFrame;
+    if (infoPtr->nLoop != -1) {
+        if (--infoPtr->nLoop == 0) {
+        ANIMATE_DoStop(infoPtr);
+        }
+    }
     }
     LeaveCriticalSection(&infoPtr->cs);
@@ -375 +376 @@
 static DWORD CALLBACK ANIMATE_AnimationThread(LPVOID ptr_)
 {
-    ANIMATE_INFO*       infoPtr = (ANIMATE_INFO*)ptr_;
+    ANIMATE_INFO*   infoPtr = (ANIMATE_INFO*)ptr_;
     HDC hDC;
-    
+
     if(!infoPtr)
     {
@@ -385 +386 @@
 
     while(1)
-    {    
-        if(GetWindowLongA(infoPtr->hWnd, GWL_STYLE) & ACS_TRANSPARENT) 
+    {
+        if(GetWindowLongA(infoPtr->hWnd, GWL_STYLE) & ACS_TRANSPARENT)
         {
             hDC = GetDC(infoPtr->hWnd);
-            /* sometimes the animation window will be destroyed in between
-             * by the main program, so a ReleaseDC() error msg is possible */
+        /* sometimes the animation window will be destroyed in between
+         * by the main program, so a ReleaseDC() error msg is possible */
             infoPtr->hbrushBG = SendMessageA(GetParent(infoPtr->hWnd),WM_CTLCOLORSTATIC,hDC, infoPtr->hWnd);
             ReleaseDC(infoPtr->hWnd,hDC);
         }
-        
+
         EnterCriticalSection(&infoPtr->cs);
         ANIMATE_DrawFrame(infoPtr);
         LeaveCriticalSection(&infoPtr->cs);
-    
+
         /* time is in microseconds, we should convert it to milliseconds */
         Sleep((infoPtr->mah.dwMicroSecPerFrame+500)/1000);
@@ -411 +412 @@
     /* nothing opened */
     if (!infoPtr->hMMio)
-        return FALSE;
+    return FALSE;
 
     if (infoPtr->hThread || infoPtr->uTimer) {
-        FIXME("Already playing ? what should I do ??\n");
-        ANIMATE_DoStop(infoPtr);
+    FIXME("Already playing ? what should I do ??\n");
+    ANIMATE_DoStop(infoPtr);
     }
 
@@ -423 +424 @@
 
     if (infoPtr->nToFrame == 0xFFFF)
-        infoPtr->nToFrame = infoPtr->mah.dwTotalFrames - 1;
-
-    TRACE("(repeat=%d from=%d to=%d);\n", 
-          infoPtr->nLoop, infoPtr->nFromFrame, infoPtr->nToFrame);
+    infoPtr->nToFrame = infoPtr->mah.dwTotalFrames - 1;
+
+    TRACE("(repeat=%d from=%d to=%d);\n",
+      infoPtr->nLoop, infoPtr->nFromFrame, infoPtr->nToFrame);
 
     if (infoPtr->nFromFrame >= infoPtr->nToFrame ||
-        infoPtr->nToFrame >= infoPtr->mah.dwTotalFrames)
-        return FALSE;
+    infoPtr->nToFrame >= infoPtr->mah.dwTotalFrames)
+    return FALSE;
 
     infoPtr->currFrame = infoPtr->nFromFrame;
 
     if (GetWindowLongA(hWnd, GWL_STYLE) & ACS_TIMER) {
-        TRACE("Using a timer\n");
-        /* create a timer to display AVI */
-        infoPtr->uTimer = SetTimer(hWnd, 1, infoPtr->mah.dwMicroSecPerFrame / 1000, NULL);
+    TRACE("Using a timer\n");
+    /* create a timer to display AVI */
+    infoPtr->uTimer = SetTimer(hWnd, 1, infoPtr->mah.dwMicroSecPerFrame / 1000, NULL);
     } else {
         DWORD threadID;
 
-        TRACE("Using an animation thread\n");
+    TRACE("Using an animation thread\n");
         infoPtr->hThread = CreateThread(0,0,ANIMATE_AnimationThread,(LPVOID)infoPtr,0,0 &threadID);
         if(!infoPtr->hThread)
@@ -448 +449 @@
            return FALSE;
     }
-        
-    }
-        
+
+    }
+
     ANIMATE_Notify(infoPtr, ACN_START);
 
@@ -459 +460 @@
 static BOOL ANIMATE_GetAviInfo(ANIMATE_INFO *infoPtr)
 {
-    MMCKINFO            ckMainRIFF;
-    MMCKINFO            mmckHead;
-    MMCKINFO            mmckList;
-    MMCKINFO            mmckInfo;
-    DWORD               numFrame;
-    DWORD               insize;
+    MMCKINFO        ckMainRIFF;
+    MMCKINFO        mmckHead;
+    MMCKINFO        mmckList;
+    MMCKINFO        mmckInfo;
+    DWORD       numFrame;
+    DWORD       insize;
 
     if (mmioDescend(infoPtr->hMMio, &ckMainRIFF, NULL, 0) != 0) {
-        WARN("Can't find 'RIFF' chunk\n");
-        return FALSE;
+    WARN("Can't find 'RIFF' chunk\n");
+    return FALSE;
     }
 
     if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
-        (ckMainRIFF.fccType != mmioFOURCC('A', 'V', 'I', ' '))) {
-        WARN("Can't find 'AVI ' chunk\n");
-        return FALSE;
+    (ckMainRIFF.fccType != mmioFOURCC('A', 'V', 'I', ' '))) {
+    WARN("Can't find 'AVI ' chunk\n");
+    return FALSE;
     }
 
     mmckHead.fccType = mmioFOURCC('h', 'd', 'r', 'l');
     if (mmioDescend(infoPtr->hMMio, &mmckHead, &ckMainRIFF, MMIO_FINDLIST) != 0) {
-        WARN("Can't find 'hdrl' list\n");
-        return FALSE;
+    WARN("Can't find 'hdrl' list\n");
+    return FALSE;
     }
 
     mmckInfo.ckid = mmioFOURCC('a', 'v', 'i', 'h');
     if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckHead, MMIO_FINDCHUNK) != 0) {
-        WARN("Can't find 'avih' chunk\n");
-        return FALSE;
+    WARN("Can't find 'avih' chunk\n");
+    return FALSE;
     }
 
     mmioRead(infoPtr->hMMio, (LPSTR)&infoPtr->mah, sizeof(infoPtr->mah));
 
-    TRACE("mah.dwMicroSecPerFrame=%ld\n",       infoPtr->mah.dwMicroSecPerFrame);
-    TRACE("mah.dwMaxBytesPerSec=%ld\n",         infoPtr->mah.dwMaxBytesPerSec);
-    TRACE("mah.dwPaddingGranularity=%ld\n",     infoPtr->mah.dwPaddingGranularity);
-    TRACE("mah.dwFlags=%ld\n",                  infoPtr->mah.dwFlags);
-    TRACE("mah.dwTotalFrames=%ld\n",            infoPtr->mah.dwTotalFrames);
-    TRACE("mah.dwInitialFrames=%ld\n",          infoPtr->mah.dwInitialFrames);
-    TRACE("mah.dwStreams=%ld\n",                infoPtr->mah.dwStreams);
-    TRACE("mah.dwSuggestedBufferSize=%ld\n",    infoPtr->mah.dwSuggestedBufferSize);
-    TRACE("mah.dwWidth=%ld\n",                  infoPtr->mah.dwWidth);
-    TRACE("mah.dwHeight=%ld\n",                 infoPtr->mah.dwHeight);
+    TRACE("mah.dwMicroSecPerFrame=%ld\n",   infoPtr->mah.dwMicroSecPerFrame);
+    TRACE("mah.dwMaxBytesPerSec=%ld\n",     infoPtr->mah.dwMaxBytesPerSec);
+    TRACE("mah.dwPaddingGranularity=%ld\n",     infoPtr->mah.dwPaddingGranularity);
+    TRACE("mah.dwFlags=%ld\n",          infoPtr->mah.dwFlags);
+    TRACE("mah.dwTotalFrames=%ld\n",        infoPtr->mah.dwTotalFrames);
+    TRACE("mah.dwInitialFrames=%ld\n",      infoPtr->mah.dwInitialFrames);
+    TRACE("mah.dwStreams=%ld\n",        infoPtr->mah.dwStreams);
+    TRACE("mah.dwSuggestedBufferSize=%ld\n",    infoPtr->mah.dwSuggestedBufferSize);
+    TRACE("mah.dwWidth=%ld\n",          infoPtr->mah.dwWidth);
+    TRACE("mah.dwHeight=%ld\n",         infoPtr->mah.dwHeight);
 
     mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
@@ -506 +507 @@
     mmckList.fccType = mmioFOURCC('s', 't', 'r', 'l');
     if (mmioDescend(infoPtr->hMMio, &mmckList, &mmckHead, MMIO_FINDLIST) != 0) {
-        WARN("Can't find 'strl' list\n");
-        return FALSE;
+    WARN("Can't find 'strl' list\n");
+    return FALSE;
     }
 
     mmckInfo.ckid = mmioFOURCC('s', 't', 'r', 'h');
     if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, MMIO_FINDCHUNK) != 0) {
-        WARN("Can't find 'strh' chunk\n");
-        return FALSE;
+    WARN("Can't find 'strh' chunk\n");
+    return FALSE;
     }
 
     mmioRead(infoPtr->hMMio, (LPSTR)&infoPtr->ash, sizeof(infoPtr->ash));
 
-    TRACE("ash.fccType='%c%c%c%c'\n",           LOBYTE(LOWORD(infoPtr->ash.fccType)), 
-                                                HIBYTE(LOWORD(infoPtr->ash.fccType)), 
-                                                LOBYTE(HIWORD(infoPtr->ash.fccType)), 
-                                                HIBYTE(HIWORD(infoPtr->ash.fccType)));
-    TRACE("ash.fccHandler='%c%c%c%c'\n",        LOBYTE(LOWORD(infoPtr->ash.fccHandler)), 
-                                                HIBYTE(LOWORD(infoPtr->ash.fccHandler)), 
-                                                LOBYTE(HIWORD(infoPtr->ash.fccHandler)), 
-                                                HIBYTE(HIWORD(infoPtr->ash.fccHandler)));
-    TRACE("ash.dwFlags=%ld\n",                  infoPtr->ash.dwFlags);
-    TRACE("ash.wPriority=%d\n",                 infoPtr->ash.wPriority);
-    TRACE("ash.wLanguage=%d\n",                 infoPtr->ash.wLanguage);
-    TRACE("ash.dwInitialFrames=%ld\n",          infoPtr->ash.dwInitialFrames);
-    TRACE("ash.dwScale=%ld\n",                  infoPtr->ash.dwScale);
-    TRACE("ash.dwRate=%ld\n",                   infoPtr->ash.dwRate);
-    TRACE("ash.dwStart=%ld\n",                  infoPtr->ash.dwStart);
-    TRACE("ash.dwLength=%ld\n",                 infoPtr->ash.dwLength);
-    TRACE("ash.dwSuggestedBufferSize=%ld\n",    infoPtr->ash.dwSuggestedBufferSize);
-    TRACE("ash.dwQuality=%ld\n",                infoPtr->ash.dwQuality);
-    TRACE("ash.dwSampleSize=%ld\n",             infoPtr->ash.dwSampleSize);
-    TRACE("ash.rcFrame=(%d,%d,%d,%d)\n",        infoPtr->ash.rcFrame.top, infoPtr->ash.rcFrame.left, 
-          infoPtr->ash.rcFrame.bottom, infoPtr->ash.rcFrame.right);
+    TRACE("ash.fccType='%c%c%c%c'\n",       LOBYTE(LOWORD(infoPtr->ash.fccType)),
+                                            HIBYTE(LOWORD(infoPtr->ash.fccType)),
+                                            LOBYTE(HIWORD(infoPtr->ash.fccType)),
+                                            HIBYTE(HIWORD(infoPtr->ash.fccType)));
+    TRACE("ash.fccHandler='%c%c%c%c'\n",    LOBYTE(LOWORD(infoPtr->ash.fccHandler)),
+                                            HIBYTE(LOWORD(infoPtr->ash.fccHandler)),
+                                            LOBYTE(HIWORD(infoPtr->ash.fccHandler)),
+                                            HIBYTE(HIWORD(infoPtr->ash.fccHandler)));
+    TRACE("ash.dwFlags=%ld\n",          infoPtr->ash.dwFlags);
+    TRACE("ash.wPriority=%d\n",         infoPtr->ash.wPriority);
+    TRACE("ash.wLanguage=%d\n",         infoPtr->ash.wLanguage);
+    TRACE("ash.dwInitialFrames=%ld\n",      infoPtr->ash.dwInitialFrames);
+    TRACE("ash.dwScale=%ld\n",          infoPtr->ash.dwScale);
+    TRACE("ash.dwRate=%ld\n",           infoPtr->ash.dwRate);
+    TRACE("ash.dwStart=%ld\n",          infoPtr->ash.dwStart);
+    TRACE("ash.dwLength=%ld\n",         infoPtr->ash.dwLength);
+    TRACE("ash.dwSuggestedBufferSize=%ld\n",    infoPtr->ash.dwSuggestedBufferSize);
+    TRACE("ash.dwQuality=%ld\n",        infoPtr->ash.dwQuality);
+    TRACE("ash.dwSampleSize=%ld\n",         infoPtr->ash.dwSampleSize);
+    TRACE("ash.rcFrame=(%d,%d,%d,%d)\n",    infoPtr->ash.rcFrame.top, infoPtr->ash.rcFrame.left,
+      infoPtr->ash.rcFrame.bottom, infoPtr->ash.rcFrame.right);
 
     mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
@@ -544 +545 @@
     mmckInfo.ckid = mmioFOURCC('s', 't', 'r', 'f');
     if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, MMIO_FINDCHUNK) != 0) {
-        WARN("Can't find 'strh' chunk\n");
-        return FALSE;
+    WARN("Can't find 'strh' chunk\n");
+    return FALSE;
     }
 
     infoPtr->inbih = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
     if (!infoPtr->inbih) {
-        WARN("Can't alloc input BIH\n");
-        return FALSE;
+    WARN("Can't alloc input BIH\n");
+    return FALSE;
     }
 
     mmioRead(infoPtr->hMMio, (LPSTR)infoPtr->inbih, mmckInfo.cksize);
 
-    TRACE("bih.biSize=%ld\n",           infoPtr->inbih->biSize);
-    TRACE("bih.biWidth=%ld\n",          infoPtr->inbih->biWidth);
-    TRACE("bih.biHeight=%ld\n",         infoPtr->inbih->biHeight);
-    TRACE("bih.biPlanes=%d\n",          infoPtr->inbih->biPlanes);
-    TRACE("bih.biBitCount=%d\n",        infoPtr->inbih->biBitCount);
-    TRACE("bih.biCompression=%ld\n",    infoPtr->inbih->biCompression);
-    TRACE("bih.biSizeImage=%ld\n",      infoPtr->inbih->biSizeImage);
-    TRACE("bih.biXPelsPerMeter=%ld\n",  infoPtr->inbih->biXPelsPerMeter);
-    TRACE("bih.biYPelsPerMeter=%ld\n",  infoPtr->inbih->biYPelsPerMeter);
-    TRACE("bih.biClrUsed=%ld\n",        infoPtr->inbih->biClrUsed);
-    TRACE("bih.biClrImportant=%ld\n",   infoPtr->inbih->biClrImportant);
+    TRACE("bih.biSize=%ld\n",       infoPtr->inbih->biSize);
+    TRACE("bih.biWidth=%ld\n",      infoPtr->inbih->biWidth);
+    TRACE("bih.biHeight=%ld\n",     infoPtr->inbih->biHeight);
+    TRACE("bih.biPlanes=%d\n",      infoPtr->inbih->biPlanes);
+    TRACE("bih.biBitCount=%d\n",    infoPtr->inbih->biBitCount);
+    TRACE("bih.biCompression=%ld\n",    infoPtr->inbih->biCompression);
+    TRACE("bih.biSizeImage=%ld\n",  infoPtr->inbih->biSizeImage);
+    TRACE("bih.biXPelsPerMeter=%ld\n",  infoPtr->inbih->biXPelsPerMeter);
+    TRACE("bih.biYPelsPerMeter=%ld\n",  infoPtr->inbih->biYPelsPerMeter);
+    TRACE("bih.biClrUsed=%ld\n",    infoPtr->inbih->biClrUsed);
+    TRACE("bih.biClrImportant=%ld\n",   infoPtr->inbih->biClrImportant);
 
     mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
 
     mmioAscend(infoPtr->hMMio, &mmckList, 0);
-    
+
 #if 0
     /* an AVI has 0 or 1 video stream, and to be animated should not contain
-     * an audio stream, so only one strl is allowed 
+     * an audio stream, so only one strl is allowed
      */
     mmckList.fccType = mmioFOURCC('s', 't', 'r', 'l');
     if (mmioDescend(infoPtr->hMMio, &mmckList, &mmckHead, MMIO_FINDLIST) == 0) {
-        WARN("There should be a single 'strl' list\n");
-        return FALSE;
+    WARN("There should be a single 'strl' list\n");
+    return FALSE;
     }
 #endif
@@ -589 +590 @@
     mmckList.fccType = mmioFOURCC('m', 'o', 'v', 'i');
     if (mmioDescend(infoPtr->hMMio, &mmckList, &ckMainRIFF, MMIO_FINDLIST) != 0) {
-        WARN("Can't find 'movi' list\n");
-        return FALSE;
+    WARN("Can't find 'movi' list\n");
+    return FALSE;
     }
 
     /* FIXME: should handle the 'rec ' LIST when present */
 
-    infoPtr->lpIndex = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 
-                                 infoPtr->mah.dwTotalFrames * sizeof(DWORD));
+    infoPtr->lpIndex = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                 infoPtr->mah.dwTotalFrames * sizeof(DWORD));
     if (!infoPtr->lpIndex) {
-        WARN("Can't alloc index array\n");
-        return FALSE;
+    WARN("Can't alloc index array\n");
+    return FALSE;
     }
 
     numFrame = insize = 0;
-    while (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, 0) == 0 && 
-           numFrame < infoPtr->mah.dwTotalFrames) {
-        infoPtr->lpIndex[numFrame] = mmckInfo.dwDataOffset;
-        if (insize < mmckInfo.cksize)
-            insize = mmckInfo.cksize;
-        numFrame++;
-        mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
+    while (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, 0) == 0 &&
+       numFrame < infoPtr->mah.dwTotalFrames) {
+    infoPtr->lpIndex[numFrame] = mmckInfo.dwDataOffset;
+    if (insize < mmckInfo.cksize)
+        insize = mmckInfo.cksize;
+    numFrame++;
+    mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
     }
     if (numFrame != infoPtr->mah.dwTotalFrames) {
-        WARN("Found %ld frames (/%ld)\n", numFrame, infoPtr->mah.dwTotalFrames);
-        return FALSE;
+    WARN("Found %ld frames (/%ld)\n", numFrame, infoPtr->mah.dwTotalFrames);
+    return FALSE;
     }
     if (insize > infoPtr->ash.dwSuggestedBufferSize) {
-        WARN("insize=%ld suggestedSize=%ld\n", insize, infoPtr->ash.dwSuggestedBufferSize);
-        infoPtr->ash.dwSuggestedBufferSize = insize;
+    WARN("insize=%ld suggestedSize=%ld\n", insize, infoPtr->ash.dwSuggestedBufferSize);
+    infoPtr->ash.dwSuggestedBufferSize = insize;
     }
 
     infoPtr->indata = HeapAlloc(GetProcessHeap(), 0, infoPtr->ash.dwSuggestedBufferSize);
     if (!infoPtr->indata) {
-        WARN("Can't alloc input buffer\n");
-        return FALSE;
+    WARN("Can't alloc input buffer\n");
+    return FALSE;
     }
 
@@ -632 +633 @@
 static BOOL    ANIMATE_GetAviCodec(ANIMATE_INFO *infoPtr)
 {
-    DWORD       outSize;
+    DWORD   outSize;
 
     /* check uncompressed AVI */
@@ -638 +639 @@
        (infoPtr->ash.fccHandler == mmioFOURCC('R', 'L', 'E', ' ')))
     {
-        infoPtr->hic = 0;             
-        return TRUE;
+        infoPtr->hic = 0;
+    return TRUE;
     }
 
@@ -645 +646 @@
     infoPtr->hic = ICOpen(ICTYPE_VIDEO, infoPtr->ash.fccHandler, ICMODE_DECOMPRESS);
     if (!infoPtr->hic) {
-        WARN("Can't load codec for the file\n");
-        return FALSE;
-    }
-    
-    outSize = ICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT, 
-                            (DWORD)infoPtr->inbih, 0L);
+    WARN("Can't load codec for the file\n");
+    return FALSE;
+    }
+
+    outSize = ICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT,
+                (DWORD)infoPtr->inbih, 0L);
 
     infoPtr->outbih = HeapAlloc(GetProcessHeap(), 0, outSize);
     if (!infoPtr->outbih) {
-        WARN("Can't alloc output BIH\n");
-        return FALSE;
-    }
-
-    if (ICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT, 
-                      (DWORD)infoPtr->inbih, (DWORD)infoPtr->outbih) != ICERR_OK) {
-        WARN("Can't get output BIH\n");
-        return FALSE;
+    WARN("Can't alloc output BIH\n");
+    return FALSE;
+    }
+
+    if (ICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT,
+              (DWORD)infoPtr->inbih, (DWORD)infoPtr->outbih) != ICERR_OK) {
+    WARN("Can't get output BIH\n");
+    return FALSE;
     }
 
     infoPtr->outdata = HeapAlloc(GetProcessHeap(), 0, infoPtr->outbih->biSizeImage);
     if (!infoPtr->outdata) {
-        WARN("Can't alloc output buffer\n");
-        return FALSE;
-    }
-
-    if (ICSendMessage(infoPtr->hic, ICM_DECOMPRESS_BEGIN, 
-                      (DWORD)infoPtr->inbih, (DWORD)infoPtr->outbih) != ICERR_OK) {
-        WARN("Can't begin decompression\n");
-        return FALSE;
+    WARN("Can't alloc output buffer\n");
+    return FALSE;
+    }
+
+    if (ICSendMessage(infoPtr->hic, ICM_DECOMPRESS_BEGIN,
+              (DWORD)infoPtr->inbih, (DWORD)infoPtr->outbih) != ICERR_OK) {
+    WARN("Can't begin decompression\n");
+    return FALSE;
     }
 
@@ -691 +692 @@
 
     if (!lParam) {
-        TRACE("Closing avi!\n");
-        return TRUE;
-    }
-    
+    TRACE("Closing avi!\n");
+    return TRUE;
+    }
+
     if (!hInstance)
        hInstance = GetWindowLongA(hWnd, GWL_HINSTANCE);
@@ -719 +720 @@
 #else
     if (HIWORD(lParam)) {
-        TRACE("(\"%s\");\n", (LPSTR)lParam);
-
-        if (!ANIMATE_LoadResA(infoPtr, hInstance, (LPSTR)lParam)) {
-            TRACE("No AVI resource found!\n");
-            if (!ANIMATE_LoadFileA(infoPtr, (LPSTR)lParam)) {
-                WARN("No AVI file found!\n");
-                return FALSE;
-            }
-        }
+    TRACE("(\"%s\");\n", (LPSTR)lParam);
+
+    if (!ANIMATE_LoadResA(infoPtr, hInstance, (LPSTR)lParam)) {
+        TRACE("No AVI resource found!\n");
+        if (!ANIMATE_LoadFileA(infoPtr, (LPSTR)lParam)) {
+        WARN("No AVI file found!\n");
+        return FALSE;
+        }
+    }
     } else {
-        TRACE("(%u);\n", (WORD)LOWORD(lParam));
-
-        if (!ANIMATE_LoadResA(infoPtr, hInstance,
-                              MAKEINTRESOURCEA((INT)lParam))) {
-            WARN("No AVI resource found!\n");
-            return FALSE;
-        }
+    TRACE("(%u);\n", (WORD)LOWORD(lParam));
+
+    if (!ANIMATE_LoadResA(infoPtr, hInstance,
+                  MAKEINTRESOURCEA((INT)lParam))) {
+        WARN("No AVI resource found!\n");
+        return FALSE;
+    }
     }
 #endif
     if (!ANIMATE_GetAviInfo(infoPtr)) {
-        WARN("Can't get AVI information\n");
-        ANIMATE_Free(infoPtr);
-        return FALSE;
+    WARN("Can't get AVI information\n");
+    ANIMATE_Free(infoPtr);
+    return FALSE;
     }
 
     if (!ANIMATE_GetAviCodec(infoPtr)) {
-        WARN("Can't get AVI Codec\n");
-        ANIMATE_Free(infoPtr);
-        return FALSE;
+    WARN("Can't get AVI Codec\n");
+    ANIMATE_Free(infoPtr);
+    return FALSE;
     }
 
     if (!GetWindowLongA(hWnd, GWL_STYLE) & ACS_CENTER) {
-        SetWindowPos(hWnd, 0, 0, 0, infoPtr->mah.dwWidth, infoPtr->mah.dwHeight,
-                     SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
+    SetWindowPos(hWnd, 0, 0, 0, infoPtr->mah.dwWidth, infoPtr->mah.dwHeight,
+             SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
     }
 
     if (GetWindowLongA(hWnd, GWL_STYLE) & ACS_AUTOPLAY) {
-        return ANIMATE_Play(hWnd, -1, (LPARAM)MAKELONG(0, infoPtr->mah.dwTotalFrames-1));
+    return ANIMATE_Play(hWnd, -1, (LPARAM)MAKELONG(0, infoPtr->mah.dwTotalFrames-1));
     }
 
@@ -771 +772 @@
     /* nothing opened */
     if (!infoPtr->hMMio)
-        return FALSE;
+    return FALSE;
 
     ANIMATE_DoStop(infoPtr);
@@ -780 +781 @@
 static LRESULT ANIMATE_Create(HWND hWnd, WPARAM wParam, LPARAM lParam)
 {
-    ANIMATE_INFO*       infoPtr;
+    ANIMATE_INFO*   infoPtr;
 
     /* allocate memory for info structure */
@@ -789 +790 @@
 #endif
     if (!infoPtr) {
-        ERR("could not allocate info memory!\n");
-        return 0;
+    ERR("could not allocate info memory!\n");
+    return 0;
     }
 
@@ -802 +803 @@
 
     InitializeCriticalSection(&infoPtr->cs);
-    
+
     return 0;
 }
@@ -826 +827 @@
 {
     RECT rect;
-    HBRUSH hBrush = 0;       
-
-    if(GetWindowLongA(hWnd, GWL_STYLE) & ACS_TRANSPARENT) 
-    {
-        hBrush = SendMessageA(GetParent(hWnd),WM_CTLCOLORSTATIC,(HDC)wParam, hWnd);    
+    HBRUSH hBrush = 0;
+
+    if(GetWindowLongA(hWnd, GWL_STYLE) & ACS_TRANSPARENT)
+    {
+        hBrush = SendMessageA(GetParent(hWnd),WM_CTLCOLORSTATIC,(HDC)wParam, hWnd);
     }
 
@@ -842 +843 @@
 {
     if (GetWindowLongA(hWnd, GWL_STYLE) & ACS_CENTER) {
-        InvalidateRect(hWnd, NULL, TRUE);
+    InvalidateRect(hWnd, NULL, TRUE);
     }
     return TRUE;
@@ -851 +852 @@
     TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", hWnd, uMsg, wParam, lParam);
     if (!ANIMATE_GetInfoPtr(hWnd) && (uMsg != WM_NCCREATE))
-        return DefWindowProcA(hWnd, uMsg, wParam, lParam);
+    return DefWindowProcA(hWnd, uMsg, wParam, lParam);
     switch (uMsg)
     {
@@ -862 +863 @@
 #else
     case ACM_OPENA:
-        return ANIMATE_OpenA(hWnd, wParam, lParam);
-        
-        /*      case ACM_OPEN32W: FIXME!! */
-        /*          return ANIMATE_Open32W(hWnd, wParam, lParam); */
-#endif
-        
+    return ANIMATE_OpenA(hWnd, wParam, lParam);
+
+    /*  case ACM_OPEN32W: FIXME!! */
+    /*      return ANIMATE_Open32W(hWnd, wParam, lParam); */
+#endif
+
     case ACM_PLAY:
-        return ANIMATE_Play(hWnd, wParam, lParam);
-        
+    return ANIMATE_Play(hWnd, wParam, lParam);
+
     case ACM_STOP:
-        return ANIMATE_Stop(hWnd, wParam, lParam);
-        
+    return ANIMATE_Stop(hWnd, wParam, lParam);
+
     case WM_NCCREATE:
-        ANIMATE_Create(hWnd, wParam, lParam);
-        return DefWindowProcA(hWnd, uMsg, wParam, lParam);
-        
+    ANIMATE_Create(hWnd, wParam, lParam);
+    return DefWindowProcA(hWnd, uMsg, wParam, lParam);
+
     case WM_NCHITTEST:
-        return HTTRANSPARENT;
+    return HTTRANSPARENT;
 
     case WM_DESTROY:
-        ANIMATE_Destroy(hWnd, wParam, lParam);
-        return DefWindowProcA(hWnd, uMsg, wParam, lParam);
-        
+    ANIMATE_Destroy(hWnd, wParam, lParam);
+    return DefWindowProcA(hWnd, uMsg, wParam, lParam);
+
     case WM_ERASEBKGND:
-        ANIMATE_EraseBackground(hWnd, wParam, lParam);
-        break;
-
-    /*  case WM_STYLECHANGED: FIXME shall we do something ?? */
+    ANIMATE_EraseBackground(hWnd, wParam, lParam);
+    break;
+
+    /*  case WM_STYLECHANGED: FIXME shall we do something ?? */
 
     case WM_TIMER:
-        if (GetWindowLongA(hWnd, GWL_STYLE) & ACS_TRANSPARENT)
+        if (GetWindowLongA(hWnd, GWL_STYLE) & ACS_TRANSPARENT)
         {
             ANIMATE_INFO* infoPtr = ANIMATE_GetInfoPtr(hWnd);
             infoPtr->hbrushBG = SendMessageA(GetParent(hWnd),WM_CTLCOLORSTATIC,(HDC)wParam, hWnd);
         }
-        return ANIMATE_DrawFrame(ANIMATE_GetInfoPtr(hWnd));
-        
+    return ANIMATE_DrawFrame(ANIMATE_GetInfoPtr(hWnd));
+
     case WM_CLOSE:
-        ANIMATE_Free(ANIMATE_GetInfoPtr(hWnd));
-        return TRUE;
+    ANIMATE_Free(ANIMATE_GetInfoPtr(hWnd));
+    return TRUE;
 
     case WM_PAINT:
         {
             ANIMATE_INFO* infoPtr = ANIMATE_GetInfoPtr(hWnd);
-                
+
             /* the animation isn't playing, don't paint */
-            if(!infoPtr->uTimer && !infoPtr->hThread)
-                /* default paint handling */
-                return DefWindowProcA(hWnd, uMsg, wParam, lParam);
-            
+        if(!infoPtr->uTimer && !infoPtr->hThread)
+        /* default paint handling */
+            return DefWindowProcA(hWnd, uMsg, wParam, lParam);
+
             if (GetWindowLongA(hWnd, GWL_STYLE) & ACS_TRANSPARENT)
                 infoPtr->hbrushBG = SendMessageA(GetParent(hWnd), WM_CTLCOLORSTATIC,
-                                                 (HDC)wParam, hWnd);
-    
+                                         (HDC)wParam, hWnd);
+
             if (wParam)
             {
@@ -924 +925 @@
             else
             {
-                PAINTSTRUCT ps;
-                HDC hDC = BeginPaint(hWnd, &ps);
+            PAINTSTRUCT ps;
+            HDC hDC = BeginPaint(hWnd, &ps);
 
                 EnterCriticalSection(&infoPtr->cs);
                 ANIMATE_PaintFrame(infoPtr, hDC);
                 LeaveCriticalSection(&infoPtr->cs);
-    
-                EndPaint(hWnd, &ps);
-            }
-        }
-        break;
+
+            EndPaint(hWnd, &ps);
+        }
+        }
+    break;
 
     case WM_SIZE:
-        ANIMATE_Size(hWnd, wParam, lParam);
-        return DefWindowProcA(hWnd, uMsg, wParam, lParam);
+    ANIMATE_Size(hWnd, wParam, lParam);
+    return DefWindowProcA(hWnd, uMsg, wParam, lParam);
 
     default:
-        if (uMsg >= WM_USER)
-            ERR("unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
-        
+    if (uMsg >= WM_USER)
+        ERR("unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
+
 #ifdef __WIN32OS2__
         return defComCtl32ProcA (hWnd, uMsg, wParam, lParam);
 #else
-        return DefWindowProcA(hWnd, uMsg, wParam, lParam);
+    return DefWindowProcA(hWnd, uMsg, wParam, lParam);
 #endif
     }
@@ -966 +967 @@
     wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
     wndClass.lpszClassName = ANIMATE_CLASSA;
- 
+
     RegisterClassA(&wndClass);
 }

trunk/src/comctl32/comboex.c

@@ +1 @@
+/* $Id: comboex.c,v 1.12 2001-09-05 12:04:56 bird Exp $ */
 /*
  * TODO   <-------------
@@ -4 +5 @@
  *     result in a FIXME:
  *           CBES_EX_NOEDITIMAGEINDENT
- *           CBES_EX_PATHWORDBREAKPROC
- *           CBES_EX_NOSIZELIMIT
- *           CBES_EX_CASESENSITIVE
+ *       CBES_EX_PATHWORDBREAKPROC
+ *       CBES_EX_NOSIZELIMIT
+ *       CBES_EX_CASESENSITIVE
  *  2. None of the following callback items are implemented. Therefor
  *     no CBEN_GETDISPINFO notifies are issued. Use in either CBEM_INSERTITEM
@@ -37 +38 @@
  *      generate message sequence similar to native DLL.
  *   2. Handle case where CBEM_SETITEM is called to display data in EDIT
- *      Control. 
+ *      Control.
  *   3. Add override for WNDPROC for the EDIT control (reqed for VK_RETURN).
  *   4. Dump input data for things using COMBOBOXEXITEM{A|W}.
@@ -55 +56 @@
  *   3. Lock image selected status to focus state of edit control if
  *      edit control exists. Mimics native actions.
- *   4. Implemented WM_SETFOCUS in EditWndProc to track status of 
+ *   4. Implemented WM_SETFOCUS in EditWndProc to track status of
  *      focus for 3 above.
  *   5. The LBN_SELCHANGE is just for documentation purposes.
@@ -70 +71 @@
  *
  *  mod 6
- *   1. Add support for WM_NOTIFYFORMAT (both incoming and outgoing) and do 
+ *   1. Add support for WM_NOTIFYFORMAT (both incoming and outgoing) and do
  *      WM_NOTIFY correctly based on results.
  *   2. Fix memory leaks of text strings in COMBOEX_WM_DELETEITEM.
  *   3. Add routines to handle special cases of NMCBEENDEDIT and NMCOMBOXEX
- *      so translation to ANSI is done correctly. 
+ *      so translation to ANSI is done correctly.
  *   4. Fix some issues with COMBOEX_DrawItem.
  *
@@ -150 +151 @@
 /*
  * Special flag set in DRAWITEMSTRUCT itemState field. It is set by
- * the ComboEx version of the Combo Window Proc so that when the 
- * WM_DRAWITEM message is then passed to ComboEx, we know that this 
+ * the ComboEx version of the Combo Window Proc so that when the
+ * WM_DRAWITEM message is then passed to ComboEx, we know that this
  * particular WM_DRAWITEM message is for listbox only items. Any messasges
  * without this flag is then for the Edit control field.
  *
- * We really cannot use the ODS_COMBOBOXEDIT flag because MSDN states that 
+ * We really cannot use the ODS_COMBOBOXEDIT flag because MSDN states that
  * only version 4.0 applications will have ODS_COMBOBOXEDIT set.
  */
@@ -189 +190 @@
     if (TRACE_ON(comboex)){
       TRACE("item %p - mask=%08x, pszText=%p, cchTM=%d, iImage=%d\n",
-            item, item->mask, item->pszText, item->cchTextMax,
-            item->iImage);
+        item, item->mask, item->pszText, item->cchTextMax,
+        item->iImage);
       TRACE("item %p - iSelectedImage=%d, iOverlay=%d, iIndent=%d, lParam=%08lx\n",
-            item, item->iSelectedImage, item->iOverlay, item->iIndent, item->lParam);
+        item, item->iSelectedImage, item->iOverlay, item->iIndent, item->lParam);
       if ((item->mask & CBEIF_TEXT) && item->pszText)
-          TRACE("item %p - pszText=%s\n",
-                item, debugstr_w((const WCHAR *)item->pszText));
+      TRACE("item %p - pszText=%s\n",
+        item, debugstr_w((const WCHAR *)item->pszText));
     }
 }
@@ -205 +206 @@
     if (TRACE_ON(comboex)){
       TRACE("input - mask=%08x, iItem=%d, pszText=%p, cchTM=%d, iImage=%d\n",
-            input->mask, input->iItem, input->pszText, input->cchTextMax,
-            input->iImage);
+        input->mask, input->iItem, input->pszText, input->cchTextMax,
+        input->iImage);
       if ((input->mask & CBEIF_TEXT) && input->pszText) {
-          if (true_for_w)
-              TRACE("input - pszText=<%s>\n", 
-                    debugstr_w((const WCHAR *)input->pszText));
-          else 
-              TRACE("input - pszText=<%s>\n", 
-                    debugstr_a((const char *)input->pszText));
+      if (true_for_w)
+          TRACE("input - pszText=<%s>\n",
+            debugstr_w((const WCHAR *)input->pszText));
+      else
+          TRACE("input - pszText=<%s>\n",
+            debugstr_a((const char *)input->pszText));
       }
       TRACE("input - iSelectedImage=%d, iOverlay=%d, iIndent=%d, lParam=%08lx\n",
-            input->iSelectedImage, input->iOverlay, input->iIndent, input->lParam);
+        input->iSelectedImage, input->iOverlay, input->iIndent, input->lParam);
     }
 }
@@ -226 +227 @@
     COMBOEX_INFO *infoPtr = COMBOEX_GetInfoPtr (hwnd);
 
-    if (infoPtr->hwndCombo)    
-        return SendMessageA (infoPtr->hwndCombo, uMsg, wParam, lParam);
+    if (infoPtr->hwndCombo)
+    return SendMessageA (infoPtr->hwndCombo, uMsg, wParam, lParam);
 
     return 0;
@@ -241 +242 @@
     hdr->code = code;
     if (infoPtr->NtfUnicode)
-        return SendMessageW (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
-                             (LPARAM)hdr);
+    return SendMessageW (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
+                 (LPARAM)hdr);
     else
-        return SendMessageA (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
-                             (LPARAM)hdr);
+    return SendMessageA (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
+                 (LPARAM)hdr);
 }
 
@@ -259 +260 @@
     hdr->hdr.code = code;
     if (infoPtr->NtfUnicode)
-        return SendMessageW (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
-                             (LPARAM)hdr);
+    return SendMessageW (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
+                 (LPARAM)hdr);
     else {
-        LPWSTR str, ostr = NULL;
-        INT ret, len = 0;
-
-        if (hdr->ceItem.mask & CBEIF_TEXT) {
-            ostr = hdr->ceItem.pszText;
-            str = ostr;
-            if (!str) str = (LPWSTR)L"";
-            len = WideCharToMultiByte (CP_ACP, 0, str, -1, 0, 0, NULL, NULL);
-            if (len > 0) {
-                hdr->ceItem.pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(CHAR));
-                WideCharToMultiByte (CP_ACP, 0, str, -1, (LPSTR)hdr->ceItem.pszText,
-                                     len, NULL, NULL);
-            }
-        }
-
-        ret = SendMessageA (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
-                            (LPARAM)hdr);
-        if (hdr->ceItem.mask & CBEIF_TEXT) {
-            if (len > 0)
-                COMCTL32_Free (hdr->ceItem.pszText);
-            hdr->ceItem.pszText = ostr;
-        }
-        return ret;
+    LPWSTR str, ostr = NULL;
+    INT ret, len = 0;
+
+    if (hdr->ceItem.mask & CBEIF_TEXT) {
+        ostr = hdr->ceItem.pszText;
+        str = ostr;
+        if (!str) str = (LPWSTR)L"";
+        len = WideCharToMultiByte (CP_ACP, 0, str, -1, 0, 0, NULL, NULL);
+        if (len > 0) {
+        hdr->ceItem.pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(CHAR));
+        WideCharToMultiByte (CP_ACP, 0, str, -1, (LPSTR)hdr->ceItem.pszText,
+                     len, NULL, NULL);
+        }
+    }
+
+    ret = SendMessageA (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
+                (LPARAM)hdr);
+    if (hdr->ceItem.mask & CBEIF_TEXT) {
+        if (len > 0)
+        COMCTL32_Free (hdr->ceItem.pszText);
+        hdr->ceItem.pszText = ostr;
+    }
+    return ret;
     }
 }
@@ -299 +300 @@
     hdr->hdr.code = (infoPtr->NtfUnicode) ? CBEN_ENDEDITW : CBEN_ENDEDITA;
     if (infoPtr->NtfUnicode)
-        return SendMessageW (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
-                             (LPARAM)hdr);
+    return SendMessageW (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
+                 (LPARAM)hdr);
     else {
-        NMCBEENDEDITA ansi;
-
-        memcpy (&ansi.hdr, &hdr->hdr, sizeof(NMHDR));
-        ansi.fChanged = hdr->fChanged;
-        ansi.iNewSelection = hdr->iNewSelection;
-        WideCharToMultiByte (CP_ACP, 0, itemText, -1,
-                             (LPSTR)&ansi.szText, CBEMAXSTRLEN, NULL, NULL);
-        ansi.iWhy = hdr->iWhy;
-        return SendMessageA (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
-                             (LPARAM)&ansi);
+    NMCBEENDEDITA ansi;
+
+    memcpy (&ansi.hdr, &hdr->hdr, sizeof(NMHDR));
+    ansi.fChanged = hdr->fChanged;
+    ansi.iNewSelection = hdr->iNewSelection;
+    WideCharToMultiByte (CP_ACP, 0, itemText, -1,
+                 (LPSTR)&ansi.szText, CBEMAXSTRLEN, NULL, NULL);
+    ansi.iWhy = hdr->iWhy;
+    return SendMessageA (GetParent(infoPtr->hwndSelf), WM_NOTIFY, 0,
+                 (LPARAM)&ansi);
     }
 }
@@ -340 +341 @@
     }
     if (cit->mask & CBEIF_IMAGE)
-        cit->iImage         = item->iImage;
+    cit->iImage         = item->iImage;
     if (cit->mask & CBEIF_SELECTEDIMAGE)
-        cit->iSelectedImage = item->iSelectedImage;
+    cit->iSelectedImage = item->iSelectedImage;
     if (cit->mask & CBEIF_OVERLAY)
-        cit->iOverlay       = item->iOverlay;
+    cit->iOverlay       = item->iOverlay;
     if (cit->mask & CBEIF_INDENT)
-        cit->iIndent        = item->iIndent;
+    cit->iIndent        = item->iIndent;
     if (cit->mask & CBEIF_LPARAM)
-        cit->lParam         = item->lParam;
+    cit->lParam         = item->lParam;
 
 }
@@ -364 +365 @@
     iinfo.rcImage.left = iinfo.rcImage.right = 0;
     if (infoPtr->himl) {
-        ImageList_GetImageInfo(infoPtr->himl, 0, &iinfo);
-        xoff = iinfo.rcImage.right - iinfo.rcImage.left + CBE_SEP;
+    ImageList_GetImageInfo(infoPtr->himl, 0, &iinfo);
+    xoff = iinfo.rcImage.right - iinfo.rcImage.left + CBE_SEP;
     }
     GetClientRect (infoPtr->hwndCombo, &rect);
@@ -380 +381 @@
 
     TRACE("Combo client (%d,%d)-(%d,%d), setting Edit to (%d,%d)-(%d,%d)\n",
-          rect.left, rect.top, rect.right, rect.bottom,
-          x, y, x + w, y + h);
+      rect.left, rect.top, rect.right, rect.bottom,
+      x, y, x + w, y + h);
     SetWindowPos(infoPtr->hwndEdit, HWND_TOP,
-                 x, y,
-                 w, h,
-                 SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOZORDER);
+         x, y,
+         w, h,
+         SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOZORDER);
 }
 
@@ -399 +400 @@
     cy = mysize.cy + CBE_EXTRA;
     if (infoPtr->himl) {
-        ImageList_GetImageInfo(infoPtr->himl, 0, &iinfo);
-        cy = max (iinfo.rcImage.bottom - iinfo.rcImage.top, cy);
-        TRACE("upgraded height due to image:  height=%d\n", cy);
+    ImageList_GetImageInfo(infoPtr->himl, 0, &iinfo);
+    cy = max (iinfo.rcImage.bottom - iinfo.rcImage.top, cy);
+    TRACE("upgraded height due to image:  height=%d\n", cy);
     }
     SendMessageW (hwnd, CB_SETITEMHEIGHT, (WPARAM) -1, (LPARAM) cy);
     if (infoPtr->hwndCombo)
         SendMessageW (infoPtr->hwndCombo, CB_SETITEMHEIGHT,
-                      (WPARAM) 0, (LPARAM) cy);
+              (WPARAM) 0, (LPARAM) cy);
 }
 
@@ -419 +420 @@
     /*      EM_SETSEL32 (0,-1)      */
     if (item->mask & CBEIF_TEXT) {
-        SendMessageW (infoPtr->hwndEdit, WM_SETTEXT, 0, (LPARAM)item->pszText);
-        SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, 0);
-        SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, -1);
-    }
-}
-
- 
+    SendMessageW (infoPtr->hwndEdit, WM_SETTEXT, 0, (LPARAM)item->pszText);
+    SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, 0);
+    SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, -1);
+    }
+}
+
+
 static CBE_ITEMDATA *
 COMBOEX_FindItem(COMBOEX_INFO *infoPtr, INT index)
@@ -433 +434 @@
 
     if ((index > infoPtr->nb_items) || (index < -1))
-        return 0;
+    return 0;
     if (index == -1)
-        return infoPtr->edit;
+    return infoPtr->edit;
     item = infoPtr->items;
     i = infoPtr->nb_items - 1;
@@ -441 +442 @@
     /* find the item in the list */
     while (item && (i > index)) {
-        item = (CBE_ITEMDATA *)item->next;
-        i--;
+    item = (CBE_ITEMDATA *)item->next;
+    i--;
     }
     if (!item || (i != index)) {
-        FIXME("COMBOBOXEX item structures broken. Please report!\n");
-        return 0;
+    FIXME("COMBOBOXEX item structures broken. Please report!\n");
+    return 0;
     }
     return item;
@@ -456 +457 @@
 {
     if (item->pszText == LPSTR_TEXTCALLBACKW)
-        FIXME("Callback not implemented yet for pszText\n");
+    FIXME("Callback not implemented yet for pszText\n");
     if (item->iImage == I_IMAGECALLBACK)
-        FIXME("Callback not implemented yet for iImage\n");
+    FIXME("Callback not implemented yet for iImage\n");
     if (item->iSelectedImage == I_IMAGECALLBACK)
-        FIXME("Callback not implemented yet for iSelectedImage\n");
+    FIXME("Callback not implemented yet for iSelectedImage\n");
     if (item->iOverlay == I_IMAGECALLBACK)
-        FIXME("Callback not implemented yet for iOverlay\n");
+    FIXME("Callback not implemented yet for iOverlay\n");
     if (item->iIndent == I_INDENTCALLBACK)
-        FIXME("Callback not implemented yet for iIndent\n");
+    FIXME("Callback not implemented yet for iIndent\n");
 }
 
@@ -482 +483 @@
     /* if item number requested does not exist then return failure */
     if ((index > infoPtr->nb_items) || (index < 0)) {
-        ERR("attempt to delete item that does not exist\n");
-        return CB_ERR;
+    ERR("attempt to delete item that does not exist\n");
+    return CB_ERR;
     }
 
     if (!(item = COMBOEX_FindItem(infoPtr, index))) {
-        ERR("attempt to delete item that was not found!\n");
-        return CB_ERR;
+    ERR("attempt to delete item that was not found!\n");
+    return CB_ERR;
     }
 
@@ -515 +516 @@
 
     if ((GetWindowLongA (hwnd, GWL_STYLE) & CBS_DROPDOWNLIST) != CBS_DROPDOWN)
-        return 0;
+    return 0;
 
     TRACE("-- 0x%x\n", infoPtr->hwndEdit);
@@ -560 +561 @@
     /* if item number requested does not exist then return failure */
     if ((index > infoPtr->nb_items) || (index < -1)) {
-        ERR("attempt to get item that does not exist\n");
-        return 0;
+    ERR("attempt to get item that does not exist\n");
+    return 0;
     }
 
     /* if the item is the edit control and there is no edit control, skip */
-    if ((index == -1) && 
+    if ((index == -1) &&
         ((GetWindowLongA (hwnd, GWL_STYLE) & CBS_DROPDOWNLIST) != CBS_DROPDOWN))
-            return 0;
+        return 0;
 
     if (!(item = COMBOEX_FindItem(infoPtr, index))) {
-        ERR("attempt to get item that was not found!\n");
-        return 0;
+    ERR("attempt to get item that was not found!\n");
+    return 0;
     }
 
@@ -594 +595 @@
 
     len = WideCharToMultiByte (CP_ACP, 0, tmpcit.pszText, -1, 0, 0, NULL, NULL);
-    if (len > 0) 
-        WideCharToMultiByte (CP_ACP, 0, tmpcit.pszText, -1, 
-                             cit->pszText, cit->cchTextMax, NULL, NULL);
+    if (len > 0)
+    WideCharToMultiByte (CP_ACP, 0, tmpcit.pszText, -1,
+                 cit->pszText, cit->cchTextMax, NULL, NULL);
 
     cit->iImage = tmpcit.iImage;
@@ -613 +614 @@
     COMBOEX_INFO *infoPtr = COMBOEX_GetInfoPtr (hwnd);
 
-    TRACE("%s hwnd=0x%x\n", 
-           infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
+    TRACE("%s hwnd=0x%x\n",
+       infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
 
     return infoPtr->bUnicode;
@@ -626 +627 @@
 
     if ((GetWindowLongA (hwnd, GWL_STYLE) & CBS_DROPDOWNLIST) != CBS_DROPDOWN)
-        return FALSE;
-    if ((infoPtr->flags & (WCBE_ACTEDIT | WCBE_EDITCHG)) == 
-        (WCBE_ACTEDIT | WCBE_EDITCHG))
-        return TRUE;
+    return FALSE;
+    if ((infoPtr->flags & (WCBE_ACTEDIT | WCBE_EDITCHG)) ==
+    (WCBE_ACTEDIT | WCBE_EDITCHG))
+    return TRUE;
     return FALSE;
 }
@@ -661 +662 @@
         /* fast path for iItem = -1 */
         item->next = infoPtr->items;
-        infoPtr->items = item;
+    infoPtr->items = item;
     }
     else {
         INT i = infoPtr->nb_items-1;
-        CBE_ITEMDATA *moving = infoPtr->items;
-
-        while ((i > index) && moving) {
-            moving = (CBE_ITEMDATA *)moving->next;
-            i--;
-        }
-        if (!moving) {
-            FIXME("COMBOBOXEX item structures broken. Please report!\n");
-            COMCTL32_Free(item);
-            return -1;
-        }
-        item->next = moving->next;
-        moving->next = item;
+    CBE_ITEMDATA *moving = infoPtr->items;
+
+    while ((i > index) && moving) {
+        moving = (CBE_ITEMDATA *)moving->next;
+        i--;
+    }
+    if (!moving) {
+        FIXME("COMBOBOXEX item structures broken. Please report!\n");
+        COMCTL32_Free(item);
+        return -1;
+    }
+    item->next = moving->next;
+    moving->next = item;
     }
 
@@ -684 +685 @@
     if (item->mask & CBEIF_TEXT) {
         LPWSTR str;
-        INT len;
+    INT len;
 
         str = cit->pszText;
         if (!str) str = (LPWSTR) L"";
-        len = strlenW (str);
-        if (len > 0) {
-            item->pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            strcpyW (item->pszText, str);
-        }
-        else
-            item->pszText = NULL;
+    len = strlenW (str);
+    if (len > 0) {
+        item->pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
+        strcpyW (item->pszText, str);
+    }
+    else
+        item->pszText = NULL;
         item->cchTextMax   = cit->cchTextMax;
     }
@@ -713 +714 @@
     COMBOEX_DumpItem (item);
 
-    SendMessageW (infoPtr->hwndCombo, CB_INSERTSTRING, 
-                  (WPARAM)cit->iItem, (LPARAM)item);
+    SendMessageW (infoPtr->hwndCombo, CB_INSERTSTRING,
+          (WPARAM)cit->iItem, (LPARAM)item);
 
     COMBOEX_CopyItem (infoPtr, item, &nmcit.ceItem);
@@ -727 +728 @@
 COMBOEX_InsertItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    COMBOBOXEXITEMA     *cit = (COMBOBOXEXITEMA *) lParam;
-    COMBOBOXEXITEMW     citW;
-    LRESULT             ret;
+    COMBOBOXEXITEMA *cit = (COMBOBOXEXITEMA *) lParam;
+    COMBOBOXEXITEMW citW;
+    LRESULT     ret;
 
     memcpy(&citW,cit,sizeof(COMBOBOXEXITEMA));
     if (cit->mask & CBEIF_TEXT) {
         LPSTR str;
-        INT len;
+    INT len;
 
         str = cit->pszText;
         if (!str) str="";
-        len = MultiByteToWideChar (CP_ACP, 0, str, -1, NULL, 0);
-        if (len > 0) {
-            citW.pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            MultiByteToWideChar (CP_ACP, 0, str, -1, citW.pszText, len);
-        }
+    len = MultiByteToWideChar (CP_ACP, 0, str, -1, NULL, 0);
+    if (len > 0) {
+        citW.pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
+        MultiByteToWideChar (CP_ACP, 0, str, -1, citW.pszText, len);
+    }
     }
     ret = COMBOEX_InsertItemW(hwnd,wParam,(LPARAM)&citW);;
 
     if (cit->mask & CBEIF_TEXT)
-        COMCTL32_Free(citW.pszText);
+    COMCTL32_Free(citW.pszText);
     return ret;
 }
@@ -763 +764 @@
 
     if (lParam & (CBES_EX_NOEDITIMAGEINDENT |
-                  CBES_EX_PATHWORDBREAKPROC |
-                  CBES_EX_NOSIZELIMIT |
-                  CBES_EX_CASESENSITIVE))
-        FIXME("Extended style not implemented %08lx\n", lParam);
+          CBES_EX_PATHWORDBREAKPROC |
+          CBES_EX_NOSIZELIMIT |
+          CBES_EX_CASESENSITIVE))
+    FIXME("Extended style not implemented %08lx\n", lParam);
 
     if ((DWORD)wParam) {
-        infoPtr->dwExtStyle = (infoPtr->dwExtStyle & ~(DWORD)wParam) | (DWORD)lParam;
+    infoPtr->dwExtStyle = (infoPtr->dwExtStyle & ~(DWORD)wParam) | (DWORD)lParam;
     }
     else
-        infoPtr->dwExtStyle = (DWORD)lParam;
+    infoPtr->dwExtStyle = (DWORD)lParam;
 
     /*
@@ -778 +779 @@
      */
     if ((infoPtr->dwExtStyle & CBES_EX_NOEDITIMAGE) ^
-        (dwTemp & CBES_EX_NOEDITIMAGE)) {
-        /* if state of EX_NOEDITIMAGE changes, invalidate all */
-        TRACE("EX_NOEDITIMAGE state changed to %ld\n",
-            infoPtr->dwExtStyle & CBES_EX_NOEDITIMAGE);
-        InvalidateRect (hwnd, NULL, TRUE);
-        COMBOEX_AdjustEditPos (infoPtr);
-        if (infoPtr->hwndEdit)
-            InvalidateRect (infoPtr->hwndEdit, NULL, TRUE);
+    (dwTemp & CBES_EX_NOEDITIMAGE)) {
+    /* if state of EX_NOEDITIMAGE changes, invalidate all */
+    TRACE("EX_NOEDITIMAGE state changed to %ld\n",
+        infoPtr->dwExtStyle & CBES_EX_NOEDITIMAGE);
+    InvalidateRect (hwnd, NULL, TRUE);
+    COMBOEX_AdjustEditPos (infoPtr);
+    if (infoPtr->hwndEdit)
+        InvalidateRect (infoPtr->hwndEdit, NULL, TRUE);
     }
 
@@ -826 +827 @@
     /* if item number requested does not exist then return failure */
     if ((index > infoPtr->nb_items) || (index < -1)) {
-        ERR("attempt to set item that does not exist yet!\n");
-        return 0;
+    ERR("attempt to set item that does not exist yet!\n");
+    return 0;
     }
 
     /* if the item is the edit control and there is no edit control, skip */
-    if ((index == -1) && 
+    if ((index == -1) &&
         ((GetWindowLongA (hwnd, GWL_STYLE) & CBS_DROPDOWNLIST) != CBS_DROPDOWN))
-            return 0;
+        return 0;
 
     if (!(item = COMBOEX_FindItem(infoPtr, index))) {
-        ERR("attempt to set item that was not found!\n");
-        return 0;
-    }
-
-    /* add/change stuff to the internal item structure */ 
+    ERR("attempt to set item that was not found!\n");
+    return 0;
+    }
+
+    /* add/change stuff to the internal item structure */
     item->mask |= cit->mask;
     if (cit->mask & CBEIF_TEXT) {
         LPWSTR str;
-        INT len;
-        WCHAR emptystr[1] = {0};
+    INT len;
+    WCHAR emptystr[1] = {0};
 
         str = cit->pszText;
         if (!str) str=emptystr;
-        len = strlenW(str);
-        if (len > 0) {
-            item->pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            strcpyW(item->pszText,str);
-        }
+    len = strlenW(str);
+    if (len > 0) {
+        item->pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
+        strcpyW(item->pszText,str);
+    }
         item->cchTextMax   = cit->cchTextMax;
     }
@@ -873 +874 @@
     /* if original request was to update edit control, do some fast foot work */
     if (cit->iItem == -1) {
-        COMBOEX_SetEditText (infoPtr, item);
-        RedrawWindow (infoPtr->hwndCombo, 0, 0, RDW_ERASE | RDW_INVALIDATE);
+    COMBOEX_SetEditText (infoPtr, item);
+    RedrawWindow (infoPtr->hwndCombo, 0, 0, RDW_ERASE | RDW_INVALIDATE);
     }
     return TRUE;
@@ -882 +883 @@
 COMBOEX_SetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    COMBOBOXEXITEMA     *cit = (COMBOBOXEXITEMA *) lParam;
-    COMBOBOXEXITEMW     citW;
-    LRESULT             ret;
+    COMBOBOXEXITEMA *cit = (COMBOBOXEXITEMA *) lParam;
+    COMBOBOXEXITEMW citW;
+    LRESULT     ret;
 
     memcpy(&citW,cit,sizeof(COMBOBOXEXITEMA));
     if (cit->mask & CBEIF_TEXT) {
         LPSTR str;
-        INT len;
+    INT len;
 
         str = cit->pszText;
         if (!str) str="";
-        len = MultiByteToWideChar (CP_ACP, 0, str, -1, NULL, 0);
-        if (len > 0) {
-            citW.pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            MultiByteToWideChar (CP_ACP, 0, str, -1, citW.pszText, len);
-        }
+    len = MultiByteToWideChar (CP_ACP, 0, str, -1, NULL, 0);
+    if (len > 0) {
+        citW.pszText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
+        MultiByteToWideChar (CP_ACP, 0, str, -1, citW.pszText, len);
+    }
     }
     ret = COMBOEX_SetItemW(hwnd,wParam,(LPARAM)&citW);;
 
     if (cit->mask & CBEIF_TEXT)
-        COMCTL32_Free(citW.pszText);
+    COMCTL32_Free(citW.pszText);
     return ret;
 }
@@ -913 +914 @@
     BOOL bTemp = infoPtr->bUnicode;
 
-    TRACE("to %s hwnd=0x%04x, was %s\n", 
-          ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd,
-          (bTemp) ? "TRUE" : "FALSE");
+    TRACE("to %s hwnd=0x%04x, was %s\n",
+      ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd,
+      (bTemp) ? "TRUE" : "FALSE");
 
     infoPtr->bUnicode = (BOOL)wParam;
@@ -937 +938 @@
     i = MultiByteToWideChar (CP_ACP, 0, (LPSTR)lParam, -1, NULL, 0);
     if (i > 0) {
-        desired = (LPWSTR)COMCTL32_Alloc ((i + 1)*sizeof(WCHAR));
-        MultiByteToWideChar (CP_ACP, 0, (LPSTR)lParam, -1, desired, i);
+    desired = (LPWSTR)COMCTL32_Alloc ((i + 1)*sizeof(WCHAR));
+    MultiByteToWideChar (CP_ACP, 0, (LPSTR)lParam, -1, desired, i);
     }
 
@@ -945 +946 @@
     /* now search from after starting loc and wrapping back to start */
     for(i=start+1; i<count; i++) {
-        item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo, 
-                          CB_GETITEMDATA, (WPARAM)i, 0);
-        TRACE("desired=%s, item=%s\n", 
-              debugstr_w(desired), debugstr_w(item->pszText));
-        if (lstrcmpiW(item->pszText, desired) == 0) {
-            COMCTL32_Free (desired);
-            return i;
-        }
+    item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo,
+              CB_GETITEMDATA, (WPARAM)i, 0);
+    TRACE("desired=%s, item=%s\n",
+          debugstr_w(desired), debugstr_w(item->pszText));
+    if (lstrcmpiW(item->pszText, desired) == 0) {
+        COMCTL32_Free (desired);
+        return i;
+    }
     }
     for(i=0; i<=start; i++) {
-        item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo, 
-                          CB_GETITEMDATA, (WPARAM)i, 0);
-        TRACE("desired=%s, item=%s\n", 
-              debugstr_w(desired), debugstr_w(item->pszText));
-        if (lstrcmpiW(item->pszText, desired) == 0) {
-            COMCTL32_Free (desired);
-            return i;
-        }
+    item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo,
+              CB_GETITEMDATA, (WPARAM)i, 0);
+    TRACE("desired=%s, item=%s\n",
+          debugstr_w(desired), debugstr_w(item->pszText));
+    if (lstrcmpiW(item->pszText, desired) == 0) {
+        COMCTL32_Free (desired);
+        return i;
+    }
     }
     COMCTL32_Free(desired);
@@ -977 +978 @@
     LRESULT lret = 0;
 
-    item1 = (CBE_ITEMDATA *)COMBOEX_Forward (hwnd, CB_GETITEMDATA, 
-                                             wParam, lParam);
+    item1 = (CBE_ITEMDATA *)COMBOEX_Forward (hwnd, CB_GETITEMDATA,
+                         wParam, lParam);
     if ((item1 != NULL) && ((LRESULT)item1 != CB_ERR)) {
-        item2 = COMBOEX_FindItem (infoPtr, index);
-        if (item2 != item1) {
-            ERR("data structures damaged!\n");
-            return CB_ERR;
-        }
-        if (item1->mask & CBEIF_LPARAM)
-            lret = (LRESULT) item1->lParam;
-        TRACE("returning 0x%08lx\n", lret);
-        return lret;
+    item2 = COMBOEX_FindItem (infoPtr, index);
+    if (item2 != item1) {
+        ERR("data structures damaged!\n");
+        return CB_ERR;
+    }
+    if (item1->mask & CBEIF_LPARAM)
+        lret = (LRESULT) item1->lParam;
+    TRACE("returning 0x%08lx\n", lret);
+    return lret;
     }
     lret = (LRESULT)item1;
@@ -1005 +1006 @@
 
     if (!(item = COMBOEX_FindItem(infoPtr, index))) {
-        /* FIXME: need to clear selection */
-        return CB_ERR;
+    /* FIXME: need to clear selection */
+    return CB_ERR;
     }
 
     TRACE("selecting item %d text=%s\n", index, (item->pszText) ?
-          debugstr_w(item->pszText) : "<null>");
+      debugstr_w(item->pszText) : "<null>");
     infoPtr->selected = index;
 
@@ -1026 +1027 @@
     CBE_ITEMDATA *item1, *item2;
 
-    item1 = (CBE_ITEMDATA *)COMBOEX_Forward (hwnd, CB_GETITEMDATA, 
-                                             wParam, lParam);
+    item1 = (CBE_ITEMDATA *)COMBOEX_Forward (hwnd, CB_GETITEMDATA,
+                         wParam, lParam);
     if ((item1 != NULL) && ((LRESULT)item1 != CB_ERR)) {
-        item2 = COMBOEX_FindItem (infoPtr, index);
-        if (item2 != item1) {
-            ERR("data structures damaged!\n");
-            return CB_ERR;
-        }
-        item1->mask |= CBEIF_LPARAM;
-        item1->lParam = lParam;
-        TRACE("setting lparam to 0x%08lx\n", lParam);
-        return 0;
+    item2 = COMBOEX_FindItem (infoPtr, index);
+    if (item2 != item1) {
+        ERR("data structures damaged!\n");
+        return CB_ERR;
+    }
+    item1->mask |= CBEIF_LPARAM;
+    item1->lParam = lParam;
+    TRACE("setting lparam to 0x%08lx\n", lParam);
+    return 0;
     }
     TRACE("non-valid result from combo 0x%08lx\n", (DWORD)item1);
@@ -1054 +1055 @@
     /* First, lets forward the message to the normal combo control
        just like Windows.     */
-    if (infoPtr->hwndCombo)    
+    if (infoPtr->hwndCombo)
        SendMessageW (infoPtr->hwndCombo, CB_SETITEMHEIGHT, wParam, lParam);
 
@@ -1060 +1061 @@
     GetWindowRect (hwnd, &cbx_wrect);
     GetClientRect (hwnd, &cbx_crect);
-    /* the height of comboex as height of the combo + comboex border */ 
+    /* the height of comboex as height of the combo + comboex border */
     height = cb_wrect.bottom-cb_wrect.top
              + cbx_wrect.bottom-cbx_wrect.top
              - (cbx_crect.bottom-cbx_crect.top);
     TRACE("EX window=(%d,%d)-(%d,%d), client=(%d,%d)-(%d,%d)\n",
-          cbx_wrect.left, cbx_wrect.top, cbx_wrect.right, cbx_wrect.bottom,
-          cbx_crect.left, cbx_crect.top, cbx_crect.right, cbx_crect.bottom);
+      cbx_wrect.left, cbx_wrect.top, cbx_wrect.right, cbx_wrect.bottom,
+      cbx_crect.left, cbx_crect.top, cbx_crect.right, cbx_crect.bottom);
     TRACE("CB window=(%d,%d)-(%d,%d), EX setting=(0,0)-(%d,%d)\n",
-          cb_wrect.left, cb_wrect.top, cb_wrect.right, cb_wrect.bottom,
-          cbx_wrect.right-cbx_wrect.left, height);
+      cb_wrect.left, cb_wrect.top, cb_wrect.right, cb_wrect.bottom,
+      cbx_wrect.right-cbx_wrect.left, height);
     SetWindowPos (hwnd, HWND_TOP, 0, 0,
-                  cbx_wrect.right-cbx_wrect.left,
-                  height,
-                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
+          cbx_wrect.right-cbx_wrect.left,
+          height,
+          SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
 
     return ret;
@@ -1101 +1102 @@
 #endif
     if (infoPtr == NULL) {
-        ERR("could not allocate info memory!\n");
-        return 0;
+    ERR("could not allocate info memory!\n");
+    return 0;
     }
 
@@ -1115 +1116 @@
 
     i = SendMessageA(GetParent (hwnd),
-                     WM_NOTIFYFORMAT, hwnd, NF_QUERY);
+             WM_NOTIFYFORMAT, hwnd, NF_QUERY);
     if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
-        ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
-            i);
-        i = NFR_ANSI;
+    ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
+        i);
+    i = NFR_ANSI;
     }
     infoPtr->NtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
@@ -1127 +1128 @@
     /* create combo box */
     dwComboStyle = GetWindowLongA (hwnd, GWL_STYLE) &
-                        (CBS_SIMPLE|CBS_DROPDOWN|CBS_DROPDOWNLIST|WS_CHILD);
+            (CBS_SIMPLE|CBS_DROPDOWN|CBS_DROPDOWNLIST|WS_CHILD);
 
     GetWindowRect(hwnd, &wnrc1);
     GetClientRect(hwnd, &clrc1);
     TRACE("EX window=(%d,%d)-(%d,%d) client=(%d,%d)-(%d,%d)\n",
-          wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
-          clrc1.left, clrc1.top, clrc1.right, clrc1.bottom);
+      wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
+      clrc1.left, clrc1.top, clrc1.right, clrc1.bottom);
     TRACE("combo style=%08lx, adding style=%08lx\n", dwComboStyle,
           WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VSCROLL |
           CBS_NOINTEGRALHEIGHT | CBS_DROPDOWNLIST |
-          WS_CHILD | WS_VISIBLE | CBS_OWNERDRAWFIXED);
+      WS_CHILD | WS_VISIBLE | CBS_OWNERDRAWFIXED);
 
     /* Native version of ComboEx creates the ComboBox with DROPDOWNLIST */
@@ -1147 +1148 @@
 
     infoPtr->hwndCombo = CreateWindowA ("ComboBox", "",
-                         /* following line added to match native */
+             /* following line added to match native */
                          WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VSCROLL |
-                         CBS_NOINTEGRALHEIGHT | CBS_DROPDOWNLIST | 
-                         /* was base and is necessary */
-                         WS_CHILD | WS_VISIBLE | CBS_OWNERDRAWFIXED | dwComboStyle,
-                         cs->y, cs->x, cs->cx, cs->cy, hwnd,
-                         (HMENU) GetWindowLongA (hwnd, GWL_ID),
-                         GetWindowLongA (hwnd, GWL_HINSTANCE), NULL);
-
-    /* 
+                         CBS_NOINTEGRALHEIGHT | CBS_DROPDOWNLIST |
+             /* was base and is necessary */
+             WS_CHILD | WS_VISIBLE | CBS_OWNERDRAWFIXED | dwComboStyle,
+             cs->y, cs->x, cs->cx, cs->cy, hwnd,
+             (HMENU) GetWindowLongA (hwnd, GWL_ID),
+             GetWindowLongA (hwnd, GWL_HINSTANCE), NULL);
+
+    /*
      * native does the following at this point according to trace:
      *  GetWindowThreadProcessId(hwndCombo,0)
@@ -1165 +1166 @@
 
     /*
-     * Setup a property to hold the pointer to the COMBOBOXEX 
+     * Setup a property to hold the pointer to the COMBOBOXEX
      * data structure.
      */
     test = GetPropA(infoPtr->hwndCombo, (LPCSTR)(LONG)ComboExInfo);
     if (!test || ((COMBOEX_INFO *)test != infoPtr)) {
-        SetPropA(infoPtr->hwndCombo, "CC32SubclassInfo", (LONG)infoPtr);
-    }
-    infoPtr->prevComboWndProc = (WNDPROC)SetWindowLongA(infoPtr->hwndCombo, 
-                                GWL_WNDPROC, (LONG)COMBOEX_ComboWndProc);
+    SetPropA(infoPtr->hwndCombo, "CC32SubclassInfo", (LONG)infoPtr);
+    }
+    infoPtr->prevComboWndProc = (WNDPROC)SetWindowLongA(infoPtr->hwndCombo,
+                            GWL_WNDPROC, (LONG)COMBOEX_ComboWndProc);
     infoPtr->font = SendMessageW (infoPtr->hwndCombo, WM_GETFONT, 0, 0);
 
@@ -1182 +1183 @@
      */
     if ((cs->style & CBS_DROPDOWNLIST) == CBS_DROPDOWN) {
-        infoPtr->hwndEdit = CreateWindowExA (0, "EDIT", "",
-                    WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | ES_AUTOHSCROLL,
-                    0, 0, 0, 0,  /* will set later */
-                    infoPtr->hwndCombo, 
-                    (HMENU) GetWindowLongA (hwnd, GWL_ID),
-                    GetWindowLongA (hwnd, GWL_HINSTANCE),
-                    NULL);
-
-        /* native does the following at this point according to trace:
-         *  GetWindowThreadProcessId(hwndEdit,0)
-         *  GetCurrentThreadId()
-         *  GetWindowThreadProcessId(hwndEdit, &???)
-         *  GetCurrentProcessId()
-         */
-
-        /*
-         * Setup a property to hold the pointer to the COMBOBOXEX 
-         * data structure.
-         */
-        test = GetPropA(infoPtr->hwndEdit, (LPCSTR)(LONG)ComboExInfo);
-        if (!test || ((COMBOEX_INFO *)test != infoPtr)) {
-            SetPropA(infoPtr->hwndEdit, "CC32SubclassInfo", (LONG)infoPtr);
-        }
-        infoPtr->prevEditWndProc = (WNDPROC)SetWindowLongA(infoPtr->hwndEdit, 
-                                 GWL_WNDPROC, (LONG)COMBOEX_EditWndProc);
-        infoPtr->font = SendMessageW (infoPtr->hwndCombo, WM_GETFONT, 0, 0);
+    infoPtr->hwndEdit = CreateWindowExA (0, "EDIT", "",
+            WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | ES_AUTOHSCROLL,
+            0, 0, 0, 0,  /* will set later */
+            infoPtr->hwndCombo,
+            (HMENU) GetWindowLongA (hwnd, GWL_ID),
+            GetWindowLongA (hwnd, GWL_HINSTANCE),
+            NULL);
+
+    /* native does the following at this point according to trace:
+     *  GetWindowThreadProcessId(hwndEdit,0)
+     *  GetCurrentThreadId()
+     *  GetWindowThreadProcessId(hwndEdit, &???)
+     *  GetCurrentProcessId()
+     */
+
+    /*
+     * Setup a property to hold the pointer to the COMBOBOXEX
+     * data structure.
+     */
+    test = GetPropA(infoPtr->hwndEdit, (LPCSTR)(LONG)ComboExInfo);
+    if (!test || ((COMBOEX_INFO *)test != infoPtr)) {
+        SetPropA(infoPtr->hwndEdit, "CC32SubclassInfo", (LONG)infoPtr);
+    }
+    infoPtr->prevEditWndProc = (WNDPROC)SetWindowLongA(infoPtr->hwndEdit,
+                 GWL_WNDPROC, (LONG)COMBOEX_EditWndProc);
+    infoPtr->font = SendMessageW (infoPtr->hwndCombo, WM_GETFONT, 0, 0);
     }
     else {
-        infoPtr->hwndEdit = 0;
-        infoPtr->font = 0;
+    infoPtr->hwndEdit = 0;
+    infoPtr->font = 0;
     }
 
@@ -1219 +1220 @@
      */
     if (!infoPtr->font) {
-        SystemParametersInfoA (SPI_GETICONTITLELOGFONT, sizeof(mylogfont), 
-                               &mylogfont, 0);
-        infoPtr->font = CreateFontIndirectA (&mylogfont);
+    SystemParametersInfoA (SPI_GETICONTITLELOGFONT, sizeof(mylogfont),
+                   &mylogfont, 0);
+    infoPtr->font = CreateFontIndirectA (&mylogfont);
     }
     SendMessageW (infoPtr->hwndCombo, WM_SETFONT, (WPARAM)infoPtr->font, 0);
     if (infoPtr->hwndEdit) {
-        SendMessageW (infoPtr->hwndEdit, WM_SETFONT, (WPARAM)infoPtr->font, 0);
-        SendMessageW (infoPtr->hwndEdit, EM_SETMARGINS, (WPARAM)EC_USEFONTINFO, 0);
+    SendMessageW (infoPtr->hwndEdit, WM_SETFONT, (WPARAM)infoPtr->font, 0);
+    SendMessageW (infoPtr->hwndEdit, EM_SETMARGINS, (WPARAM)EC_USEFONTINFO, 0);
     }
 
@@ -1237 +1238 @@
     GetWindowRect(infoPtr->hwndCombo, &cmbwrc);
     TRACE("EX window=(%d,%d)-(%d,%d) client=(%d,%d)-(%d,%d) CB wnd=(%d,%d)-(%d,%d)\n",
-          wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
-          clrc1.left, clrc1.top, clrc1.right, clrc1.bottom,
-          cmbwrc.left, cmbwrc.top, cmbwrc.right, cmbwrc.bottom);
-    SetWindowPos(infoPtr->hwndCombo, HWND_TOP, 
-                 0, 0, wnrc1.right-wnrc1.left, wnrc1.bottom-wnrc1.top,
-                 SWP_NOACTIVATE | SWP_NOREDRAW);
+      wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
+      clrc1.left, clrc1.top, clrc1.right, clrc1.bottom,
+      cmbwrc.left, cmbwrc.top, cmbwrc.right, cmbwrc.bottom);
+    SetWindowPos(infoPtr->hwndCombo, HWND_TOP,
+         0, 0, wnrc1.right-wnrc1.left, wnrc1.bottom-wnrc1.top,
+         SWP_NOACTIVATE | SWP_NOREDRAW);
 
     GetWindowRect(infoPtr->hwndCombo, &cmbwrc);
     TRACE("CB window=(%d,%d)-(%d,%d)\n",
-          cmbwrc.left, cmbwrc.top, cmbwrc.right, cmbwrc.bottom);
-    SetWindowPos(hwnd, HWND_TOP, 
-                 0, 0, cmbwrc.right-cmbwrc.left, cmbwrc.bottom-cmbwrc.top,
-                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
+      cmbwrc.left, cmbwrc.top, cmbwrc.right, cmbwrc.bottom);
+    SetWindowPos(hwnd, HWND_TOP,
+         0, 0, cmbwrc.right-cmbwrc.left, cmbwrc.bottom-cmbwrc.top,
+         SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
 
     COMBOEX_AdjustEditPos (infoPtr);
 
     /*
-     * Create an item structure to represent the data in the 
+     * Create an item structure to represent the data in the
      * EDIT control.
      */
@@ -1284 +1285 @@
     {
     case CBN_DROPDOWN:
-        SendMessageW (GetParent (hwnd), WM_COMMAND, wParam, 
-                             (LPARAM)hwnd);
-        /*
-         * from native trace of first dropdown after typing in URL in IE4 
-         *  CB_GETCURSEL(Combo)
-         *  GetWindowText(Edit)
-         *  CB_GETCURSEL(Combo)
-         *  CB_GETCOUNT(Combo)
-         *  CB_GETITEMDATA(Combo, n)
-         *  WM_NOTIFY(parent, CBEN_ENDEDITA|W)
-         *  CB_GETCURSEL(Combo)
-         *  CB_SETCURSEL(COMBOEX, n)
-         *  SetFocus(Combo)
-         * the rest is supposition  
-         */
-        cursel = SendMessageW (infoPtr->hwndCombo, CB_GETCURSEL, 0, 0);
-        if (cursel == -1) {
-            /* find match from edit against those in Combobox */
-            GetWindowTextW (infoPtr->hwndEdit, wintext, 520);
-            n = SendMessageW (infoPtr->hwndCombo, CB_GETCOUNT, 0, 0);
-            for (cursel = 0; cursel < n; cursel++){
-                item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo, 
-                                                     CB_GETITEMDATA, 
-                                                     cursel, 0);
-                if ((INT)item == CB_ERR) break;
-                if (lstrcmpiW(item->pszText, wintext) == 0) break;
-            }
-            if ((cursel == n) || ((INT)item == CB_ERR)) {
-                TRACE("failed to find match??? item=%p cursel=%d\n",
-                      item, cursel);
-                if (infoPtr->hwndEdit)
-                    SetFocus(infoPtr->hwndEdit);
-                return 0;
-            }
-        }
-        else {
-            item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo, 
-                                                 CB_GETITEMDATA, 
-                                                 cursel, 0);
-            if ((INT)item == CB_ERR) {
-                TRACE("failed to find match??? item=%p cursel=%d\n",
-                      item, cursel);
-                if (infoPtr->hwndEdit)
-                    SetFocus(infoPtr->hwndEdit);
-                return 0;
-            }
-        }
-
-        /* Save flags for testing and reset them */
-        oldflags = infoPtr->flags;
-        infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
-
-        if (oldflags & WCBE_ACTEDIT) {
-            cbeend.fChanged = (oldflags & WCBE_EDITCHG);
-            cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
-                                                 CB_GETCURSEL, 0, 0);
-            cbeend.iWhy = CBENF_DROPDOWN;
-
-            if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, item->pszText)) {
-                /* abort the change */
-                TRACE("Notify requested abort of change\n");
-                return 0;
-            }
-        }
-
-        /* if selection has changed the set the new current selection */
-        cursel = SendMessageW (infoPtr->hwndCombo, CB_GETCURSEL, 0, 0);
-        if ((oldflags & WCBE_EDITCHG) || (cursel != infoPtr->selected)) {
-            infoPtr->selected = cursel;
-            SendMessageW (hwnd, CB_SETCURSEL, cursel, 0);
-            SetFocus(infoPtr->hwndCombo);
-        }
-        return 0;
+    SendMessageW (GetParent (hwnd), WM_COMMAND, wParam,
+                 (LPARAM)hwnd);
+    /*
+     * from native trace of first dropdown after typing in URL in IE4
+     *  CB_GETCURSEL(Combo)
+     *  GetWindowText(Edit)
+     *  CB_GETCURSEL(Combo)
+     *  CB_GETCOUNT(Combo)
+     *  CB_GETITEMDATA(Combo, n)
+     *  WM_NOTIFY(parent, CBEN_ENDEDITA|W)
+     *  CB_GETCURSEL(Combo)
+     *  CB_SETCURSEL(COMBOEX, n)
+     *  SetFocus(Combo)
+     * the rest is supposition
+     */
+    cursel = SendMessageW (infoPtr->hwndCombo, CB_GETCURSEL, 0, 0);
+    if (cursel == -1) {
+        /* find match from edit against those in Combobox */
+        GetWindowTextW (infoPtr->hwndEdit, wintext, 520);
+        n = SendMessageW (infoPtr->hwndCombo, CB_GETCOUNT, 0, 0);
+        for (cursel = 0; cursel < n; cursel++){
+        item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo,
+                             CB_GETITEMDATA,
+                             cursel, 0);
+        if ((INT)item == CB_ERR) break;
+        if (lstrcmpiW(item->pszText, wintext) == 0) break;
+        }
+        if ((cursel == n) || ((INT)item == CB_ERR)) {
+        TRACE("failed to find match??? item=%p cursel=%d\n",
+              item, cursel);
+        if (infoPtr->hwndEdit)
+            SetFocus(infoPtr->hwndEdit);
+        return 0;
+        }
+    }
+    else {
+        item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo,
+                         CB_GETITEMDATA,
+                         cursel, 0);
+        if ((INT)item == CB_ERR) {
+        TRACE("failed to find match??? item=%p cursel=%d\n",
+              item, cursel);
+        if (infoPtr->hwndEdit)
+            SetFocus(infoPtr->hwndEdit);
+        return 0;
+        }
+    }
+
+    /* Save flags for testing and reset them */
+    oldflags = infoPtr->flags;
+    infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
+
+    if (oldflags & WCBE_ACTEDIT) {
+        cbeend.fChanged = (oldflags & WCBE_EDITCHG);
+        cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
+                         CB_GETCURSEL, 0, 0);
+        cbeend.iWhy = CBENF_DROPDOWN;
+
+        if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, item->pszText)) {
+        /* abort the change */
+        TRACE("Notify requested abort of change\n");
+        return 0;
+        }
+    }
+
+    /* if selection has changed the set the new current selection */
+    cursel = SendMessageW (infoPtr->hwndCombo, CB_GETCURSEL, 0, 0);
+    if ((oldflags & WCBE_EDITCHG) || (cursel != infoPtr->selected)) {
+        infoPtr->selected = cursel;
+        SendMessageW (hwnd, CB_SETCURSEL, cursel, 0);
+        SetFocus(infoPtr->hwndCombo);
+    }
+    return 0;
 
     case CBN_SELCHANGE:
-        /*
-         * CB_GETCURSEL(Combo)
-         * CB_GETITEMDATA(Combo)   < simulated by COMBOEX_FindItem
-         * lstrlenA
-         * WM_SETTEXT(Edit)
-         * WM_GETTEXTLENGTH(Edit)
-         * WM_GETTEXT(Edit)
-         * EM_SETSEL(Edit, 0,0)
-         * WM_GETTEXTLENGTH(Edit)
-         * WM_GETTEXT(Edit)
-         * EM_SETSEL(Edit, 0,len)
-         * return WM_COMMAND to parent
-         */
-        oldItem = SendMessageW (infoPtr->hwndCombo, CB_GETCURSEL, 0, 0);
-        if (!(item = COMBOEX_FindItem(infoPtr, oldItem))) {
-            ERR("item %d not found. Problem!\n", oldItem);
-            break;
-        }
-        infoPtr->selected = oldItem;
-        COMBOEX_SetEditText (infoPtr, item);
-        return SendMessageW (GetParent (hwnd), WM_COMMAND, wParam, 
-                             (LPARAM)hwnd);
+    /*
+     * CB_GETCURSEL(Combo)
+     * CB_GETITEMDATA(Combo)   < simulated by COMBOEX_FindItem
+     * lstrlenA
+     * WM_SETTEXT(Edit)
+     * WM_GETTEXTLENGTH(Edit)
+     * WM_GETTEXT(Edit)
+     * EM_SETSEL(Edit, 0,0)
+     * WM_GETTEXTLENGTH(Edit)
+     * WM_GETTEXT(Edit)
+     * EM_SETSEL(Edit, 0,len)
+     * return WM_COMMAND to parent
+     */
+    oldItem = SendMessageW (infoPtr->hwndCombo, CB_GETCURSEL, 0, 0);
+    if (!(item = COMBOEX_FindItem(infoPtr, oldItem))) {
+        ERR("item %d not found. Problem!\n", oldItem);
+        break;
+    }
+    infoPtr->selected = oldItem;
+    COMBOEX_SetEditText (infoPtr, item);
+    return SendMessageW (GetParent (hwnd), WM_COMMAND, wParam,
+                 (LPARAM)hwnd);
 
     case CBN_SELENDOK:
-        /* 
-         * We have to change the handle since we are the control
-         * issuing the message. IE4 depends on this.
-         */
-        return SendMessageW (GetParent (hwnd), WM_COMMAND, wParam, 
-                             (LPARAM)hwnd);
+    /*
+     * We have to change the handle since we are the control
+     * issuing the message. IE4 depends on this.
+     */
+    return SendMessageW (GetParent (hwnd), WM_COMMAND, wParam,
+                 (LPARAM)hwnd);
 
     case CBN_KILLFOCUS:
-        /*
-         * from native trace:
-         *
-         *  pass to parent
-         *  WM_GETTEXT(Edit, 104)
-         *  CB_GETCURSEL(Combo) rets -1
-         *  WM_NOTIFY(CBEN_ENDEDITA) with CBENF_KILLFOCUS
-         *  CB_GETCURSEL(Combo)
-         *  InvalidateRect(Combo, 0, 0)
-         *  return 0
-         */
-        SendMessageW (GetParent (hwnd), WM_COMMAND, wParam, 
-                             (LPARAM)hwnd);
-        if (infoPtr->flags & WCBE_ACTEDIT) {
-            GetWindowTextW (infoPtr->hwndEdit, wintext, 260);
-            cbeend.fChanged = (infoPtr->flags & WCBE_EDITCHG);
-            cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
-                                                 CB_GETCURSEL, 0, 0);
-            cbeend.iWhy = CBENF_KILLFOCUS;
-
-            infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
-            if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, wintext)) {
-                /* abort the change */
-                TRACE("Notify requested abort of change\n");
-                return 0;
-            }
-        }
-        /* possible CB_GETCURSEL */
-        InvalidateRect (infoPtr->hwndCombo, 0, 0);
-        return 0;
+    /*
+     * from native trace:
+     *
+     *  pass to parent
+     *  WM_GETTEXT(Edit, 104)
+     *  CB_GETCURSEL(Combo) rets -1
+     *  WM_NOTIFY(CBEN_ENDEDITA) with CBENF_KILLFOCUS
+     *  CB_GETCURSEL(Combo)
+     *  InvalidateRect(Combo, 0, 0)
+     *  return 0
+     */
+    SendMessageW (GetParent (hwnd), WM_COMMAND, wParam,
+                 (LPARAM)hwnd);
+    if (infoPtr->flags & WCBE_ACTEDIT) {
+        GetWindowTextW (infoPtr->hwndEdit, wintext, 260);
+        cbeend.fChanged = (infoPtr->flags & WCBE_EDITCHG);
+        cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
+                         CB_GETCURSEL, 0, 0);
+        cbeend.iWhy = CBENF_KILLFOCUS;
+
+        infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
+        if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, wintext)) {
+        /* abort the change */
+        TRACE("Notify requested abort of change\n");
+        return 0;
+        }
+    }
+    /* possible CB_GETCURSEL */
+    InvalidateRect (infoPtr->hwndCombo, 0, 0);
+    return 0;
 
     case CBN_CLOSEUP:
     default:
-        /* 
-         * We have to change the handle since we are the control
-         * issuing the message. IE4 depends on this.
-         * We also need to set the focus back to the Edit control
-         * after passing the command to the parent of the ComboEx.
-         */
-        lret = SendMessageW (GetParent (hwnd), WM_COMMAND, wParam, 
-                             (LPARAM)hwnd);
-        if (infoPtr->hwndEdit)
-            SetFocus(infoPtr->hwndEdit);
-        return lret;
+    /*
+     * We have to change the handle since we are the control
+     * issuing the message. IE4 depends on this.
+     * We also need to set the focus back to the Edit control
+     * after passing the command to the parent of the ComboEx.
+     */
+    lret = SendMessageW (GetParent (hwnd), WM_COMMAND, wParam,
+                 (LPARAM)hwnd);
+    if (infoPtr->hwndEdit)
+        SetFocus(infoPtr->hwndEdit);
+    return lret;
     }
     return 0;
@@ -1450 +1451 @@
 
     TRACE("CtlType=%08x, CtlID=%08x, itemID=%08x, hwnd=%x, data=%08lx\n",
-          dis->CtlType, dis->CtlID, dis->itemID, dis->hwndItem, dis->itemData);
+      dis->CtlType, dis->CtlID, dis->itemID, dis->hwndItem, dis->itemData);
 
     if ((dis->itemID >= infoPtr->nb_items) || (dis->itemID < 0)) return FALSE;
@@ -1458 +1459 @@
 
     if (i == dis->itemID) {
-        infoPtr->items = infoPtr->items->next;
+    infoPtr->items = infoPtr->items->next;
     }
     else {
-        item = olditem;
-        i--;
-
-        /* find the prior item in the list */
-        while (item->next && (i > dis->itemID)) {
-            item = (CBE_ITEMDATA *)item->next;
-            i--;
-        }
-        if (!item->next || (i != dis->itemID)) {
-            FIXME("COMBOBOXEX item structures broken. Please report!\n");
-            return FALSE;
-        }
-        olditem = item->next;
-        item->next = (CBE_ITEMDATA *)((CBE_ITEMDATA *)item->next)->next;
+    item = olditem;
+    i--;
+
+    /* find the prior item in the list */
+    while (item->next && (i > dis->itemID)) {
+        item = (CBE_ITEMDATA *)item->next;
+        i--;
+    }
+    if (!item->next || (i != dis->itemID)) {
+        FIXME("COMBOBOXEX item structures broken. Please report!\n");
+        return FALSE;
+    }
+    olditem = item->next;
+    item->next = (CBE_ITEMDATA *)((CBE_ITEMDATA *)item->next)->next;
     }
     infoPtr->nb_items--;
@@ -1482 +1483 @@
 
     if (olditem->pszText)
-        COMCTL32_Free(olditem->pszText);
+    COMCTL32_Free(olditem->pszText);
     COMCTL32_Free(olditem);
 
@@ -1510 +1511 @@
     /* dump the DRAWITEMSTRUCT if tracing "comboex" but not "message" */
     if (!TRACE_ON(message)) {
-        TRACE("DRAWITEMSTRUCT: CtlType=0x%08x CtlID=0x%08x\n", 
-              dis->CtlType, dis->CtlID);
-        TRACE("itemID=0x%08x itemAction=0x%08x itemState=0x%08x\n", 
-              dis->itemID, dis->itemAction, dis->itemState);
-        TRACE("hWnd=0x%04x hDC=0x%04x (%d,%d)-(%d,%d) itemData=0x%08lx\n",
-              dis->hwndItem, dis->hDC, dis->rcItem.left, 
-              dis->rcItem.top, dis->rcItem.right, dis->rcItem.bottom, 
-              dis->itemData);
+    TRACE("DRAWITEMSTRUCT: CtlType=0x%08x CtlID=0x%08x\n",
+          dis->CtlType, dis->CtlID);
+    TRACE("itemID=0x%08x itemAction=0x%08x itemState=0x%08x\n",
+          dis->itemID, dis->itemAction, dis->itemState);
+    TRACE("hWnd=0x%04x hDC=0x%04x (%d,%d)-(%d,%d) itemData=0x%08lx\n",
+          dis->hwndItem, dis->hDC, dis->rcItem.left,
+          dis->rcItem.top, dis->rcItem.right, dis->rcItem.bottom,
+          dis->itemData);
     }
 
@@ -1532 +1533 @@
     /*      though the list box or combo box has the focus.             */
     if (dis->itemID == 0xffffffff) {
-        if ( ( (dis->itemAction & ODA_FOCUS) && (dis->itemState & ODS_SELECTED)) ||
-             ( (dis->itemAction & (ODA_SELECT | ODA_DRAWENTIRE)) && (dis->itemState & ODS_FOCUS) ) ) { 
-
-            TRACE("drawing item -1 special focus, rect=(%d,%d)-(%d,%d)\n",
-                  dis->rcItem.left, dis->rcItem.top,
-                  dis->rcItem.right, dis->rcItem.bottom);
-        }
-        else if ((dis->CtlType == ODT_COMBOBOX) && 
-                 (dis->itemAction == ODA_DRAWENTIRE)) {
-            /* draw of edit control data */
-
-            /* testing */
-            {
-                RECT exrc, cbrc, edrc;
-                GetWindowRect (hwnd, &exrc);
-                GetWindowRect (infoPtr->hwndCombo, &cbrc);
-                edrc.left=edrc.top=edrc.right=edrc.bottom=-1;
-                if (infoPtr->hwndEdit)
-                    GetWindowRect (infoPtr->hwndEdit, &edrc);
-                TRACE("window rects ex=(%d,%d)-(%d,%d), cb=(%d,%d)-(%d,%d), ed=(%d,%d)-(%d,%d)\n",
-                      exrc.left, exrc.top, exrc.right, exrc.bottom,
-                      cbrc.left, cbrc.top, cbrc.right, cbrc.bottom,
-                      edrc.left, edrc.top, edrc.right, edrc.bottom);
-            }
-        }
-        else {
-            ERR("NOT drawing item  -1 special focus, rect=(%d,%d)-(%d,%d), action=%08x, state=%08x\n",
-                dis->rcItem.left, dis->rcItem.top,
-                dis->rcItem.right, dis->rcItem.bottom,
-                dis->itemAction, dis->itemState);
-            return 0;
-        }
+    if ( ( (dis->itemAction & ODA_FOCUS) && (dis->itemState & ODS_SELECTED)) ||
+         ( (dis->itemAction & (ODA_SELECT | ODA_DRAWENTIRE)) && (dis->itemState & ODS_FOCUS) ) ) {
+
+        TRACE("drawing item -1 special focus, rect=(%d,%d)-(%d,%d)\n",
+          dis->rcItem.left, dis->rcItem.top,
+          dis->rcItem.right, dis->rcItem.bottom);
+    }
+    else if ((dis->CtlType == ODT_COMBOBOX) &&
+         (dis->itemAction == ODA_DRAWENTIRE)) {
+        /* draw of edit control data */
+
+        /* testing */
+        {
+        RECT exrc, cbrc, edrc;
+        GetWindowRect (hwnd, &exrc);
+        GetWindowRect (infoPtr->hwndCombo, &cbrc);
+        edrc.left=edrc.top=edrc.right=edrc.bottom=-1;
+        if (infoPtr->hwndEdit)
+            GetWindowRect (infoPtr->hwndEdit, &edrc);
+        TRACE("window rects ex=(%d,%d)-(%d,%d), cb=(%d,%d)-(%d,%d), ed=(%d,%d)-(%d,%d)\n",
+              exrc.left, exrc.top, exrc.right, exrc.bottom,
+              cbrc.left, cbrc.top, cbrc.right, cbrc.bottom,
+              edrc.left, edrc.top, edrc.right, edrc.bottom);
+        }
+    }
+    else {
+        ERR("NOT drawing item  -1 special focus, rect=(%d,%d)-(%d,%d), action=%08x, state=%08x\n",
+        dis->rcItem.left, dis->rcItem.top,
+        dis->rcItem.right, dis->rcItem.bottom,
+        dis->itemAction, dis->itemState);
+        return 0;
+    }
     }
 
     /* If draw item is -1 (edit control) setup the item pointer */
     if (dis->itemID == 0xffffffff) {
-        CHAR str[260];
-        INT wlen, alen;
-
-        item = infoPtr->edit;
-
-        if (infoPtr->hwndEdit) {
-
-            /* free previous text of edit item */
-            if (item->pszText) {
-                COMCTL32_Free(item->pszText);
-                item->pszText = 0;
-                item->mask &= ~CBEIF_TEXT;
-            }
-            alen = SendMessageA (infoPtr->hwndEdit, WM_GETTEXT, 260, (LPARAM)&str);
-            TRACE("edit control hwndEdit=%0x, text len=%d str=<%s>\n",
-                  infoPtr->hwndEdit, alen, str);
-            if (alen > 0) {
-                item->mask |= CBEIF_TEXT;
-                wlen = MultiByteToWideChar (CP_ACP, 0, str, -1, NULL, 0);
-                if (wlen > 0) {
-                    item->pszText = (LPWSTR)COMCTL32_Alloc ((wlen + 1)*sizeof(WCHAR));
-                    MultiByteToWideChar (CP_ACP, 0, str, -1, item->pszText, wlen);
-                }
-            }
-        }
+    CHAR str[260];
+    INT wlen, alen;
+
+    item = infoPtr->edit;
+
+    if (infoPtr->hwndEdit) {
+
+        /* free previous text of edit item */
+        if (item->pszText) {
+        COMCTL32_Free(item->pszText);
+        item->pszText = 0;
+        item->mask &= ~CBEIF_TEXT;
+        }
+        alen = SendMessageA (infoPtr->hwndEdit, WM_GETTEXT, 260, (LPARAM)&str);
+        TRACE("edit control hwndEdit=%0x, text len=%d str=<%s>\n",
+          infoPtr->hwndEdit, alen, str);
+        if (alen > 0) {
+        item->mask |= CBEIF_TEXT;
+        wlen = MultiByteToWideChar (CP_ACP, 0, str, -1, NULL, 0);
+        if (wlen > 0) {
+            item->pszText = (LPWSTR)COMCTL32_Alloc ((wlen + 1)*sizeof(WCHAR));
+            MultiByteToWideChar (CP_ACP, 0, str, -1, item->pszText, wlen);
+        }
+        }
+    }
     }
 
     /* if the item pointer is not set, then get the data and locate it */
     if (!item) {
-        item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo,
-                             CB_GETITEMDATA, (WPARAM)dis->itemID, 0);
-        if (item == (CBE_ITEMDATA *)CB_ERR)
-            {
-                FIXME("invalid item for id %d \n",dis->itemID);
-                return 0;
-            }
+    item = (CBE_ITEMDATA *)SendMessageW (infoPtr->hwndCombo,
+                 CB_GETITEMDATA, (WPARAM)dis->itemID, 0);
+    if (item == (CBE_ITEMDATA *)CB_ERR)
+        {
+        FIXME("invalid item for id %d \n",dis->itemID);
+        return 0;
+        }
     }
 
@@ -1612 +1613 @@
         xbase += (item->iIndent * CBE_INDENT);
     if (item->mask & CBEIF_IMAGE) {
-        ImageList_GetImageInfo(infoPtr->himl, item->iImage, &iinfo);
-        xioff = (iinfo.rcImage.right - iinfo.rcImage.left + CBE_SEP);
+    ImageList_GetImageInfo(infoPtr->himl, item->iImage, &iinfo);
+    xioff = (iinfo.rcImage.right - iinfo.rcImage.left + CBE_SEP);
     }
 
@@ -1619 +1620 @@
     case ODA_FOCUS:
         if (dis->itemState & ODS_SELECTED /*1*/) {
-            if ((item->mask & CBEIF_TEXT) && item->pszText) {
-                RECT rect2;
-
-                len = strlenW (item->pszText);
-                GetTextExtentPointW (dis->hDC, item->pszText, len, &txtsize);
-                rect.left = xbase + xioff - 1;
-                rect.right = rect.left + txtsize.cx + 2;
-                rect.top = dis->rcItem.top;
-                rect.bottom = dis->rcItem.bottom;
-                GetClipBox (dis->hDC, &rect2);
-                TRACE("drawing item %d focus, rect=(%d,%d)-(%d,%d)\n",
-                      dis->itemID, rect.left, rect.top,
-                      rect.right, rect.bottom);
-                TRACE("                      clip=(%d,%d)-(%d,%d)\n",
-                      rect2.left, rect2.top,
-                      rect2.right, rect2.bottom);
-
-                DrawFocusRect(dis->hDC, &rect);
-            }
-            else {
-                FIXME("ODA_FOCUS and ODS_SELECTED but no text\n");
-            }
-        }
-        else {
-            FIXME("ODA_FOCUS but not ODS_SELECTED\n");
-        }
+        if ((item->mask & CBEIF_TEXT) && item->pszText) {
+        RECT rect2;
+
+            len = strlenW (item->pszText);
+        GetTextExtentPointW (dis->hDC, item->pszText, len, &txtsize);
+        rect.left = xbase + xioff - 1;
+        rect.right = rect.left + txtsize.cx + 2;
+        rect.top = dis->rcItem.top;
+        rect.bottom = dis->rcItem.bottom;
+        GetClipBox (dis->hDC, &rect2);
+        TRACE("drawing item %d focus, rect=(%d,%d)-(%d,%d)\n",
+              dis->itemID, rect.left, rect.top,
+              rect.right, rect.bottom);
+        TRACE("                      clip=(%d,%d)-(%d,%d)\n",
+              rect2.left, rect2.top,
+              rect2.right, rect2.bottom);
+
+        DrawFocusRect(dis->hDC, &rect);
+        }
+        else {
+        FIXME("ODA_FOCUS and ODS_SELECTED but no text\n");
+        }
+    }
+    else {
+        FIXME("ODA_FOCUS but not ODS_SELECTED\n");
+    }
         break;
     case ODA_SELECT:
     case ODA_DRAWENTIRE:
         drawimage = -1;
-        drawstate = ILD_NORMAL;
-        if (!(infoPtr->dwExtStyle & CBES_EX_NOEDITIMAGE)) {
-            if (item->mask & CBEIF_IMAGE) 
-                drawimage = item->iImage;
-            if (dis->itemState & ODS_COMBOEXLBOX) {
-                /* drawing listbox entry */
-                if (dis->itemState & ODS_SELECTED) {
-                    if (item->mask & CBEIF_SELECTEDIMAGE)
-                        drawimage = item->iSelectedImage;
-                    drawstate = ILD_SELECTED;
-                }
-            }
-            else {
-                /* drawing combo/edit entry */
-                if (infoPtr->hwndEdit) {
-                    /* if we have an edit control, the slave the 
-                     * selection state to the Edit focus state 
-                     */
-                    if (infoPtr->flags & WCBE_EDITFOCUSED) {
-                        if (item->mask & CBEIF_SELECTEDIMAGE)
-                            drawimage = item->iSelectedImage;
-                        drawstate = ILD_SELECTED;
-                    }
-                }
-                else {
-                    /* if we don't have an edit control, use 
-                     * the requested state.
-                     */
-                    if (dis->itemState & ODS_SELECTED) {
-                        if (item->mask & CBEIF_SELECTEDIMAGE)
-                            drawimage = item->iSelectedImage;
-                        drawstate = ILD_SELECTED;
-                    }
-                }
-            }
-        }
-        if (drawimage != -1) {
-            TRACE("drawing image state=%d\n", dis->itemState & ODS_SELECTED);
-            ImageList_Draw (infoPtr->himl, drawimage, dis->hDC, 
-                            xbase, dis->rcItem.top, drawstate);
-        }
-
-        /* setup pointer to text to be drawn */
-        if ((item->mask & CBEIF_TEXT) && item->pszText)
-            str = item->pszText;
-        else
-            str = (LPWSTR) L"";
-
-        /* now draw the text */
-        len = lstrlenW (str);
-        GetTextExtentPointW (dis->hDC, str, len, &txtsize);
-        nbkc = GetSysColor ((dis->itemState & ODS_SELECTED) ?
-                            COLOR_HIGHLIGHT : COLOR_WINDOW);
-        SetBkColor (dis->hDC, nbkc);
-        ntxc = GetSysColor ((dis->itemState & ODS_SELECTED) ?
-                            COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT);
-        SetTextColor (dis->hDC, ntxc);
-        x = xbase + xioff;
-        y = dis->rcItem.top +
-            (dis->rcItem.bottom - dis->rcItem.top - txtsize.cy) / 2;
-        rect.left = x;
-        rect.right = x + txtsize.cx;
-        rect.top = dis->rcItem.top + 1;
-        rect.bottom = dis->rcItem.bottom - 1;
-        TRACE("drawing item %d text, rect=(%d,%d)-(%d,%d)\n",
-              dis->itemID, rect.left, rect.top, rect.right, rect.bottom);
-        ExtTextOutW (dis->hDC, x, y, ETO_OPAQUE | ETO_CLIPPED,
-                     &rect, str, len, 0);
-        if (dis->itemState & ODS_FOCUS) {
-            rect.top -= 1;
-            rect.bottom += 1;
-            rect.left -= 1;
-            rect.right += 1;
-            TRACE("drawing item %d focus after text, rect=(%d,%d)-(%d,%d)\n",
-                  dis->itemID, rect.left, rect.top, rect.right, rect.bottom);
-            DrawFocusRect (dis->hDC, &rect);
-        }
-        break;
+    drawstate = ILD_NORMAL;
+    if (!(infoPtr->dwExtStyle & CBES_EX_NOEDITIMAGE)) {
+        if (item->mask & CBEIF_IMAGE)
+        drawimage = item->iImage;
+        if (dis->itemState & ODS_COMBOEXLBOX) {
+        /* drawing listbox entry */
+        if (dis->itemState & ODS_SELECTED) {
+            if (item->mask & CBEIF_SELECTEDIMAGE)
+            drawimage = item->iSelectedImage;
+            drawstate = ILD_SELECTED;
+        }
+        }
+        else {
+        /* drawing combo/edit entry */
+        if (infoPtr->hwndEdit) {
+            /* if we have an edit control, the slave the
+                     * selection state to the Edit focus state
+             */
+            if (infoPtr->flags & WCBE_EDITFOCUSED) {
+            if (item->mask & CBEIF_SELECTEDIMAGE)
+                drawimage = item->iSelectedImage;
+            drawstate = ILD_SELECTED;
+            }
+        }
+        else {
+            /* if we don't have an edit control, use
+             * the requested state.
+             */
+            if (dis->itemState & ODS_SELECTED) {
+            if (item->mask & CBEIF_SELECTEDIMAGE)
+                drawimage = item->iSelectedImage;
+            drawstate = ILD_SELECTED;
+            }
+        }
+        }
+    }
+    if (drawimage != -1) {
+        TRACE("drawing image state=%d\n", dis->itemState & ODS_SELECTED);
+        ImageList_Draw (infoPtr->himl, drawimage, dis->hDC,
+                xbase, dis->rcItem.top, drawstate);
+    }
+
+    /* setup pointer to text to be drawn */
+    if ((item->mask & CBEIF_TEXT) && item->pszText)
+        str = item->pszText;
+    else
+        str = (LPWSTR) L"";
+
+    /* now draw the text */
+    len = lstrlenW (str);
+    GetTextExtentPointW (dis->hDC, str, len, &txtsize);
+    nbkc = GetSysColor ((dis->itemState & ODS_SELECTED) ?
+                COLOR_HIGHLIGHT : COLOR_WINDOW);
+    SetBkColor (dis->hDC, nbkc);
+    ntxc = GetSysColor ((dis->itemState & ODS_SELECTED) ?
+                COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT);
+    SetTextColor (dis->hDC, ntxc);
+    x = xbase + xioff;
+    y = dis->rcItem.top +
+        (dis->rcItem.bottom - dis->rcItem.top - txtsize.cy) / 2;
+    rect.left = x;
+    rect.right = x + txtsize.cx;
+    rect.top = dis->rcItem.top + 1;
+    rect.bottom = dis->rcItem.bottom - 1;
+    TRACE("drawing item %d text, rect=(%d,%d)-(%d,%d)\n",
+          dis->itemID, rect.left, rect.top, rect.right, rect.bottom);
+    ExtTextOutW (dis->hDC, x, y, ETO_OPAQUE | ETO_CLIPPED,
+             &rect, str, len, 0);
+    if (dis->itemState & ODS_FOCUS) {
+        rect.top -= 1;
+        rect.bottom += 1;
+        rect.left -= 1;
+        rect.right += 1;
+        TRACE("drawing item %d focus after text, rect=(%d,%d)-(%d,%d)\n",
+          dis->itemID, rect.left, rect.top, rect.right, rect.bottom);
+        DrawFocusRect (dis->hDC, &rect);
+    }
+    break;
     default:
-        FIXME("unknown action hwnd=%08x, wparam=%08x, lparam=%08lx, action=%d\n", 
-              hwnd, wParam, lParam, dis->itemAction);
+        FIXME("unknown action hwnd=%08x, wparam=%08x, lparam=%08lx, action=%d\n",
+          hwnd, wParam, lParam, dis->itemAction);
     }
 
@@ -1742 +1743 @@
 
     if (infoPtr->hwndCombo)
-        DestroyWindow (infoPtr->hwndCombo);
+    DestroyWindow (infoPtr->hwndCombo);
 
     if (infoPtr->edit) {
-        COMCTL32_Free (infoPtr->edit);
-        infoPtr->edit = 0;
+    COMCTL32_Free (infoPtr->edit);
+    infoPtr->edit = 0;
     }
 
@@ -1752 +1753 @@
         CBE_ITEMDATA *this, *next;
 
-        this = infoPtr->items;
-        while (this) {
-            next = (CBE_ITEMDATA *)this->next;
-            if ((this->mask & CBEIF_TEXT) && this->pszText)
-                COMCTL32_Free (this->pszText);
-            COMCTL32_Free (this);
-            this = next;
-        }
+    this = infoPtr->items;
+    while (this) {
+        next = (CBE_ITEMDATA *)this->next;
+        if ((this->mask & CBEIF_TEXT) && this->pszText)
+            COMCTL32_Free (this->pszText);
+        COMCTL32_Free (this);
+        this = next;
+    }
     }
 
@@ -1785 +1786 @@
 
     TRACE("adjusted height hwnd=%08x, height=%d\n",
-          hwnd, mis->itemHeight);
+      hwnd, mis->itemHeight);
 
     return 0;
@@ -1800 +1801 @@
     newstyle = oldstyle & ~(WS_VSCROLL | WS_HSCROLL);
     if (newstyle != oldstyle) {
-        TRACE("req style %08lx, reseting style %08lx\n",
-              oldstyle, newstyle);
-        SetWindowLongA (hwnd, GWL_STYLE, newstyle);
+    TRACE("req style %08lx, reseting style %08lx\n",
+          oldstyle, newstyle);
+    SetWindowLongA (hwnd, GWL_STYLE, newstyle);
     }
     return 1;
@@ -1815 +1816 @@
 
     if (lParam == NF_REQUERY) {
-        i = SendMessageA(GetParent (hwnd),
-                         WM_NOTIFYFORMAT, infoPtr->hwndSelf, NF_QUERY);
-        if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
-            ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
-                i);
-            i = NFR_ANSI;
-        }
-        infoPtr->NtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
-        return (LRESULT)i;
+    i = SendMessageA(GetParent (hwnd),
+             WM_NOTIFYFORMAT, infoPtr->hwndSelf, NF_QUERY);
+    if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
+        ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
+        i);
+        i = NFR_ANSI;
+    }
+    infoPtr->NtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
+    return (LRESULT)i;
     }
     return (LRESULT)((infoPtr->bUnicode) ? NFR_UNICODE : NFR_ANSI);
@@ -1837 +1838 @@
     GetWindowRect (hwnd, &rect);
     TRACE("my rect (%d,%d)-(%d,%d)\n",
-          rect.left, rect.top, rect.right, rect.bottom);
+      rect.left, rect.top, rect.right, rect.bottom);
 
     MoveWindow (infoPtr->hwndCombo, 0, 0, rect.right -rect.left,
-                  rect.bottom - rect.top, TRUE);
+          rect.bottom - rect.top, TRUE);
 
     COMBOEX_AdjustEditPos (infoPtr);
@@ -1862 +1863 @@
     /* width is winpos value + border width of comboex */
     width = wp->cx
-            + (cbx_wrect.right-cbx_wrect.left) 
-            - (cbx_crect.right-cbx_crect.left); 
+        + (cbx_wrect.right-cbx_wrect.left)
+            - (cbx_crect.right-cbx_crect.left);
 
     TRACE("winpos=(%d,%d %dx%d) flags=0x%08x\n",
-          wp->x, wp->y, wp->cx, wp->cy, wp->flags);
+      wp->x, wp->y, wp->cx, wp->cy, wp->flags);
     TRACE("EX window=(%d,%d)-(%d,%d), client=(%d,%d)-(%d,%d)\n",
-          cbx_wrect.left, cbx_wrect.top, cbx_wrect.right, cbx_wrect.bottom,
-          cbx_crect.left, cbx_crect.top, cbx_crect.right, cbx_crect.bottom);
+      cbx_wrect.left, cbx_wrect.top, cbx_wrect.right, cbx_wrect.bottom,
+      cbx_crect.left, cbx_crect.top, cbx_crect.right, cbx_crect.bottom);
     TRACE("CB window=(%d,%d)-(%d,%d), EX setting=(0,0)-(%d,%d)\n",
-          cb_wrect.left, cb_wrect.top, cb_wrect.right, cb_wrect.bottom,
-          width, cb_wrect.bottom-cb_wrect.top);
+      cb_wrect.left, cb_wrect.top, cb_wrect.right, cb_wrect.bottom,
+      width, cb_wrect.bottom-cb_wrect.top);
 
     if (width) SetWindowPos (infoPtr->hwndCombo, HWND_TOP, 0, 0,
-                             width,
-                             cb_wrect.bottom-cb_wrect.top,
-                             SWP_NOACTIVATE);
+                 width,
+                 cb_wrect.bottom-cb_wrect.top,
+                 SWP_NOACTIVATE);
 
     GetWindowRect (infoPtr->hwndCombo, &cb_wrect);
@@ -1883 +1884 @@
     /* height is combo window height plus border width of comboex */
     height =   (cb_wrect.bottom-cb_wrect.top)
-             + (cbx_wrect.bottom-cbx_wrect.top)
+         + (cbx_wrect.bottom-cbx_wrect.top)
              - (cbx_crect.bottom-cbx_crect.top);
     if (wp->cy < height) wp->cy = height;
     if (infoPtr->hwndEdit) {
-        COMBOEX_AdjustEditPos (infoPtr);
-        InvalidateRect (infoPtr->hwndCombo, 0, TRUE);
+    COMBOEX_AdjustEditPos (infoPtr);
+    InvalidateRect (infoPtr->hwndCombo, 0, TRUE);
     }
 
@@ -1906 +1907 @@
     LRESULT lret;
 
-    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx, info_ptr=%p\n", 
-          hwnd, uMsg, wParam, lParam, infoPtr);
+    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx, info_ptr=%p\n",
+      hwnd, uMsg, wParam, lParam, infoPtr);
 
     if (!infoPtr) return 0;
@@ -1915 +1916 @@
 
     case WM_CHAR:
-            /* handle (ignore) the return character */
-            if (wParam == VK_RETURN) return 0;
-            /* all other characters pass into the real Edit */
-            return CallWindowProcA (infoPtr->prevEditWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
+        /* handle (ignore) the return character */
+        if (wParam == VK_RETURN) return 0;
+        /* all other characters pass into the real Edit */
+        return CallWindowProcA (infoPtr->prevEditWndProc,
+                   hwnd, uMsg, wParam, lParam);
 
     case WM_ERASEBKGND:
-            /*
-             * The following was determined by traces of the native 
-             */
+        /*
+         * The following was determined by traces of the native
+         */
             hDC = (HDC) wParam;
-            nbkc = GetSysColor (COLOR_WINDOW);
-            obkc = SetBkColor (hDC, nbkc);
+        nbkc = GetSysColor (COLOR_WINDOW);
+        obkc = SetBkColor (hDC, nbkc);
             GetClientRect (hwnd, &rect);
-            TRACE("erasing (%d,%d)-(%d,%d)\n",
-                  rect.left, rect.top, rect.right, rect.bottom);
-            ExtTextOutW (hDC, 0, 0, ETO_OPAQUE, &rect, 0, 0, 0);
+        TRACE("erasing (%d,%d)-(%d,%d)\n",
+          rect.left, rect.top, rect.right, rect.bottom);
+        ExtTextOutW (hDC, 0, 0, ETO_OPAQUE, &rect, 0, 0, 0);
             SetBkColor (hDC, obkc);
-            return CallWindowProcA (infoPtr->prevEditWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
+        return CallWindowProcA (infoPtr->prevEditWndProc,
+                   hwnd, uMsg, wParam, lParam);
 
     case WM_KEYDOWN: {
-            INT oldItem, selected;
-            CBE_ITEMDATA *item;
-
-            switch ((INT)wParam)
-            {
-            case VK_ESCAPE:
-                /* native version seems to do following for COMBOEX */
-                /*
-                 *   GetWindowTextA(Edit,&?, 0x104)             x
-                 *   CB_GETCURSEL to Combo rets -1              x
-                 *   WM_NOTIFY to COMBOEX parent (rebar)        x
-                 *     (CBEN_ENDEDIT{A|W} 
-                 *      fChanged = FALSE                        x
-                 *      inewSelection = -1                      x
-                 *      txt="www.hoho"                          x
-                 *      iWhy = 3                                x
-                 *   CB_GETCURSEL to Combo rets -1              x
-                 *   InvalidateRect(Combo, 0)                   x
-                 *   WM_SETTEXT to Edit                         x
-                 *   EM_SETSEL to Edit (0,0)                    x
-                 *   EM_SETSEL to Edit (0,-1)                   x
-                 *   RedrawWindow(Combo, 0, 0, 5)               x
-                 */
-                TRACE("special code for VK_ESCAPE\n");
-
-                GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
-
-                infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
-                cbeend.fChanged = FALSE;
-                cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
-                                                     CB_GETCURSEL, 0, 0);
-                cbeend.iWhy = CBENF_ESCAPE;
-
-                if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text)) {
-                    /* abort the change */
-                    TRACE("Notify requested abort of change\n");
-                    return 0;
-                }
-                oldItem = SendMessageW (infoPtr->hwndCombo,CB_GETCURSEL, 0, 0);
-                InvalidateRect (infoPtr->hwndCombo, 0, 0);
-                if (!(item = COMBOEX_FindItem(infoPtr, oldItem))) {
-                    ERR("item %d not found. Problem!\n", oldItem);
-                    break;
-                }
-                infoPtr->selected = oldItem;              
-                COMBOEX_SetEditText (infoPtr, item);
-                RedrawWindow (infoPtr->hwndCombo, 0, 0, RDW_ERASE | 
-                              RDW_INVALIDATE);
-                break;
-
-            case VK_RETURN:
-                /* native version seems to do following for COMBOEX */
-                /*
-                 *   GetWindowTextA(Edit,&?, 0x104)             x
-                 *   CB_GETCURSEL to Combo  rets -1             x
-                 *   CB_GETCOUNT to Combo  rets 0
-                 *   if >0 loop 
-                 *       CB_GETITEMDATA to match
-                 * *** above 3 lines simulated by FindItem      x  
-                 *   WM_NOTIFY to COMBOEX parent (rebar)        x
-                 *     (CBEN_ENDEDIT{A|W}                       x
-                 *        fChanged = TRUE (-1)                  x
-                 *        iNewSelection = -1 or selected        x
-                 *        txt=                                  x
-                 *        iWhy = 2 (CBENF_RETURN)               x
-                 *   CB_GETCURSEL to Combo  rets -1             x
-                 *   if -1 send CB_SETCURSEL to Combo -1        x
-                 *   InvalidateRect(Combo, 0, 0)                x
-                 *   SetFocus(Edit)                             x
-                 *   CallWindowProc(406615a8, Edit, 0x100, 0xd, 0x1c0001)
-                 */
-
-                TRACE("special code for VK_RETURN\n");
-
-                GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
-
-                infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
-                selected = SendMessageW (infoPtr->hwndCombo,
-                                         CB_GETCURSEL, 0, 0);
-
-                if (selected != -1) {
-                    item = COMBOEX_FindItem (infoPtr, selected);
-                    TRACE("handling VK_RETURN, selected = %d, selected_text=%s\n",
-                          selected, debugstr_w(item->pszText));
-                    TRACE("handling VK_RETURN, edittext=%s\n",
-                          debugstr_w(edit_text));
-                    if (lstrcmpiW (item->pszText, edit_text)) {
-                        /* strings not equal -- indicate edit has changed */
-                        selected = -1;
-                    }
-                }
-
-                cbeend.iNewSelection = selected;
-                cbeend.fChanged = TRUE; 
-                cbeend.iWhy = CBENF_RETURN;
-                if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text)) {
-                    /* abort the change, restore previous */
-                    TRACE("Notify requested abort of change\n");
-                    COMBOEX_SetEditText (infoPtr, infoPtr->edit);
-                    RedrawWindow (infoPtr->hwndCombo, 0, 0, RDW_ERASE | 
-                                  RDW_INVALIDATE);
-                    return 0;
-                }
-                oldItem = SendMessageW (infoPtr->hwndCombo,CB_GETCURSEL, 0, 0);
-                if (oldItem != -1) {
-                    /* if something is selected, then deselect it */
-                    SendMessageW (infoPtr->hwndCombo, CB_SETCURSEL, 
-                                  (WPARAM)-1, 0);
-                }
-                InvalidateRect (infoPtr->hwndCombo, 0, 0);
-                SetFocus(infoPtr->hwndEdit);
-                break;
-
-            default:
-                return CallWindowProcA (infoPtr->prevEditWndProc,
-                                       hwnd, uMsg, wParam, lParam);
-            }
-            return 0;
+        INT oldItem, selected;
+        CBE_ITEMDATA *item;
+
+        switch ((INT)wParam)
+        {
+        case VK_ESCAPE:
+        /* native version seems to do following for COMBOEX */
+        /*
+         *   GetWindowTextA(Edit,&?, 0x104)             x
+         *   CB_GETCURSEL to Combo rets -1              x
+         *   WM_NOTIFY to COMBOEX parent (rebar)        x
+         *     (CBEN_ENDEDIT{A|W}
+         *      fChanged = FALSE                        x
+         *      inewSelection = -1                      x
+         *      txt="www.hoho"                          x
+         *      iWhy = 3                                x
+         *   CB_GETCURSEL to Combo rets -1              x
+         *   InvalidateRect(Combo, 0)                   x
+         *   WM_SETTEXT to Edit                         x
+         *   EM_SETSEL to Edit (0,0)                    x
+         *   EM_SETSEL to Edit (0,-1)                   x
+         *   RedrawWindow(Combo, 0, 0, 5)               x
+         */
+        TRACE("special code for VK_ESCAPE\n");
+
+        GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
+
+        infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
+        cbeend.fChanged = FALSE;
+        cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
+                             CB_GETCURSEL, 0, 0);
+        cbeend.iWhy = CBENF_ESCAPE;
+
+        if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text)) {
+            /* abort the change */
+            TRACE("Notify requested abort of change\n");
+            return 0;
+        }
+        oldItem = SendMessageW (infoPtr->hwndCombo,CB_GETCURSEL, 0, 0);
+        InvalidateRect (infoPtr->hwndCombo, 0, 0);
+        if (!(item = COMBOEX_FindItem(infoPtr, oldItem))) {
+            ERR("item %d not found. Problem!\n", oldItem);
+            break;
+        }
+        infoPtr->selected = oldItem;
+        COMBOEX_SetEditText (infoPtr, item);
+        RedrawWindow (infoPtr->hwndCombo, 0, 0, RDW_ERASE |
+                  RDW_INVALIDATE);
+        break;
+
+        case VK_RETURN:
+        /* native version seems to do following for COMBOEX */
+        /*
+         *   GetWindowTextA(Edit,&?, 0x104)             x
+         *   CB_GETCURSEL to Combo  rets -1             x
+         *   CB_GETCOUNT to Combo  rets 0
+         *   if >0 loop
+         *       CB_GETITEMDATA to match
+         * *** above 3 lines simulated by FindItem      x
+         *   WM_NOTIFY to COMBOEX parent (rebar)        x
+         *     (CBEN_ENDEDIT{A|W}                       x
+         *        fChanged = TRUE (-1)                  x
+         *        iNewSelection = -1 or selected        x
+         *        txt=                                  x
+         *        iWhy = 2 (CBENF_RETURN)               x
+         *   CB_GETCURSEL to Combo  rets -1             x
+         *   if -1 send CB_SETCURSEL to Combo -1        x
+         *   InvalidateRect(Combo, 0, 0)                x
+         *   SetFocus(Edit)                             x
+         *   CallWindowProc(406615a8, Edit, 0x100, 0xd, 0x1c0001)
+         */
+
+        TRACE("special code for VK_RETURN\n");
+
+        GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
+
+        infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
+        selected = SendMessageW (infoPtr->hwndCombo,
+                     CB_GETCURSEL, 0, 0);
+
+        if (selected != -1) {
+            item = COMBOEX_FindItem (infoPtr, selected);
+            TRACE("handling VK_RETURN, selected = %d, selected_text=%s\n",
+              selected, debugstr_w(item->pszText));
+            TRACE("handling VK_RETURN, edittext=%s\n",
+              debugstr_w(edit_text));
+            if (lstrcmpiW (item->pszText, edit_text)) {
+            /* strings not equal -- indicate edit has changed */
+            selected = -1;
             }
+        }
+
+        cbeend.iNewSelection = selected;
+        cbeend.fChanged = TRUE;
+        cbeend.iWhy = CBENF_RETURN;
+        if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text)) {
+            /* abort the change, restore previous */
+            TRACE("Notify requested abort of change\n");
+            COMBOEX_SetEditText (infoPtr, infoPtr->edit);
+            RedrawWindow (infoPtr->hwndCombo, 0, 0, RDW_ERASE |
+                  RDW_INVALIDATE);
+            return 0;
+        }
+        oldItem = SendMessageW (infoPtr->hwndCombo,CB_GETCURSEL, 0, 0);
+        if (oldItem != -1) {
+            /* if something is selected, then deselect it */
+            SendMessageW (infoPtr->hwndCombo, CB_SETCURSEL,
+                  (WPARAM)-1, 0);
+        }
+        InvalidateRect (infoPtr->hwndCombo, 0, 0);
+        SetFocus(infoPtr->hwndEdit);
+        break;
+
+        default:
+        return CallWindowProcA (infoPtr->prevEditWndProc,
+                       hwnd, uMsg, wParam, lParam);
+        }
+        return 0;
+            }
 
     case WM_SETFOCUS:
-            /* remember the focus to set state of icon */
-            lret = CallWindowProcA (infoPtr->prevEditWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
-            infoPtr->flags |= WCBE_EDITFOCUSED;
-            return lret;
+        /* remember the focus to set state of icon */
+        lret = CallWindowProcA (infoPtr->prevEditWndProc,
+                   hwnd, uMsg, wParam, lParam);
+        infoPtr->flags |= WCBE_EDITFOCUSED;
+        return lret;
 
     case WM_KILLFOCUS:
-            /* 
-             * do NOTIFY CBEN_ENDEDIT with CBENF_KILLFOCUS
-             */
-            infoPtr->flags &= ~WCBE_EDITFOCUSED;
-            if (infoPtr->flags & WCBE_ACTEDIT) {
-                infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
-
-                GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
-                cbeend.fChanged = FALSE;
-                cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
-                                                     CB_GETCURSEL, 0, 0);
-                cbeend.iWhy = CBENF_KILLFOCUS;
-
-                COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text);
-            }
-            /* fall through */
+        /*
+         * do NOTIFY CBEN_ENDEDIT with CBENF_KILLFOCUS
+         */
+        infoPtr->flags &= ~WCBE_EDITFOCUSED;
+        if (infoPtr->flags & WCBE_ACTEDIT) {
+        infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
+
+        GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
+        cbeend.fChanged = FALSE;
+        cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
+                             CB_GETCURSEL, 0, 0);
+        cbeend.iWhy = CBENF_KILLFOCUS;
+
+        COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text);
+        }
+        /* fall through */
 
     default:
-            return CallWindowProcA (infoPtr->prevEditWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
+        return CallWindowProcA (infoPtr->prevEditWndProc,
+                   hwnd, uMsg, wParam, lParam);
     }
     return 0;
@@ -2102 +2103 @@
     WCHAR edit_text[260];
 
-    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx, info_ptr=%p\n", 
-          hwnd, uMsg, wParam, lParam, infoPtr);
+    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx, info_ptr=%p\n",
+      hwnd, uMsg, wParam, lParam, infoPtr);
 
     if (!infoPtr) return 0;
@@ -2111 +2112 @@
 
     case CB_FINDSTRINGEXACT:
-            return COMBOEX_FindStringExact (infoPtr, wParam, lParam);
+        return COMBOEX_FindStringExact (infoPtr, wParam, lParam);
 
     case WM_DRAWITEM:
-            /*
-             * The only way this message should come is from the
-             * child Listbox issuing the message. Flag this so
-             * that ComboEx knows this is listbox.
-             */
-            ((DRAWITEMSTRUCT *)lParam)->itemState |= ODS_COMBOEXLBOX;
-            return CallWindowProcA (infoPtr->prevComboWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
+        /*
+         * The only way this message should come is from the
+         * child Listbox issuing the message. Flag this so
+         * that ComboEx knows this is listbox.
+         */
+        ((DRAWITEMSTRUCT *)lParam)->itemState |= ODS_COMBOEXLBOX;
+        return CallWindowProcA (infoPtr->prevComboWndProc,
+                   hwnd, uMsg, wParam, lParam);
 
     case WM_ERASEBKGND:
-            /*
-             * The following was determined by traces of the native 
-             */
+        /*
+         * The following was determined by traces of the native
+         */
             hDC = (HDC) wParam;
-            nbkc = GetSysColor (COLOR_WINDOW);
-            obkc = SetBkColor (hDC, nbkc);
+        nbkc = GetSysColor (COLOR_WINDOW);
+        obkc = SetBkColor (hDC, nbkc);
             GetClientRect (hwnd, &rect);
-            TRACE("erasing (%d,%d)-(%d,%d)\n",
-                  rect.left, rect.top, rect.right, rect.bottom);
-            ExtTextOutW (hDC, 0, 0, ETO_OPAQUE, &rect, 0, 0, 0);
+        TRACE("erasing (%d,%d)-(%d,%d)\n",
+          rect.left, rect.top, rect.right, rect.bottom);
+        ExtTextOutW (hDC, 0, 0, ETO_OPAQUE, &rect, 0, 0, 0);
             SetBkColor (hDC, obkc);
-            return CallWindowProcA (infoPtr->prevComboWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
+        return CallWindowProcA (infoPtr->prevComboWndProc,
+                   hwnd, uMsg, wParam, lParam);
 
     case WM_SETCURSOR:
-            /*
-             *  WM_NOTIFY to comboex parent (rebar)
-             *   with NM_SETCURSOR with extra words of 0,0,0,0,0x02010001
-             *  CallWindowProc (previous)
-             */
-            nmmse.dwItemSpec = 0;
-            nmmse.dwItemData = 0;
-            nmmse.pt.x = 0;
-            nmmse.pt.y = 0;
-            nmmse.dwHitInfo = lParam;
-            COMBOEX_Notify (infoPtr, NM_SETCURSOR, (NMHDR *)&nmmse);
-            return CallWindowProcA (infoPtr->prevComboWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
+        /*
+         *  WM_NOTIFY to comboex parent (rebar)
+         *   with NM_SETCURSOR with extra words of 0,0,0,0,0x02010001
+         *  CallWindowProc (previous)
+         */
+        nmmse.dwItemSpec = 0;
+        nmmse.dwItemData = 0;
+        nmmse.pt.x = 0;
+        nmmse.pt.y = 0;
+        nmmse.dwHitInfo = lParam;
+        COMBOEX_Notify (infoPtr, NM_SETCURSOR, (NMHDR *)&nmmse);
+        return CallWindowProcA (infoPtr->prevComboWndProc,
+                   hwnd, uMsg, wParam, lParam);
 
     case WM_COMMAND:
-            switch (HIWORD(wParam)) {
-
-            case EN_UPDATE:
-                /* traces show that COMBOEX does not issue CBN_EDITUPDATE
-                 * on the EN_UPDATE
-                 */
-                return 0;
-
-            case EN_KILLFOCUS:
-                /*
-                 * Native does:
-                 *
-                 *  GetFocus() retns AA
-                 *  GetWindowTextA(Edit)
-                 *  CB_GETCURSEL(Combo) (got -1)
-                 *  WM_NOTIFY(CBEN_ENDEDITA) with CBENF_KILLFOCUS
-                 *  CB_GETCURSEL(Combo) (got -1)
-                 *  InvalidateRect(Combo, 0, 0)
-                 *  WM_KILLFOCUS(Combo, AA)
-                 *  return 0;
-                 */
-                focusedhwnd = GetFocus();
-                if (infoPtr->flags & WCBE_ACTEDIT) {
-                    GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
-                    cbeend.fChanged = (infoPtr->flags & WCBE_EDITCHG);
-                    cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
-                                                         CB_GETCURSEL, 0, 0);
-                    cbeend.iWhy = CBENF_KILLFOCUS;
-
-                    infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
-                    if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text)) {
-                        /* abort the change */
-                        TRACE("Notify requested abort of change\n");
-                        return 0;
-                    }
-                }
-                /* possible CB_GETCURSEL */
-                InvalidateRect (infoPtr->hwndCombo, 0, 0);
-                if (focusedhwnd)
-                    SendMessageW (infoPtr->hwndCombo, WM_KILLFOCUS,
-                                  (WPARAM)focusedhwnd, 0); 
-                return 0;
-
-            case EN_SETFOCUS: {
-                /* 
-                 * For EN_SETFOCUS this issues the same calls and messages
-                 *  as the native seems to do.
-                 *
-                 * for some cases however native does the following:
-                 *   (noticed after SetFocus during LBUTTONDOWN on
-                 *    on dropdown arrow)
-                 *  WM_GETTEXTLENGTH (Edit);
-                 *  WM_GETTEXT (Edit, len+1, str);
-                 *  EM_SETSEL (Edit, 0, 0);
-                 *  WM_GETTEXTLENGTH (Edit);
-                 *  WM_GETTEXT (Edit, len+1, str);
-                 *  EM_SETSEL (Edit, 0, len);
-                 *  WM_NOTIFY (parent, CBEN_BEGINEDIT)
-                 */
-                NMHDR hdr;
-
-                SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, 0);
-                SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, -1);
-                COMBOEX_Notify (infoPtr, CBEN_BEGINEDIT, &hdr);
-                infoPtr->flags |= WCBE_ACTEDIT;
-                infoPtr->flags &= ~WCBE_EDITCHG; /* no change yet */
-                return 0;
-                }
-
-            case EN_CHANGE: {
-                /* 
-                 * For EN_CHANGE this issues the same calls and messages
-                 *  as the native seems to do.
-                 */
-                WCHAR edit_text[260];
-                WCHAR *lastwrk;
-                INT selected, cnt;
-                CBE_ITEMDATA *item;
-
-                selected = SendMessageW (infoPtr->hwndCombo,
-                                         CB_GETCURSEL, 0, 0);
-
-                /* lstrlenA( lastworkingURL ) */
-
-                GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
-                if (selected == -1) {
-                    lastwrk = infoPtr->edit->pszText;
-                    cnt = lstrlenW (lastwrk);
-                    if (cnt >= 259) cnt = 259;
-                }
-                else {
-                    item = COMBOEX_FindItem (infoPtr, selected);
-                    cnt = lstrlenW (item->pszText);
-                    lastwrk = item->pszText;
-                    if (cnt >= 259) cnt = 259;
-                }
-
-                TRACE("handling EN_CHANGE, selected = %d, selected_text=%s\n",
-                    selected, debugstr_w(lastwrk));
-                TRACE("handling EN_CHANGE, edittext=%s\n",
-                      debugstr_w(edit_text));
-
-                /* lstrcmpiW is between lastworkingURL and GetWindowText */
-
-                if (lstrcmpiW (lastwrk, edit_text)) {
-                    /* strings not equal -- indicate edit has changed */
-                    infoPtr->flags |= WCBE_EDITCHG;
-                }
-                SendMessageW ( GetParent(infoPtr->hwndSelf), WM_COMMAND,
-                               MAKEWPARAM(GetDlgCtrlID (infoPtr->hwndSelf),
-                                          CBN_EDITCHANGE),
-                               infoPtr->hwndSelf);
-                return 0;
-                }
-
-            case LBN_SELCHANGE:
-                /*
-                 * Therefore from traces there is no additional code here
-                 */
-
-                /*
-                 * Using native COMCTL32 gets the following:
-                 *  1 == SHDOCVW.DLL  issues call/message
-                 *  2 == COMCTL32.DLL  issues call/message
-                 *  3 == WINE  issues call/message
-                 *
-                 *
-                 * for LBN_SELCHANGE:
-                 *    1  CB_GETCURSEL(ComboEx)
-                 *    1  CB_GETDROPPEDSTATE(ComboEx)
-                 *    1  CallWindowProc( *2* for WM_COMMAND(LBN_SELCHANGE)
-                 *    2  CallWindowProc( *3* for WM_COMMAND(LBN_SELCHANGE)
-                 **   call CBRollUp( xxx, TRUE for LBN_SELCHANGE, TRUE)
-                 *    3  WM_COMMAND(ComboEx, CBN_SELENDOK)
-                 *      WM_USER+49(ComboLB, 1,0)  <=============!!!!!!!!!!!
-                 *    3  ShowWindow(ComboLB, SW_HIDE)
-                 *    3  RedrawWindow(Combo,  RDW_UPDATENOW)
-                 *    3  WM_COMMAND(ComboEX, CBN_CLOSEUP)
-                 **   end of CBRollUp
-                 *    3  WM_COMMAND(ComboEx, CBN_SELCHANGE)  (echo to parent)
-                 *    ?  LB_GETCURSEL              <==|
-                 *    ?  LB_GETTEXTLEN                |
-                 *    ?  LB_GETTEXT                   | Needs to be added to
-                 *    ?  WM_CTLCOLOREDIT(ComboEx)     | Combo processing
-                 *    ?  LB_GETITEMDATA               |
-                 *    ?  WM_DRAWITEM(ComboEx)      <==|
-                 */
-            default:
-                break;
-            }/* fall through */
+        switch (HIWORD(wParam)) {
+
+        case EN_UPDATE:
+        /* traces show that COMBOEX does not issue CBN_EDITUPDATE
+         * on the EN_UPDATE
+         */
+        return 0;
+
+        case EN_KILLFOCUS:
+        /*
+         * Native does:
+         *
+         *  GetFocus() retns AA
+         *  GetWindowTextA(Edit)
+         *  CB_GETCURSEL(Combo) (got -1)
+         *  WM_NOTIFY(CBEN_ENDEDITA) with CBENF_KILLFOCUS
+         *  CB_GETCURSEL(Combo) (got -1)
+         *  InvalidateRect(Combo, 0, 0)
+         *  WM_KILLFOCUS(Combo, AA)
+         *  return 0;
+         */
+        focusedhwnd = GetFocus();
+        if (infoPtr->flags & WCBE_ACTEDIT) {
+            GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
+            cbeend.fChanged = (infoPtr->flags & WCBE_EDITCHG);
+            cbeend.iNewSelection = SendMessageW (infoPtr->hwndCombo,
+                             CB_GETCURSEL, 0, 0);
+            cbeend.iWhy = CBENF_KILLFOCUS;
+
+            infoPtr->flags &= ~(WCBE_ACTEDIT | WCBE_EDITCHG);
+            if (COMBOEX_NotifyEndEdit (infoPtr, &cbeend, edit_text)) {
+            /* abort the change */
+            TRACE("Notify requested abort of change\n");
+            return 0;
+            }
+        }
+        /* possible CB_GETCURSEL */
+        InvalidateRect (infoPtr->hwndCombo, 0, 0);
+        if (focusedhwnd)
+            SendMessageW (infoPtr->hwndCombo, WM_KILLFOCUS,
+                  (WPARAM)focusedhwnd, 0);
+        return 0;
+
+        case EN_SETFOCUS: {
+        /*
+         * For EN_SETFOCUS this issues the same calls and messages
+         *  as the native seems to do.
+         *
+         * for some cases however native does the following:
+         *   (noticed after SetFocus during LBUTTONDOWN on
+         *    on dropdown arrow)
+         *  WM_GETTEXTLENGTH (Edit);
+         *  WM_GETTEXT (Edit, len+1, str);
+         *  EM_SETSEL (Edit, 0, 0);
+         *  WM_GETTEXTLENGTH (Edit);
+         *  WM_GETTEXT (Edit, len+1, str);
+         *  EM_SETSEL (Edit, 0, len);
+         *  WM_NOTIFY (parent, CBEN_BEGINEDIT)
+         */
+        NMHDR hdr;
+
+        SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, 0);
+        SendMessageW (infoPtr->hwndEdit, EM_SETSEL, 0, -1);
+        COMBOEX_Notify (infoPtr, CBEN_BEGINEDIT, &hdr);
+        infoPtr->flags |= WCBE_ACTEDIT;
+        infoPtr->flags &= ~WCBE_EDITCHG; /* no change yet */
+        return 0;
+            }
+
+        case EN_CHANGE: {
+        /*
+         * For EN_CHANGE this issues the same calls and messages
+         *  as the native seems to do.
+         */
+        WCHAR edit_text[260];
+        WCHAR *lastwrk;
+        INT selected, cnt;
+        CBE_ITEMDATA *item;
+
+        selected = SendMessageW (infoPtr->hwndCombo,
+                     CB_GETCURSEL, 0, 0);
+
+        /* lstrlenA( lastworkingURL ) */
+
+        GetWindowTextW (infoPtr->hwndEdit, edit_text, 260);
+        if (selected == -1) {
+            lastwrk = infoPtr->edit->pszText;
+            cnt = lstrlenW (lastwrk);
+            if (cnt >= 259) cnt = 259;
+        }
+        else {
+            item = COMBOEX_FindItem (infoPtr, selected);
+            cnt = lstrlenW (item->pszText);
+            lastwrk = item->pszText;
+            if (cnt >= 259) cnt = 259;
+        }
+
+        TRACE("handling EN_CHANGE, selected = %d, selected_text=%s\n",
+            selected, debugstr_w(lastwrk));
+        TRACE("handling EN_CHANGE, edittext=%s\n",
+              debugstr_w(edit_text));
+
+        /* lstrcmpiW is between lastworkingURL and GetWindowText */
+
+        if (lstrcmpiW (lastwrk, edit_text)) {
+            /* strings not equal -- indicate edit has changed */
+            infoPtr->flags |= WCBE_EDITCHG;
+        }
+        SendMessageW ( GetParent(infoPtr->hwndSelf), WM_COMMAND,
+                   MAKEWPARAM(GetDlgCtrlID (infoPtr->hwndSelf),
+                      CBN_EDITCHANGE),
+                   infoPtr->hwndSelf);
+        return 0;
+            }
+
+        case LBN_SELCHANGE:
+        /*
+         * Therefore from traces there is no additional code here
+         */
+
+        /*
+         * Using native COMCTL32 gets the following:
+         *  1 == SHDOCVW.DLL  issues call/message
+         *  2 == COMCTL32.DLL  issues call/message
+         *  3 == WINE  issues call/message
+         *
+         *
+         * for LBN_SELCHANGE:
+         *    1  CB_GETCURSEL(ComboEx)
+         *    1  CB_GETDROPPEDSTATE(ComboEx)
+         *    1  CallWindowProc( *2* for WM_COMMAND(LBN_SELCHANGE)
+         *    2  CallWindowProc( *3* for WM_COMMAND(LBN_SELCHANGE)
+         **   call CBRollUp( xxx, TRUE for LBN_SELCHANGE, TRUE)
+         *    3  WM_COMMAND(ComboEx, CBN_SELENDOK)
+         *      WM_USER+49(ComboLB, 1,0)  <=============!!!!!!!!!!!
+         *    3  ShowWindow(ComboLB, SW_HIDE)
+         *    3  RedrawWindow(Combo,  RDW_UPDATENOW)
+         *    3  WM_COMMAND(ComboEX, CBN_CLOSEUP)
+         **   end of CBRollUp
+         *    3  WM_COMMAND(ComboEx, CBN_SELCHANGE)  (echo to parent)
+         *    ?  LB_GETCURSEL              <==|
+         *    ?  LB_GETTEXTLEN                |
+         *    ?  LB_GETTEXT                   | Needs to be added to
+         *    ?  WM_CTLCOLOREDIT(ComboEx)     | Combo processing
+         *    ?  LB_GETITEMDATA               |
+         *    ?  WM_DRAWITEM(ComboEx)      <==|
+         */
+        default:
+        break;
+        }/* fall through */
     default:
-            return CallWindowProcA (infoPtr->prevComboWndProc, 
-                                   hwnd, uMsg, wParam, lParam);
+        return CallWindowProcA (infoPtr->prevComboWndProc,
+                   hwnd, uMsg, wParam, lParam);
     }
     return 0;
@@ -2320 +2321 @@
 
     if (!COMBOEX_GetInfoPtr (hwnd)) {
-        if (uMsg == WM_CREATE)
-            return COMBOEX_Create (hwnd, wParam, lParam);
-        if (uMsg == WM_NCCREATE)
-            COMBOEX_NCCreate (hwnd, wParam, lParam);
+    if (uMsg == WM_CREATE)
+        return COMBOEX_Create (hwnd, wParam, lParam);
+    if (uMsg == WM_NCCREATE)
+        COMBOEX_NCCreate (hwnd, wParam, lParam);
         return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     }
@@ -2330 +2331 @@
     {
         case CBEM_DELETEITEM:  /* maps to CB_DELETESTRING */
-            return COMBOEX_DeleteItem (hwnd, wParam, lParam);
-
-        case CBEM_GETCOMBOCONTROL:
-            return COMBOEX_GetComboControl (hwnd, wParam, lParam);
-
-        case CBEM_GETEDITCONTROL:
-            return COMBOEX_GetEditControl (hwnd, wParam, lParam);
-
-        case CBEM_GETEXTENDEDSTYLE:
-            return COMBOEX_GetExtendedStyle (hwnd, wParam, lParam);
-
-        case CBEM_GETIMAGELIST:
-            return COMBOEX_GetImageList (hwnd, wParam, lParam);
-
-        case CBEM_GETITEMA:
-            return COMBOEX_GetItemA (hwnd, wParam, lParam);
-
-        case CBEM_GETITEMW:
-            return COMBOEX_GetItemW (hwnd, wParam, lParam);
-
-        case CBEM_GETUNICODEFORMAT:
-            return COMBOEX_GetUnicodeFormat (hwnd, wParam, lParam);
-
-        case CBEM_HASEDITCHANGED:
-            return COMBOEX_HasEditChanged (hwnd, wParam, lParam);
-
-        case CBEM_INSERTITEMA:
-            return COMBOEX_InsertItemA (hwnd, wParam, lParam);
-
-        case CBEM_INSERTITEMW:
-            return COMBOEX_InsertItemW (hwnd, wParam, lParam);
-
-        case CBEM_SETEXSTYLE:   /* FIXME: obsoleted, should be the same as: */
-        case CBEM_SETEXTENDEDSTYLE:
-            return COMBOEX_SetExtendedStyle (hwnd, wParam, lParam);
-
-        case CBEM_SETIMAGELIST:
-            return COMBOEX_SetImageList (hwnd, wParam, lParam);
-
-        case CBEM_SETITEMA:
-            return COMBOEX_SetItemA (hwnd, wParam, lParam);
-
-        case CBEM_SETITEMW:
-            return COMBOEX_SetItemW (hwnd, wParam, lParam);
-
-        case CBEM_SETUNICODEFORMAT:
-            return COMBOEX_SetUnicodeFormat (hwnd, wParam, lParam);
+        return COMBOEX_DeleteItem (hwnd, wParam, lParam);
+
+    case CBEM_GETCOMBOCONTROL:
+        return COMBOEX_GetComboControl (hwnd, wParam, lParam);
+
+    case CBEM_GETEDITCONTROL:
+        return COMBOEX_GetEditControl (hwnd, wParam, lParam);
+
+    case CBEM_GETEXTENDEDSTYLE:
+        return COMBOEX_GetExtendedStyle (hwnd, wParam, lParam);
+
+    case CBEM_GETIMAGELIST:
+        return COMBOEX_GetImageList (hwnd, wParam, lParam);
+
+    case CBEM_GETITEMA:
+        return COMBOEX_GetItemA (hwnd, wParam, lParam);
+
+    case CBEM_GETITEMW:
+        return COMBOEX_GetItemW (hwnd, wParam, lParam);
+
+    case CBEM_GETUNICODEFORMAT:
+        return COMBOEX_GetUnicodeFormat (hwnd, wParam, lParam);
+
+    case CBEM_HASEDITCHANGED:
+        return COMBOEX_HasEditChanged (hwnd, wParam, lParam);
+
+    case CBEM_INSERTITEMA:
+        return COMBOEX_InsertItemA (hwnd, wParam, lParam);
+
+    case CBEM_INSERTITEMW:
+        return COMBOEX_InsertItemW (hwnd, wParam, lParam);
+
+    case CBEM_SETEXSTYLE:   /* FIXME: obsoleted, should be the same as: */
+    case CBEM_SETEXTENDEDSTYLE:
+        return COMBOEX_SetExtendedStyle (hwnd, wParam, lParam);
+
+    case CBEM_SETIMAGELIST:
+        return COMBOEX_SetImageList (hwnd, wParam, lParam);
+
+    case CBEM_SETITEMA:
+        return COMBOEX_SetItemA (hwnd, wParam, lParam);
+
+    case CBEM_SETITEMW:
+        return COMBOEX_SetItemW (hwnd, wParam, lParam);
+
+    case CBEM_SETUNICODEFORMAT:
+        return COMBOEX_SetUnicodeFormat (hwnd, wParam, lParam);
 
 
 /*   Combo messages we are not sure if we need to process or just forward */
-        case CB_GETDROPPEDCONTROLRECT:
-        case CB_GETITEMHEIGHT:
-        case CB_GETLBTEXT:
-        case CB_GETLBTEXTLEN:
-        case CB_GETEXTENDEDUI:
-        case CB_LIMITTEXT:
-        case CB_RESETCONTENT:
-        case CB_SELECTSTRING:
-        case WM_SETTEXT:
-        case WM_GETTEXT:
-            FIXME("(0x%x 0x%x 0x%lx): possibly missing function\n",
-                  uMsg, wParam, lParam);
-            return COMBOEX_Forward (hwnd, uMsg, wParam, lParam);
+    case CB_GETDROPPEDCONTROLRECT:
+    case CB_GETITEMHEIGHT:
+    case CB_GETLBTEXT:
+    case CB_GETLBTEXTLEN:
+    case CB_GETEXTENDEDUI:
+    case CB_LIMITTEXT:
+    case CB_RESETCONTENT:
+    case CB_SELECTSTRING:
+    case WM_SETTEXT:
+    case WM_GETTEXT:
+        FIXME("(0x%x 0x%x 0x%lx): possibly missing function\n",
+          uMsg, wParam, lParam);
+        return COMBOEX_Forward (hwnd, uMsg, wParam, lParam);
 
 /*   Combo messages OK to just forward to the regular COMBO */
-        case CB_GETCOUNT:        
-        case CB_GETCURSEL:
-        case CB_GETDROPPEDSTATE:
+    case CB_GETCOUNT:
+    case CB_GETCURSEL:
+    case CB_GETDROPPEDSTATE:
         case CB_SETDROPPEDWIDTH:
         case CB_SETEXTENDEDUI:
         case CB_SHOWDROPDOWN:
-            return COMBOEX_Forward (hwnd, uMsg, wParam, lParam);
+        return COMBOEX_Forward (hwnd, uMsg, wParam, lParam);
 
 /*   Combo messages we need to process specially */
         case CB_FINDSTRINGEXACT:
-            return COMBOEX_FindStringExact (COMBOEX_GetInfoPtr (hwnd), 
-                                            wParam, lParam);
-
-        case CB_GETITEMDATA:
-            return COMBOEX_GetItemData (hwnd, wParam, lParam);
-
-        case CB_SETCURSEL:
-            return COMBOEX_SetCursel (hwnd, wParam, lParam);
-
-        case CB_SETITEMDATA:
-            return COMBOEX_SetItemData (hwnd, wParam, lParam);
-
-        case CB_SETITEMHEIGHT:
-            return COMBOEX_SetItemHeight (hwnd, wParam, lParam);
+        return COMBOEX_FindStringExact (COMBOEX_GetInfoPtr (hwnd),
+                        wParam, lParam);
+
+    case CB_GETITEMDATA:
+        return COMBOEX_GetItemData (hwnd, wParam, lParam);
+
+    case CB_SETCURSEL:
+        return COMBOEX_SetCursel (hwnd, wParam, lParam);
+
+    case CB_SETITEMDATA:
+        return COMBOEX_SetItemData (hwnd, wParam, lParam);
+
+    case CB_SETITEMHEIGHT:
+        return COMBOEX_SetItemHeight (hwnd, wParam, lParam);
 
 
 
 /*   Window messages passed to parent */
-        case WM_COMMAND:
-            return COMBOEX_Command (hwnd, wParam, lParam);
-
-        case WM_NOTIFY:
-            if (infoPtr->NtfUnicode)
-                return SendMessageW (GetParent (hwnd),
-                                     uMsg, wParam, lParam);
-            else
-                return SendMessageA (GetParent (hwnd),
-                                     uMsg, wParam, lParam);
+    case WM_COMMAND:
+        return COMBOEX_Command (hwnd, wParam, lParam);
+
+    case WM_NOTIFY:
+        if (infoPtr->NtfUnicode)
+        return SendMessageW (GetParent (hwnd),
+                     uMsg, wParam, lParam);
+        else
+        return SendMessageA (GetParent (hwnd),
+                     uMsg, wParam, lParam);
 
 
 /*   Window messages we need to process */
         case WM_DELETEITEM:
-            return COMBOEX_WM_DeleteItem (hwnd, wParam, lParam);
+        return COMBOEX_WM_DeleteItem (hwnd, wParam, lParam);
 
         case WM_DRAWITEM:
             return COMBOEX_DrawItem (hwnd, wParam, lParam);
 
-        case WM_DESTROY:
-            return COMBOEX_Destroy (hwnd, wParam, lParam);
+    case WM_DESTROY:
+        return COMBOEX_Destroy (hwnd, wParam, lParam);
 
         case WM_MEASUREITEM:
@@ -2449 +2450 @@
 
         case WM_NOTIFYFORMAT:
-            return COMBOEX_NotifyFormat (hwnd, wParam, lParam);
-
-        case WM_SIZE:
-            return COMBOEX_Size (hwnd, wParam, lParam);
+        return COMBOEX_NotifyFormat (hwnd, wParam, lParam);
+
+    case WM_SIZE:
+        return COMBOEX_Size (hwnd, wParam, lParam);
 
         case WM_WINDOWPOSCHANGING:
-            return COMBOEX_WindowPosChanging (hwnd, wParam, lParam);
-
-        default:
-            if (uMsg >= WM_USER)
-                ERR("unknown msg %04x wp=%08x lp=%08lx\n",
-                     uMsg, wParam, lParam);
+        return COMBOEX_WindowPosChanging (hwnd, wParam, lParam);
+
+    default:
+        if (uMsg >= WM_USER)
+        ERR("unknown msg %04x wp=%08x lp=%08lx\n",
+             uMsg, wParam, lParam);
 #ifdef __WIN32OS2__
             return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
 #else
-            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
 #endif
     }
@@ -2484 +2485 @@
     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
     wndClass.lpszClassName = WC_COMBOBOXEXA;
- 
+
     RegisterClassA (&wndClass);
 

trunk/src/comctl32/comctl32.c

@@ -1 @@
-/*              
+/* $Id: comctl32.c,v 1.18 2001-09-05 12:04:56 bird Exp $ */
+/*
  * Common controls functions
  *
@@ -99 +100 @@
 
     switch (fdwReason) {
-        case DLL_PROCESS_ATTACH:
+    case DLL_PROCESS_ATTACH:
             COMCTL32_hModule = (HMODULE)hinstDLL;
 
@@ -130 +131 @@
             break;
 
-        case DLL_PROCESS_DETACH:
+    case DLL_PROCESS_DETACH:
             /* unregister all common control classes */
             ANIMATE_Unregister ();
@@ -204 +205 @@
 VOID WINAPI
 MenuHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu,
-          HINSTANCE hInst, HWND hwndStatus, LPUINT lpwIDs)
+      HINSTANCE hInst, HWND hwndStatus, LPUINT lpwIDs)
 {
     UINT uMenuID = 0;
 
     if (!IsWindow (hwndStatus))
-        return;
+    return;
 
     switch (uMsg) {
-        case WM_MENUSELECT:
-            TRACE("WM_MENUSELECT wParam=0x%X lParam=0x%lX\n",
-                   wParam, lParam);
+    case WM_MENUSELECT:
+        TRACE("WM_MENUSELECT wParam=0x%X lParam=0x%lX\n",
+           wParam, lParam);
 
             if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) {
                 /* menu was closed */
-                TRACE("menu was closed!\n");
+        TRACE("menu was closed!\n");
                 SendMessageA (hwndStatus, SB_SIMPLE, FALSE, 0);
             }
-            else {
-                /* menu item was selected */
-                if (HIWORD(wParam) & MF_POPUP)
-                    uMenuID = (UINT)*(lpwIDs+1);
-                else
-                    uMenuID = (UINT)LOWORD(wParam);
-                TRACE("uMenuID = %u\n", uMenuID);
-
-                if (uMenuID) {
-                    CHAR szText[256];
-
-                    if (!LoadStringA (hInst, uMenuID, szText, 256))
-                        szText[0] = '\0';
-
-                    SendMessageA (hwndStatus, SB_SETTEXTA,
-                                    255 | SBT_NOBORDERS, (LPARAM)szText);
-                    SendMessageA (hwndStatus, SB_SIMPLE, TRUE, 0);
-                }
-            }
-            break;
+        else {
+        /* menu item was selected */
+        if (HIWORD(wParam) & MF_POPUP)
+            uMenuID = (UINT)*(lpwIDs+1);
+        else
+            uMenuID = (UINT)LOWORD(wParam);
+        TRACE("uMenuID = %u\n", uMenuID);
+
+        if (uMenuID) {
+            CHAR szText[256];
+
+            if (!LoadStringA (hInst, uMenuID, szText, 256))
+            szText[0] = '\0';
+
+            SendMessageA (hwndStatus, SB_SETTEXTA,
+                    255 | SBT_NOBORDERS, (LPARAM)szText);
+            SendMessageA (hwndStatus, SB_SIMPLE, TRUE, 0);
+        }
+        }
+        break;
 
         case WM_COMMAND :
-            TRACE("WM_COMMAND wParam=0x%X lParam=0x%lX\n",
-                   wParam, lParam);
-            /* WM_COMMAND is not invalid since it is documented
-             * in the windows api reference. So don't output
+        TRACE("WM_COMMAND wParam=0x%X lParam=0x%lX\n",
+           wParam, lParam);
+        /* WM_COMMAND is not invalid since it is documented
+         * in the windows api reference. So don't output
              * any FIXME for WM_COMMAND
              */
-            WARN("We don't care about the WM_COMMAND\n");
-            break;
-
-        default:
-            FIXME("Invalid Message 0x%x!\n", uMsg);
-            break;
-    }
-}
-
-
-/***********************************************************************
- * ShowHideMenuCtl [COMCTL32.3] 
+        WARN("We don't care about the WM_COMMAND\n");
+        break;
+
+    default:
+        FIXME("Invalid Message 0x%x!\n", uMsg);
+        break;
+    }
+}
+
+
+/***********************************************************************
+ * ShowHideMenuCtl [COMCTL32.3]
  *
  * Shows or hides controls and updates the corresponding menu item.
@@ -297 +298 @@
 
     if (lpInfo == NULL)
-        return FALSE;
+    return FALSE;
 
     if (!(lpInfo[0]) || !(lpInfo[1]))
-        return FALSE;
+    return FALSE;
 
     /* search for control */
     lpMenuId = &lpInfo[2];
     while (*lpMenuId != uFlags)
-        lpMenuId += 2;
+    lpMenuId += 2;
 
     if (GetMenuState (lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) {
-        /* uncheck menu item */
-        CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED);
-
-        /* hide control */
-        lpMenuId++;
-        SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
-                        SWP_HIDEWINDOW);
+    /* uncheck menu item */
+    CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED);
+
+    /* hide control */
+    lpMenuId++;
+    SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
+            SWP_HIDEWINDOW);
     }
     else {
-        /* check menu item */
-        CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED);
-
-        /* show control */
-        lpMenuId++;
-        SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
-                        SWP_SHOWWINDOW);
+    /* check menu item */
+    CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED);
+
+    /* show control */
+    lpMenuId++;
+    SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
+            SWP_SHOWWINDOW);
     }
 
@@ -357 +358 @@
 
     TRACE("(0x%08lx 0x%08lx 0x%08lx)\n",
-           (DWORD)hwnd, (DWORD)lpRect, (DWORD)lpInfo);
+       (DWORD)hwnd, (DWORD)lpRect, (DWORD)lpInfo);
 
     GetClientRect (hwnd, lpRect);
@@ -363 +364 @@
 
     do {
-        lpRun += 2;
-        if (*lpRun == 0)
-            return;
-        lpRun++;
-        hwndCtrl = GetDlgItem (hwnd, *lpRun);
-        if (GetWindowLongA (hwndCtrl, GWL_STYLE) & WS_VISIBLE) {
-            TRACE("control id 0x%x\n", *lpRun);
-            GetWindowRect (hwndCtrl, &rcCtrl);
-            MapWindowPoints ((HWND)0, hwnd, (LPPOINT)&rcCtrl, 2);
-            SubtractRect (lpRect, lpRect, &rcCtrl);
-        }
-        lpRun++;
+    lpRun += 2;
+    if (*lpRun == 0)
+        return;
+    lpRun++;
+    hwndCtrl = GetDlgItem (hwnd, *lpRun);
+    if (GetWindowLongA (hwndCtrl, GWL_STYLE) & WS_VISIBLE) {
+        TRACE("control id 0x%x\n", *lpRun);
+        GetWindowRect (hwndCtrl, &rcCtrl);
+        MapWindowPoints ((HWND)0, hwnd, (LPPOINT)&rcCtrl, 2);
+        SubtractRect (lpRect, lpRect, &rcCtrl);
+    }
+    lpRun++;
     } while (*lpRun);
 }
@@ -416 +417 @@
       r.left += 3;
       DrawTextA (hdc, text, lstrlenA(text),
-                   &r, DT_LEFT|DT_VCENTER|DT_SINGLELINE);  
+           &r, DT_LEFT|DT_VCENTER|DT_SINGLELINE);
       if (oldbkmode != TRANSPARENT)
-        SetBkMode(hdc, oldbkmode);
+    SetBkMode(hdc, oldbkmode);
     }
 }
@@ -466 +467 @@
 CreateStatusWindowA (INT style, LPCSTR text, HWND parent, UINT wid)
 {
-    return CreateWindowA(STATUSCLASSNAMEA, text, style, 
-                           CW_USEDEFAULT, CW_USEDEFAULT,
-                           CW_USEDEFAULT, CW_USEDEFAULT, 
-                           parent, wid, 0, 0);
+    return CreateWindowA(STATUSCLASSNAMEA, text, style,
+               CW_USEDEFAULT, CW_USEDEFAULT,
+               CW_USEDEFAULT, CW_USEDEFAULT,
+               parent, wid, 0, 0);
 }
 
@@ -491 +492 @@
 {
     return CreateWindowW(STATUSCLASSNAMEW, text, style,
-                           CW_USEDEFAULT, CW_USEDEFAULT,
-                           CW_USEDEFAULT, CW_USEDEFAULT,
-                           parent, wid, 0, 0);
+               CW_USEDEFAULT, CW_USEDEFAULT,
+               CW_USEDEFAULT, CW_USEDEFAULT,
+               parent, wid, 0, 0);
 }
 
@@ -521 +522 @@
 HWND WINAPI
 CreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
-                     HWND parent, INT id, HINSTANCE inst,
-                     HWND buddy, INT maxVal, INT minVal, INT curVal)
+             HWND parent, INT id, HINSTANCE inst,
+             HWND buddy, INT maxVal, INT minVal, INT curVal)
 {
     HWND hUD =
-        CreateWindowA (UPDOWN_CLASSA, 0, style, x, y, cx, cy,
-                         parent, id, inst, 0);
+    CreateWindowA (UPDOWN_CLASSA, 0, style, x, y, cx, cy,
+             parent, id, inst, 0);
     if (hUD) {
-        SendMessageA (hUD, UDM_SETBUDDY, buddy, 0);
-        SendMessageA (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
-        SendMessageA (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));     
+    SendMessageA (hUD, UDM_SETBUDDY, buddy, 0);
+    SendMessageA (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
+    SendMessageA (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));
     }
 
@@ -584 +585 @@
 
     if (!lpInitCtrls)
-        return FALSE;
+    return FALSE;
     if (lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX))
-        return FALSE;
+    return FALSE;
 
     TRACE("(0x%08lx)\n", lpInitCtrls->dwICC);
 
     for (cCount = 0; cCount < 32; cCount++) {
-        dwMask = 1 << cCount;
-        if (!(lpInitCtrls->dwICC & dwMask))
-            continue;
-
-        switch (lpInitCtrls->dwICC & dwMask) {
-            /* dummy initialization */
-            case ICC_ANIMATE_CLASS:
-            case ICC_BAR_CLASSES:
-            case ICC_LISTVIEW_CLASSES:
-            case ICC_TREEVIEW_CLASSES:
-            case ICC_TAB_CLASSES:
-            case ICC_UPDOWN_CLASS:
-            case ICC_PROGRESS_CLASS:
-            case ICC_HOTKEY_CLASS:
-                break;
-
-            /* advanced classes - not included in Win95 */
-            case ICC_DATE_CLASSES:
-                MONTHCAL_Register ();
-                DATETIME_Register ();
-                break;
-
-            case ICC_USEREX_CLASSES:
-                COMBOEX_Register ();
-                break;
-
-            case ICC_COOL_CLASSES:
-                REBAR_Register ();
-                break;
-
-            case ICC_INTERNET_CLASSES:
-                IPADDRESS_Register ();
-                break;
-
-            case ICC_PAGESCROLLER_CLASS:
-                PAGER_Register ();
-                break;
-
-            case ICC_NATIVEFNTCTL_CLASS:
-                NATIVEFONT_Register ();
-                break;
-
-            default:
-                FIXME("Unknown class! dwICC=0x%lX\n", dwMask);
-                break;
-        }
+    dwMask = 1 << cCount;
+    if (!(lpInitCtrls->dwICC & dwMask))
+        continue;
+
+    switch (lpInitCtrls->dwICC & dwMask) {
+        /* dummy initialization */
+        case ICC_ANIMATE_CLASS:
+        case ICC_BAR_CLASSES:
+        case ICC_LISTVIEW_CLASSES:
+        case ICC_TREEVIEW_CLASSES:
+        case ICC_TAB_CLASSES:
+        case ICC_UPDOWN_CLASS:
+        case ICC_PROGRESS_CLASS:
+        case ICC_HOTKEY_CLASS:
+        break;
+
+        /* advanced classes - not included in Win95 */
+        case ICC_DATE_CLASSES:
+        MONTHCAL_Register ();
+        DATETIME_Register ();
+        break;
+
+        case ICC_USEREX_CLASSES:
+        COMBOEX_Register ();
+        break;
+
+        case ICC_COOL_CLASSES:
+        REBAR_Register ();
+        break;
+
+        case ICC_INTERNET_CLASSES:
+        IPADDRESS_Register ();
+        break;
+
+        case ICC_PAGESCROLLER_CLASS:
+        PAGER_Register ();
+        break;
+
+        case ICC_NATIVEFNTCTL_CLASS:
+        NATIVEFONT_Register ();
+        break;
+
+        default:
+        FIXME("Unknown class! dwICC=0x%lX\n", dwMask);
+        break;
+    }
     }
 
@@ -681 +682 @@
     hwndTB =
         CreateWindowExA (0, TOOLBARCLASSNAMEA, "", style|WS_CHILD, 0, 0, 0, 0,
-                           hwnd, (HMENU)wID, 0, NULL);
+               hwnd, (HMENU)wID, 0, NULL);
     if(hwndTB) {
-        TBADDBITMAP tbab;
+    TBADDBITMAP tbab;
 
         SendMessageA (hwndTB, TB_BUTTONSTRUCTSIZE,
-                        (WPARAM)uStructSize, 0);
+            (WPARAM)uStructSize, 0);
 
        /* set bitmap and button size */
@@ -705 +706 @@
 
 
-        /* add bitmaps */
-        if (nBitmaps > 0)
-        {
-        tbab.hInst = hBMInst;
-        tbab.nID   = wBMID;
-
-        SendMessageA (hwndTB, TB_ADDBITMAP,
-                        (WPARAM)nBitmaps, (LPARAM)&tbab);
-        }
-        /* add buttons */
-        if(iNumButtons > 0)
-        SendMessageA (hwndTB, TB_ADDBUTTONSA,
-                        (WPARAM)iNumButtons, (LPARAM)lpButtons);
+    /* add bitmaps */
+    if (nBitmaps > 0)
+    {
+    tbab.hInst = hBMInst;
+    tbab.nID   = wBMID;
+
+    SendMessageA (hwndTB, TB_ADDBITMAP,
+            (WPARAM)nBitmaps, (LPARAM)&tbab);
+    }
+    /* add buttons */
+    if(iNumButtons > 0)
+    SendMessageA (hwndTB, TB_ADDBUTTONSA,
+            (WPARAM)iNumButtons, (LPARAM)lpButtons);
     }
 
@@ -741 +742 @@
 HBITMAP WINAPI
 CreateMappedBitmap (HINSTANCE hInstance, INT idBitmap, UINT wFlags,
-                    LPCOLORMAP lpColorMap, INT iNumMaps)
+            LPCOLORMAP lpColorMap, INT iNumMaps)
 {
     HGLOBAL hglb;
@@ -754 +755 @@
     COLORREF cRef;
     COLORMAP internalColorMap[4] =
-        {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
+    {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
 
     /* initialize pointer to colortable and default color table */
     if (lpColorMap) {
-        iMaps = iNumMaps;
-        sysColorMap = lpColorMap;
+    iMaps = iNumMaps;
+    sysColorMap = lpColorMap;
     }
     else {
-        internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT);
-        internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW);
-        internalColorMap[2].to = GetSysColor (COLOR_BTNFACE);
-        internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT);
-        iMaps = 4;
-        sysColorMap = (LPCOLORMAP)internalColorMap;
+    internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT);
+    internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW);
+    internalColorMap[2].to = GetSysColor (COLOR_BTNFACE);
+    internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT);
+    iMaps = 4;
+    sysColorMap = (LPCOLORMAP)internalColorMap;
     }
 
     hRsrc = FindResourceA (hInstance, (LPSTR)idBitmap, RT_BITMAPA);
     if (hRsrc == 0)
-        return 0;
+    return 0;
     hglb = LoadResource (hInstance, hRsrc);
     if (hglb == 0)
-        return 0;
+    return 0;
     lpBitmap = (LPBITMAPINFOHEADER)LockResource (hglb);
     if (lpBitmap == NULL)
-        return 0;
+    return 0;
 
     nColorTableSize = (1 << lpBitmap->biBitCount);
@@ -784 +785 @@
     lpBitmapInfo = (LPBITMAPINFOHEADER)GlobalAlloc (GMEM_FIXED, nSize);
     if (lpBitmapInfo == NULL)
-        return 0;
+    return 0;
     RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize);
 
@@ -790 +791 @@
 
     for (iColor = 0; iColor < nColorTableSize; iColor++) {
-        for (i = 0; i < iMaps; i++) {
+    for (i = 0; i < iMaps; i++) {
             cRef = RGB(pColorTable[iColor].rgbRed,
                        pColorTable[iColor].rgbGreen,
                        pColorTable[iColor].rgbBlue);
-            if ( cRef  == sysColorMap[i].from) {
+        if ( cRef  == sysColorMap[i].from) {
 #if 0
-                if (wFlags & CBS_MASKED) {
-                    if (sysColorMap[i].to != COLOR_BTNTEXT)
-                        pColorTable[iColor] = RGB(255, 255, 255);
-                }
-                else
+        if (wFlags & CBS_MASKED) {
+            if (sysColorMap[i].to != COLOR_BTNTEXT)
+            pColorTable[iColor] = RGB(255, 255, 255);
+        }
+        else
 #endif
                     pColorTable[iColor].rgbBlue  = GetBValue(sysColorMap[i].to);
                     pColorTable[iColor].rgbGreen = GetGValue(sysColorMap[i].to);
                     pColorTable[iColor].rgbRed   = GetRValue(sysColorMap[i].to);
-                break;
-            }
-        }
+        break;
+        }
+    }
     }
     nWidth  = (INT)lpBitmapInfo->biWidth;
@@ -814 +815 @@
     hbm = CreateCompatibleBitmap (hdcScreen, nWidth, nHeight);
     if (hbm) {
-        HDC hdcDst = CreateCompatibleDC (hdcScreen);
-        HBITMAP hbmOld = SelectObject (hdcDst, hbm);
-        LPBYTE lpBits = (LPBYTE)(lpBitmap + 1);
-        lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
-        StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
-                         lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS,
-                         SRCCOPY);
-        SelectObject (hdcDst, hbmOld);
-        DeleteDC (hdcDst);
+    HDC hdcDst = CreateCompatibleDC (hdcScreen);
+    HBITMAP hbmOld = SelectObject (hdcDst, hbm);
+    LPBYTE lpBits = (LPBYTE)(lpBitmap + 1);
+    lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
+    StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
+                 lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS,
+                 SRCCOPY);
+    SelectObject (hdcDst, hbmOld);
+    DeleteDC (hdcDst);
     }
     ReleaseDC ((HWND)0, hdcScreen);
@@ -855 +856 @@
 HWND WINAPI
 CreateToolbar (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
-               HINSTANCE hBMInst, UINT wBMID,
-               LPCOLDTBBUTTON lpButtons,INT iNumButtons)
+           HINSTANCE hBMInst, UINT wBMID,
+           LPCOLDTBBUTTON lpButtons,INT iNumButtons)
 {
     return CreateToolbarEx (hwnd, style | CCS_NODIVIDER, wID, nBitmaps,
-                            hBMInst, wBMID, (LPCTBBUTTON)lpButtons,
-                            iNumButtons, 0, 0, 0, 0, sizeof (OLDTBBUTTON));
+                hBMInst, wBMID, (LPCTBBUTTON)lpButtons,
+                iNumButtons, 0, 0, 0, 0, sizeof (OLDTBBUTTON));
 }
 
@@ -885 +886 @@
     if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
         WARN("wrong DLLVERSIONINFO size from app");
-        return E_INVALIDARG;
+    return E_INVALIDARG;
     }
 
@@ -894 +895 @@
 
     TRACE("%lu.%lu.%lu.%lu\n",
-           pdvi->dwMajorVersion, pdvi->dwMinorVersion,
-           pdvi->dwBuildNumber, pdvi->dwPlatformID);
+       pdvi->dwMajorVersion, pdvi->dwMinorVersion,
+       pdvi->dwBuildNumber, pdvi->dwPlatformID);
 
     return S_OK;
@@ -901 +902 @@
 
 /***********************************************************************
- *              DllInstall (COMCTL32.@)
+ *      DllInstall (COMCTL32.@)
  */
 HRESULT WINAPI COMCTL32_DllInstall(BOOL bInstall, LPCWSTR cmdline)
 {
-  FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE", 
-        debugstr_w(cmdline));
+  FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
+    debugstr_w(cmdline));
 
   return S_OK;
@@ -916 +917 @@
     POINT pos; /* center of hover rectangle */
     INT iHoverTime; /* elapsed time the cursor has been inside of the hover rect */
-} _TRACKINGLIST; 
+} _TRACKINGLIST;
 
 static _TRACKINGLIST TrackingList[10];
@@ -955 +956 @@
         if(TrackingList[i].tme.dwFlags & TME_HOVER) {
             /* add the timer interval to the hovering time */
-            TrackingList[i].iHoverTime+=iTimerInterval;  
-     
+            TrackingList[i].iHoverTime+=iTimerInterval;
+
             /* has the cursor moved outside the rectangle centered around pos? */
             if((abs(pos.x - TrackingList[i].pos.x) > (hoverwidth / 2.0))
@@ -985 +986 @@
         }
     }
-        
+
     /* stop the timer if the tracking list is empty */
     if(iTrackMax == 0) {
@@ -1036 +1037 @@
 
     flags = ptme->dwFlags;
-    
+
     /* if HOVER_DEFAULT was specified replace this with the systems current value */
     if(ptme->dwHoverTime == HOVER_DEFAULT)
@@ -1042 +1043 @@
 
     GetCursorPos(&pos);
-    hwnd = WindowFromPoint(pos);    
+    hwnd = WindowFromPoint(pos);
 
     if ( flags & TME_CANCEL ) {
@@ -1048 +1049 @@
         cancel = 1;
     }
-    
+
     if ( flags & TME_HOVER  ) {
         flags &= ~ TME_HOVER;
         hover = 1;
     }
-    
+
     if ( flags & TME_LEAVE ) {
         flags &= ~ TME_LEAVE;
@@ -1075 +1076 @@
         else
             ptme->dwFlags = 0;
-    
+
         return TRUE; /* return here, TME_QUERY is retrieving information */
     }
@@ -1098 +1099 @@
             {
                 TrackingList[i] = TrackingList[--iTrackMax];
-        
+
                 if(iTrackMax == 0) {
                     KillTimer(0, timer);
@@ -1119 +1120 @@
                         TrackingList[i].tme.dwHoverTime = ptme->dwHoverTime;
                     }
- 
+
                     if(leave)
                         TrackingList[i].tme.dwFlags |= TME_LEAVE;
 
                     /* reset iHoverTime as per winapi specs */
-                    TrackingList[i].iHoverTime = 0;                  
-  
+                    TrackingList[i].iHoverTime = 0;
+
                     return TRUE;
                 }
-            }           
+            }
 
             /* if the tracking list is full return FALSE */
@@ -1198 +1199 @@
 
     hwndToolTip = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0,
-                                  CW_USEDEFAULT, CW_USEDEFAULT,
-                                  CW_USEDEFAULT, CW_USEDEFAULT, hwndOwner,
-                                  0, 0, 0);
+                  CW_USEDEFAULT, CW_USEDEFAULT,
+                  CW_USEDEFAULT, CW_USEDEFAULT, hwndOwner,
+                  0, 0, 0);
 
     /* Send NM_TOOLTIPSCREATED notification */
     if (hwndToolTip)
     {
-        NMTOOLTIPSCREATED nmttc;
+    NMTOOLTIPSCREATED nmttc;
         /* true owner can be different if hwndOwner is a child window */
         HWND hwndTrueOwner = GetWindow(hwndToolTip, GW_OWNER);
         nmttc.hdr.hwndFrom = hwndTrueOwner;
         nmttc.hdr.idFrom = GetWindowLongA(hwndTrueOwner, GWL_ID);
-        nmttc.hdr.code = NM_TOOLTIPSCREATED;
-        nmttc.hwndToolTips = hwndToolTip;
+    nmttc.hdr.code = NM_TOOLTIPSCREATED;
+    nmttc.hwndToolTips = hwndToolTip;
 
        SendMessageA(GetParent(hwndTrueOwner), WM_NOTIFY,
                     (WPARAM)GetWindowLongA(hwndTrueOwner, GWL_ID),
-                     (LPARAM)&nmttc);
+             (LPARAM)&nmttc);
     }
 

trunk/src/comctl32/comctl32undoc.c

@@ +1 @@
+/* $Id: comctl32undoc.c,v 1.22 2001-09-05 12:04:57 bird Exp $ */
 /*
  * Undocumented functions from COMCTL32.DLL
@@ -98 +99 @@
 
     FIXME ("phDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
-           phDpa, loadProc, pStream, lParam);
+       phDpa, loadProc, pStream, lParam);
 
     if (!phDpa || !loadProc || !pStream)
-        return E_INVALIDARG;
+    return E_INVALIDARG;
 
     *phDpa = (HDPA)NULL;
@@ -110 +111 @@
     errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &newPosition);
     if (errCode != S_OK)
-        return errCode;
+    return errCode;
 
     errCode = IStream_Read (pStream, &streamData, sizeof(STREAMDATA), &ulRead);
     if (errCode != S_OK)
-        return errCode;
+    return errCode;
 
     FIXME ("dwSize=%lu dwData2=%lu dwItems=%lu\n",
-           streamData.dwSize, streamData.dwData2, streamData.dwItems);
+       streamData.dwSize, streamData.dwData2, streamData.dwItems);
 
     if (lParam < sizeof(STREAMDATA) ||
-        streamData.dwSize < sizeof(STREAMDATA) ||
-        streamData.dwData2 < 1) {
-        errCode = E_FAIL;
+    streamData.dwSize < sizeof(STREAMDATA) ||
+    streamData.dwData2 < 1) {
+    errCode = E_FAIL;
     }
 
@@ -128 +129 @@
     hDpa = DPA_Create (streamData.dwItems);
     if (!hDpa)
-        return E_OUTOFMEMORY;
+    return E_OUTOFMEMORY;
 
     if (!DPA_Grow (hDpa, streamData.dwItems))
-        return E_OUTOFMEMORY;
+    return E_OUTOFMEMORY;
 
     /* load data from the stream into the dpa */
@@ -137 +138 @@
     for (loadData.nCount = 0; loadData.nCount < streamData.dwItems; loadData.nCount++) {
         errCode = (loadProc)(&loadData, pStream, lParam);
-        if (errCode != S_OK) {
-            errCode = S_FALSE;
-            break;
-        }
-
-        *ptr = loadData.ptr;
-        ptr++;
+    if (errCode != S_OK) {
+        errCode = S_FALSE;
+        break;
+    }
+
+    *ptr = loadData.ptr;
+    ptr++;
     }
 
@@ -177 +178 @@
 
     FIXME ("hDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
-           hDpa, loadProc, pStream, lParam);
+       hDpa, loadProc, pStream, lParam);
 
     return E_FAIL;
@@ -200 +201 @@
 BOOL WINAPI
 DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
-           PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
+       PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
 {
     INT nCount;
@@ -208 +209 @@
 
     TRACE("%p %p %08lx %p %p %08lx)\n",
-           hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
+       hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
 
     if (IsBadWritePtr (hdpa1, sizeof(DPA)))
-        return FALSE;
+    return FALSE;
 
     if (IsBadWritePtr (hdpa2, sizeof(DPA)))
-        return FALSE;
+    return FALSE;
 
     if (IsBadCodePtr ((FARPROC)pfnCompare))
-        return FALSE;
+    return FALSE;
 
     if (IsBadCodePtr ((FARPROC)pfnMerge))
-        return FALSE;
+    return FALSE;
 
     if (dwFlags & DPAM_SORT) {
-        TRACE("sorting dpa's!\n");
-        if (hdpa1->nItemCount > 0)
-        DPA_Sort (hdpa1, pfnCompare, lParam);
-        TRACE ("dpa 1 sorted!\n");
-        if (hdpa2->nItemCount > 0)
-        DPA_Sort (hdpa2, pfnCompare, lParam);
-        TRACE ("dpa 2 sorted!\n");
+    TRACE("sorting dpa's!\n");
+    if (hdpa1->nItemCount > 0)
+    DPA_Sort (hdpa1, pfnCompare, lParam);
+    TRACE ("dpa 1 sorted!\n");
+    if (hdpa2->nItemCount > 0)
+    DPA_Sort (hdpa2, pfnCompare, lParam);
+    TRACE ("dpa 2 sorted!\n");
     }
 
     if (hdpa2->nItemCount < 1)
-        return TRUE;
+    return TRUE;
 
     TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
-           hdpa1->nItemCount, hdpa2->nItemCount);
+       hdpa1->nItemCount, hdpa2->nItemCount);
 
 
@@ -250 +251 @@
     {
         if (nIndex < 0) break;
-        nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
-        TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n", 
-              nResult, nIndex, nCount);
-
-        if (nResult == 0)
-        {
-            PVOID ptr;
-
-            ptr = (pfnMerge)(1, *pWork1, *pWork2, lParam);
-            if (!ptr)
-                return FALSE;
-
-            nCount--;
-            pWork2--;
-            *pWork1 = ptr;
-            nIndex--;
-            pWork1--;
-        }
-        else if (nResult < 0)
-        {
-            if (!dwFlags & 8)
-            {
-                PVOID ptr;
-
-                ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
-
-                (pfnMerge)(2, ptr, NULL, lParam);
-            }
-            nIndex--;
-            pWork1--;
-        }
-        else
-        {
-            if (!dwFlags & 4)
-            {
-                PVOID ptr;
-
-                ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
-                if (!ptr)
-                    return FALSE;
-                DPA_InsertPtr (hdpa1, nIndex, ptr);
-            }
-            nCount--;
-            pWork2--;
-        }
+    nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
+    TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
+          nResult, nIndex, nCount);
+
+    if (nResult == 0)
+    {
+        PVOID ptr;
+
+        ptr = (pfnMerge)(1, *pWork1, *pWork2, lParam);
+        if (!ptr)
+        return FALSE;
+
+        nCount--;
+        pWork2--;
+        *pWork1 = ptr;
+        nIndex--;
+        pWork1--;
+    }
+    else if (nResult < 0)
+    {
+        if (!dwFlags & 8)
+        {
+        PVOID ptr;
+
+        ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
+
+        (pfnMerge)(2, ptr, NULL, lParam);
+        }
+        nIndex--;
+        pWork1--;
+    }
+    else
+    {
+        if (!dwFlags & 4)
+        {
+        PVOID ptr;
+
+        ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
+        if (!ptr)
+            return FALSE;
+        DPA_InsertPtr (hdpa1, nIndex, ptr);
+        }
+        nCount--;
+        pWork2--;
+    }
 
     }
@@ -358 +359 @@
 
     if (lpSrc)
-        lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
+    lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
     else
-        lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
+    lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
 
     TRACE("-- ret=%p\n", lpDest);
@@ -458 +459 @@
 HANDLE WINAPI
 CreateMRUListLazyA (LPCREATEMRULIST lpcml, DWORD dwParam2,
-                    DWORD dwParam3, DWORD dwParam4);
+            DWORD dwParam3, DWORD dwParam4);
 
 
@@ -490 +491 @@
 #if 0
     if (!(hmru->dwParam1 & 1001)) {
-        RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
-                          hmru->lpszMRUString,
-                          strlen (hmru->lpszMRUString));
+    RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
+              hmru->lpszMRUString,
+              strlen (hmru->lpszMRUString));
     }
 
@@ -506 +507 @@
 /**************************************************************************
  *              AddMRUData [COMCTL32.167]
- * 
+ *
  * Add item to MRU binary list.  If item already exists in list then it is
  * simply moved up to the top of the list and not added again.  If list is
@@ -530 +531 @@
 /**************************************************************************
  *              AddMRUStringA [COMCTL32.153]
- * 
+ *
  * Add item to MRU string list.  If item already exists in list them it is
  * simply moved up to the top of the list and not added again.  If list is
@@ -572 +573 @@
 /**************************************************************************
  *                  FindMRUData [COMCTL32.169]
- * 
+ *
  * Searches binary list for item that matches lpData of length cbData.
  * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
@@ -590 +591 @@
 {
     FIXME("(%08x, %p, %ld, %p) empty stub!\n",
-           hList, lpData, cbData, lpRegNum);
+       hList, lpData, cbData, lpRegNum);
 
     return 0;
@@ -597 +598 @@
 /**************************************************************************
  *                  FindMRUStringA [COMCTL32.155]
- * 
+ *
  * Searches string list for item that matches lpszString.
  * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
@@ -614 +615 @@
 {
     FIXME("(%08x, %s, %p) empty stub!\n", hList, debugstr_a(lpszString),
-          lpRegNum);
+      lpRegNum);
 
     return 0;
@@ -640 +641 @@
 
     if (lpcml == NULL)
-        return 0;
+    return 0;
 
     if (lpcml->cbSize < sizeof(CREATEMRULIST))
-        return 0;
+    return 0;
 
     FIXME("(%lu %lu %lx %lx \"%s\" %p)\n",
-          lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
-          (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare);
+      lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
+      (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare);
 
     /* dummy pointer creation */
@@ -659 +660 @@
 /**************************************************************************
  *                EnumMRUListA [COMCTL32.154]
- * 
+ *
  * Enumerate item in a list
  *
@@ -673 +674 @@
  *    of list returns -1.
  *    If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
- *    the list. 
+ *    the list.
  */
 INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer,
@@ -679 +680 @@
 {
     FIXME("(%08x, %d, %p, %ld): stub\n", hList, nItemPos, lpBuffer,
-          nBufferSize);
+      nBufferSize);
     return 0;
 }
@@ -702 +703 @@
 
     if (!lpDest && lpSrc)
-        return strlen (lpSrc);
+    return strlen (lpSrc);
 
     if (nMaxLen == 0)
-        return 0;
+    return 0;
 
     if (lpSrc == NULL) {
-        lpDest[0] = '\0';
-        return 0;
+    lpDest[0] = '\0';
+    return 0;
     }
 
     len = strlen (lpSrc);
     if (len >= nMaxLen)
-        len = nMaxLen - 1;
+    len = nMaxLen - 1;
 
     RtlMoveMemory (lpDest, lpSrc, len);
@@ -737 +738 @@
 {
     TRACE("(%p %p)\n", lppDest, lpSrc);
- 
+
     if (lpSrc) {
-        LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
-        if (!ptr)
-            return FALSE;
-        strcpy (ptr, lpSrc);
-        *lppDest = ptr;
+    LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
+    if (!ptr)
+        return FALSE;
+    strcpy (ptr, lpSrc);
+    *lppDest = ptr;
     }
     else {
-        if (*lppDest) {
-            COMCTL32_Free (*lppDest);
-            *lppDest = NULL;
-        }
+    if (*lppDest) {
+        COMCTL32_Free (*lppDest);
+        *lppDest = NULL;
+    }
     }
 
@@ -775 +776 @@
 
     if (!lpDest && lpSrc)
-        return strlenW (lpSrc);
+    return strlenW (lpSrc);
 
     if (nMaxLen == 0)
-        return 0;
+    return 0;
 
     if (lpSrc == NULL) {
-        lpDest[0] = L'\0';
-        return 0;
+    lpDest[0] = L'\0';
+    return 0;
     }
 
     len = strlenW (lpSrc);
     if (len >= nMaxLen)
-        len = nMaxLen - 1;
+    len = nMaxLen - 1;
 
     RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
@@ -810 +811 @@
 {
     TRACE("(%p %p)\n", lppDest, lpSrc);
- 
+
     if (lpSrc) {
-        INT len = strlenW (lpSrc) + 1;
-        LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
-        if (!ptr)
-            return FALSE;
-        strcpyW (ptr, lpSrc);
-        *lppDest = ptr;
+    INT len = strlenW (lpSrc) + 1;
+    LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
+    if (!ptr)
+        return FALSE;
+    strcpyW (ptr, lpSrc);
+    *lppDest = ptr;
     }
     else {
-        if (*lppDest) {
-            COMCTL32_Free (*lppDest);
-            *lppDest = NULL;
-        }
+    if (*lppDest) {
+        COMCTL32_Free (*lppDest);
+        *lppDest = NULL;
+    }
     }
 
@@ -852 +853 @@
 
     if (!lpDest && lpSrc)
-        return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
+    return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
 
     if (nMaxLen == 0)
-        return 0;
+    return 0;
 
     if (lpSrc == NULL) {
-        lpDest[0] = '\0';
-        return 0;
+    lpDest[0] = '\0';
+    return 0;
     }
 
     len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
     if (len >= nMaxLen)
-        len = nMaxLen - 1;
+    len = nMaxLen - 1;
 
     WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
@@ -897 +898 @@
 
     if (lpSrc) {
-        INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
-        LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len*sizeof(WCHAR));
-
-        if (!ptr)
-            return FALSE;
-        MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
-        *lppDest = ptr;
+    INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
+    LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len*sizeof(WCHAR));
+
+    if (!ptr)
+        return FALSE;
+    MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
+    *lppDest = ptr;
     }
     else {
-        if (*lppDest) {
-            COMCTL32_Free (*lppDest);
-            *lppDest = NULL;
-        }
+    if (*lppDest) {
+        COMCTL32_Free (*lppDest);
+        *lppDest = NULL;
+    }
     }
 
@@ -944 +945 @@
     if (hdsa)
     {
-        hdsa->nItemCount = 0;
+    hdsa->nItemCount = 0;
         hdsa->pData = NULL;
-        hdsa->nMaxCount = 0;
-        hdsa->nItemSize = nSize;
-        hdsa->nGrow = max(1, nGrow);
+    hdsa->nMaxCount = 0;
+    hdsa->nItemSize = nSize;
+    hdsa->nGrow = max(1, nGrow);
     }
 
@@ -972 +973 @@
 
     if (!hdsa)
-        return FALSE;
+    return FALSE;
 
     if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
-        return FALSE;
+    return FALSE;
 
     return COMCTL32_Free (hdsa);
@@ -982 +983 @@
 
 /**************************************************************************
- * DSA_GetItem [COMCTL32.322] 
+ * DSA_GetItem [COMCTL32.322]
  *
  * PARAMS
@@ -1000 +1001 @@
 
     TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
-    
+
     if (!hdsa)
-        return FALSE;
+    return FALSE;
     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
-        return FALSE;
+    return FALSE;
 
     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
@@ -1014 +1015 @@
 
 /**************************************************************************
- * DSA_GetItemPtr [COMCTL32.323] 
+ * DSA_GetItemPtr [COMCTL32.323]
  *
  * Retrieves a pointer to the specified item.
@@ -1035 +1036 @@
 
     if (!hdsa)
-        return NULL;
+    return NULL;
     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
-        return NULL;
+    return NULL;
 
     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
-    
+
     TRACE("-- ret=%p\n", pSrc);
 
@@ -1048 +1049 @@
 
 /**************************************************************************
- * DSA_SetItem [COMCTL32.325] 
+ * DSA_SetItem [COMCTL32.325]
  *
  * Sets the contents of an item in the array.
@@ -1067 +1068 @@
     INT  nSize, nNewItems;
     LPVOID pDest, lpTemp;
-    
+
     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
 
     if ((!hdsa) || nIndex < 0)
-        return FALSE;
-      
+    return FALSE;
+
     if (hdsa->nItemCount <= nIndex) {
-        /* within the old array */
-        if (hdsa->nMaxCount > nIndex) {
-            /* within the allocated space, set a new boundary */
-            hdsa->nItemCount = nIndex + 1;
-        }
-        else {
-            /* resize the block of memory */
-            nNewItems =
-                hdsa->nGrow * ((INT)(((nIndex + 1) - 1) / hdsa->nGrow) + 1);
-            nSize = hdsa->nItemSize * nNewItems;
-
-            lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
-            if (!lpTemp)
-                return FALSE;
-
-            hdsa->nMaxCount = nNewItems;
-            hdsa->nItemCount = nIndex + 1;
-            hdsa->pData = lpTemp;
-        }    
+    /* within the old array */
+    if (hdsa->nMaxCount > nIndex) {
+        /* within the allocated space, set a new boundary */
+        hdsa->nItemCount = nIndex + 1;
+    }
+    else {
+        /* resize the block of memory */
+        nNewItems =
+        hdsa->nGrow * ((INT)(((nIndex + 1) - 1) / hdsa->nGrow) + 1);
+        nSize = hdsa->nItemSize * nNewItems;
+
+        lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
+        if (!lpTemp)
+        return FALSE;
+
+        hdsa->nMaxCount = nNewItems;
+        hdsa->nItemCount = nIndex + 1;
+        hdsa->pData = lpTemp;
+    }
     }
 
@@ -1098 +1099 @@
     pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
     TRACE("-- move dest=%p src=%p size=%d\n",
-           pDest, pSrc, hdsa->nItemSize);
+       pDest, pSrc, hdsa->nItemSize);
     memmove (pDest, pSrc, hdsa->nItemSize);
 
@@ -1106 +1107 @@
 
 /**************************************************************************
- * DSA_InsertItem [COMCTL32.324] 
+ * DSA_InsertItem [COMCTL32.324]
  *
  * PARAMS
@@ -1124 +1125 @@
     LPVOID  lpTemp, lpDest;
     LPDWORD p;
-    
+
     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
 
     if ((!hdsa) || nIndex < 0)
-        return -1;
+    return -1;
 
     for (i = 0; i < hdsa->nItemSize; i += 4) {
-        p = *(DWORD**)((char *) pSrc + i);
-        if (IsBadStringPtrA ((char*)p, 256))
-            TRACE("-- %d=%p\n", i, (DWORD*)p);
-        else
-            TRACE("-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
-    }
-   
+    p = *(DWORD**)((char *) pSrc + i);
+    if (IsBadStringPtrA ((char*)p, 256))
+        TRACE("-- %d=%p\n", i, (DWORD*)p);
+    else
+        TRACE("-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
+    }
+
     /* when nIndex >= nItemCount then append */
     if (nIndex >= hdsa->nItemCount)
-        nIndex = hdsa->nItemCount;
+    nIndex = hdsa->nItemCount;
 
     /* do we need to resize ? */
     if (hdsa->nItemCount >= hdsa->nMaxCount) {
-        nNewItems = hdsa->nMaxCount + hdsa->nGrow;
-        nSize = hdsa->nItemSize * nNewItems;
-
-        lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
-        if (!lpTemp)
-            return -1;
-
-        hdsa->nMaxCount = nNewItems;
-        hdsa->pData = lpTemp;         
+    nNewItems = hdsa->nMaxCount + hdsa->nGrow;
+    nSize = hdsa->nItemSize * nNewItems;
+
+    lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
+    if (!lpTemp)
+        return -1;
+
+    hdsa->nMaxCount = nNewItems;
+    hdsa->pData = lpTemp;
     }
 
     /* do we need to move elements ? */
     if (nIndex < hdsa->nItemCount) {
-        lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
-        lpDest = (char *) lpTemp + hdsa->nItemSize;
-        nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
-        TRACE("-- move dest=%p src=%p size=%d\n",
-               lpDest, lpTemp, nSize);
-        memmove (lpDest, lpTemp, nSize);
+    lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+    lpDest = (char *) lpTemp + hdsa->nItemSize;
+    nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
+    TRACE("-- move dest=%p src=%p size=%d\n",
+           lpDest, lpTemp, nSize);
+    memmove (lpDest, lpTemp, nSize);
     }
 
@@ -1169 +1170 @@
     lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
     TRACE("-- move dest=%p src=%p size=%d\n",
-           lpDest, pSrc, hdsa->nItemSize);
+       lpDest, pSrc, hdsa->nItemSize);
     memmove (lpDest, pSrc, hdsa->nItemSize);
 
@@ -1177 +1178 @@
 
 /**************************************************************************
- * DSA_DeleteItem [COMCTL32.326] 
+ * DSA_DeleteItem [COMCTL32.326]
  *
  * PARAMS
@@ -1193 +1194 @@
     LPVOID lpDest,lpSrc;
     INT  nSize;
-    
+
     TRACE("(%p %d)\n", hdsa, nIndex);
 
     if (!hdsa)
-        return -1;
+    return -1;
     if (nIndex < 0 || nIndex >= hdsa->nItemCount)
-        return -1;
+    return -1;
 
     /* do we need to move ? */
     if (nIndex < hdsa->nItemCount - 1) {
-        lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
-        lpSrc = (char *) lpDest + hdsa->nItemSize;
-        nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
-        TRACE("-- move dest=%p src=%p size=%d\n",
-               lpDest, lpSrc, nSize);
-        memmove (lpDest, lpSrc, nSize);
-    }
-    
+    lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
+    lpSrc = (char *) lpDest + hdsa->nItemSize;
+    nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
+    TRACE("-- move dest=%p src=%p size=%d\n",
+           lpDest, lpSrc, nSize);
+    memmove (lpDest, lpSrc, nSize);
+    }
+
     hdsa->nItemCount--;
-    
+
     /* free memory ? */
     if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
-        nSize = hdsa->nItemSize * hdsa->nItemCount;
-
-        lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
-        if (!lpDest)
-            return -1;
-
-        hdsa->nMaxCount = hdsa->nItemCount;
-        hdsa->pData = lpDest;
+    nSize = hdsa->nItemSize * hdsa->nItemCount;
+
+    lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
+    if (!lpDest)
+        return -1;
+
+    hdsa->nMaxCount = hdsa->nItemCount;
+    hdsa->pData = lpDest;
     }
 
@@ -1247 +1248 @@
     TRACE("(%p)\n", hdsa);
 
-    if (!hdsa) 
-        return FALSE;
+    if (!hdsa)
+    return FALSE;
     if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
-        return FALSE;
+    return FALSE;
 
     hdsa->nItemCount = 0;
@@ -1285 +1286 @@
     hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
     if (hdpa) {
-        hdpa->nGrow = max(8, nGrow);
-        hdpa->hHeap = COMCTL32_hHeap;
-        hdpa->nMaxCount = hdpa->nGrow * 2;
-        hdpa->ptrs =
-            (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
+    hdpa->nGrow = max(8, nGrow);
+    hdpa->hHeap = COMCTL32_hHeap;
+    hdpa->nMaxCount = hdpa->nGrow * 2;
+    hdpa->ptrs =
+        (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
     }
 
@@ -1315 +1316 @@
 
     if (!hdpa)
-        return FALSE;
+    return FALSE;
 
     if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
-        return FALSE;
+    return FALSE;
 
     return HeapFree (hdpa->hHeap, 0, hdpa);
@@ -1344 +1345 @@
 
     if (!hdpa)
-        return FALSE;
+    return FALSE;
 
     hdpa->nGrow = max(8, nGrow);
@@ -1379 +1380 @@
 
     if (!hdpa)
-        return NULL;
+    return NULL;
 
     TRACE("(%p %p)\n", hdpa, hdpaNew);
 
     if (!hdpaNew) {
-        /* create a new DPA */
-        hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
-                                    sizeof(DPA));
-        hdpaTemp->hHeap = hdpa->hHeap;
-        hdpaTemp->nGrow = hdpa->nGrow;
+    /* create a new DPA */
+    hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                    sizeof(DPA));
+    hdpaTemp->hHeap = hdpa->hHeap;
+    hdpaTemp->nGrow = hdpa->nGrow;
     }
     else
-        hdpaTemp = hdpaNew;
+    hdpaTemp = hdpaNew;
 
     if (hdpaTemp->ptrs) {
-        /* remove old pointer array */
-        HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
-        hdpaTemp->ptrs = NULL;
-        hdpaTemp->nItemCount = 0;
-        hdpaTemp->nMaxCount = 0;
+    /* remove old pointer array */
+    HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
+    hdpaTemp->ptrs = NULL;
+    hdpaTemp->nItemCount = 0;
+    hdpaTemp->nMaxCount = 0;
     }
 
     /* create a new pointer array */
     nNewItems = hdpaTemp->nGrow *
-                ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
+        ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
     nSize = nNewItems * sizeof(LPVOID);
     hdpaTemp->ptrs =
-        (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
+    (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
     hdpaTemp->nMaxCount = nNewItems;
 
@@ -1412 +1413 @@
     hdpaTemp->nItemCount = hdpa->nItemCount;
     memmove (hdpaTemp->ptrs, hdpa->ptrs,
-             hdpaTemp->nItemCount * sizeof(LPVOID));
+         hdpaTemp->nItemCount * sizeof(LPVOID));
 
     return hdpaTemp;
@@ -1438 +1439 @@
 
     if (!hdpa)
-        return NULL;
+    return NULL;
     if (!hdpa->ptrs) {
-        WARN("no pointer array.\n");
-        return NULL;
+    WARN("no pointer array.\n");
+    return NULL;
     }
     if ((i < 0) || (i >= hdpa->nItemCount)) {
-        WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
-        return NULL;
+    WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
+    return NULL;
     }
 
@@ -1474 +1475 @@
 
     if (!hdpa->ptrs)
-        return -1;
+    return -1;
 
     for (i = 0; i < hdpa->nItemCount; i++) {
-        if (hdpa->ptrs[i] == p)
-            return i;
+    if (hdpa->ptrs[i] == p)
+        return i;
     }
 
@@ -1509 +1510 @@
 
     if ((!hdpa) || (i < 0))
-        return -1;
+    return -1;
 
     if (!hdpa->ptrs) {
-        hdpa->ptrs =
-            (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
-                                2 * hdpa->nGrow * sizeof(LPVOID));
-        if (!hdpa->ptrs)
-            return -1;
-        hdpa->nMaxCount = hdpa->nGrow * 2;
+    hdpa->ptrs =
+        (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                2 * hdpa->nGrow * sizeof(LPVOID));
+    if (!hdpa->ptrs)
+        return -1;
+    hdpa->nMaxCount = hdpa->nGrow * 2;
         nIndex = 0;
     }
     else {
-        if (hdpa->nItemCount >= hdpa->nMaxCount) {
-            TRACE("-- resizing\n");
-            nNewItems = hdpa->nMaxCount + hdpa->nGrow;
-            nSize = nNewItems * sizeof(LPVOID);
-
-            lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
-                                           hdpa->ptrs, nSize);
-            if (!lpTemp)
-                return -1;
-            hdpa->nMaxCount = nNewItems;
-            hdpa->ptrs = lpTemp;
-        }
-
-        if (i >= hdpa->nItemCount) {
-            nIndex = hdpa->nItemCount;
-            TRACE("-- appending at %d\n", nIndex);
-        }
-        else {
-            TRACE("-- inserting at %d\n", i);
-            lpTemp = hdpa->ptrs + i;
-            lpDest = lpTemp + 1;
-            nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
-            TRACE("-- move dest=%p src=%p size=%x\n",
-                   lpDest, lpTemp, nSize);
-            memmove (lpDest, lpTemp, nSize);
-            nIndex = i;
-        }
+    if (hdpa->nItemCount >= hdpa->nMaxCount) {
+        TRACE("-- resizing\n");
+        nNewItems = hdpa->nMaxCount + hdpa->nGrow;
+        nSize = nNewItems * sizeof(LPVOID);
+
+        lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                       hdpa->ptrs, nSize);
+        if (!lpTemp)
+        return -1;
+        hdpa->nMaxCount = nNewItems;
+        hdpa->ptrs = lpTemp;
+    }
+
+    if (i >= hdpa->nItemCount) {
+        nIndex = hdpa->nItemCount;
+        TRACE("-- appending at %d\n", nIndex);
+    }
+    else {
+        TRACE("-- inserting at %d\n", i);
+        lpTemp = hdpa->ptrs + i;
+        lpDest = lpTemp + 1;
+        nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
+        TRACE("-- move dest=%p src=%p size=%x\n",
+           lpDest, lpTemp, nSize);
+        memmove (lpDest, lpTemp, nSize);
+        nIndex = i;
+    }
     }
 
@@ -1577 +1578 @@
 {
     LPVOID *lpTemp;
-    
+
     TRACE("(%p %d %p)\n", hdpa, i, p);
 
     if ((!hdpa) || i < 0)
-        return FALSE;
-      
+    return FALSE;
+
     if (hdpa->nItemCount <= i) {
-        /* within the old array */
-        if (hdpa->nMaxCount > i) {
-            /* within the allocated space, set a new boundary */
-            hdpa->nItemCount = i+1;
-        }
-        else {
-            /* resize the block of memory */
-            INT nNewItems =
-                hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1);
-            INT nSize = nNewItems * sizeof(LPVOID);
-
-            lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
-                                           hdpa->ptrs, nSize);
-            if (!lpTemp)
-                return FALSE;
-
-            hdpa->nItemCount = nNewItems;
-            hdpa->ptrs = lpTemp;        
-        }    
+    /* within the old array */
+    if (hdpa->nMaxCount > i) {
+        /* within the allocated space, set a new boundary */
+        hdpa->nItemCount = i+1;
+    }
+    else {
+        /* resize the block of memory */
+        INT nNewItems =
+        hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1);
+        INT nSize = nNewItems * sizeof(LPVOID);
+
+        lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                       hdpa->ptrs, nSize);
+        if (!lpTemp)
+        return FALSE;
+
+        hdpa->nItemCount = nNewItems;
+        hdpa->ptrs = lpTemp;
+    }
     }
 
@@ -1631 +1632 @@
     LPVOID *lpDest, *lpSrc, lpTemp = NULL;
     INT  nSize;
-    
+
     TRACE("(%p %d)\n", hdpa, i);
 
     if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
-        return NULL;
+    return NULL;
 
     lpTemp = hdpa->ptrs[i];
@@ -1641 +1642 @@
     /* do we need to move ?*/
     if (i < hdpa->nItemCount - 1) {
-        lpDest = hdpa->ptrs + i;
-        lpSrc = lpDest + 1;
-        nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
-        TRACE("-- move dest=%p src=%p size=%x\n",
-               lpDest, lpSrc, nSize);
-        memmove (lpDest, lpSrc, nSize);
-    }
-    
+    lpDest = hdpa->ptrs + i;
+    lpSrc = lpDest + 1;
+    nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
+    TRACE("-- move dest=%p src=%p size=%x\n",
+           lpDest, lpSrc, nSize);
+    memmove (lpDest, lpSrc, nSize);
+    }
+
     hdpa->nItemCount --;
-    
+
     /* free memory ?*/
     if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
-        INT nNewItems = max(hdpa->nGrow * 2, hdpa->nItemCount);
-        nSize = nNewItems * sizeof(LPVOID);
-        lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
-                                      hdpa->ptrs, nSize);
-        if (!lpDest)
-            return NULL;
-
-        hdpa->nMaxCount = nNewItems;
-        hdpa->ptrs = (LPVOID*)lpDest;         
+    INT nNewItems = max(hdpa->nGrow * 2, hdpa->nItemCount);
+    nSize = nNewItems * sizeof(LPVOID);
+    lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
+                      hdpa->ptrs, nSize);
+    if (!lpDest)
+        return NULL;
+
+    hdpa->nMaxCount = nNewItems;
+    hdpa->ptrs = (LPVOID*)lpDest;
     }
 
@@ -1686 +1687 @@
     TRACE("(%p)\n", hdpa);
 
-    if (!hdpa) 
-        return FALSE;
+    if (!hdpa)
+    return FALSE;
 
     if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
-        return FALSE;
+    return FALSE;
 
     hdpa->nItemCount = 0;
     hdpa->nMaxCount = hdpa->nGrow * 2;
     hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
-                                     hdpa->nMaxCount * sizeof(LPVOID));
+                     hdpa->nMaxCount * sizeof(LPVOID));
 
     return TRUE;
@@ -1719 +1720 @@
 static VOID
 DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r,
-               PFNDPACOMPARE pfnCompare, LPARAM lParam)
+           PFNDPACOMPARE pfnCompare, LPARAM lParam)
 {
     INT m;
@@ -1725 +1726 @@
 
     TRACE("l=%i r=%i\n", l, r);
- 
+
     if (l==r)    /* one element is always sorted */
         return;
     if (r<l)     /* oops, got it in the wrong order */
-        {
+    {
         DPA_QuickSort(lpPtrs, r, l, pfnCompare, lParam);
         return;
-        }
+    }
     m = (l+r)/2; /* divide by two */
     DPA_QuickSort(lpPtrs, l, m, pfnCompare, lParam);
@@ -1738 +1739 @@
 
     /* join the two sides */
-    while( (l<=m) && (m<r) ) 
+    while( (l<=m) && (m<r) )
     {
         if(pfnCompare(lpPtrs[l],lpPtrs[m+1],lParam)>0)
@@ -1772 +1773 @@
 {
     if (!hdpa || !pfnCompare)
-        return FALSE;
+    return FALSE;
 
     TRACE("(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
 
     if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
-        DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
-                       pfnCompare, lParam);
+    DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
+               pfnCompare, lParam);
 
     return TRUE;
@@ -1809 +1810 @@
 INT WINAPI
 DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart,
-            PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
+        PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
 {
     if (!hdpa || !pfnCompare || !pFind)
-        return -1;
+    return -1;
 
     TRACE("(%p %p %d %p 0x%08lx 0x%08x)\n",
-           hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
+       hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
 
     if (uOptions & DPAS_SORTED) {
-        /* array is sorted --> use binary search */
-        INT l, r, x, n;
-        LPVOID *lpPtr;
-
-        TRACE("binary search\n");
-
-        l = (nStart == -1) ? 0 : nStart;
-        r = hdpa->nItemCount - 1;
-        lpPtr = hdpa->ptrs;
-        while (r >= l) {
-            x = (l + r) / 2;
-            n = (pfnCompare)(pFind, lpPtr[x], lParam);
-            if (n < 0)
-                r = x - 1;
-            else
-                l = x + 1;
-            if (n == 0) {
-                TRACE("-- ret=%d\n", n);
-                return n;
-            }
-        }
-
-        if (uOptions & DPAS_INSERTBEFORE) {
-            TRACE("-- ret=%d\n", r);
-            return r;
-        }
-
-        if (uOptions & DPAS_INSERTAFTER) {
-            TRACE("-- ret=%d\n", l);
-            return l;
-        }
+    /* array is sorted --> use binary search */
+    INT l, r, x, n;
+    LPVOID *lpPtr;
+
+    TRACE("binary search\n");
+
+    l = (nStart == -1) ? 0 : nStart;
+    r = hdpa->nItemCount - 1;
+    lpPtr = hdpa->ptrs;
+    while (r >= l) {
+        x = (l + r) / 2;
+        n = (pfnCompare)(pFind, lpPtr[x], lParam);
+        if (n < 0)
+        r = x - 1;
+        else
+        l = x + 1;
+        if (n == 0) {
+        TRACE("-- ret=%d\n", n);
+        return n;
+        }
+    }
+
+    if (uOptions & DPAS_INSERTBEFORE) {
+        TRACE("-- ret=%d\n", r);
+        return r;
+    }
+
+    if (uOptions & DPAS_INSERTAFTER) {
+        TRACE("-- ret=%d\n", l);
+        return l;
+    }
     }
     else {
-        /* array is not sorted --> use linear search */
-        LPVOID *lpPtr;
-        INT  nIndex;
-
-        TRACE("linear search\n");
-        
-        nIndex = (nStart == -1)? 0 : nStart;
-        lpPtr = hdpa->ptrs;
-        for (; nIndex < hdpa->nItemCount; nIndex++) {
-            if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
-                TRACE("-- ret=%d\n", nIndex);
-                return nIndex;
-            }
-        }
+    /* array is not sorted --> use linear search */
+    LPVOID *lpPtr;
+    INT  nIndex;
+
+    TRACE("linear search\n");
+
+    nIndex = (nStart == -1)? 0 : nStart;
+    lpPtr = hdpa->ptrs;
+    for (; nIndex < hdpa->nItemCount; nIndex++) {
+        if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
+        TRACE("-- ret=%d\n", nIndex);
+        return nIndex;
+        }
+    }
     }
 
@@ -1894 +1895 @@
 
     if (hHeap)
-        hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
+    hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
     else
-        hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
+    hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
 
     if (hdpa) {
-        hdpa->nGrow = min(8, nGrow);
-        hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
-        hdpa->nMaxCount = hdpa->nGrow * 2;
-        hdpa->ptrs =
-            (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
-                                hdpa->nMaxCount * sizeof(LPVOID));
+    hdpa->nGrow = min(8, nGrow);
+    hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
+    hdpa->nMaxCount = hdpa->nGrow * 2;
+    hdpa->ptrs =
+        (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
+                hdpa->nMaxCount * sizeof(LPVOID));
     }
 
@@ -1940 +1941 @@
 
     TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
-           lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
-           lpNotify->dwParam5);
+       lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
+       lpNotify->dwParam5);
 
     if (!lpNotify->hwndTo)
-        return 0;
+    return 0;
 
     if (lpNotify->hwndFrom == -1) {
-        lpNmh = lpHdr;
-        idFrom = lpHdr->idFrom;
+    lpNmh = lpHdr;
+    idFrom = lpHdr->idFrom;
     }
     else {
-        if (lpNotify->hwndFrom) {
-            HWND hwndParent = GetParent (lpNotify->hwndFrom);
-            if (hwndParent) {
-                hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER);
-                if (hwndParent)
-                    idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
-            }
-        }
-
-        lpNmh = (lpHdr) ? lpHdr : &nmhdr;
-
-        lpNmh->hwndFrom = lpNotify->hwndFrom;
-        lpNmh->idFrom = idFrom;
-        lpNmh->code = uCode;
+    if (lpNotify->hwndFrom) {
+        HWND hwndParent = GetParent (lpNotify->hwndFrom);
+        if (hwndParent) {
+        hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER);
+        if (hwndParent)
+            idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
+        }
+    }
+
+    lpNmh = (lpHdr) ? lpHdr : &nmhdr;
+
+    lpNmh->hwndFrom = lpNotify->hwndFrom;
+    lpNmh->idFrom = idFrom;
+    lpNmh->code = uCode;
     }
 
@@ -1987 +1988 @@
 LRESULT WINAPI
 COMCTL32_SendNotify (HWND hwndFrom, HWND hwndTo,
-                     UINT uCode, LPNMHDR lpHdr)
+             UINT uCode, LPNMHDR lpHdr)
 {
     NOTIFYDATA notify;
 
     TRACE("(0x%04x 0x%04x %d %p)\n",
-           hwndFrom, hwndTo, uCode, lpHdr);
+       hwndFrom, hwndTo, uCode, lpHdr);
 
     notify.hwndFrom = hwndFrom;
@@ -2020 +2021 @@
 LRESULT WINAPI
 COMCTL32_SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
-                       LPNMHDR lpHdr, DWORD dwParam5)
+               LPNMHDR lpHdr, DWORD dwParam5)
 {
     NOTIFYDATA notify;
@@ -2026 +2027 @@
 
     TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
-           hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
+       hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
 
     hwndNotify = hwndTo;
     if (!hwndTo) {
-        if (IsWindow (hwndFrom)) {
-            hwndNotify = GetParent (hwndFrom);
-            if (!hwndNotify)
-                return 0;
-        }
+    if (IsWindow (hwndFrom)) {
+        hwndNotify = GetParent (hwndFrom);
+        if (!hwndNotify)
+        return 0;
+    }
     }
 
@@ -2069 +2070 @@
 
     if (*lpStr2 == 0)
-        return ((LPSTR)lpStr1);
+    return ((LPSTR)lpStr1);
     len1 = 0;
     while (lpStr1[len1] != 0) ++len1;
@@ -2075 +2076 @@
     while (lpStr2[len2] != 0) ++len2;
     if (len2 == 0)
-        return ((LPSTR)(lpStr1 + len1));
+    return ((LPSTR)(lpStr1 + len1));
     first = tolower (*lpStr2);
     while (len1 >= len2) {
-        if (tolower(*lpStr1) == first) {
-            for (i = 1; i < len2; ++i)
-                if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
-                    break;
-            if (i >= len2)
-                return ((LPSTR)lpStr1);
+    if (tolower(*lpStr1) == first) {
+        for (i = 1; i < len2; ++i)
+        if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
+            break;
+        if (i >= len2)
+        return ((LPSTR)lpStr1);
         }
-        ++lpStr1; --len1;
+    ++lpStr1; --len1;
     }
     return (NULL);
@@ -2116 +2117 @@
  *
  * Enumerates all items in a dynamic pointer array.
- *
- * PARAMS
- *     hdpa     [I] handle to the dynamic pointer array
- *     enumProc [I]
- *     lParam   [I] 
- *
- * RETURNS
- *     none
- */
-
-VOID WINAPI
-DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
-{
-    INT i;
-
-    TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam);
-
-    if (!hdpa)
-        return;
-    if (hdpa->nItemCount <= 0)
-        return;
-
-    for (i = 0; i < hdpa->nItemCount; i++) {
-        if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
-            return;
-    }
-
-    return;
-}
-
-
-/**************************************************************************
- * DPA_DestroyCallback [COMCTL32.386]
- *
- * Enumerates all items in a dynamic pointer array and destroys it.
  *
  * PARAMS
@@ -2158 +2124 @@
  *
  * RETURNS
+ *     none
+ */
+
+VOID WINAPI
+DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
+{
+    INT i;
+
+    TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam);
+
+    if (!hdpa)
+    return;
+    if (hdpa->nItemCount <= 0)
+    return;
+
+    for (i = 0; i < hdpa->nItemCount; i++) {
+    if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
+        return;
+    }
+
+    return;
+}
+
+
+/**************************************************************************
+ * DPA_DestroyCallback [COMCTL32.386]
+ *
+ * Enumerates all items in a dynamic pointer array and destroys it.
+ *
+ * PARAMS
+ *     hdpa     [I] handle to the dynamic pointer array
+ *     enumProc [I]
+ *     lParam   [I]
+ *
+ * RETURNS
  *     Success: TRUE
  *     Failure: FALSE
@@ -2195 +2196 @@
 
     if (!hdsa)
-        return;
+    return;
     if (hdsa->nItemCount <= 0)
-        return;
+    return;
 
     for (i = 0; i < hdsa->nItemCount; i++) {
-        LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
-        if ((enumProc)(lpItem, lParam) == 0)
-            return;
+    LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
+    if ((enumProc)(lpItem, lParam) == 0)
+        return;
     }
 
@@ -2301 +2302 @@
         if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
         lpGotIt = lpStart;
-    }    
+    }
     return (LPSTR)lpGotIt;
 }
@@ -2355 +2356 @@
     if( strchrW(lpSet, *(WORD*)lpLoop))
       return (INT)(lpLoop-lpStr);
-  
+
   return (INT)(lpLoop-lpStr);
 }
@@ -2399 +2400 @@
 
     if (IsWindow (hwnd) == FALSE)
-        return FALSE;
+    return FALSE;
 
     if (b == 0)
-        return FALSE;
+    return FALSE;
 
 

trunk/src/comctl32/datetime.c

@@ +1 @@
+/* $Id: datetime.c,v 1.18 2001-09-05 12:04:57 bird Exp $ */
 /*
  * Date and time picker control
@@ -34 +35 @@
         COMCTL32_HEADER header;
 #endif
-        HWND hMonthCal;
-        HWND hUpdown;
-        SYSTEMTIME date;
-        BOOL dateValid;
-        HWND hwndCheckbut;
-        RECT rcClient; /* rect around the edge of the window */
-        RECT rcDraw; /* rect inside of the border */
-        RECT checkbox;  /* checkbox allowing the control to be enabled/disabled */
-        RECT calbutton; /* button that toggles the dropdown of the monthcal control */
-        BOOL bCalDepressed; /* TRUE = cal button is depressed */
-        int  select;
-        HFONT hFont;
-        int nrFieldsAllocated;
-        int nrFields;
-        int haveFocus;
-        int *fieldspec;
-        RECT *fieldRect;
-        int  *buflen;           
-        char textbuf[256];
+    HWND hMonthCal;
+    HWND hUpdown;
+    SYSTEMTIME date;
+    BOOL dateValid;
+    HWND hwndCheckbut;
+    RECT rcClient; /* rect around the edge of the window */
+    RECT rcDraw; /* rect inside of the border */
+    RECT checkbox;  /* checkbox allowing the control to be enabled/disabled */
+    RECT calbutton; /* button that toggles the dropdown of the monthcal control */
+    BOOL bCalDepressed; /* TRUE = cal button is depressed */
+    int  select;
+    HFONT hFont;
+    int nrFieldsAllocated;
+    int nrFields;
+    int haveFocus;
+    int *fieldspec;
+    RECT *fieldRect;
+    int  *buflen;
+    char textbuf[256];
         POINT monthcal_pos;
 } DATETIME_INFO, *LPDATETIME_INFO;
@@ -61 +62 @@
 /* this list of defines is closely related to `allowedformatchars' defined
  * in datetime.c; the high nibble indicates the `base type' of the format
- * specifier. 
+ * specifier.
  * Do not change without first reading DATETIME_UseFormat.
- * 
+ *
  */
 
-#define DT_END_FORMAT      0 
-#define ONEDIGITDAY     0x01
-#define TWODIGITDAY     0x02
-#define THREECHARDAY    0x03
+#define DT_END_FORMAT      0
+#define ONEDIGITDAY     0x01
+#define TWODIGITDAY     0x02
+#define THREECHARDAY    0x03
 #define FULLDAY         0x04
 #define ONEDIGIT12HOUR  0x11
@@ -94 +95 @@
 #define FORMATCALLBACK  0x81      /* -> maximum of 0x80 callbacks possible */
 #define FORMATCALLMASK  0x80
-#define DT_STRING       0x0100
+#define DT_STRING   0x0100
 
 #define DTHT_DATEFIELD  0xff      /* for hit-testing */
 
 #define DTHT_NONE     0
-#define DTHT_CHECKBOX 0x200     /* these should end at '00' , to make */
+#define DTHT_CHECKBOX 0x200 /* these should end at '00' , to make */
 #define DTHT_MCPOPUP  0x300     /* & DTHT_DATEFIELD 0 when DATETIME_KeyDown */
 #define DTHT_GOTFOCUS 0x400     /* tests for date-fields */
@@ -126 +127 @@
   if (!lParam) return GDT_NONE;
 
-  if ((dwStyle & DTS_SHOWNONE) && 
+  if ((dwStyle & DTS_SHOWNONE) &&
        (SendMessageA (infoPtr->hwndCheckbut, BM_GETCHECK, 0, 0)))
         return GDT_NONE;
@@ -145 +146 @@
   if (!lParam) return 0;
 
-  if (lParam==GDT_VALID) 
-        MONTHCAL_CopyTime (lprgSysTimeArray, &infoPtr->date);
+  if (lParam==GDT_VALID)
+    MONTHCAL_CopyTime (lprgSysTimeArray, &infoPtr->date);
   if (lParam==GDT_NONE) {
-        infoPtr->dateValid=FALSE;
+    infoPtr->dateValid=FALSE;
     SendMessageA (infoPtr->hwndCheckbut, BM_SETCHECK, 0, 0);
-        }
+    }
   return 1;
 }
@@ -228 +229 @@
 
 
-/* 
-   Split up a formattxt in actions. 
+/*
+   Split up a formattxt in actions.
    See ms documentation for the meaning of the letter codes/'specifiers'.
 
-   Notes: 
+   Notes:
    *'dddddd' is handled as 'dddd' plus 'dd'.
-   *unrecognized formats are strings (here given the type DT_STRING; 
+   *unrecognized formats are strings (here given the type DT_STRING;
    start of the string is encoded in lower bits of DT_STRING.
    Therefore, 'string' ends finally up as '<show seconds>tring'.
@@ -241 +242 @@
 
 
-static void 
+static void
 DATETIME_UseFormat (DATETIME_INFO *infoPtr, const char *formattxt)
 {
@@ -256 +257 @@
 
  for (i=0; i<strlen (formattxt); i++)  {
-        TRACE ("\n%d %c:",i, formattxt[i]);
-        for (j=0; j<len; j++) {
-                if (allowedformatchars[j]==formattxt[i]) {   
-                        TRACE ("%c[%d,%x]",allowedformatchars[j], *nrFields,
-                                                         infoPtr->fieldspec[*nrFields]);
-                        if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
-                                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
-                                break;
-                        }
-                        if (infoPtr->fieldspec[*nrFields]>>4!=j) {   
-                                (*nrFields)++;  
-                                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
-                                break;
-                        }
-                        if ((infoPtr->fieldspec[*nrFields] & 0x0f)==maxrepetition[j]) {
-                                (*nrFields)++;  
-                                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
-                                break;
-                        }
-                        infoPtr->fieldspec[*nrFields]++;
-                        break;
-                }   /* if allowedformatchar */
-         } /* for j */
-
-
-                        /* char is not a specifier: handle char like a string */
-        if (j==len) {
-                if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
-                        infoPtr->fieldspec[*nrFields]=DT_STRING+k;
-                        infoPtr->buflen[*nrFields]=0;
-        } else 
-                if ((infoPtr->fieldspec[*nrFields] & DT_STRING)!=DT_STRING)  {
-                        (*nrFields)++;
-                        infoPtr->fieldspec[*nrFields]=DT_STRING+k;
-                        infoPtr->buflen[*nrFields]=0;
-                } 
-                infoPtr->textbuf[k]=formattxt[i];
-                k++;
-                infoPtr->buflen[*nrFields]++;
-        }   /* if j=len */
-
-        if (*nrFields==infoPtr->nrFieldsAllocated) {
-                FIXME ("out of memory; should reallocate. crash ahead.\n");
-        }
+    TRACE ("\n%d %c:",i, formattxt[i]);
+    for (j=0; j<len; j++) {
+        if (allowedformatchars[j]==formattxt[i]) {
+            TRACE ("%c[%d,%x]",allowedformatchars[j], *nrFields,
+                             infoPtr->fieldspec[*nrFields]);
+            if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
+                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
+                break;
+            }
+            if (infoPtr->fieldspec[*nrFields]>>4!=j) {
+                (*nrFields)++;
+                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
+                break;
+            }
+            if ((infoPtr->fieldspec[*nrFields] & 0x0f)==maxrepetition[j]) {
+                (*nrFields)++;
+                infoPtr->fieldspec[*nrFields]=(j<<4) +1;
+                break;
+            }
+            infoPtr->fieldspec[*nrFields]++;
+            break;
+        }   /* if allowedformatchar */
+     } /* for j */
+
+
+            /* char is not a specifier: handle char like a string */
+    if (j==len) {
+        if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
+            infoPtr->fieldspec[*nrFields]=DT_STRING+k;
+            infoPtr->buflen[*nrFields]=0;
+        } else
+        if ((infoPtr->fieldspec[*nrFields] & DT_STRING)!=DT_STRING)  {
+            (*nrFields)++;
+            infoPtr->fieldspec[*nrFields]=DT_STRING+k;
+            infoPtr->buflen[*nrFields]=0;
+        }
+        infoPtr->textbuf[k]=formattxt[i];
+        k++;
+        infoPtr->buflen[*nrFields]++;
+    }   /* if j=len */
+
+    if (*nrFields==infoPtr->nrFieldsAllocated) {
+        FIXME ("out of memory; should reallocate. crash ahead.\n");
+    }
 
   } /* for i */
@@ -309 +310 @@
 
 
-static LRESULT 
+static LRESULT
 DATETIME_SetFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -318 +319 @@
  TRACE("%04x %08lx\n",wParam,lParam);
  if (!lParam) {
-        DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
-
-        if (dwStyle & DTS_LONGDATEFORMAT) 
-                format_item=LOCALE_SLONGDATE;
-        else if (dwStyle & DTS_TIMEFORMAT) 
-                format_item=LOCALE_STIMEFORMAT;
+    DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
+
+    if (dwStyle & DTS_LONGDATEFORMAT)
+        format_item=LOCALE_SLONGDATE;
+    else if (dwStyle & DTS_TIMEFORMAT)
+        format_item=LOCALE_STIMEFORMAT;
         else /* DTS_SHORTDATEFORMAT */
-                format_item=LOCALE_SSHORTDATE;
-        GetLocaleInfoA( GetSystemDefaultLCID(), format_item,format_buf,sizeof(format_buf));
-        DATETIME_UseFormat (infoPtr, format_buf);
- }      
+        format_item=LOCALE_SSHORTDATE;
+    GetLocaleInfoA( GetSystemDefaultLCID(), format_item,format_buf,sizeof(format_buf));
+    DATETIME_UseFormat (infoPtr, format_buf);
+ }
  else
-        DATETIME_UseFormat (infoPtr, (char *) lParam);
+    DATETIME_UseFormat (infoPtr, (char *) lParam);
 
  return infoPtr->nrFields;
@@ -336 +337 @@
 
 
-static LRESULT 
+static LRESULT
 DATETIME_SetFormatW (HWND hwnd, WPARAM wParam, LPARAM lParam)
 
@@ -342 +343 @@
  TRACE("%04x %08lx\n",wParam,lParam);
  if (lParam) {
-        LPSTR buf;
-        int retval;
+    LPSTR buf;
+    int retval;
         int len = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, NULL, 0, NULL, NULL );
 
-        buf = (LPSTR) COMCTL32_Alloc (len);
+    buf = (LPSTR) COMCTL32_Alloc (len);
         WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, buf, len, NULL, NULL );
-        retval=DATETIME_SetFormat (hwnd, 0, (LPARAM) buf);
-        COMCTL32_Free (buf);
-        return retval;
- } 
+    retval=DATETIME_SetFormat (hwnd, 0, (LPARAM) buf);
+    COMCTL32_Free (buf);
+    return retval;
+ }
  else
-        return DATETIME_SetFormat (hwnd, 0, 0);
-
-}
-
-
-static void 
+    return DATETIME_SetFormat (hwnd, 0, 0);
+
+}
+
+
+static void
 DATETIME_ReturnTxt (DATETIME_INFO *infoPtr, int count, char *result)
 {
@@ -368 +369 @@
  TRACE ("%d,%d\n", infoPtr->nrFields, count);
  if ((count>infoPtr->nrFields) || (count<0)) {
-        WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
-        return;
+    WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
+    return;
  }
 
  if (!infoPtr->fieldspec) return;
- 
+
  spec=infoPtr->fieldspec[count];
  if (spec & DT_STRING) {
-        int txtlen=infoPtr->buflen[count];
-
-        strncpy (result, infoPtr->textbuf + (spec &~ DT_STRING), txtlen);
-        result[txtlen]=0;
-        TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
-        return;
+    int txtlen=infoPtr->buflen[count];
+
+    strncpy (result, infoPtr->textbuf + (spec &~ DT_STRING), txtlen);
+    result[txtlen]=0;
+    TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
+    return;
  }
 
-                
+
  switch (spec) {
-        case DT_END_FORMAT: 
-                *result=0;
-                break;
-        case ONEDIGITDAY: 
-                sprintf (result,"%d",date.wDay);
-                break;
-        case TWODIGITDAY: 
-                sprintf (result,"%.2d",date.wDay);
-                break;
-        case THREECHARDAY: 
-                GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1+(date.wDayOfWeek+6)%7,
-                                result,4);
-                /*sprintf (result,"%.3s",days[date.wDayOfWeek]);*/
-                break;
-        case FULLDAY:
-                GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SDAYNAME1+ (date.wDayOfWeek+6)%7,
-                                buffer,sizeof(buffer));
-                strcpy  (result,buffer);
-                break;
-        case ONEDIGIT12HOUR: 
-                if (date.wHour>12) 
-                        sprintf (result,"%d",date.wHour-12);
-                else 
-                        sprintf (result,"%d",date.wHour);
-                break;
-        case TWODIGIT12HOUR: 
-                if (date.wHour>12) 
-                        sprintf (result,"%.2d",date.wHour-12);
-                else 
-                        sprintf (result,"%.2d",date.wHour);
-                break;
-        case ONEDIGIT24HOUR: 
-                sprintf (result,"%d",date.wHour);
-                break;
-        case TWODIGIT24HOUR: 
-                sprintf (result,"%.2d",date.wHour);
-                break;
-        case ONEDIGITSECOND: 
-                sprintf (result,"%d",date.wSecond);
-                break;
-        case TWODIGITSECOND: 
-                sprintf (result,"%.2d",date.wSecond);
-                break;
-        case ONEDIGITMINUTE: 
-                sprintf (result,"%d",date.wMinute);
-                break;
-        case TWODIGITMINUTE: 
-                sprintf (result,"%.2d",date.wMinute);
-                break;
-        case ONEDIGITMONTH: 
-                sprintf (result,"%d",date.wMonth);
-                break;
-        case TWODIGITMONTH: 
-                sprintf (result,"%.2d",date.wMonth);
-                break;
-        case THREECHARMONTH: 
-                GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
-                  buffer,sizeof(buffer));
-                sprintf (result,"%.3s",buffer);
-                break;
-        case FULLMONTH:   
-                GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
+    case DT_END_FORMAT:
+        *result=0;
+        break;
+    case ONEDIGITDAY:
+        sprintf (result,"%d",date.wDay);
+        break;
+    case TWODIGITDAY:
+        sprintf (result,"%.2d",date.wDay);
+        break;
+    case THREECHARDAY:
+            GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1+(date.wDayOfWeek+6)%7,
+                result,4);
+        /*sprintf (result,"%.3s",days[date.wDayOfWeek]);*/
+        break;
+    case FULLDAY:
+            GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SDAYNAME1+ (date.wDayOfWeek+6)%7,
+                buffer,sizeof(buffer));
+        strcpy  (result,buffer);
+        break;
+    case ONEDIGIT12HOUR:
+        if (date.wHour>12)
+            sprintf (result,"%d",date.wHour-12);
+        else
+            sprintf (result,"%d",date.wHour);
+        break;
+    case TWODIGIT12HOUR:
+        if (date.wHour>12)
+            sprintf (result,"%.2d",date.wHour-12);
+        else
+            sprintf (result,"%.2d",date.wHour);
+        break;
+    case ONEDIGIT24HOUR:
+        sprintf (result,"%d",date.wHour);
+        break;
+    case TWODIGIT24HOUR:
+        sprintf (result,"%.2d",date.wHour);
+        break;
+    case ONEDIGITSECOND:
+        sprintf (result,"%d",date.wSecond);
+        break;
+    case TWODIGITSECOND:
+        sprintf (result,"%.2d",date.wSecond);
+        break;
+    case ONEDIGITMINUTE:
+        sprintf (result,"%d",date.wMinute);
+        break;
+    case TWODIGITMINUTE:
+        sprintf (result,"%.2d",date.wMinute);
+        break;
+    case ONEDIGITMONTH:
+        sprintf (result,"%d",date.wMonth);
+        break;
+    case TWODIGITMONTH:
+        sprintf (result,"%.2d",date.wMonth);
+        break;
+    case THREECHARMONTH:
+        GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
+          buffer,sizeof(buffer));
+        sprintf (result,"%.3s",buffer);
+        break;
+    case FULLMONTH:
+        GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
 #ifdef __WIN32OS2__
-                                buffer,sizeof(buffer));
-                strcpy  (result,buffer);
+                buffer,sizeof(buffer));
+        strcpy  (result,buffer);
 #else
-                  result,sizeof(result));
+          result,sizeof(result));
 #endif
-                break;
-        case ONELETTERAMPM:   
-                if (date.wHour<12) 
-                        strcpy (result,"A");
-                else 
-                        strcpy (result,"P");
-                break;
-        case TWOLETTERAMPM:   
-                if (date.wHour<12) 
-                        strcpy (result,"AM");
-                else 
-                        strcpy (result,"PM");
-                break;
-        case FORMATCALLBACK:   
-                FIXME ("Not implemented\n");
-                strcpy (result,"xxx");
-                break;
-        case ONEDIGITYEAR: 
-                sprintf (result,"%d",date.wYear-10* (int) floor(date.wYear/10));
-                break;
-        case TWODIGITYEAR: 
-                sprintf (result,"%.2d",date.wYear-100* (int) floor(date.wYear/100));
-                break;
-        case FULLYEAR:   
-                sprintf (result,"%d",date.wYear);
-                break;
+        break;
+    case ONELETTERAMPM:
+        if (date.wHour<12)
+            strcpy (result,"A");
+        else
+            strcpy (result,"P");
+        break;
+    case TWOLETTERAMPM:
+        if (date.wHour<12)
+            strcpy (result,"AM");
+        else
+            strcpy (result,"PM");
+        break;
+    case FORMATCALLBACK:
+        FIXME ("Not implemented\n");
+        strcpy (result,"xxx");
+        break;
+    case ONEDIGITYEAR:
+        sprintf (result,"%d",date.wYear-10* (int) floor(date.wYear/10));
+        break;
+    case TWODIGITYEAR:
+        sprintf (result,"%.2d",date.wYear-100* (int) floor(date.wYear/100));
+        break;
+    case FULLYEAR:
+        sprintf (result,"%d",date.wYear);
+        break;
     }
-        
-        TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
-}
-
-
-static void 
+
+    TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
+}
+
+
+static void
 DATETIME_IncreaseField (DATETIME_INFO *infoPtr, int number)
 {
@@ -497 +498 @@
  spec=infoPtr->fieldspec[number];
  if ((spec & DTHT_DATEFIELD)==0) return;
-                
+
  switch (spec) {
-        case ONEDIGITDAY: 
-        case TWODIGITDAY: 
-        case THREECHARDAY: 
-        case FULLDAY:
-                date->wDay++;
-                if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
-                  date->wDay=1; 
-                break;
-        case ONEDIGIT12HOUR: 
-        case TWODIGIT12HOUR: 
-        case ONEDIGIT24HOUR: 
-        case TWODIGIT24HOUR: 
-                date->wHour++;
-                if (date->wHour>23) date->wHour=0;
-                break;
-        case ONEDIGITSECOND: 
-        case TWODIGITSECOND: 
-                date->wSecond++;
-                if (date->wSecond>59) date->wSecond=0;
-                break;
-        case ONEDIGITMINUTE: 
-        case TWODIGITMINUTE: 
-                date->wMinute++;
-                if (date->wMinute>59) date->wMinute=0;
-                break;
-        case ONEDIGITMONTH: 
-        case TWODIGITMONTH: 
-        case THREECHARMONTH: 
-        case FULLMONTH:   
-                date->wMonth++;
-                if (date->wMonth>12) date->wMonth=1;
-                if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear)) 
-                        date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
-                break;
-        case ONELETTERAMPM:   
-        case TWOLETTERAMPM:   
-                date->wHour+=12;
-                if (date->wHour>23) date->wHour-=24;
-                break;
-        case FORMATCALLBACK:   
-                FIXME ("Not implemented\n");
-                break;
-        case ONEDIGITYEAR: 
-        case TWODIGITYEAR: 
-        case FULLYEAR:   
-                date->wYear++;
-                break;
-        }
-
-}
-
-
-static void 
+    case ONEDIGITDAY:
+    case TWODIGITDAY:
+    case THREECHARDAY:
+    case FULLDAY:
+        date->wDay++;
+        if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
+          date->wDay=1;
+        break;
+    case ONEDIGIT12HOUR:
+    case TWODIGIT12HOUR:
+    case ONEDIGIT24HOUR:
+    case TWODIGIT24HOUR:
+        date->wHour++;
+        if (date->wHour>23) date->wHour=0;
+        break;
+    case ONEDIGITSECOND:
+    case TWODIGITSECOND:
+        date->wSecond++;
+        if (date->wSecond>59) date->wSecond=0;
+        break;
+    case ONEDIGITMINUTE:
+    case TWODIGITMINUTE:
+        date->wMinute++;
+        if (date->wMinute>59) date->wMinute=0;
+        break;
+    case ONEDIGITMONTH:
+    case TWODIGITMONTH:
+    case THREECHARMONTH:
+    case FULLMONTH:
+        date->wMonth++;
+        if (date->wMonth>12) date->wMonth=1;
+        if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
+            date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
+        break;
+    case ONELETTERAMPM:
+    case TWOLETTERAMPM:
+        date->wHour+=12;
+        if (date->wHour>23) date->wHour-=24;
+        break;
+    case FORMATCALLBACK:
+        FIXME ("Not implemented\n");
+        break;
+    case ONEDIGITYEAR:
+    case TWODIGITYEAR:
+    case FULLYEAR:
+        date->wYear++;
+        break;
+    }
+
+}
+
+
+static void
 DATETIME_DecreaseField (DATETIME_INFO *infoPtr, int number)
 {
@@ -562 +563 @@
  spec = infoPtr->fieldspec[number];
  if ((spec & DTHT_DATEFIELD)==0) return;
-                
+
  TRACE ("%x\n",spec);
 
  switch (spec) {
-        case ONEDIGITDAY: 
-        case TWODIGITDAY: 
-        case THREECHARDAY: 
-        case FULLDAY:
-                date->wDay--;
-                if (date->wDay<1) 
-                  date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
-                break;
-        case ONEDIGIT12HOUR: 
-        case TWODIGIT12HOUR: 
-        case ONEDIGIT24HOUR: 
-        case TWODIGIT24HOUR: 
-                if (date->wHour) 
-                        date->wHour--;
-                else
-                        date->wHour=23;
-                break;
-        case ONEDIGITSECOND: 
-        case TWODIGITSECOND: 
-                if (date->wHour) 
-                        date->wSecond--;
-                else
-                        date->wHour=59;
-                break;
-        case ONEDIGITMINUTE: 
-        case TWODIGITMINUTE: 
-                if (date->wMinute) 
-                        date->wMinute--;
-                else
-                        date->wMinute=59;
-                break;
-        case ONEDIGITMONTH: 
-        case TWODIGITMONTH: 
-        case THREECHARMONTH: 
-        case FULLMONTH:   
-                if (date->wMonth>1) 
-                        date->wMonth--;
-                else
-                        date->wMonth=12;
-                if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear)) 
-                        date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
-                break;
-        case ONELETTERAMPM:   
-        case TWOLETTERAMPM:   
-                if (date->wHour<12) 
-                        date->wHour+=12;
-                else
-                        date->wHour-=12;
-                break;
-        case FORMATCALLBACK:   
-                FIXME ("Not implemented\n");
-                break;
-        case ONEDIGITYEAR: 
-        case TWODIGITYEAR: 
-        case FULLYEAR:   
-                date->wYear--;
-                break;
-        }
-
-}
-
-
-static void 
+    case ONEDIGITDAY:
+    case TWODIGITDAY:
+    case THREECHARDAY:
+    case FULLDAY:
+        date->wDay--;
+        if (date->wDay<1)
+          date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
+        break;
+    case ONEDIGIT12HOUR:
+    case TWODIGIT12HOUR:
+    case ONEDIGIT24HOUR:
+    case TWODIGIT24HOUR:
+        if (date->wHour)
+            date->wHour--;
+        else
+            date->wHour=23;
+        break;
+    case ONEDIGITSECOND:
+    case TWODIGITSECOND:
+        if (date->wHour)
+            date->wSecond--;
+        else
+            date->wHour=59;
+        break;
+    case ONEDIGITMINUTE:
+    case TWODIGITMINUTE:
+        if (date->wMinute)
+            date->wMinute--;
+        else
+            date->wMinute=59;
+        break;
+    case ONEDIGITMONTH:
+    case TWODIGITMONTH:
+    case THREECHARMONTH:
+    case FULLMONTH:
+        if (date->wMonth>1)
+            date->wMonth--;
+        else
+            date->wMonth=12;
+        if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
+            date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
+        break;
+    case ONELETTERAMPM:
+    case TWOLETTERAMPM:
+        if (date->wHour<12)
+            date->wHour+=12;
+        else
+            date->wHour-=12;
+        break;
+    case FORMATCALLBACK:
+        FIXME ("Not implemented\n");
+        break;
+    case ONEDIGITYEAR:
+    case TWODIGITYEAR:
+    case FULLYEAR:
+        date->wYear--;
+        break;
+    }
+
+}
+
+
+static void
 DATETIME_ResetFieldDown (DATETIME_INFO *infoPtr, int number)
 {
@@ -639 +640 @@
  spec = infoPtr->fieldspec[number];
  if ((spec & DTHT_DATEFIELD)==0) return;
-                
+
 
  switch (spec) {
-        case ONEDIGITDAY: 
-        case TWODIGITDAY: 
-        case THREECHARDAY: 
-        case FULLDAY:
-                date->wDay = 1;
-                break;
-        case ONEDIGIT12HOUR: 
-        case TWODIGIT12HOUR: 
-        case ONEDIGIT24HOUR: 
-        case TWODIGIT24HOUR: 
-        case ONELETTERAMPM:   
-        case TWOLETTERAMPM:   
-                date->wHour = 0;
-                break;
-        case ONEDIGITSECOND: 
-        case TWODIGITSECOND: 
-                date->wSecond = 0;
-                break;
-        case ONEDIGITMINUTE: 
-        case TWODIGITMINUTE: 
-                date->wMinute = 0;
-                break;
-        case ONEDIGITMONTH: 
-        case TWODIGITMONTH: 
-        case THREECHARMONTH: 
-        case FULLMONTH:   
-                date->wMonth = 1;
-        case FORMATCALLBACK:   
-                FIXME ("Not implemented\n");
-                break;
-        case ONEDIGITYEAR: 
-        case TWODIGITYEAR: 
+    case ONEDIGITDAY:
+    case TWODIGITDAY:
+    case THREECHARDAY:
+    case FULLDAY:
+        date->wDay = 1;
+        break;
+    case ONEDIGIT12HOUR:
+    case TWODIGIT12HOUR:
+    case ONEDIGIT24HOUR:
+    case TWODIGIT24HOUR:
+    case ONELETTERAMPM:
+    case TWOLETTERAMPM:
+        date->wHour = 0;
+        break;
+    case ONEDIGITSECOND:
+    case TWODIGITSECOND:
+        date->wSecond = 0;
+        break;
+    case ONEDIGITMINUTE:
+    case TWODIGITMINUTE:
+        date->wMinute = 0;
+        break;
+    case ONEDIGITMONTH:
+    case TWODIGITMONTH:
+    case THREECHARMONTH:
+    case FULLMONTH:
+        date->wMonth = 1;
+    case FORMATCALLBACK:
+        FIXME ("Not implemented\n");
+        break;
+    case ONEDIGITYEAR:
+    case TWODIGITYEAR:
         /* FYI: On 9/14/1752 the calender changed and England and the American */
         /* colonies changed to the Gregorian calender.  This change involved */
         /* having September 14th following September 2nd.  So no date algorithms */
         /* work before that date. */
-        case FULLYEAR:   
-                date->wSecond = 0;
-                date->wMinute = 0;
-                date->wHour = 0;
-                date->wDay = 14;                /* overactive ms-programmers..*/
-                date->wMonth = 9;
-                date->wYear = 1752;
-                break;
-        }
-
-}
-
-
-static void 
+    case FULLYEAR:
+        date->wSecond = 0;
+        date->wMinute = 0;
+        date->wHour = 0;
+        date->wDay = 14;        /* overactive ms-programmers..*/
+        date->wMonth = 9;
+        date->wYear = 1752;
+        break;
+    }
+
+}
+
+
+static void
 DATETIME_ResetFieldUp (DATETIME_INFO *infoPtr, int number)
 {
@@ -702 +703 @@
  spec=infoPtr->fieldspec[number];
  if ((spec & DTHT_DATEFIELD)==0) return;
-                
+
  switch (spec) {
-        case ONEDIGITDAY: 
-        case TWODIGITDAY: 
-        case THREECHARDAY: 
-        case FULLDAY:
-                date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
-                break;
-        case ONEDIGIT12HOUR: 
-        case TWODIGIT12HOUR: 
-        case ONEDIGIT24HOUR: 
-        case TWODIGIT24HOUR: 
-        case ONELETTERAMPM:   
-        case TWOLETTERAMPM:   
-                date->wHour=23;
-                break;
-        case ONEDIGITSECOND: 
-        case TWODIGITSECOND: 
-                date->wSecond=59;
-                break;
-        case ONEDIGITMINUTE: 
-        case TWODIGITMINUTE: 
-                date->wMinute=59;
-                break;
-        case ONEDIGITMONTH: 
-        case TWODIGITMONTH: 
-        case THREECHARMONTH: 
-        case FULLMONTH:   
-                date->wMonth=12;
-        case FORMATCALLBACK:   
-                FIXME ("Not implemented\n");
-                break;
-        case ONEDIGITYEAR: 
-        case TWODIGITYEAR: 
-        case FULLYEAR:   
-                date->wYear=9999;    /* Y10K problem? naaah. */
-                break;
-        }
+    case ONEDIGITDAY:
+    case TWODIGITDAY:
+    case THREECHARDAY:
+    case FULLDAY:
+        date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
+        break;
+    case ONEDIGIT12HOUR:
+    case TWODIGIT12HOUR:
+    case ONEDIGIT24HOUR:
+    case TWODIGIT24HOUR:
+    case ONELETTERAMPM:
+    case TWOLETTERAMPM:
+        date->wHour=23;
+        break;
+    case ONEDIGITSECOND:
+    case TWODIGITSECOND:
+        date->wSecond=59;
+        break;
+    case ONEDIGITMINUTE:
+    case TWODIGITMINUTE:
+        date->wMinute=59;
+        break;
+    case ONEDIGITMONTH:
+    case TWODIGITMONTH:
+    case THREECHARMONTH:
+    case FULLMONTH:
+        date->wMonth=12;
+    case FORMATCALLBACK:
+        FIXME ("Not implemented\n");
+        break;
+    case ONEDIGITYEAR:
+    case TWODIGITYEAR:
+    case FULLYEAR:
+        date->wYear=9999;    /* Y10K problem? naaah. */
+        break;
+    }
 
 }
@@ -758 +759 @@
   SIZE size;
   COLORREF oldBk, oldTextColor;
-  
+
   /* draw control edge */
   TRACE("\n");
@@ -764 +765 @@
   FillRect(hdc, rcClient, hbr);
   DrawEdge(hdc, rcClient, EDGE_SUNKEN, BF_RECT);
-  DeleteObject(hbr);   
-        
+  DeleteObject(hbr);
+
   if (infoPtr->dateValid) {
     char txt[80];
@@ -798 +799 @@
               DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
         SetBkColor (hdc, oldBk);
-                SetTextColor (hdc, oldTextColor);
+        SetTextColor (hdc, oldTextColor);
       }
       else
@@ -832 +833 @@
     if (PtInRect (&infoPtr->fieldRect[i], pt)) {
       retval = i;
-      TRACE("Hit in date text in field %d\n", i);           
+      TRACE("Hit in date text in field %d\n", i);
       break;
     }
@@ -845 +846 @@
 DATETIME_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);  
+  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
   DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
   int old, new;
@@ -874 +875 @@
       infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
                                 infoPtr->calbutton.left) + 145);
-    else 
+    else
       infoPtr->monthcal_pos.x = 8;
 
@@ -888 +889 @@
 
     TRACE ("dt:%x mc:%x mc parent:%x, desktop:%x, mcpp:%x\n",
-              hwnd,infoPtr->hMonthCal, 
+              hwnd,infoPtr->hMonthCal,
               GetParent (infoPtr->hMonthCal),
               GetDesktopWindow (),
@@ -904 +905 @@
 DATETIME_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);  
+  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 
   TRACE("\n");
-  
+
   if(infoPtr->bCalDepressed == TRUE) {
     infoPtr->bCalDepressed = FALSE;
@@ -934 +935 @@
 DATETIME_ParentNotify (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
- DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);   
+ DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
  LPNMHDR lpnmh = (LPNMHDR) lParam;
 
@@ -954 +955 @@
 
 {
- DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);   
+ DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
  LPNMHDR lpnmh = (LPNMHDR) lParam;
 
@@ -964 +965 @@
 
 
-static LRESULT 
+static LRESULT
 DATETIME_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -978 +979 @@
 
  if (infoPtr->select & FORMATCALLMASK) {
-        FIXME ("Callbacks not implemented yet\n");
+    FIXME ("Callbacks not implemented yet\n");
  }
 
  switch (wParam) {
-        case VK_ADD:
-        case VK_UP: 
-                DATETIME_IncreaseField (infoPtr,FieldNum);
-                DATETIME_SendDateTimeChangeNotify (hwnd);
-                break;
-        case VK_SUBTRACT:
-        case VK_DOWN:
-                DATETIME_DecreaseField (infoPtr,FieldNum);
-                DATETIME_SendDateTimeChangeNotify (hwnd);
-                break;
-        case VK_HOME:
-                DATETIME_ResetFieldDown (infoPtr,FieldNum);
-                DATETIME_SendDateTimeChangeNotify (hwnd);
-                break;
-        case VK_END:
-                DATETIME_ResetFieldUp(infoPtr,FieldNum);
-                DATETIME_SendDateTimeChangeNotify (hwnd);
-                break;
-        case VK_LEFT: 
-                do {
-                        if (infoPtr->select==0) {
-                                infoPtr->select = infoPtr->nrFields - 1;
-                                wrap++;
-                        } else 
-                        infoPtr->select--;
-                }
-                while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
-                break;
-        case VK_RIGHT:  
-                do {
-                        infoPtr->select++;
-                        if (infoPtr->select==infoPtr->nrFields) {
-                                infoPtr->select = 0;
-                                wrap++;
-                        }
-                        }
-                while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
-                break;
-        }
+    case VK_ADD:
+        case VK_UP:
+        DATETIME_IncreaseField (infoPtr,FieldNum);
+        DATETIME_SendDateTimeChangeNotify (hwnd);
+        break;
+    case VK_SUBTRACT:
+    case VK_DOWN:
+        DATETIME_DecreaseField (infoPtr,FieldNum);
+        DATETIME_SendDateTimeChangeNotify (hwnd);
+        break;
+    case VK_HOME:
+        DATETIME_ResetFieldDown (infoPtr,FieldNum);
+        DATETIME_SendDateTimeChangeNotify (hwnd);
+        break;
+    case VK_END:
+        DATETIME_ResetFieldUp(infoPtr,FieldNum);
+        DATETIME_SendDateTimeChangeNotify (hwnd);
+        break;
+    case VK_LEFT:
+        do {
+            if (infoPtr->select==0) {
+                infoPtr->select = infoPtr->nrFields - 1;
+                wrap++;
+            } else
+            infoPtr->select--;
+        }
+        while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
+        break;
+    case VK_RIGHT:
+        do {
+            infoPtr->select++;
+            if (infoPtr->select==infoPtr->nrFields) {
+                infoPtr->select = 0;
+                wrap++;
+            }
+            }
+        while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
+        break;
+    }
 
   InvalidateRect(hwnd, NULL, FALSE);
@@ -1031 +1032 @@
 DATETIME_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);        
+    DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 
     TRACE ("\n");
 
     if (infoPtr->haveFocus) {
-        DATETIME_SendSimpleNotify (hwnd, NM_KILLFOCUS);
-        infoPtr->haveFocus = 0;
+    DATETIME_SendSimpleNotify (hwnd, NM_KILLFOCUS);
+    infoPtr->haveFocus = 0;
     }
 
@@ -1049 +1050 @@
 DATETIME_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);        
+    DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 
     TRACE ("\n");
 
     if (infoPtr->haveFocus==0) {
-        DATETIME_SendSimpleNotify (hwnd, NM_SETFOCUS);  
-        infoPtr->haveFocus = DTHT_GOTFOCUS;
+    DATETIME_SendSimpleNotify (hwnd, NM_SETFOCUS);
+    infoPtr->haveFocus = DTHT_GOTFOCUS;
     }
 
@@ -1068 +1069 @@
 
 {
- DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);   
+ DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
  NMDATETIMECHANGE dtdtc;
 
@@ -1136 +1137 @@
     infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
                                 infoPtr->calbutton.left) + 145);
-  else 
+  else
     infoPtr->monthcal_pos.x = 8;
 
@@ -1172 +1173 @@
 
   if (dwStyle & DTS_SHOWNONE) {
-    infoPtr->hwndCheckbut=CreateWindowExA (0,"button", 0, 
-         WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 
+    infoPtr->hwndCheckbut=CreateWindowExA (0,"button", 0,
+         WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
          2,2,13,13,
-         hwnd, 
+         hwnd,
          0, GetWindowLongA  (hwnd, GWL_HINSTANCE), 0);
          SendMessageA (infoPtr->hwndCheckbut, BM_SETCHECK, 1, 0);
@@ -1196 +1197 @@
 
   /* create the monthcal control */
-    infoPtr->hMonthCal = CreateWindowExA (0,"SysMonthCal32", 0, 
-        WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
-        0, 0, 0, 0,
-        GetParent(hwnd), 
-        0, 0, 0);
+    infoPtr->hMonthCal = CreateWindowExA (0,"SysMonthCal32", 0,
+    WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
+    0, 0, 0, 0,
+    GetParent(hwnd),
+    0, 0, 0);
 
   /* initialize info structure */
@@ -1214 +1215 @@
 {
     DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
-        
+
     TRACE("\n");
     COMCTL32_Free (infoPtr);
@@ -1227 +1228 @@
 
     if (!DATETIME_GetInfoPtr(hwnd) && (uMsg != WM_CREATE))
-        return DefWindowProcA( hwnd, uMsg, wParam, lParam );
-    
+    return DefWindowProcA( hwnd, uMsg, wParam, lParam );
+
     switch (uMsg)
     {
@@ -1236 +1237 @@
 
     case DTM_SETSYSTEMTIME:
-        return DATETIME_SetSystemTime (hwnd, wParam, lParam);
+    return DATETIME_SetSystemTime (hwnd, wParam, lParam);
 
     case DTM_GETRANGE:
@@ -1266 +1267 @@
 
     case WM_PARENTNOTIFY:
-        return DATETIME_ParentNotify (hwnd, wParam, lParam);
+    return DATETIME_ParentNotify (hwnd, wParam, lParam);
 
     case WM_NOTIFY:
-        return DATETIME_Notify (hwnd, wParam, lParam);
+    return DATETIME_Notify (hwnd, wParam, lParam);
 
     case WM_GETDLGCODE:
@@ -1296 +1297 @@
 
     case WM_CREATE:
-        return DATETIME_Create (hwnd, wParam, lParam);
+    return DATETIME_Create (hwnd, wParam, lParam);
 
     case WM_DESTROY:
-        return DATETIME_Destroy (hwnd, wParam, lParam);
+    return DATETIME_Destroy (hwnd, wParam, lParam);
 
     default:
-        if (uMsg >= WM_USER)
-                ERR("unknown msg %04x wp=%08x lp=%08lx\n",
-                     uMsg, wParam, lParam);
+    if (uMsg >= WM_USER)
+        ERR("unknown msg %04x wp=%08x lp=%08lx\n",
+             uMsg, wParam, lParam);
 #ifdef __WIN32OS2__
         return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
 #else
-        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+    return DefWindowProcA (hwnd, uMsg, wParam, lParam);
 #endif
     }
@@ -1329 +1330 @@
     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
     wndClass.lpszClassName = DATETIMEPICK_CLASSA;
- 
+
     RegisterClassA (&wndClass);
 }

trunk/src/comctl32/flatsb.c

@@ +1 @@
+/* $Id: flatsb.c,v 1.10 2001-09-05 12:04:58 bird Exp $ */
 /*
  * Flat Scrollbar control
@@ -39 +40 @@
 
 /***********************************************************************
- *              InitializeFlatSB
- *
- *      returns nonzero if successful, zero otherwise
+ *      InitializeFlatSB
+ *
+ *  returns nonzero if successful, zero otherwise
  *
  */
@@ -52 +53 @@
 
 /***********************************************************************
- *              UninitializeFlatSB
- *
- *      returns:
- *      E_FAIL          if one of the scroll bars is currently in use
- *      S_FALSE         if InitializeFlatSB was never called on this hwnd
- *      S_OK            otherwise
+ *      UninitializeFlatSB
+ *
+ *  returns:
+ *  E_FAIL      if one of the scroll bars is currently in use
+ *  S_FALSE     if InitializeFlatSB was never called on this hwnd
+ *  S_OK        otherwise
  *
  */
@@ -68 +69 @@
 
 /***********************************************************************
- *              FlatSB_GetScrollProp
- *
- *      Returns nonzero if successful, or zero otherwise. If index is WSB_PROP_HSTYLE,
- *      the return is nonzero if InitializeFlatSB has been called for this window, or
- *      zero otherwise. 
- *
- */
-BOOL WINAPI 
+ *      FlatSB_GetScrollProp
+ *
+ *  Returns nonzero if successful, or zero otherwise. If index is WSB_PROP_HSTYLE,
+ *  the return is nonzero if InitializeFlatSB has been called for this window, or
+ *  zero otherwise.
+ *
+ */
+BOOL WINAPI
 FlatSB_GetScrollProp(HWND hwnd, INT propIndex, LPINT prop)
 {
@@ -84 +85 @@
 
 /***********************************************************************
- *              FlatSB_SetScrollProp
- */
-BOOL WINAPI 
+ *      FlatSB_SetScrollProp
+ */
+BOOL WINAPI
 FlatSB_SetScrollProp(HWND hwnd, UINT index, INT newValue, BOOL flag)
 {
@@ -95 +96 @@
 
 /***********************************************************************
- *      From the Microsoft docs:
- *      "If flat scroll bars haven't been initialized for the
- *      window, the flat scroll bar APIs will defer to the corresponding
- *      standard APIs.  This allows the developer to turn flat scroll
- *      bars on and off without having to write conditional code."
- *
- *      So, if we just call the standard functions until we implement
- *      the flat scroll bar functions, flat scroll bars will show up and 
- *      behave properly, as though they had simply not been setup to
- *      have flat properties.
- *
- *      Susan <sfarley@codeweavers.com>
- *
- */
-
-/***********************************************************************
- *              FlatSB_EnableScrollBar
- */
-BOOL WINAPI 
+ *  From the Microsoft docs:
+ *  "If flat scroll bars haven't been initialized for the
+ *  window, the flat scroll bar APIs will defer to the corresponding
+ *  standard APIs.  This allows the developer to turn flat scroll
+ *  bars on and off without having to write conditional code."
+ *
+ *  So, if we just call the standard functions until we implement
+ *  the flat scroll bar functions, flat scroll bars will show up and
+ *  behave properly, as though they had simply not been setup to
+ *  have flat properties.
+ *
+ *  Susan <sfarley@codeweavers.com>
+ *
+ */
+
+/***********************************************************************
+ *      FlatSB_EnableScrollBar
+ */
+BOOL WINAPI
 FlatSB_EnableScrollBar(HWND hwnd, int nBar, UINT flags)
 {
@@ -120 +121 @@
 
 /***********************************************************************
- *              FlatSB_ShowScrollBar
- */
-BOOL WINAPI 
+ *      FlatSB_ShowScrollBar
+ */
+BOOL WINAPI
 FlatSB_ShowScrollBar(HWND hwnd, int nBar, BOOL fShow)
 {
@@ -129 +130 @@
 
 /***********************************************************************
- *              FlatSB_GetScrollRange
- */
-BOOL WINAPI 
+ *      FlatSB_GetScrollRange
+ */
+BOOL WINAPI
 FlatSB_GetScrollRange(HWND hwnd, int nBar, LPINT min, LPINT max)
 {
@@ -138 +139 @@
 
 /***********************************************************************
- *              FlatSB_GetScrollInfo
- */
-BOOL WINAPI 
+ *      FlatSB_GetScrollInfo
+ */
+BOOL WINAPI
 FlatSB_GetScrollInfo(HWND hwnd, int nBar, LPSCROLLINFO info)
 {
@@ -147 +148 @@
 
 /***********************************************************************
- *              FlatSB_GetScrollPos
- */
-INT WINAPI 
+ *      FlatSB_GetScrollPos
+ */
+INT WINAPI
 FlatSB_GetScrollPos(HWND hwnd, int nBar)
 {
@@ -156 +157 @@
 
 /***********************************************************************
- *              FlatSB_SetScrollPos
- */
-INT WINAPI 
+ *      FlatSB_SetScrollPos
+ */
+INT WINAPI
 FlatSB_SetScrollPos(HWND hwnd, int nBar, INT pos, BOOL bRedraw)
 {
@@ -165 +166 @@
 
 /***********************************************************************
- *              FlatSB_SetScrollInfo
- */
-INT WINAPI 
+ *      FlatSB_SetScrollInfo
+ */
+INT WINAPI
 FlatSB_SetScrollInfo(HWND hwnd, int nBar, LPSCROLLINFO info, BOOL bRedraw)
 {
@@ -174 +175 @@
 
 /***********************************************************************
- *              FlatSB_SetScrollRange
- */
-INT WINAPI 
+ *      FlatSB_SetScrollRange
+ */
+INT WINAPI
 FlatSB_SetScrollRange(HWND hwnd, int nBar, INT min, INT max, BOOL bRedraw)
 {
@@ -212 +213 @@
     switch (uMsg)
     {
-        case WM_CREATE:
-            return FlatSB_Create (hwnd, wParam, lParam);
-
-        case WM_DESTROY:
-            return FlatSB_Destroy (hwnd, wParam, lParam);
-
-        default:
-            if (uMsg >= WM_USER)
-                ERR("unknown msg %04x wp=%08x lp=%08lx\n",
+    case WM_CREATE:
+        return FlatSB_Create (hwnd, wParam, lParam);
+
+    case WM_DESTROY:
+        return FlatSB_Destroy (hwnd, wParam, lParam);
+
+    default:
+        if (uMsg >= WM_USER)
+        ERR("unknown msg %04x wp=%08x lp=%08lx\n",
                     uMsg, wParam, lParam);
 #ifdef __WIN32OS2__
             return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
 #else
-            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
 #endif
     }
@@ -245 +246 @@
     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
     wndClass.lpszClassName = FLATSB_CLASSA;
- 
+
     RegisterClassA (&wndClass);
 }

trunk/src/comctl32/imagelist.c

@@ +1 @@
+/* $Id: imagelist.c,v 1.15 2001-09-05 12:04:58 bird Exp $ */
 /*
  *  ImageList implementation
@@ -20 +21 @@
  *    - 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 +70 @@
 
 /*************************************************************************
- * IMAGELIST_InternalExpandBitmaps [Internal] 
+ * IMAGELIST_InternalExpandBitmaps [Internal]
  *
  * Expands the bitmaps of an image list by the given number of images.
@@ -92 +93 @@
     if ((himl->cCurImage + nImageCount < himl->cMaxImage)
         && (himl->cy >= cy))
-        return;
+    return;
 
     if (cy == 0) cy = himl->cy;
@@ -116 +117 @@
 
     if (himl->hbmMask) {
-        hbmNewBitmap = 
+        hbmNewBitmap =
             CreateBitmap (nNewWidth, cy, 1, 1, NULL);
 
@@ -138 +139 @@
 
 /*************************************************************************
- * IMAGELIST_InternalDraw [Internal] 
+ * IMAGELIST_InternalDraw [Internal]
  *
  * Draws the image in the ImageList (without the mask)
@@ -151 +152 @@
  *
  * 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 +165 @@
     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 +177 @@
 
 /*************************************************************************
- * IMAGELIST_InternalDrawMask [Internal] 
+ * IMAGELIST_InternalDrawMask [Internal]
  *
  * Draws the image in the ImageList with the mask
@@ -189 +190 @@
  *
  * 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 +206 @@
     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 +222 @@
     hOffScreenDC = CreateCompatibleDC( pimldp->hdcDst );
 
-    if ( hOffScreenDC ) 
+    if ( hOffScreenDC )
     {
         hOffScreenBmp = CreateCompatibleBitmap( pimldp->hdcDst, cx, cy );
 
-        if ( hOffScreenBmp ) 
+        if ( hOffScreenBmp )
             SelectObject( hOffScreenDC, hOffScreenBmp  );
         else
@@ -235 +236 @@
     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 +261 @@
     }
 
-    /* 
+    /*
      * 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 +280 @@
         BitBlt( hOffScreenDC, 0, 0, cx, cy, hImageDC,himlLocal->cx * pimldp->i,
                 0, SRCPAINT );
-    
-    }
-    
+
+    }
+
     /*
      * Draw the image when no Background is specified
@@ -287 +288 @@
     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 +299 @@
                 0, bUseCustomBackground ? SRCCOPY : SRCAND);
     }
-    
+
     /*
      * Blit the bitmap to the screen now.
@@ -305 +306 @@
             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 +335 @@
  *
  * 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 +376 @@
 
         BitBlt(hBlendMaskDC,
-            0,0, cx, cy, 
+            0,0, cx, cy,
             hMaskDC,
             himlLocal->cx * pimldp->i,0,
@@ -381 +382 @@
 
         BitBlt(hBlendMaskDC,
-            0,0, cx, cy, 
+            0,0, cx, cy,
             hBlendMaskDC,
-            0,0, 
+            0,0,
             NOTSRCCOPY);
 
@@ -397 +398 @@
     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 +414 @@
 
 /*************************************************************************
- * IMAGELIST_InternalDrawOverlay [Internal] 
- *
- * Draws the overlay image 
+ * IMAGELIST_InternalDrawOverlay [Internal]
+ *
+ * Draws the overlay image
  *
  * PARAMS
@@ -426 +427 @@
  *
  * 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 +448 @@
             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 +458 @@
                 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 +493 @@
 
 INT WINAPI
-ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
+ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
 {
     HDC     hdcImage, hdcBitmap;
@@ -531 +532 @@
         hOldBitmapTemp = (HBITMAP) SelectObject(hdcTemp, hbmMask);
 
-        BitBlt (hdcMask, 
+        BitBlt (hdcMask,
             nStartX, 0, bmp.bmWidth, bmp.bmHeight,
-            hdcTemp, 
-            0, 0, 
+            hdcTemp,
+            0, 0,
             SRCCOPY);
 
@@ -542 +543 @@
         /* 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 +587 @@
 
 /*************************************************************************
- * ImageList_AddMasked [COMCTL32.42] 
+ * ImageList_AddMasked [COMCTL32.42]
  *
  * Adds an image or images to an image list and creates a mask from the
@@ -651 +652 @@
         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 +669 @@
         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 +699 @@
 
 /*************************************************************************
- * ImageList_BeginDrag [COMCTL32.43] 
+ * ImageList_BeginDrag [COMCTL32.43]
  *
  * Creates a temporary image list that contains one image. It will be used
@@ -716 +717 @@
 BOOL WINAPI
 ImageList_BeginDrag (HIMAGELIST himlTrack, INT iTrack,
-                     INT dxHotspot, INT dyHotspot)
+                 INT dxHotspot, INT dyHotspot)
 {
     HDC hdcSrc, hdcDst;
@@ -723 +724 @@
 
     if (himlTrack == NULL)
-        return FALSE;
+    return FALSE;
 
     if (himlInternalDrag)
@@ -729 +730 @@
 
     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 +765 @@
 
 /*************************************************************************
- * 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 +788 @@
 
 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 +816 @@
                                        himlSrc->uBitsPixel, NULL);
         hbmTempMask = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
-                                      1, NULL);
+                      1, NULL);
 
         /* copy (and stretch) destination to temporary bitmaps.(save) */
@@ -908 +909 @@
 HIMAGELIST WINAPI
 ImageList_Create (INT cx, INT cy, UINT flags,
-                  INT cInitial, INT cGrow)
+          INT cInitial, INT cGrow)
 {
     HIMAGELIST himl;
@@ -914 +915 @@
     INT      nCount;
     HBITMAP  hbmTemp;
-    static WORD aBitBlend25[] = 
+    static WORD aBitBlend25[] =
         {0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00};
 
@@ -948 +949 @@
     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 +987 @@
 
 /*************************************************************************
- * ImageList_Destroy [COMCTL32.46] 
+ * ImageList_Destroy [COMCTL32.46]
  *
  * Destroys an image list.
@@ -1000 +1001 @@
 BOOL WINAPI
 ImageList_Destroy (HIMAGELIST himl)
-{ 
+{
     if (!himl)
-        return FALSE;
+    return FALSE;
 
     /* delete image bitmaps */
@@ -1015 +1016 @@
     if (himl->hbrBlend50)
         DeleteObject (himl->hbrBlend50);
-        
+
     COMCTL32_Free (himl);
 
@@ -1023 +1024 @@
 
 /*************************************************************************
- * ImageList_DragEnter [COMCTL32.47] 
+ * ImageList_DragEnter [COMCTL32.47]
  *
  * Locks window update and displays the drag image at the given position.
@@ -1045 +1046 @@
 {
     if (himlInternalDrag == NULL)
-        return FALSE;
+    return FALSE;
 
     if (hwndLock)
-        hwndInternalDrag = hwndLock;
+    hwndInternalDrag = hwndLock;
     else
-        hwndInternalDrag = GetDesktopWindow ();
+    hwndInternalDrag = GetDesktopWindow ();
 
     xInternalPos = x;
@@ -1057 +1058 @@
     hdcBackBuffer = CreateCompatibleDC (0);
     hbmBackBuffer = CreateCompatibleBitmap (hdcBackBuffer,
-                himlInternalDrag->cx, himlInternalDrag->cy);
+        himlInternalDrag->cx, himlInternalDrag->cy);
 
     ImageList_DragShowNolock (TRUE);
@@ -1066 +1067 @@
 
 /*************************************************************************
- * ImageList_DragLeave [COMCTL32.48] 
+ * ImageList_DragLeave [COMCTL32.48]
  *
  * Unlocks window update and hides the drag image.
@@ -1082 +1083 @@
 {
     if (hwndLock)
-        hwndInternalDrag = hwndLock;
+    hwndInternalDrag = hwndLock;
     else
-        hwndInternalDrag = GetDesktopWindow ();
+    hwndInternalDrag = GetDesktopWindow ();
 
     ImageList_DragShowNolock (FALSE);
@@ -1096 +1097 @@
 
 /*************************************************************************
- * ImageList_DragMove [COMCTL32.49] 
+ * ImageList_DragMove [COMCTL32.49]
  *
  * Moves the drag image.
@@ -1128 +1129 @@
 
 /*************************************************************************
- * ImageList_DragShowNolock [COMCTL32.50] 
+ * ImageList_DragShowNolock [COMCTL32.50]
  *
  * Shows or hides the drag image.
@@ -1152 +1153 @@
 
     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 +1200 @@
 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 +1253 @@
 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 +1278 @@
 
 /*************************************************************************
- * ImageList_DrawIndirect [COMCTL32.53] 
+ * ImageList_DrawIndirect [COMCTL32.53]
  *
  * Draws an image using ...
@@ -1292 +1293 @@
 ImageList_DrawIndirect (IMAGELISTDRAWPARAMS *pimldp)
 {
-    INT      cx, cy;    
-    /* 
+    INT      cx, cy;
+    /*
         Do some Error Checking
     */
@@ -1303 +1304 @@
         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 +1323 @@
         IMAGELIST_InternalDraw(pimldp, cx, cy);
     }
-    /* 
+    /*
         Apply the blend if needed to the Image
     */
@@ -1387 +1388 @@
         DeleteDC (hdcSrc);
 
-        himlDst->cCurImage = himlSrc->cCurImage;
-        himlDst->cMaxImage = himlSrc->cMaxImage;
+    himlDst->cCurImage = himlSrc->cCurImage;
+    himlDst->cMaxImage = himlSrc->cMaxImage;
     }
     return himlDst;
@@ -1447 +1448 @@
 {
     if (himl == NULL)
-        return CLR_NONE;
+    return CLR_NONE;
 
     return himl->clrBk;
@@ -1483 +1484 @@
 
 /*************************************************************************
- * ImageList_GetIcon [COMCTL32.59] 
+ * ImageList_GetIcon [COMCTL32.59]
  *
  * Creates an icon from a masked image of an image list.
@@ -1506 +1507 @@
 
     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 +1520 @@
     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 +1532 @@
     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 +1574 @@
 {
     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 +1604 @@
 {
     if (himl == NULL)
-        return 0;
+    return 0;
 
     return himl->cCurImage;
@@ -1628 +1629 @@
 {
     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 +1646 @@
 
 /*************************************************************************
- * ImageList_GetImageRect [COMCTL32.63] 
+ * ImageList_GetImageRect [COMCTL32.63]
  *
  * Retrieves the rectangle of the specified image in an image list.
@@ -1666 +1667 @@
 {
     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 +1705 @@
 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 +1745 @@
         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 +1753 @@
 
     DeleteObject (handle);
-    
+
     return himl;
 }
@@ -1781 +1782 @@
 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 +1809 @@
         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 +1817 @@
 
     DeleteObject (handle);
-    
+
     return himl;
 }
@@ -1822 +1823 @@
 
 /*************************************************************************
- * ImageList_Merge [COMCTL32.67] 
+ * ImageList_Merge [COMCTL32.67]
  *
  * Creates a new image list that contains a merged image from the specified
@@ -1842 +1843 @@
 HIMAGELIST WINAPI
 ImageList_Merge (HIMAGELIST himl1, INT i1, HIMAGELIST himl2, INT i2,
-                 INT dx, INT dy)
+         INT dx, INT dy)
 {
     HIMAGELIST himlDst = NULL;
@@ -1851 +1852 @@
 
     if ((himl1 == NULL) || (himl2 == NULL))
-        return NULL;
+    return NULL;
 
     /* check indices */
@@ -1903 +1904 @@
         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 +1924 @@
         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 +1936 @@
         DeleteDC (hdcDstImage);
     }
-   
+
     return himlDst;
 }
@@ -1945 +1946 @@
     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 +1955 @@
 /* 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 +2063 @@
  *
  * 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 +2086 @@
 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 +2141 @@
     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 +2169 @@
         return FALSE;
     }
-    
+
     if ((i < -1) || (i >= himl->cCurImage)) {
         ERR("index out of range! %d\n", i);
@@ -2211 +2212 @@
         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 +2227 @@
         if (i > 0) {
             TRACE("Pre image copy: Copy %d images\n", i);
-       
+
             SelectObject (hdcSrc, himl->hbmImage);
             SelectObject (hdcDst, hbmNewImage);
@@ -2277 +2278 @@
 
 /*************************************************************************
- * ImageList_Replace [COMCTL32.70] 
+ * ImageList_Replace [COMCTL32.70]
  *
  * Replaces an image in an image list with a new image.
@@ -2294 +2295 @@
 BOOL WINAPI
 ImageList_Replace (HIMAGELIST himl, INT i, HBITMAP hbmImage,
-                   HBITMAP hbmMask)
+           HBITMAP hbmMask)
 {
     HDC hdcImageList, hdcImage;
@@ -2303 +2304 @@
         return FALSE;
     }
-    
+
     if ((i >= himl->cMaxImage) || (i < 0)) {
         ERR("Invalid image index!\n");
@@ -2333 +2334 @@
         */
         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 +2376 @@
 
     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 +2405 @@
     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 +2430 @@
 
     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 +2445 @@
 
 /*************************************************************************
- * ImageList_SetBkColor [COMCTL32.76] 
+ * ImageList_SetBkColor [COMCTL32.76]
  *
  * Sets the background color of an image list.
@@ -2463 +2464 @@
 
     if (himl == NULL)
-        return CLR_NONE;
+    return CLR_NONE;
 
     clrOldBk = himl->clrBk;
@@ -2492 +2493 @@
 BOOL WINAPI
 ImageList_SetDragCursorImage (HIMAGELIST himlDrag, INT iDrag,
-                              INT dxHotspot, INT dyHotspot)
+                  INT dxHotspot, INT dyHotspot)
 {
     HIMAGELIST himlTemp;
@@ -2499 +2500 @@
 
     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 +2519 @@
 
 /*************************************************************************
- * ImageList_SetFilter [COMCTL32.78] 
+ * ImageList_SetFilter [COMCTL32.78]
  *
  * Sets a filter (or does something completely different)!!???
@@ -2540 +2541 @@
 {
     FIXME("(%p 0x%x 0x%lx):empty stub!\n",
-           himl, i, dwFilter);
+       himl, i, dwFilter);
 
     return FALSE;
@@ -2567 +2568 @@
 
     if (!himl)
-        return FALSE;
+    return FALSE;
 
     /* remove all images */
@@ -2617 +2618 @@
 
     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 +2637 @@
         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 +2662 @@
             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 +2710 @@
 {
     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 +2745 @@
 {
     if (!himl)
-        return FALSE;
+    return FALSE;
 
     FIXME("empty stub!\n");

trunk/src/comctl32/initcomctl32.cpp

@@ +1 @@
+/* $Id: initcomctl32.cpp,v 1.3 2001-09-05 12:04:58 bird Exp $ */
 /*
  * COMCTL32 DLL entry point
@@ -26 +27 @@
 #define  INCL_DOSMODULEMGR
 #define  INCL_DOSPROCESS
-#include <os2wrap.h>    //Odin32 OS/2 api wrappers
+#include <os2wrap.h>    //Odin32 OS/2 api wrappers
 #include <stdlib.h>
 #include <stdio.h>
@@ -59 +60 @@
    {
         BOOL ret = COMCTL32_LibMain(hinstDLL, fdwReason, fImpLoad);
-        return ret;
+    return ret;
    }
    }
@@ -85 +86 @@
    switch (ulFlag) {
       case 0 :
-         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&comctl32_PEResTab,
+     dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&comctl32_PEResTab,
                                    COMCTL32_MAJORIMAGE_VERSION, COMCTL32_MINORIMAGE_VERSION,
                                    IMAGE_SUBSYSTEM_WINDOWS_GUI);
-         if(dllHandle == 0) 
-                return 0UL;
+         if(dllHandle == 0)
+        return 0UL;
 
          break;
       case 1 :
          if(dllHandle) {
-                UnregisterLxDll(dllHandle);
+        UnregisterLxDll(dllHandle);
          }
          break;

trunk/src/comctl32/initterm.cpp

@@ +1 @@
+/* $Id: initterm.cpp,v 1.16 2001-09-05 12:04:59 bird Exp $ */
 /*
  * COMCTL32 DLL entry point
@@ -26 +27 @@
 #define  INCL_DOSMODULEMGR
 #define  INCL_DOSPROCESS
-#include <os2wrap.h>    //Odin32 OS/2 api wrappers
+#include <os2wrap.h>    //Odin32 OS/2 api wrappers
 #include <stdlib.h>
 #include <stdio.h>

trunk/src/comctl32/listview.c

@@ +1 @@
+/* $Id: listview.c,v 1.33 2001-09-05 12:04:59 bird Exp $ */
 /*
  * Listview control

trunk/src/comctl32/monthcal.c

@@ +1 @@
+/* $Id: monthcal.c,v 1.12 2001-09-05 12:05:00 bird Exp $ */
 /* Month calendar control
-
+ *
  *
  * Copyright 1998, 1999 Eric Kohl (ekohl@abo.rhein-zeitung.de)
  * Copyright 1999 Alex Priem (alexp@sci.kun.nl)
  * Copyright 1999 Chris Morgan <cmorgan@wpi.edu> and
- *                James Abbatiello <abbeyj@wpi.edu>
+ *        James Abbatiello <abbeyj@wpi.edu>
  * Copyright 2000 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>
  *
@@ -13 +14 @@
  *
  *  FIXME: handle resources better (doesn't work now); also take care
-           of internationalization. 
+ *         of internationalization.
  *  FIXME: keyboard handling.
  */
@@ -43 +44 @@
 DEFAULT_DEBUG_CHANNEL(monthcal);
 
-#define MC_SEL_LBUTUP       1   /* Left button released */
-#define MC_SEL_LBUTDOWN     2   /* Left button pressed in calendar */
+#define MC_SEL_LBUTUP       1   /* Left button released */
+#define MC_SEL_LBUTDOWN     2   /* Left button pressed in calendar */
 #define MC_PREVPRESSED      4   /* Prev month button pressed */
 #define MC_NEXTPRESSED      8   /* Next month button pressed */
-#define MC_NEXTMONTHDELAY   350 /* when continuously pressing `next */
-                                                                                /* month', wait 500 ms before going */
-                                                                                /* to the next month */
-#define MC_NEXTMONTHTIMER   1                   /* Timer ID's */
-#define MC_PREVMONTHTIMER   2                   
+#define MC_NEXTMONTHDELAY   350 /* when continuously pressing `next */
+                                        /* month', wait 500 ms before going */
+                                        /* to the next month */
+#define MC_NEXTMONTHTIMER   1           /* Timer ID's */
+#define MC_PREVMONTHTIMER   2
 
 typedef struct
@@ -58 +59 @@
     COMCTL32_HEADER header;
 #endif
-    COLORREF    bk;
-    COLORREF    txt;
-    COLORREF    titlebk;
-    COLORREF    titletxt;
-    COLORREF    monthbk;
-    COLORREF    trailingtxt;
-    HFONT       hFont;
-    HFONT       hBoldFont;
-    int         textHeight;
-    int         textWidth;
-    int         height_increment;
-    int         width_increment;
-    int         left_offset;
-    int         top_offset;
-    int         firstDayplace; /* place of the first day of the current month */
-    int         delta;  /* scroll rate; # of months that the */
+    COLORREF    bk;
+    COLORREF    txt;
+    COLORREF    titlebk;
+    COLORREF    titletxt;
+    COLORREF    monthbk;
+    COLORREF    trailingtxt;
+    HFONT   hFont;
+    HFONT   hBoldFont;
+    int     textHeight;
+    int     textWidth;
+    int     height_increment;
+    int     width_increment;
+    int     left_offset;
+    int     top_offset;
+    int     firstDayplace; /* place of the first day of the current month */
+    int     delta;  /* scroll rate; # of months that the */
                         /* control moves when user clicks a scroll button */
-    int         visible;        /* # of months visible */
-    int         firstDay;       /* Start month calendar with firstDay's day */
-    int         monthRange;
+    int     visible;    /* # of months visible */
+    int     firstDay;   /* Start month calendar with firstDay's day */
+    int     monthRange;
     MONTHDAYSTATE *monthdayState;
-    SYSTEMTIME  todaysDate;
-    DWORD       currentMonth;
-    DWORD       currentYear;
-    int         status;         /* See MC_SEL flags */
-    int         curSelDay;      /* current selected day */
-    int         firstSelDay;    /* first selected day */
-    int         maxSelCount;
-    SYSTEMTIME  minSel;
-    SYSTEMTIME  maxSel;
-    DWORD       rangeValid;
-    SYSTEMTIME  minDate;
-    SYSTEMTIME  maxDate;
-                
-    RECT rcClient;      /* rect for whole client area */
-    RECT rcDraw;        /* rect for drawable portion of client area */
-    RECT title;         /* rect for the header above the calendar */
-    RECT titlebtnnext;  /* the `next month' button in the header */
-    RECT titlebtnprev;  /* the `prev month' button in the header */     
-    RECT titlemonth;    /* the `month name' txt in the header */
-    RECT titleyear;     /* the `year number' txt in the header */
-    RECT wdays;         /* week days at top */
-    RECT days;          /* calendar area */
-    RECT weeknums;      /* week numbers at left side */
-    RECT todayrect;     /* `today: xx/xx/xx' text rect */
+    SYSTEMTIME  todaysDate;
+    DWORD   currentMonth;
+    DWORD   currentYear;
+    int     status;     /* See MC_SEL flags */
+    int     curSelDay;  /* current selected day */
+    int     firstSelDay;    /* first selected day */
+    int     maxSelCount;
+    SYSTEMTIME  minSel;
+    SYSTEMTIME  maxSel;
+    DWORD   rangeValid;
+    SYSTEMTIME  minDate;
+    SYSTEMTIME  maxDate;
+
+    RECT rcClient;  /* rect for whole client area */
+    RECT rcDraw;    /* rect for drawable portion of client area */
+    RECT title;     /* rect for the header above the calendar */
+    RECT titlebtnnext;  /* the `next month' button in the header */
+    RECT titlebtnprev;  /* the `prev month' button in the header */
+    RECT titlemonth;    /* the `month name' txt in the header */
+    RECT titleyear; /* the `year number' txt in the header */
+    RECT wdays;     /* week days at top */
+    RECT days;      /* calendar area */
+    RECT weeknums;  /* week numbers at left side */
+    RECT todayrect; /* `today: xx/xx/xx' text rect */
     HWND hWndYearEdit;  /* Window Handle of edit box to handle years */
     HWND hWndYearUpDown;/* Window Handle of updown box to handle years */
@@ -141 +142 @@
 
 /* make sure that time is valid */
-static int MONTHCAL_ValidateTime(SYSTEMTIME time) 
+static int MONTHCAL_ValidateTime(SYSTEMTIME time)
 {
   if(time.wMonth > 12) return FALSE;
   if(time.wDayOfWeek > 6) return FALSE;
   if(time.wDay > MONTHCAL_MonthLength(time.wMonth, time.wYear))
-          return FALSE;
+      return FALSE;
   if(time.wHour > 23) return FALSE;
   if(time.wMinute > 59) return FALSE;
@@ -156 +157 @@
 
 
-void MONTHCAL_CopyTime(const SYSTEMTIME *from, SYSTEMTIME *to) 
+void MONTHCAL_CopyTime(const SYSTEMTIME *from, SYSTEMTIME *to)
 {
   to->wYear = from->wYear;
@@ -169 +170 @@
 
 
-/* Note:Depending on DST, this may be offset by a day. 
+/* Note:Depending on DST, this may be offset by a day.
    Need to find out if we're on a DST place & adjust the clock accordingly.
    Above function assumes we have a valid data.
@@ -182 +183 @@
   year-=(month < 3);
 
-  return((year + year/4 - year/100 + year/400 + 
+  return((year + year/4 - year/100 + year/400 +
          DayOfWeekTable[month-1] + day - 1 ) % 7);
 }
@@ -189 +190 @@
    and day in the calendar. day== 0 mean the last day of tha last month
 */
-static int MONTHCAL_CalcDayFromPos(MONTHCAL_INFO *infoPtr, int x, int y, 
-                                   int *daypos,int *weekpos) 
+static int MONTHCAL_CalcDayFromPos(MONTHCAL_INFO *infoPtr, int x, int y,
+                   int *daypos,int *weekpos)
 {
   int retval, firstDay;
@@ -202 +203 @@
   *daypos = (x - infoPtr->days.left ) / infoPtr->width_increment;
   *weekpos = (y - infoPtr->days.top ) / infoPtr->height_increment;
-    
+
   firstDay = (MONTHCAL_CalculateDayOfWeek(1, infoPtr->currentMonth, infoPtr->currentYear)+6 - infoPtr->firstDay)%7;
   retval = *daypos + (7 * *weekpos) - firstDay;
@@ -211 +212 @@
 /* sets x and y to be the position of the day */
 /* x == day, y == week where(0,0) == firstDay, 1st week */
-static void MONTHCAL_CalcDayXY(MONTHCAL_INFO *infoPtr, int day, int month, 
+static void MONTHCAL_CalcDayXY(MONTHCAL_INFO *infoPtr, int day, int month,
                                  int *x, int *y)
 {
@@ -227 +228 @@
     if(prevMonth==0)
        prevMonth = 12;
-   
+
     *x = (MONTHCAL_MonthLength(prevMonth, infoPtr->currentYear) - firstDay) % 7;
     *y = 0;
@@ -240 +241 @@
 
 /* x: column(day), y: row(week) */
-static void MONTHCAL_CalcDayRect(MONTHCAL_INFO *infoPtr, RECT *r, int x, int y) 
+static void MONTHCAL_CalcDayRect(MONTHCAL_INFO *infoPtr, RECT *r, int x, int y)
 {
   r->left = infoPtr->days.left + x * infoPtr->width_increment;
@@ -252 +253 @@
 /* day is the day value of the month(1 == 1st), month is the month */
 /* value(january == 1, december == 12) */
-static inline void MONTHCAL_CalcPosFromDay(MONTHCAL_INFO *infoPtr, 
+static inline void MONTHCAL_CalcPosFromDay(MONTHCAL_INFO *infoPtr,
                                             int day, int month, RECT *r)
 {
@@ -278 +279 @@
   x = day_rect.left;
   y = day_rect.top;
-        
+
   points[0].x = x;
   points[0].y = y - 1;
@@ -287 +288 @@
   points[3].x = x + infoPtr->width_increment;
   points[3].y = y + 0.5 * infoPtr->height_increment;
-        
+
   points[4].x = x + infoPtr->width_increment;
   points[4].y = y + 0.9 * infoPtr->height_increment;
@@ -294 +295 @@
   points[6].x = x + 0.5 * infoPtr->width_increment;
   points[6].y = y + 0.9 * infoPtr->height_increment; /* bring the bottom up just
-                                a hair to fit inside the day rectangle */
-        
+                a hair to fit inside the day rectangle */
+
   points[7].x = x + 0.2 * infoPtr->width_increment;
   points[7].y = y + 0.8 * infoPtr->height_increment;
@@ -309 +310 @@
   points[12].x = x + 0.4 * infoPtr->width_increment;
   points[12].y = y + 0.2 * infoPtr->height_increment;
-  
+
   PolyBezier(hdc, points, 13);
   DeleteObject(hRedPen);
@@ -329 +330 @@
   sprintf(buf, "%d", day);
 
-/* No need to check styles: when selection is not valid, it is set to zero. 
+/* No need to check styles: when selection is not valid, it is set to zero.
  * 1<day<31, so evertyhing's OK.
  */
@@ -349 +350 @@
 
     /* FIXME: this may need to be changed now b/c of the other
-        drawing changes 11/3/99 CMM */
+    drawing changes 11/3/99 CMM */
     r2.left   = r.left - 0.25 * infoPtr->textWidth;
     r2.top    = r.top;
@@ -390 +391 @@
 
 /* CHECKME: For `todays date', do we need to check the locale?*/
-static void MONTHCAL_Refresh(HWND hwnd, HDC hdc, PAINTSTRUCT* ps) 
+static void MONTHCAL_Refresh(HWND hwnd, HDC hdc, PAINTSTRUCT* ps)
 {
   MONTHCAL_INFO *infoPtr=MONTHCAL_GetInfoPtr(hwnd);
@@ -425 +426 @@
   hbr = CreateSolidBrush (infoPtr->bk);
   FillRect(hdc, rcClient, hbr);
-  DeleteObject(hbr);       
+  DeleteObject(hbr);
 
   /* draw header */
@@ -434 +435 @@
     DeleteObject(hbr);
   }
-        
+
   /* if the previous button is pressed draw it depressed */
   if(IntersectRect(&rcTemp, &(ps->rcPaint), prev))
-  {  
+  {
     if((infoPtr->status & MC_PREVPRESSED))
         DrawFrameControl(hdc, prev, DFC_SCROLL,
-           DFCS_SCROLLLEFT | DFCS_PUSHED |
+       DFCS_SCROLLLEFT | DFCS_PUSHED |
           (dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
     else /* if the previous button is pressed draw it depressed */
       DrawFrameControl(hdc, prev, DFC_SCROLL,
-           DFCS_SCROLLLEFT |(dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
-  }
-
-  /* if next button is depressed draw it depressed */   
+       DFCS_SCROLLLEFT |(dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
+  }
+
+  /* if next button is depressed draw it depressed */
   if(IntersectRect(&rcTemp, &(ps->rcPaint), next))
   {
     if((infoPtr->status & MC_NEXTPRESSED))
       DrawFrameControl(hdc, next, DFC_SCROLL,
-           DFCS_SCROLLRIGHT | DFCS_PUSHED |
+           DFCS_SCROLLRIGHT | DFCS_PUSHED |
            (dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
     else /* if the next button is pressed draw it depressed */
@@ -466 +467 @@
   titlemonth->left   = title->left;
   titlemonth->right  = title->right;
- 
+
   GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SMONTHNAME1+infoPtr->currentMonth -1,
-                  buf1,sizeof(buf1));
+          buf1,sizeof(buf1));
   sprintf(buf, "%s %ld", buf1, infoPtr->currentYear);
- 
+
   if(IntersectRect(&rcTemp, &(ps->rcPaint), titlemonth))
   {
-    DrawTextA(hdc, buf, strlen(buf), titlemonth, 
+    DrawTextA(hdc, buf, strlen(buf), titlemonth,
                         DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   }
@@ -481 +482 @@
 /* titlemonth left/right contained rect for whole titletxt('June  1999')
   * MCM_HitTestInfo wants month & year rects, so prepare these now.
-  *(no, we can't draw them separately; the whole text is centered) 
+  *(no, we can't draw them separately; the whole text is centered)
   */
   GetTextExtentPoint32A(hdc, buf, strlen(buf), &size);
@@ -489 +490 @@
   titlemonth->right = titlemonth->left + size.cx;
   titleyear->left = titlemonth->right;
- 
+
   /* draw month area */
   rcTemp.top=infoPtr->wdays.top;
@@ -501 +502 @@
     DeleteObject(hbr);
   }
-        
+
 /* draw line under day abbreviatons */
 
   MoveToEx(hdc, infoPtr->days.left + 3, title->bottom + textHeight + 1, NULL);
-     
+
   LineTo(hdc, rcDraw->right - 3, title->bottom + textHeight + 1);
-  
+
   prevMonth = infoPtr->currentMonth - 1;
   if(prevMonth == 0) /* if currentMonth is january(1) prevMonth is */
@@ -529 +530 @@
   for(j=0; j<7; j++) {
     GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SABBREVDAYNAME1 + (i +j)%7,
-                    buf,sizeof(buf));
+            buf,sizeof(buf));
     DrawTextA(hdc, buf, strlen(buf), days,
                          DT_CENTER | DT_VCENTER | DT_SINGLELINE );
@@ -537 +538 @@
 
 /* draw day numbers; first, the previous month */
-  
+
   firstDay = MONTHCAL_CalculateDayOfWeek(1, infoPtr->currentMonth, infoPtr->currentYear);
-  
-  day = MONTHCAL_MonthLength(prevMonth, infoPtr->currentYear)  + 
+
+  day = MONTHCAL_MonthLength(prevMonth, infoPtr->currentYear)  +
     (infoPtr->firstDay + 7  - firstDay)%7 + 1;
   if (day > MONTHCAL_MonthLength(prevMonth, infoPtr->currentYear))
@@ -553 +554 @@
     if(IntersectRect(&rcTemp, &(ps->rcPaint), &rcDay))
     {
-      MONTHCAL_DrawDay(hdc, infoPtr, day, prevMonth, i, 0, 
+      MONTHCAL_DrawDay(hdc, infoPtr, day, prevMonth, i, 0,
           infoPtr->monthdayState[m] & mask);
     }
@@ -577 +578 @@
     {
 
-      MONTHCAL_DrawDay(hdc, infoPtr, day, infoPtr->currentMonth, i, 0, 
-        infoPtr->monthdayState[m] & mask);
+      MONTHCAL_DrawDay(hdc, infoPtr, day, infoPtr->currentMonth, i, 0,
+    infoPtr->monthdayState[m] & mask);
 
       if((infoPtr->currentMonth==infoPtr->todaysDate.wMonth) &&
           (day==infoPtr->todaysDate.wDay) &&
-          (infoPtr->currentYear == infoPtr->todaysDate.wYear)) {
+      (infoPtr->currentYear == infoPtr->todaysDate.wYear)) {
         if(!(dwStyle & MCS_NOTODAYCIRCLE))
-          MONTHCAL_CircleDay(hdc, infoPtr, day, infoPtr->currentMonth);
+      MONTHCAL_CircleDay(hdc, infoPtr, day, infoPtr->currentMonth);
       }
     }
@@ -595 +596 @@
   j = 1; /* move to the 2nd week of the current month */
   i = 0; /* move back to sunday */
-  while(day <= MONTHCAL_MonthLength(infoPtr->currentMonth, infoPtr->currentYear)) {     
+  while(day <= MONTHCAL_MonthLength(infoPtr->currentMonth, infoPtr->currentYear)) {
     MONTHCAL_CalcDayRect(infoPtr, &rcDay, i, j);
     if(IntersectRect(&rcTemp, &(ps->rcPaint), &rcDay))
@@ -604 +605 @@
       if((infoPtr->currentMonth==infoPtr->todaysDate.wMonth) &&
           (day==infoPtr->todaysDate.wDay) &&
-          (infoPtr->currentYear == infoPtr->todaysDate.wYear)) 
-        if(!(dwStyle & MCS_NOTODAYCIRCLE))  
-          MONTHCAL_CircleDay(hdc, infoPtr, day, infoPtr->currentMonth);
+          (infoPtr->currentYear == infoPtr->todaysDate.wYear))
+        if(!(dwStyle & MCS_NOTODAYCIRCLE))
+      MONTHCAL_CircleDay(hdc, infoPtr, day, infoPtr->currentMonth);
     }
     mask<<=1;
@@ -627 +628 @@
     MONTHCAL_CalcDayRect(infoPtr, &rcDay, i, j);
     if(IntersectRect(&rcTemp, &(ps->rcPaint), &rcDay))
-    {   
+    {
       MONTHCAL_DrawDay(hdc, infoPtr, day, infoPtr->currentMonth + 1, i, j,
-                infoPtr->monthdayState[m] & mask);
+        infoPtr->monthdayState[m] & mask);
     }
 
     mask<<=1;
     day++;
-    i++;        
+    i++;
     if(i==7) { /* past saturday, go to next week's sunday */
       i = 0;
@@ -650 +651 @@
     if(!(dwStyle & MCS_NOTODAYCIRCLE))  {
       /*day is the number of days from nextmonth we put on the calendar */
-      MONTHCAL_CircleDay(hdc, infoPtr, 
-                         day+MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear), 
-                         infoPtr->currentMonth);
+      MONTHCAL_CircleDay(hdc, infoPtr,
+             day+MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear),
+             infoPtr->currentMonth);
       offset+=textWidth;
     }
     if (!LoadStringA(COMCTL32_hModule,IDM_TODAY,buf1,sizeof(buf1)))
       {
-        WARN("Can't load resource\n");
-        strcpy(buf1,"Today:");
+    WARN("Can't load resource\n");
+    strcpy(buf1,"Today:");
       }
     MONTHCAL_CalcDayRect(infoPtr, &rtoday, 1, 6);
@@ -674 +675 @@
   }
 
-/*eventually draw week numbers*/   
+/*eventually draw week numbers*/
   if(dwStyle & MCS_WEEKNUMBERS)  {
     /* display weeknumbers*/
@@ -682 +683 @@
        LOCALE_IFIRSTWEEKOFYEAR == 0 (e.g US?):
        The week containing Jan 1 is the first week of year
-       LOCALE_IFIRSTWEEKOFYEAR == 2 (e.g. Germany): 
+       LOCALE_IFIRSTWEEKOFYEAR == 2 (e.g. Germany):
        First week of year must contain 4 days of the new year
        LOCALE_IFIRSTWEEKOFYEAR == 1  (what contries?)
@@ -688 +689 @@
     */
     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_IFIRSTWEEKOFYEAR,
-                     buf, sizeof(buf));
+             buf, sizeof(buf));
     sscanf(buf, "%d", &weeknum);
     switch (weeknum)
       {
       case 1: mindays = 6;
-        break;
+    break;
       case 2: mindays = 3;
-        break;
+    break;
       case 0:
       default:
-        mindays = 0;
+    mindays = 0;
       }
     if (infoPtr->currentMonth < 2)
       {
-        /* calculate all those exceptions for january */
-        weeknum1=MONTHCAL_CalculateDayOfWeek(1,1,infoPtr->currentYear);
-        if ((infoPtr->firstDay +7 - weeknum1)%7 > mindays) 
-            weeknum =1;
-        else
-          {
-            weeknum = 0;
-            for(i=0; i<11; i++) 
-              weeknum+=MONTHCAL_MonthLength(i+1, infoPtr->currentYear-1);
-            weeknum +=startofprescal+ 7;
-            weeknum /=7;
-            weeknum1=MONTHCAL_CalculateDayOfWeek(1,1,infoPtr->currentYear-1);
-            if ((infoPtr->firstDay + 7 - weeknum1)%7 > mindays)
-              weeknum++;
-          }
+    /* calculate all those exceptions for january */
+    weeknum1=MONTHCAL_CalculateDayOfWeek(1,1,infoPtr->currentYear);
+    if ((infoPtr->firstDay +7 - weeknum1)%7 > mindays)
+        weeknum =1;
+    else
+      {
+        weeknum = 0;
+        for(i=0; i<11; i++)
+          weeknum+=MONTHCAL_MonthLength(i+1, infoPtr->currentYear-1);
+        weeknum +=startofprescal+ 7;
+        weeknum /=7;
+        weeknum1=MONTHCAL_CalculateDayOfWeek(1,1,infoPtr->currentYear-1);
+        if ((infoPtr->firstDay + 7 - weeknum1)%7 > mindays)
+          weeknum++;
+      }
       }
     else
       {
-        weeknum = 0;
-        for(i=0; i<prevMonth-1; i++) 
-          weeknum+=MONTHCAL_MonthLength(i+1, infoPtr->currentYear);
-        weeknum +=startofprescal+ 7;
-        weeknum /=7;
-        weeknum1=MONTHCAL_CalculateDayOfWeek(1,1,infoPtr->currentYear);
-        if ((infoPtr->firstDay + 7 - weeknum1)%7 > mindays)
-          weeknum++;
+    weeknum = 0;
+    for(i=0; i<prevMonth-1; i++)
+      weeknum+=MONTHCAL_MonthLength(i+1, infoPtr->currentYear);
+    weeknum +=startofprescal+ 7;
+    weeknum /=7;
+    weeknum1=MONTHCAL_CalculateDayOfWeek(1,1,infoPtr->currentYear);
+    if ((infoPtr->firstDay + 7 - weeknum1)%7 > mindays)
+      weeknum++;
       }
     days->left = infoPtr->weeknums.left;
@@ -735 +736 @@
     for(i=0; i<6; i++) {
       if((i==0)&&(weeknum>50))
-        {
-          sprintf(buf, "%d", weeknum);
-          weeknum=0;
-        }
+    {
+      sprintf(buf, "%d", weeknum);
+      weeknum=0;
+    }
       else if((i==5)&&(weeknum>47))
-        {
-          sprintf(buf, "%d", 1);
-        }
+    {
+      sprintf(buf, "%d", 1);
+    }
       else
-        sprintf(buf, "%d", weeknum + i);
+    sprintf(buf, "%d", weeknum + i);
       DrawTextA(hdc, buf, -1, days, DT_CENTER | DT_VCENTER | DT_SINGLELINE );
       days->top+=infoPtr->height_increment;
       days->bottom+=infoPtr->height_increment;
     }
-                        
+
     MoveToEx(hdc, infoPtr->weeknums.right, infoPtr->weeknums.top + 3 , NULL);
     LineTo(hdc,   infoPtr->weeknums.right, infoPtr->weeknums.bottom );
-                
+
   }
   /* currentFont was font at entering Refresh */
 
   SetBkColor(hdc, oldBkColor);
-  SelectObject(hdc, currentFont);     
+  SelectObject(hdc, currentFont);
   SetTextColor(hdc, oldTextColor);
 }
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetMinReqRect(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -768 +769 @@
   LPRECT lpRect = (LPRECT) lParam;
   TRACE("%x %lx\n", wParam, lParam);
-        
+
   /* validate parameters */
 
@@ -781 +782 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetColor(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -807 +808 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_SetColor(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -847 +848 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetMonthDelta(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -853 +854 @@
 
   TRACE("%x %lx\n", wParam, lParam);
-  
+
   if(infoPtr->delta)
     return infoPtr->delta;
@@ -861 +862 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_SetMonthDelta(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -868 +869 @@
 
   TRACE("%x %lx\n", wParam, lParam);
-        
+
   infoPtr->delta = (int)wParam;
   return prev;
@@ -874 +875 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetFirstDayOfWeek(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
-        
+
   return infoPtr->firstDay;
 }
@@ -887 +888 @@
 /* FIXME: this needs to be implemented properly in MONTHCAL_Refresh() */
 /* FIXME: we need more error checking here */
-static LRESULT 
+static LRESULT
 MONTHCAL_SetFirstDayOfWeek(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -903 +904 @@
     {
       GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_IFIRSTDAYOFWEEK,
-                     buf, sizeof(buf));
+             buf, sizeof(buf));
       TRACE("%s %d\n", buf, strlen(buf));
       if(sscanf(buf, "%d", &day) == 1)
-        infoPtr->firstDay = day;
+    infoPtr->firstDay = day;
       else
-        infoPtr->firstDay = 0;
+    infoPtr->firstDay = 0;
     }
   return prev;
@@ -916 +917 @@
 /* FIXME: fill this in */
 static LRESULT
-MONTHCAL_GetMonthRange(HWND hwnd, WPARAM wParam, LPARAM lParam) 
+MONTHCAL_GetMonthRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
@@ -937 +938 @@
 
 /* FIXME: are validated times taken from current date/time or simply
- * copied? 
+ * copied?
  * FIXME:    check whether MCM_GETMONTHRANGE shows correct result after
  *            adjusting range with MCM_SETRANGE
@@ -950 +951 @@
 
   TRACE("%x %lx\n", wParam, lParam);
-  
+
   if(wParam & GDTR_MAX) {
     if(MONTHCAL_ValidateTime(lprgSysTimeArray[1])){
@@ -973 +974 @@
   infoPtr->monthRange = infoPtr->maxDate.wMonth - infoPtr->minDate.wMonth;
 
-  if(infoPtr->monthRange!=prev) { 
-        COMCTL32_ReAlloc(infoPtr->monthdayState, 
-                infoPtr->monthRange * sizeof(MONTHDAYSTATE));
+  if(infoPtr->monthRange!=prev) {
+    COMCTL32_ReAlloc(infoPtr->monthdayState,
+        infoPtr->monthRange * sizeof(MONTHDAYSTATE));
   }
 
@@ -983 +984 @@
 
 /* CHECKME: At the moment, we copy ranges anyway,regardless of
- * infoPtr->rangeValid; a invalid range is simply filled with zeros in 
+ * infoPtr->rangeValid; a invalid range is simply filled with zeros in
  * SetRange.  Is this the right behavior?
 */
@@ -1015 +1016 @@
   if(iMonths!=infoPtr->monthRange) return 0;
 
-  for(i=0; i<iMonths; i++) 
+  for(i=0; i<iMonths; i++)
     infoPtr->monthdayState[i] = dayStates[i];
   return 1;
 }
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetCurSel(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1036 +1037 @@
 /* FIXME: if the specified date is not visible, make it visible */
 /* FIXME: redraw? */
-static LRESULT 
+static LRESULT
 MONTHCAL_SetCurSel(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1057 +1058 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetMaxSelCount(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1067 +1068 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_SetMaxSelCount(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1081 +1082 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetSelRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1100 +1101 @@
     return TRUE;
   }
- 
+
   return FALSE;
 }
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_SetSelRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1124 +1125 @@
     return TRUE;
   }
- 
+
   return FALSE;
 }
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_GetToday(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1145 +1146 @@
 
 
-static LRESULT 
+static LRESULT
 MONTHCAL_SetToday(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -1170 +1171 @@
   DWORD retval;
   int day,wday,wnum;
-  
-  
+
+
   x = lpht->pt.x;
   y = lpht->pt.y;
   retval = MCHT_NOWHERE;
-  
-
-  /* Comment in for debugging... 
-  TRACE("%d %d wd[%d %d %d %d] d[%d %d %d %d] t[%d %d %d %d] wn[%d %d %d %d]\n", x, y, 
-        infoPtr->wdays.left, infoPtr->wdays.right,
-        infoPtr->wdays.top, infoPtr->wdays.bottom,
-        infoPtr->days.left, infoPtr->days.right,
-        infoPtr->days.top, infoPtr->days.bottom,
-        infoPtr->todayrect.left, infoPtr->todayrect.right,
-        infoPtr->todayrect.top, infoPtr->todayrect.bottom,
-        infoPtr->weeknums.left, infoPtr->weeknums.right,
-        infoPtr->weeknums.top, infoPtr->weeknums.bottom);
+
+
+  /* Comment in for debugging...
+  TRACE("%d %d wd[%d %d %d %d] d[%d %d %d %d] t[%d %d %d %d] wn[%d %d %d %d]\n", x, y,
+    infoPtr->wdays.left, infoPtr->wdays.right,
+    infoPtr->wdays.top, infoPtr->wdays.bottom,
+    infoPtr->days.left, infoPtr->days.right,
+    infoPtr->days.top, infoPtr->days.bottom,
+    infoPtr->todayrect.left, infoPtr->todayrect.right,
+    infoPtr->todayrect.top, infoPtr->todayrect.bottom,
+    infoPtr->weeknums.left, infoPtr->weeknums.right,
+    infoPtr->weeknums.top, infoPtr->weeknums.bottom);
   */
 
   /* are we in the header? */
-  
+
   if(PtInRect(&infoPtr->title, lpht->pt)) {
     if(PtInRect(&infoPtr->titlebtnprev, lpht->pt)) {
@@ -1208 +1209 @@
       goto done;
     }
-    
+
     retval = MCHT_TITLE;
     goto done;
   }
-  
+
   day = MONTHCAL_CalcDayFromPos(infoPtr,x,y,&wday,&wnum);
   if(PtInRect(&infoPtr->wdays, lpht->pt)) {
@@ -1218 +1219 @@
     lpht->st.wYear  = infoPtr->currentYear;
     lpht->st.wMonth = (day < 1)? infoPtr->currentMonth -1 : infoPtr->currentMonth;
-    lpht->st.wDay   = (day < 1)? 
+    lpht->st.wDay   = (day < 1)?
       MONTHCAL_MonthLength(infoPtr->currentMonth-1,infoPtr->currentYear) -day : day;
     goto done;
   }
-  if(PtInRect(&infoPtr->weeknums, lpht->pt)) {  
-    retval = MCHT_CALENDARWEEKNUM; 
+  if(PtInRect(&infoPtr->weeknums, lpht->pt)) {
+    retval = MCHT_CALENDARWEEKNUM;
     lpht->st.wYear  = infoPtr->currentYear;
-    lpht->st.wMonth = (day < 1) ? infoPtr->currentMonth -1 : 
-      (day > MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear)) ? 
+    lpht->st.wMonth = (day < 1) ? infoPtr->currentMonth -1 :
+      (day > MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear)) ?
       infoPtr->currentMonth +1 :infoPtr->currentMonth;
-    lpht->st.wDay   = (day < 1 ) ? 
-      MONTHCAL_MonthLength(infoPtr->currentMonth-1,infoPtr->currentYear) -day : 
-      (day > MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear)) ? 
+    lpht->st.wDay   = (day < 1 ) ?
+      MONTHCAL_MonthLength(infoPtr->currentMonth-1,infoPtr->currentYear) -day :
+      (day > MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear)) ?
       day - MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear) : day;
-    goto done;                              
-  }
-  if(PtInRect(&infoPtr->days, lpht->pt)) 
+    goto done;
+  }
+  if(PtInRect(&infoPtr->days, lpht->pt))
     {
       lpht->st.wYear  = infoPtr->currentYear;
-      if ( day < 1) 
-        {
-          retval = MCHT_CALENDARDATEPREV;
-          lpht->st.wMonth = infoPtr->currentMonth - 1;
-          if (lpht->st.wMonth <1)
-            {
-              lpht->st.wMonth = 12;
-              lpht->st.wYear--;
-            }
-          lpht->st.wDay   = MONTHCAL_MonthLength(lpht->st.wMonth,lpht->st.wYear) -day;
-        }
+      if ( day < 1)
+    {
+      retval = MCHT_CALENDARDATEPREV;
+      lpht->st.wMonth = infoPtr->currentMonth - 1;
+      if (lpht->st.wMonth <1)
+        {
+          lpht->st.wMonth = 12;
+          lpht->st.wYear--;
+        }
+      lpht->st.wDay   = MONTHCAL_MonthLength(lpht->st.wMonth,lpht->st.wYear) -day;
+    }
       else if (day > MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear))
-        {
-          retval = MCHT_CALENDARDATENEXT;
-          lpht->st.wMonth = infoPtr->currentMonth + 1;
-          if (lpht->st.wMonth <12)
-            {
-              lpht->st.wMonth = 1;
-              lpht->st.wYear++;
-            }
-          lpht->st.wDay   = day - MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear) ;
-        }
+    {
+      retval = MCHT_CALENDARDATENEXT;
+      lpht->st.wMonth = infoPtr->currentMonth + 1;
+      if (lpht->st.wMonth <12)
+        {
+          lpht->st.wMonth = 1;
+          lpht->st.wYear++;
+        }
+      lpht->st.wDay   = day - MONTHCAL_MonthLength(infoPtr->currentMonth,infoPtr->currentYear) ;
+    }
       else {
-        retval = MCHT_CALENDARDATE;
-        lpht->st.wMonth = infoPtr->currentMonth;
-        lpht->st.wDay   = day;
+    retval = MCHT_CALENDARDATE;
+    lpht->st.wMonth = infoPtr->currentMonth;
+    lpht->st.wDay   = day;
       }
       goto done;
     }
   if(PtInRect(&infoPtr->todayrect, lpht->pt)) {
-    retval = MCHT_TODAYLINK; 
+    retval = MCHT_TODAYLINK;
     goto done;
   }
-  
-  
+
+
   /* Hit nothing special? What's left must be background :-) */
-  
-  retval = MCHT_CALENDARBK;       
- done: 
+
+  retval = MCHT_CALENDARBK;
+ done:
   lpht->uHit = retval;
   return retval;
@@ -1300 +1301 @@
     nmds.nmhdr.idFrom   = GetWindowLongA(hwnd, GWL_ID);
     nmds.nmhdr.code     = MCN_GETDAYSTATE;
-    nmds.cDayState      = infoPtr->monthRange;
-    nmds.prgDayState    = COMCTL32_Alloc(infoPtr->monthRange * sizeof(MONTHDAYSTATE));
+    nmds.cDayState  = infoPtr->monthRange;
+    nmds.prgDayState    = COMCTL32_Alloc(infoPtr->monthRange * sizeof(MONTHDAYSTATE));
 
     SendMessageA(GetParent(hwnd), WM_NOTIFY,
@@ -1330 +1331 @@
     nmds.nmhdr.idFrom   = GetWindowLongA(hwnd, GWL_ID);
     nmds.nmhdr.code     = MCN_GETDAYSTATE;
-    nmds.cDayState      = infoPtr->monthRange;
-    nmds.prgDayState    = COMCTL32_Alloc 
+    nmds.cDayState  = infoPtr->monthRange;
+    nmds.prgDayState    = COMCTL32_Alloc
                         (infoPtr->monthRange * sizeof(MONTHDAYSTATE));
 
@@ -1348 +1349 @@
   POINT menupoint;
   char buf[32];
-  
+
   hMenu = CreatePopupMenu();
   if (!LoadStringA(COMCTL32_hModule,IDM_GOTODAY,buf,sizeof(buf)))
@@ -1360 +1361 @@
   ClientToScreen(hwnd, &menupoint);
   if( TrackPopupMenu(hMenu,TPM_RIGHTBUTTON| TPM_NONOTIFY|TPM_RETURNCMD,
-                     menupoint.x,menupoint.y,0,hwnd,NULL))
+             menupoint.x,menupoint.y,0,hwnd,NULL))
     {
       infoPtr->currentMonth=infoPtr->todaysDate.wMonth;
       infoPtr->currentYear=infoPtr->todaysDate.wYear;
       InvalidateRect(hwnd, NULL, FALSE);
-    }   
+    }
   return 0;
 }
@@ -1381 +1382 @@
   POINT menupoint;
   TRACE("%x %lx\n", wParam, lParam);
-        
+
   if (infoPtr->hWndYearUpDown)
     {
       infoPtr->currentYear=SendMessageA( infoPtr->hWndYearUpDown, UDM_SETPOS,   (WPARAM) 0,(LPARAM)0);
       if(!DestroyWindow(infoPtr->hWndYearUpDown))
-        {
-          FIXME("Can't destroy Updown Control\n");
-        }
+    {
+      FIXME("Can't destroy Updown Control\n");
+    }
       else
-        infoPtr->hWndYearUpDown=0;
+    infoPtr->hWndYearUpDown=0;
       if(!DestroyWindow(infoPtr->hWndYearEdit))
-        {
-          FIXME("Can't destroy Updown Control\n");
-        }
+    {
+      FIXME("Can't destroy Updown Control\n");
+    }
       else
-        infoPtr->hWndYearEdit=0;
+    infoPtr->hWndYearEdit=0;
       InvalidateRect(hwnd, NULL, FALSE);
     }
-  
+
   ht.pt.x = (INT)LOWORD(lParam);
   ht.pt.y = (INT)HIWORD(lParam);
@@ -1414 +1415 @@
     return TRUE;
   }
-  if(hit == MCHT_TITLEBTNPREV){ 
+  if(hit == MCHT_TITLEBTNPREV){
     MONTHCAL_GoToPrevMonth(hwnd, infoPtr);
     infoPtr->status = MC_PREVPRESSED;
@@ -1424 +1425 @@
   if(hit == MCHT_TITLEMONTH) {
     hMenu = CreatePopupMenu();
-    
+
     for (i=0; i<12;i++)
       {
-        GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SMONTHNAME1+i,
-                  buf,sizeof(buf));
-        AppendMenuA(hMenu, MF_STRING|MF_ENABLED,i+1, buf);
+    GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SMONTHNAME1+i,
+          buf,sizeof(buf));
+    AppendMenuA(hMenu, MF_STRING|MF_ENABLED,i+1, buf);
       }
     menupoint.x=infoPtr->titlemonth.right;
@@ -1435 +1436 @@
     ClientToScreen(hwnd, &menupoint);
     i= TrackPopupMenu(hMenu,TPM_LEFTALIGN | TPM_NONOTIFY | TPM_RIGHTBUTTON | TPM_RETURNCMD,
-                      menupoint.x,menupoint.y,0,hwnd,NULL);
+              menupoint.x,menupoint.y,0,hwnd,NULL);
     if ((i>0) && (i<13))
       {
-        infoPtr->currentMonth=i;
-        InvalidateRect(hwnd, NULL, FALSE);
+    infoPtr->currentMonth=i;
+    InvalidateRect(hwnd, NULL, FALSE);
       }
   }
   if(hit == MCHT_TITLEYEAR) {
     infoPtr->hWndYearEdit=CreateWindowExA(0,
-                         "EDIT",
-                           0,
-                         WS_VISIBLE | WS_CHILD |UDS_SETBUDDYINT,
-                         infoPtr->titleyear.left+3,infoPtr->titlebtnnext.top,
-                         infoPtr->titleyear.right-infoPtr->titleyear.left,
-                         infoPtr->textHeight,
-                         hwnd,
-                         (HMENU)NULL, 
-                         (HINSTANCE)NULL, 
-                         NULL);
+             "EDIT",
+               0,
+             WS_VISIBLE | WS_CHILD |UDS_SETBUDDYINT,
+             infoPtr->titleyear.left+3,infoPtr->titlebtnnext.top,
+             infoPtr->titleyear.right-infoPtr->titleyear.left,
+             infoPtr->textHeight,
+             hwnd,
+             (HMENU)NULL,
+             (HINSTANCE)NULL,
+             NULL);
     infoPtr->hWndYearUpDown=CreateWindowExA(0,
-                         UPDOWN_CLASSA,
-                           0,
-                         WS_VISIBLE | WS_CHILD |UDS_SETBUDDYINT|UDS_NOTHOUSANDS|UDS_ARROWKEYS,
-                         infoPtr->titleyear.right+6,infoPtr->titlebtnnext.top,
-                         20,
-                         infoPtr->textHeight,
-                         hwnd,
-                         (HMENU)NULL, 
-                         (HINSTANCE)NULL, 
-                         NULL);
+             UPDOWN_CLASSA,
+               0,
+             WS_VISIBLE | WS_CHILD |UDS_SETBUDDYINT|UDS_NOTHOUSANDS|UDS_ARROWKEYS,
+             infoPtr->titleyear.right+6,infoPtr->titlebtnnext.top,
+             20,
+             infoPtr->textHeight,
+             hwnd,
+             (HMENU)NULL,
+             (HINSTANCE)NULL,
+             NULL);
     SendMessageA( infoPtr->hWndYearUpDown, UDM_SETRANGE, (WPARAM) 0, MAKELONG (9999, 1753));
     SendMessageA( infoPtr->hWndYearUpDown, UDM_SETBUDDY, (WPARAM) infoPtr->hWndYearEdit, (LPARAM)0 );
     SendMessageA( infoPtr->hWndYearUpDown, UDM_SETPOS,   (WPARAM) 0,(LPARAM)infoPtr->currentYear );
     return TRUE;
-         
+
   }
   if(hit == MCHT_TODAYLINK) {
@@ -1487 +1488 @@
     MONTHCAL_CopyTime(&nmsc.stSelStart, &infoPtr->minSel);
     MONTHCAL_CopyTime(&nmsc.stSelEnd, &infoPtr->maxSel);
-        
+
     SendMessageA(GetParent(hwnd), WM_NOTIFY,
            (WPARAM)nmsc.nmhdr.idFrom,(LPARAM)&nmsc);
@@ -1493 +1494 @@
     MONTHCAL_CopyTime(&ht.st, &selArray[0]);
     MONTHCAL_CopyTime(&ht.st, &selArray[1]);
-    MONTHCAL_SetSelRange(hwnd,0,(LPARAM) &selArray); 
+    MONTHCAL_SetSelRange(hwnd,0,(LPARAM) &selArray);
 
     /* redraw both old and new days if the selected day changed */
@@ -1546 +1547 @@
     return TRUE;
   }
-  if(hit == MCHT_CALENDARDATEPREV){ 
+  if(hit == MCHT_CALENDARDATEPREV){
     MONTHCAL_GoToPrevMonth(hwnd, infoPtr);
     InvalidateRect(hwnd, NULL, FALSE);
@@ -1564 +1565 @@
   MONTHCAL_CopyTime(&nmsc.stSelStart, &infoPtr->minSel);
   MONTHCAL_CopyTime(&nmsc.stSelEnd, &infoPtr->maxSel);
-        
+
   SendMessageA(GetParent(hwnd), WM_NOTIFY,
            (WPARAM)nmsc.nmhdr.idFrom, (LPARAM)&nmsc);
-  
+
   /* redraw if necessary */
   if(redraw)
     InvalidateRect(hwnd, NULL, FALSE);
-        
+
   return 0;
 }
@@ -1586 +1587 @@
 
   switch(wParam) {
-  case MC_NEXTMONTHTIMER: 
+  case MC_NEXTMONTHTIMER:
     redraw = TRUE;
     MONTHCAL_GoToNextMonth(hwnd, infoPtr);
@@ -1618 +1619 @@
   ht.pt.x = LOWORD(lParam);
   ht.pt.y = HIWORD(lParam);
-        
+
   hit = MONTHCAL_HitTest(hwnd, (LPARAM)&ht);
-  
+
   /* not on the calendar date numbers? bail out */
   TRACE("hit:%x\n",hit);
@@ -1638 +1639 @@
     if(infoPtr->firstSelDay==selArray[0].wDay) i=1;
     TRACE("oldRange:%d %d %d %d\n", infoPtr->firstSelDay, selArray[0].wDay, selArray[1].wDay, i);
-    if(infoPtr->firstSelDay==selArray[1].wDay) {  
+    if(infoPtr->firstSelDay==selArray[1].wDay) {
       /* 1st time we get here: selArray[0]=selArray[1])  */
       /* if we're still at the first selected date, return */
@@ -1644 +1645 @@
       if(selday<infoPtr->firstSelDay) i = 0;
     }
-                        
+
     if(abs(infoPtr->firstSelDay - selday) >= infoPtr->maxSelCount) {
       if(selday>infoPtr->firstSelDay)
@@ -1651 +1652 @@
         selday = infoPtr->firstSelDay - infoPtr->maxSelCount;
     }
-                
+
     if(selArray[i].wDay!=selday) {
       TRACE("newRange:%d %d %d %d\n", infoPtr->firstSelDay, selArray[0].wDay, selArray[1].wDay, i);
-                        
+
       selArray[i].wDay = selday;
 
@@ -1712 +1713 @@
 {
   TRACE("\n");
-  
+
   InvalidateRect(hwnd, NULL, FALSE);
 
@@ -1769 +1770 @@
 
   /* recalculate the height and width increments and offsets */
-  /* FIXME: We use up all available width. This will inhibit having multiple 
-     calendars in a row, like win doesn 
+  /* FIXME: We use up all available width. This will inhibit having multiple
+     calendars in a row, like win doesn
   */
   if(dwStyle & MCS_WEEKNUMBERS)
@@ -1776 +1777 @@
   else
     xdiv=7.0;
-  infoPtr->width_increment = (infoPtr->rcDraw.right - infoPtr->rcDraw.left) / xdiv; 
-  infoPtr->height_increment = (infoPtr->rcDraw.bottom - infoPtr->rcDraw.top) / 10.0; 
+  infoPtr->width_increment = (infoPtr->rcDraw.right - infoPtr->rcDraw.left) / xdiv;
+  infoPtr->height_increment = (infoPtr->rcDraw.bottom - infoPtr->rcDraw.top) / 10.0;
   infoPtr->left_offset = (infoPtr->rcDraw.right - infoPtr->rcDraw.left) - (infoPtr->width_increment * xdiv);
   infoPtr->top_offset = (infoPtr->rcDraw.bottom - infoPtr->rcDraw.top) - (infoPtr->height_increment * 10.0);
@@ -1790 +1791 @@
     rcDraw->bottom = rcDraw->top + 9 * infoPtr->textHeight + 5;
     }*/
-   
+
   /* calculate title area */
   title->top    = rcClient->top;
@@ -1805 +1806 @@
   next->right  = title->right - 6;
   next->left   = next->right - (title->bottom - title->top);
-  
+
   /* titlemonth->left and right change based upon the current month */
   /* and are recalculated in refresh as the current month may change */
@@ -1811 +1812 @@
   titlemonth->top    = titleyear->top    = title->top    + (infoPtr->height_increment)/2;
   titlemonth->bottom = titleyear->bottom = title->bottom - (infoPtr->height_increment)/2;
-  
+
   /* setup the dimensions of the rectangle we draw the names of the */
   /* days of the week in */
   weeknumrect->left =infoPtr->left_offset;
-  if(dwStyle & MCS_WEEKNUMBERS)  
+  if(dwStyle & MCS_WEEKNUMBERS)
     weeknumrect->right=prev->right;
   else
@@ -1823 +1824 @@
   wdays->top    = title->bottom ;
   wdays->bottom = wdays->top + infoPtr->height_increment;
-  
+
   days->top    = weeknumrect->top = wdays->bottom ;
   days->bottom = weeknumrect->bottom = days->top     + 6 * infoPtr->height_increment;
-  
+
   todayrect->left   = rcClient->left;
   todayrect->right  = rcClient->right;
@@ -1832 +1833 @@
   todayrect->bottom = days->bottom + infoPtr->height_increment;
 
-  /* uncomment for excessive debugging 
+  /* uncomment for excessive debugging
   TRACE("dx=%d dy=%d rcC[%d %d %d %d] t[%d %d %d %d] wd[%d %d %d %d] w[%d %d %d %d] t[%d %d %d %d]\n",
-        infoPtr->width_increment,infoPtr->height_increment,
-         rcClient->left, rcClient->right, rcClient->top, rcClient->bottom,
-            title->left,    title->right,    title->top,    title->bottom,
-            wdays->left,    wdays->right,    wdays->top,    wdays->bottom,
-             days->left,     days->right,     days->top,     days->bottom,
-        todayrect->left,todayrect->right,todayrect->top,todayrect->bottom);
+    infoPtr->width_increment,infoPtr->height_increment,
+     rcClient->left, rcClient->right, rcClient->top, rcClient->bottom,
+        title->left,    title->right,    title->top,    title->bottom,
+        wdays->left,    wdays->right,    wdays->top,    wdays->bottom,
+         days->left,     days->right,     days->top,     days->bottom,
+    todayrect->left,todayrect->right,todayrect->top,todayrect->bottom);
   */
-  
+
   /* restore the originally selected font */
-  SelectObject(hdc, currentFont);     
+  SelectObject(hdc, currentFont);
 
   ReleaseDC(hwnd, hdc);
@@ -1865 +1866 @@
 {
   MONTHCAL_INFO *infoPtr;
-  LOGFONTA      logFont;
+  LOGFONTA  logFont;
 
   /* allocate memory for info structure */
@@ -1900 +1901 @@
   infoPtr->maxSelCount  = 7;
   infoPtr->monthRange = 3;
-  infoPtr->monthdayState = COMCTL32_Alloc 
+  infoPtr->monthdayState = COMCTL32_Alloc
                          (infoPtr->monthRange * sizeof(MONTHDAYSTATE));
   infoPtr->titlebk     = GetSysColor(COLOR_ACTIVECAPTION);
@@ -1907 +1908 @@
   infoPtr->trailingtxt = GetSysColor(COLOR_GRAYTEXT);
   infoPtr->bk          = GetSysColor(COLOR_WINDOW);
-  infoPtr->txt         = GetSysColor(COLOR_WINDOWTEXT);
+  infoPtr->txt         = GetSysColor(COLOR_WINDOWTEXT);
 
   /* call MONTHCAL_UpdateSize to set all of the dimensions */
@@ -2062 +2063 @@
   wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
   wndClass.lpszClassName = MONTHCAL_CLASSA;
- 
+
   RegisterClassA(&wndClass);
 }

trunk/src/comctl32/pager.c

@@ +1 @@
+/* $Id: pager.c,v 1.9 2001-09-05 12:05:01 bird Exp $ */
 /*
  * Pager control
@@ -39 +40 @@
     INT    nPos;       /* scroll position */
     INT    nWidth;     /* from child wnd's response to PGN_CALCSIZE */
-    INT    nHeight;    /* from child wnd's response to PGN_CALCSIZE */ 
+    INT    nHeight;    /* from child wnd's response to PGN_CALCSIZE */
     BOOL   bForward;   /* forward WM_MOUSEMOVE msgs to the contained wnd */
     INT    TLbtnState; /* state of top or left btn */
@@ -57 +58 @@
 #define REPEAT_DELAY     50
 
-/* the horizontal arrows are: 
+/* the horizontal arrows are:
  *
  * 01234    01234
@@ -66 +67 @@
  * 5 **      **
  * 6  *      *
- * 7  
+ * 7
  *
  */
@@ -74 +75 @@
     INT x, y, w, h;
     HPEN hOldPen;
-    
+
     w = r.right - r.left + 1;
     h = r.bottom - r.top + 1;
@@ -107 +108 @@
 }
 
-/* the vertical arrows are: 
+/* the vertical arrows are:
  *
  * 01234567    01234567
- * 1******        **  
+ * 1******        **
  * 2 ****        ****
  * 3  **        ******
@@ -121 +122 @@
     INT x, y, w, h;
     HPEN hOldPen;
-    
+
     w = r.right - r.left + 1;
     h = r.bottom - r.top + 1;
@@ -165 +166 @@
 
     if ((rc.right - rc.left <= 0) || (rc.bottom - rc.top <= 0))
-        return;  
+        return;
 
     hBrush = CreateSolidBrush(clrBk);
@@ -172 +173 @@
     FillRect(hdc, &rc, hBrush);
 
-    if (btnState == PGF_HOT) 
+    if (btnState == PGF_HOT)
     {
        DrawEdge( hdc, &rc, BDR_RAISEDINNER, BF_RECT);
@@ -180 +181 @@
            PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
     }
-    else if (btnState == PGF_NORMAL) 
+    else if (btnState == PGF_NORMAL)
     {
        DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT);
@@ -188 +189 @@
            PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
     }
-    else if (btnState == PGF_DEPRESSED) 
+    else if (btnState == PGF_DEPRESSED)
     {
        DrawEdge( hdc, &rc, BDR_SUNKENOUTER, BF_RECT);
@@ -196 +197 @@
            PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
     }
-    else if (btnState == PGF_GRAYED) 
+    else if (btnState == PGF_GRAYED)
     {
        DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT);
@@ -233 +234 @@
 PAGER_GetButtonState (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd); 
+    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
     LRESULT btnState = PGF_INVISIBLE;
     INT btn = (INT)lParam;
@@ -250 +251 @@
 PAGER_GetPos(HWND hwnd)
 {
-    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd); 
+    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
     TRACE("[%04x] returns %d\n", hwnd, infoPtr->nPos);
     return (LRESULT)infoPtr->nPos;
@@ -258 +259 @@
 PAGER_GetButtonSize(HWND hwnd)
 {
-    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd); 
+    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
     TRACE("[%04x] returns %d\n", hwnd, infoPtr->nButtonSize);
     return (LRESULT)infoPtr->nButtonSize;
@@ -266 +267 @@
 PAGER_GetBorder(HWND hwnd)
 {
-    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd); 
+    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
     TRACE("[%04x] returns %d\n", hwnd, infoPtr->nBorder);
     return (LRESULT)infoPtr->nBorder;
@@ -274 +275 @@
 PAGER_GetBkColor(HWND hwnd)
 {
-    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd); 
+    PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
     TRACE("[%04x] returns %06lx\n", hwnd, infoPtr->clrBk);
     return (LRESULT)infoPtr->clrBk;
 }
 
-static void 
-PAGER_CalcSize (HWND hwnd, INT* size, BOOL getWidth) 
+static void
+PAGER_CalcSize (HWND hwnd, INT* size, BOOL getWidth)
 {
     NMPGCALCSIZE nmpgcs;
@@ -333 +334 @@
                 infoPtr->nHeight = wndSize;
 
-            TRACE("[%04x] SWP %dx%d at (%d,%d)\n", hwnd, 
+            TRACE("[%04x] SWP %dx%d at (%d,%d)\n", hwnd,
                          infoPtr->nWidth, infoPtr->nHeight,
                          0, -nPos);
@@ -379 +380 @@
 }
 
-static void 
+static void
 PAGER_GrayAndRestoreBtns(PAGER_INFO* infoPtr, INT scrollRange,
                          BOOL* needsResize, BOOL* needsRepaint)
@@ -416 +417 @@
 
 
-static void 
+static void
 PAGER_NormalizeBtns(PAGER_INFO* infoPtr, BOOL* needsRepaint)
 {
@@ -432 +433 @@
 }
 
-static void 
+static void
 PAGER_HideGrayBtns(PAGER_INFO* infoPtr, BOOL* needsResize)
 {
@@ -464 +465 @@
 
     if (resizeClient) /* initiate NCCalcSize to resize client wnd */
-        SetWindowPos(hwnd, 0,0,0,0,0, 
+        SetWindowPos(hwnd, 0,0,0,0,0,
                      SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
                      SWP_NOZORDER | SWP_NOACTIVATE);
 
     if (repaintBtns)
-        SendMessageA(hwnd, WM_NCPAINT, 0, 0); 
-}
-
-static LRESULT  
+        SendMessageA(hwnd, WM_NCPAINT, 0, 0);
+}
+
+static LRESULT
 PAGER_SetPos(HWND hwnd, INT newPos, BOOL fromBtnPress)
 {
@@ -518 +519 @@
 }
 
-static void 
+static void
 PAGER_SetFixedWidth(HWND hwnd, PAGER_INFO* infoPtr)
 {
@@ -544 +545 @@
 
     /* adjust non-scrollable dimension to fit the child */
-    SetWindowPos(hwnd, 0, 0,0, infoPtr->nWidth, h, 
+    SetWindowPos(hwnd, 0, 0,0, infoPtr->nWidth, h,
                  SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER);
 
 
     TRACE("[%04x] infoPtr->nWidth set to %d\n",
-               hwnd, infoPtr->nWidth);
-}
-
-static void 
+           hwnd, infoPtr->nWidth);
+}
+
+static void
 PAGER_SetFixedHeight(HWND hwnd, PAGER_INFO* infoPtr)
 {
@@ -578 +579 @@
 
     /* adjust non-scrollable dimension to fit the child */
-    SetWindowPos(hwnd, 0, 0,0, w, infoPtr->nHeight, 
+    SetWindowPos(hwnd, 0, 0,0, w, infoPtr->nHeight,
                  SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER);
 
     TRACE("[%04x] infoPtr->nHeight set to %d\n",
-               hwnd, infoPtr->nHeight);
+           hwnd, infoPtr->nHeight);
 }
 
@@ -601 +602 @@
             PAGER_SetPos(hwnd, 0, FALSE);
         }
-        else 
+        else
         {
             PAGER_UpdateBtns(hwnd, infoPtr, scrollRange, TRUE);
@@ -700 +701 @@
         nmpgScroll.hdr.code = PGN_SCROLL;
 
-        GetWindowRect(hwnd, &rcWnd);  
-        GetClientRect(hwnd, &nmpgScroll.rcParent);  
+        GetWindowRect(hwnd, &rcWnd);
+        GetClientRect(hwnd, &nmpgScroll.rcParent);
         nmpgScroll.iXpos = nmpgScroll.iYpos = 0;
         nmpgScroll.iDir = dir;
@@ -716 +717 @@
         }
         nmpgScroll.iScroll -= 2*infoPtr->nButtonSize;
-  
+
         SendMessageA (hwnd, WM_NOTIFY,
                     (WPARAM)nmpgScroll.hdr.idFrom, (LPARAM)&nmpgScroll);
-  
+
         TRACE("[%04x] PGN_SCROLL returns iScroll=%d\n", hwnd, nmpgScroll.iScroll);
 
@@ -769 +770 @@
         FIXME("[%04x] Drag and Drop style is not implemented yet.\n", hwnd);
     /*
-         * If neither horizontal nor vertical style specified, default to vertical.
-         * This is probably not necessary, since the style may be set later on as
-         * the control is initialized, but just in case it isn't, set it here.
-         */
+     * If neither horizontal nor vertical style specified, default to vertical.
+     * This is probably not necessary, since the style may be set later on as
+     * the control is initialized, but just in case it isn't, set it here.
+     */
     if (!(dwStyle & PGS_HORZ) && !(dwStyle & PGS_VERT))
     {
@@ -800 +801 @@
     /*
      * lParam points to a RECT struct.  On entry, the struct
-     * contains the proposed wnd rectangle for the window. 
+     * contains the proposed wnd rectangle for the window.
      * On exit, the struct should contain the screen
      * coordinates of the corresponding window's client area.
      */
-        
+
     if (PAGER_IsHorizontal(hwnd))
     {
         if (infoPtr->TLbtnState) /* != PGF_INVISIBLE */
             lpRect->left += infoPtr->nButtonSize;
-        if (infoPtr->BRbtnState) 
+        if (infoPtr->BRbtnState)
             lpRect->right -= infoPtr->nButtonSize;
     }
@@ -863 +864 @@
                      bHorizontal, TRUE, infoPtr->TLbtnState);
     PAGER_DrawButton(hdc, infoPtr->clrBk, rcBottomRight,
-                     bHorizontal, FALSE, infoPtr->BRbtnState); 
+                     bHorizontal, FALSE, infoPtr->BRbtnState);
 
     ReleaseDC( hwnd, hdc );
@@ -869 +870 @@
 }
 
-static INT 
+static INT
 PAGER_HitTest (HWND hwnd, LPPOINT pt)
 {
@@ -976 +977 @@
         if(!(trackinfo.dwFlags & TME_LEAVE)) {
             trackinfo.dwFlags = TME_LEAVE; /* notify upon leaving */
- 
+
            /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
            /* and can properly deactivate the hot button */
@@ -982 +983 @@
         }
 
-        SendMessageA(hwnd, WM_NCPAINT, 0, 0); 
+        SendMessageA(hwnd, WM_NCPAINT, 0, 0);
     }
 
@@ -1025 +1026 @@
 
     TRACE("[%04x]\n", hwnd);
-        
+
     hit = PAGER_HitTest(hwnd, &pt);
 
@@ -1033 +1034 @@
         repaintBtns = infoPtr->TLbtnState != PGF_DEPRESSED;
         infoPtr->TLbtnState = PGF_DEPRESSED;
-        SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0); 
+        SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0);
     }
     else if (hit == HTRIGHT || hit == HTBOTTOM)
@@ -1039 +1040 @@
         repaintBtns = infoPtr->BRbtnState != PGF_DEPRESSED;
         infoPtr->BRbtnState = PGF_DEPRESSED;
-        SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0); 
+        SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0);
     }
 
     if (repaintBtns)
-        SendMessageA(hwnd, WM_NCPAINT, 0, 0); 
+        SendMessageA(hwnd, WM_NCPAINT, 0, 0);
 
     switch(hit)
@@ -1130 +1131 @@
 
     if (!infoPtr && (uMsg != WM_CREATE))
-        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+    return DefWindowProcA (hwnd, uMsg, wParam, lParam);
 
     switch (uMsg)
@@ -1156 +1157 @@
         case PGM_RECALCSIZE:
             return PAGER_RecalcSize(hwnd);
-    
+
         case PGM_SETBKCOLOR:
             return PAGER_SetBkColor (hwnd, wParam, lParam);
@@ -1204 +1205 @@
             if (infoPtr->bForward && infoPtr->hwndChild)
                 PostMessageA(infoPtr->hwndChild, WM_MOUSEMOVE, wParam, lParam);
-            return TRUE;                        
+            return TRUE;
 
         case WM_MOUSELEAVE:
-            return PAGER_MouseLeave (hwnd, wParam, lParam);     
+            return PAGER_MouseLeave (hwnd, wParam, lParam);
 
         case WM_LBUTTONDOWN:
@@ -1219 +1220 @@
 /*
         case WM_PAINT:
-            return PAGER_Paint (hwnd, wParam); 
+            return PAGER_Paint (hwnd, wParam);
 */
         case WM_TIMER:
@@ -1233 +1234 @@
             {
                 PAGER_Scroll(hwnd, infoPtr->direction);
-                SetTimer(hwnd, TIMERID2, REPEAT_DELAY, 0);          
+                SetTimer(hwnd, TIMERID2, REPEAT_DELAY, 0);
             }
             break;
@@ -1266 +1267 @@
     wndClass.hbrBackground = 0;
     wndClass.lpszClassName = WC_PAGESCROLLERA;
- 
+
     RegisterClassA (&wndClass);
 }

trunk/src/comctl32/rebar.c

@@ +1 @@
+/* $Id: rebar.c,v 1.16 2001-09-05 12:05:01 bird Exp $ */
 /*
  *
@@ -21 +22 @@
  *   - vertical placement
  *   - ComboBox and ComboBoxEx placement
- *   - center image 
+ *   - center image
  *   - Layout code.
  *   - Display code.
@@ -30 +31 @@
  *  rev 2,3,4
  *   - Implement initial version of row grouping, row separators,
- *     text and background colors. Support additional messages. 
+ *     text and background colors. Support additional messages.
  *     Support RBBS_BREAK. Implement ERASEBKGND and improve painting.
  *  rev 5
  *   - implement support for dragging Gripper left or right in a row. Supports
- *     WM_LBUTTONDOWN, WM_LBUTTONUP, and WM_MOUSEMOVE. Also support 
+ *     WM_LBUTTONDOWN, WM_LBUTTONUP, and WM_MOUSEMOVE. Also support
  *     RBS_BANDBORDERS.
  *  rev 6
@@ -62 +63 @@
  * 12. Correct drawing of rebar borders and handling of RBS_BORDERS.
  * rev 7d
- * 13. Support WM_NOTIFYFORMAT (both incoming and outgoing) and do 
+ * 13. Support WM_NOTIFYFORMAT (both incoming and outgoing) and do
  *     WM_NOTIFY correctly based on results.
  * 14. Implement WM_SETREDRAW.
  * 15. Native WM_ERASEBKGND draws horz and vert separators between bands and
- *     rows, and fills in the background color for each band. The gripper, 
+ *     rows, and fills in the background color for each band. The gripper,
  *     image, and text for each band is drawn by the WM_PAINT process. Change
  *     this code to match.
@@ -95 +96 @@
  *  2. Following still not handled: RBBS_FIXEDBMP, RBBS_CHILDEDGE,
  *            RBBS_USECHEVRON
- *  3. Following are only partially handled: 
+ *  3. Following are only partially handled:
  *            RBS_AUTOSIZE, RBBS_VARIABLEHEIGHT
  *  5. Native uses (on each draw!!) SM_CYBORDER (or SM_CXBORDER for CCS_VERT)
- *     to set the size of the separator width (the value SEP_WIDTH_SIZE 
+ *     to set the size of the separator width (the value SEP_WIDTH_SIZE
  *     in here). Should be fixed!!
  *  6. The following messages are not implemented:
@@ -211 +212 @@
     BOOL     NtfUnicode;  /* TRUE if parent wants notify in W format */
     BOOL     DoRedraw;    /* TRUE to acutally draw bands */
-    UINT     fStatus;     /* Status flags (see below)  */ 
+    UINT     fStatus;     /* Status flags (see below)  */
     HCURSOR  hcurArrow;   /* handle to the arrow cursor */
     HCURSOR  hcurHorz;    /* handle to the EW cursor */
@@ -263 +264 @@
 
 /* This is the increment that is used over the band height */
-/* Determined by experiment.                               */ 
+/* Determined by experiment.                               */
 #define REBARSPACE      4
 
@@ -274 +275 @@
 #define rcBrb(b) ((infoPtr->dwStyle & CCS_VERT) ? b->rcBand.bottom : b->rcBand.right)
 #define rcBw(b)  ((infoPtr->dwStyle & CCS_VERT) ? (b->rcBand.bottom - b->rcBand.top) : \
-                  (b->rcBand.right - b->rcBand.left))
+          (b->rcBand.right - b->rcBand.left))
 #define ircBlt(b) ((infoPtr->dwStyle & CCS_VERT) ? b->rcBand.left : b->rcBand.top)
 #define ircBrb(b) ((infoPtr->dwStyle & CCS_VERT) ? b->rcBand.right : b->rcBand.bottom)
 #define ircBw(b)  ((infoPtr->dwStyle & CCS_VERT) ? (b->rcBand.right - b->rcBand.left) : \
-                  (b->rcBand.bottom - b->rcBand.top))
+          (b->rcBand.bottom - b->rcBand.top))
 
 /*  The following define determines if a given band is hidden      */
@@ -338 +339 @@
     *line = 0;
     while (band_stylename[i]) {
-        if (style & (1<<i)) {
-            if (*line != 0) strcat(line, " | ");
-            strcat(line, band_stylename[i]);
-        }
-        i++;
+    if (style & (1<<i)) {
+        if (*line != 0) strcat(line, " | ");
+        strcat(line, band_stylename[i]);
+    }
+    i++;
     }
     return line;
@@ -355 +356 @@
     *line = 0;
     while (band_maskname[i]) {
-        if (mask & (1<<i)) {
-            if (*line != 0) strcat(line, " | ");
-            strcat(line, band_maskname[i]);
-        }
-        i++;
+    if (mask & (1<<i)) {
+        if (*line != 0) strcat(line, " | ");
+        strcat(line, band_maskname[i]);
+    }
+    i++;
     }
     return line;
@@ -370 +371 @@
     if( !TRACE_ON(rebar) ) return;
     TRACE("band info: ID=%u, size=%u, child=%04x, clrF=0x%06lx, clrB=0x%06lx\n",
-          pB->wID, pB->cbSize, pB->hwndChild, pB->clrFore, pB->clrBack); 
+      pB->wID, pB->cbSize, pB->hwndChild, pB->clrFore, pB->clrBack);
     TRACE("band info: mask=0x%08x (%s)\n", pB->fMask, REBAR_FmtMask(pB->fMask));
     if (pB->fMask & RBBIM_STYLE)
-        TRACE("band info: style=0x%08x (%s)\n", pB->fStyle, REBAR_FmtStyle(pB->fStyle));
+    TRACE("band info: style=0x%08x (%s)\n", pB->fStyle, REBAR_FmtStyle(pB->fStyle));
     if (pB->fMask & (RBBIM_SIZE | RBBIM_IDEALSIZE | RBBIM_HEADERSIZE | RBBIM_LPARAM )) {
-        TRACE("band info:");
-        if (pB->fMask & RBBIM_SIZE)
-            DPRINTF(" cx=%u", pB->cx);
-        if (pB->fMask & RBBIM_IDEALSIZE)
-            DPRINTF(" xIdeal=%u", pB->cxIdeal);
-        if (pB->fMask & RBBIM_HEADERSIZE)
-            DPRINTF(" xHeader=%u", pB->cxHeader);
-        if (pB->fMask & RBBIM_LPARAM)
-            DPRINTF(" lParam=0x%08lx", pB->lParam);
-        DPRINTF("\n");
+    TRACE("band info:");
+    if (pB->fMask & RBBIM_SIZE)
+        DPRINTF(" cx=%u", pB->cx);
+    if (pB->fMask & RBBIM_IDEALSIZE)
+        DPRINTF(" xIdeal=%u", pB->cxIdeal);
+    if (pB->fMask & RBBIM_HEADERSIZE)
+        DPRINTF(" xHeader=%u", pB->cxHeader);
+    if (pB->fMask & RBBIM_LPARAM)
+        DPRINTF(" lParam=0x%08lx", pB->lParam);
+    DPRINTF("\n");
     }
     if (pB->fMask & RBBIM_CHILDSIZE)
-        TRACE("band info: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
-              pB->cxMinChild, 
-              pB->cyMinChild, pB->cyChild, pB->cyMaxChild, pB->cyIntegral);
+    TRACE("band info: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
+          pB->cxMinChild,
+          pB->cyMinChild, pB->cyChild, pB->cyMaxChild, pB->cyIntegral);
 }
 
@@ -400 +401 @@
     if(! TRACE_ON(rebar) ) return;
 
-    TRACE("hwnd=%04x: color=%08lx/%08lx, bands=%u, rows=%u, cSize=%ld,%ld\n", 
-          iP->hwndSelf, iP->clrText, iP->clrBk, iP->uNumBands, iP->uNumRows,
-          iP->calcSize.cx, iP->calcSize.cy);
+    TRACE("hwnd=%04x: color=%08lx/%08lx, bands=%u, rows=%u, cSize=%ld,%ld\n",
+      iP->hwndSelf, iP->clrText, iP->clrBk, iP->uNumBands, iP->uNumRows,
+      iP->calcSize.cx, iP->calcSize.cy);
     TRACE("hwnd=%04x: flags=%08x, dragStart=%d,%d, dragNow=%d,%d, ihitBand=%d\n",
-          iP->hwndSelf, iP->fStatus, iP->dragStart.x, iP->dragStart.y,
-          iP->dragNow.x, iP->dragNow.y,
-          iP->ihitBand);
+      iP->hwndSelf, iP->fStatus, iP->dragStart.x, iP->dragStart.y,
+      iP->dragNow.x, iP->dragNow.y,
+      iP->ihitBand);
     TRACE("hwnd=%04x: style=%08lx, I'm Unicode=%s, notify in Unicode=%s, redraw=%s\n",
-          iP->hwndSelf, iP->dwStyle, (iP->bUnicode)?"TRUE":"FALSE",
-          (iP->NtfUnicode)?"TRUE":"FALSE", (iP->DoRedraw)?"TRUE":"FALSE");
+      iP->hwndSelf, iP->dwStyle, (iP->bUnicode)?"TRUE":"FALSE",
+      (iP->NtfUnicode)?"TRUE":"FALSE", (iP->DoRedraw)?"TRUE":"FALSE");
     for (i = 0; i < iP->uNumBands; i++) {
-        pB = &iP->bands[i];
-        TRACE("band # %u: ID=%u, child=%04x, row=%u, clrF=0x%06lx, clrB=0x%06lx\n",
-              i, pB->wID, pB->hwndChild, pB->iRow, pB->clrFore, pB->clrBack);
-        TRACE("band # %u: mask=0x%08x (%s)\n", i, pB->fMask, REBAR_FmtMask(pB->fMask));
-        if (pB->fMask & RBBIM_STYLE)
-            TRACE("band # %u: style=0x%08x (%s)\n", 
-                  i, pB->fStyle, REBAR_FmtStyle(pB->fStyle));
-        TRACE("band # %u: uMinH=%u xHeader=%u", 
-              i, pB->uMinHeight, pB->cxHeader);
-        if (pB->fMask & (RBBIM_SIZE | RBBIM_IDEALSIZE | RBBIM_LPARAM )) {
-            if (pB->fMask & RBBIM_SIZE)
-                DPRINTF(" cx=%u", pB->cx);
-            if (pB->fMask & RBBIM_IDEALSIZE)
-                DPRINTF(" xIdeal=%u", pB->cxIdeal);
-            if (pB->fMask & RBBIM_LPARAM)
-                DPRINTF(" lParam=0x%08lx", pB->lParam);
-        }
-        DPRINTF("\n");
-        if (RBBIM_CHILDSIZE)
-            TRACE("band # %u: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
-                  i, pB->cxMinChild, pB->cyMinChild, pB->cyChild, pB->cyMaxChild, pB->cyIntegral);
-        TRACE("band # %u: lcx=%u, ccx=%u, hcx=%u, lcy=%u, ccy=%u, hcy=%u, offChild=%ld,%ld\n",
-              i, pB->lcx, pB->ccx, pB->hcx, pB->lcy, pB->ccy, pB->hcy, pB->offChild.cx, pB->offChild.cy);
-        TRACE("band # %u: fStatus=%08x, fDraw=%08x, Band=(%d,%d)-(%d,%d), Grip=(%d,%d)-(%d,%d)\n",
-              i, pB->fStatus, pB->fDraw,
-              pB->rcBand.left, pB->rcBand.top, pB->rcBand.right, pB->rcBand.bottom,
-              pB->rcGripper.left, pB->rcGripper.top, pB->rcGripper.right, pB->rcGripper.bottom);
-        TRACE("band # %u: Img=(%d,%d)-(%d,%d), Txt=(%d,%d)-(%d,%d), Child=(%d,%d)-(%d,%d)\n",
-              i,
-              pB->rcCapImage.left, pB->rcCapImage.top, pB->rcCapImage.right, pB->rcCapImage.bottom,
-              pB->rcCapText.left, pB->rcCapText.top, pB->rcCapText.right, pB->rcCapText.bottom,
-              pB->rcChild.left, pB->rcChild.top, pB->rcChild.right, pB->rcChild.bottom);
+    pB = &iP->bands[i];
+    TRACE("band # %u: ID=%u, child=%04x, row=%u, clrF=0x%06lx, clrB=0x%06lx\n",
+          i, pB->wID, pB->hwndChild, pB->iRow, pB->clrFore, pB->clrBack);
+    TRACE("band # %u: mask=0x%08x (%s)\n", i, pB->fMask, REBAR_FmtMask(pB->fMask));
+    if (pB->fMask & RBBIM_STYLE)
+        TRACE("band # %u: style=0x%08x (%s)\n",
+          i, pB->fStyle, REBAR_FmtStyle(pB->fStyle));
+    TRACE("band # %u: uMinH=%u xHeader=%u",
+          i, pB->uMinHeight, pB->cxHeader);
+    if (pB->fMask & (RBBIM_SIZE | RBBIM_IDEALSIZE | RBBIM_LPARAM )) {
+        if (pB->fMask & RBBIM_SIZE)
+        DPRINTF(" cx=%u", pB->cx);
+        if (pB->fMask & RBBIM_IDEALSIZE)
+        DPRINTF(" xIdeal=%u", pB->cxIdeal);
+        if (pB->fMask & RBBIM_LPARAM)
+        DPRINTF(" lParam=0x%08lx", pB->lParam);
+    }
+    DPRINTF("\n");
+    if (RBBIM_CHILDSIZE)
+        TRACE("band # %u: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
+          i, pB->cxMinChild, pB->cyMinChild, pB->cyChild, pB->cyMaxChild, pB->cyIntegral);
+    TRACE("band # %u: lcx=%u, ccx=%u, hcx=%u, lcy=%u, ccy=%u, hcy=%u, offChild=%ld,%ld\n",
+          i, pB->lcx, pB->ccx, pB->hcx, pB->lcy, pB->ccy, pB->hcy, pB->offChild.cx, pB->offChild.cy);
+    TRACE("band # %u: fStatus=%08x, fDraw=%08x, Band=(%d,%d)-(%d,%d), Grip=(%d,%d)-(%d,%d)\n",
+          i, pB->fStatus, pB->fDraw,
+          pB->rcBand.left, pB->rcBand.top, pB->rcBand.right, pB->rcBand.bottom,
+          pB->rcGripper.left, pB->rcGripper.top, pB->rcGripper.right, pB->rcGripper.bottom);
+    TRACE("band # %u: Img=(%d,%d)-(%d,%d), Txt=(%d,%d)-(%d,%d), Child=(%d,%d)-(%d,%d)\n",
+          i,
+          pB->rcCapImage.left, pB->rcCapImage.top, pB->rcCapImage.right, pB->rcCapImage.bottom,
+          pB->rcCapText.left, pB->rcCapText.top, pB->rcCapText.right, pB->rcCapText.bottom,
+          pB->rcChild.left, pB->rcChild.top, pB->rcChild.right, pB->rcChild.bottom);
     }
 
@@ -456 +457 @@
     if (!parent) {
         parent = GetParent (infoPtr->hwndSelf);
-        owner = GetWindow (infoPtr->hwndSelf, GW_OWNER);
-        if (owner) parent = owner;
+    owner = GetWindow (infoPtr->hwndSelf, GW_OWNER);
+    if (owner) parent = owner;
     }
     return parent;
@@ -474 +475 @@
 
     TRACE("window %04x, code=%08x, %s\n", parent, code,
-          (infoPtr->NtfUnicode) ? "via Unicode" : "via ANSI");
+      (infoPtr->NtfUnicode) ? "via Unicode" : "via ANSI");
 
     if (infoPtr->NtfUnicode)
-        return SendMessageW (parent, WM_NOTIFY, (WPARAM) nmhdr->idFrom,
-                             (LPARAM)nmhdr);
+    return SendMessageW (parent, WM_NOTIFY, (WPARAM) nmhdr->idFrom,
+                 (LPARAM)nmhdr);
     else
-        return SendMessageA (parent, WM_NOTIFY, (WPARAM) nmhdr->idFrom,
-                             (LPARAM)nmhdr);
+    return SendMessageA (parent, WM_NOTIFY, (WPARAM) nmhdr->idFrom,
+                 (LPARAM)nmhdr);
 }
 
@@ -492 +493 @@
     notify_rebar.dwMask = 0;
     if (uBand!=-1) {
-        lpBand = &infoPtr->bands[uBand];
-        if (lpBand->fMask & RBBIM_ID) {
-            notify_rebar.dwMask |= RBNM_ID;
-            notify_rebar.wID = lpBand->wID;
-        }
-        if (lpBand->fMask & RBBIM_LPARAM) {
-            notify_rebar.dwMask |= RBNM_LPARAM;
-            notify_rebar.lParam = lpBand->lParam;
-        }
-        if (lpBand->fMask & RBBIM_STYLE) {
-            notify_rebar.dwMask |= RBNM_STYLE;
-            notify_rebar.fStyle = lpBand->fStyle;
-        }
+    lpBand = &infoPtr->bands[uBand];
+    if (lpBand->fMask & RBBIM_ID) {
+        notify_rebar.dwMask |= RBNM_ID;
+        notify_rebar.wID = lpBand->wID;
+    }
+    if (lpBand->fMask & RBBIM_LPARAM) {
+        notify_rebar.dwMask |= RBNM_LPARAM;
+        notify_rebar.lParam = lpBand->lParam;
+    }
+    if (lpBand->fMask & RBBIM_STYLE) {
+        notify_rebar.dwMask |= RBNM_STYLE;
+        notify_rebar.fStyle = lpBand->fStyle;
+    }
     }
     notify_rebar.uBand = uBand;
@@ -521 +522 @@
     /* draw caption image */
     if (lpBand->fDraw & DRAW_IMAGE) {
-        POINT pt;
-
-        /* center image */
-        pt.y = (lpBand->rcCapImage.bottom + lpBand->rcCapImage.top - infoPtr->imageSize.cy)/2;
-        pt.x = (lpBand->rcCapImage.right + lpBand->rcCapImage.left - infoPtr->imageSize.cx)/2;
-
-        ImageList_Draw (infoPtr->himl, lpBand->iImage, hdc,
-                        pt.x, pt.y,
-                        ILD_TRANSPARENT);
+    POINT pt;
+
+    /* center image */
+    pt.y = (lpBand->rcCapImage.bottom + lpBand->rcCapImage.top - infoPtr->imageSize.cy)/2;
+    pt.x = (lpBand->rcCapImage.right + lpBand->rcCapImage.left - infoPtr->imageSize.cx)/2;
+
+    ImageList_Draw (infoPtr->himl, lpBand->iImage, hdc,
+            pt.x, pt.y,
+            ILD_TRANSPARENT);
     }
 
     /* draw caption text */
     if (lpBand->fDraw & DRAW_TEXT) {
-        HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
-        INT oldBkMode = SetBkMode (hdc, TRANSPARENT);
-        COLORREF oldcolor = CLR_NONE;
-        oldcolor = SetTextColor (hdc, (lpBand->clrFore != CLR_NONE) ?
-                                 lpBand->clrFore : infoPtr->clrBtnText);
-        DrawTextW (hdc, lpBand->lpText, -1, &lpBand->rcCapText,
-                   DT_CENTER | DT_VCENTER | DT_SINGLELINE);
-        if (oldBkMode != TRANSPARENT)
-            SetBkMode (hdc, oldBkMode);
-        SetTextColor (hdc, oldcolor);
-        SelectObject (hdc, hOldFont);
+    HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
+    INT oldBkMode = SetBkMode (hdc, TRANSPARENT);
+    COLORREF oldcolor = CLR_NONE;
+    oldcolor = SetTextColor (hdc, (lpBand->clrFore != CLR_NONE) ?
+                 lpBand->clrFore : infoPtr->clrBtnText);
+    DrawTextW (hdc, lpBand->lpText, -1, &lpBand->rcCapText,
+           DT_CENTER | DT_VCENTER | DT_SINGLELINE);
+    if (oldBkMode != TRANSPARENT)
+        SetBkMode (hdc, oldBkMode);
+    SetTextColor (hdc, oldcolor);
+    SelectObject (hdc, hOldFont);
     }
 }
@@ -559 +560 @@
     oldrow = infoPtr->bands[0].iRow;
     for (i = 0; i < infoPtr->uNumBands; i++) {
-        lpBand = &infoPtr->bands[i];
-
-        if (HIDDENBAND(lpBand)) continue; 
-
-        /* now draw the band */
-        REBAR_DrawBand (hdc, infoPtr, lpBand);
+    lpBand = &infoPtr->bands[i];
+
+    if (HIDDENBAND(lpBand)) continue;
+
+    /* now draw the band */
+    REBAR_DrawBand (hdc, infoPtr, lpBand);
 
     }
@@ -572 +573 @@
 static void
 REBAR_FixVert (REBAR_INFO *infoPtr, UINT rowstart, UINT rowend,
-                   INT mcy)
-     /* Function:                                                    */ 
+           INT mcy)
+     /* Function:                                                    */
      /*   Cycle through bands in row and fix height of each band.    */
      /*   Also determine whether each band has changed.              */
@@ -585 +586 @@
     for (i = (INT)rowstart; i<=(INT)rowend; i++) {
         lpBand = &infoPtr->bands[i];
-        if (HIDDENBAND(lpBand)) continue;
-
-        /* adjust height of bands in row to "mcy" value */
-        if (infoPtr->dwStyle & CCS_VERT) {
-            if (lpBand->rcBand.right != lpBand->rcBand.left + mcy)
-                lpBand->rcBand.right = lpBand->rcBand.left + mcy;
-        }
-        else {
-            if (lpBand->rcBand.bottom != lpBand->rcBand.top + mcy)
-                lpBand->rcBand.bottom = lpBand->rcBand.top + mcy;
-
-        }
-
-        /* mark whether we need to invalidate this band and trace */
-        if ((lpBand->rcoldBand.left !=lpBand->rcBand.left) ||
-            (lpBand->rcoldBand.top !=lpBand->rcBand.top) ||
-            (lpBand->rcoldBand.right !=lpBand->rcBand.right) ||
-            (lpBand->rcoldBand.bottom !=lpBand->rcBand.bottom)) {
-            lpBand->fDraw |= NTF_INVALIDATE;
-            TRACE("band %d row=%d: changed to (%d,%d)-(%d,%d) from (%d,%d)-(%d,%d)\n",
-                  i, lpBand->iRow,
-                  lpBand->rcBand.left, lpBand->rcBand.top,
-                  lpBand->rcBand.right, lpBand->rcBand.bottom,
-                  lpBand->rcoldBand.left, lpBand->rcoldBand.top,
-                  lpBand->rcoldBand.right, lpBand->rcoldBand.bottom);
-        }
-        else
-            TRACE("band %d row=%d: unchanged (%d,%d)-(%d,%d)\n",
-                  i, lpBand->iRow,
-                  lpBand->rcBand.left, lpBand->rcBand.top,
-                  lpBand->rcBand.right, lpBand->rcBand.bottom);
+    if (HIDDENBAND(lpBand)) continue;
+
+    /* adjust height of bands in row to "mcy" value */
+    if (infoPtr->dwStyle & CCS_VERT) {
+        if (lpBand->rcBand.right != lpBand->rcBand.left + mcy)
+            lpBand->rcBand.right = lpBand->rcBand.left + mcy;
+    }
+    else {
+        if (lpBand->rcBand.bottom != lpBand->rcBand.top + mcy)
+            lpBand->rcBand.bottom = lpBand->rcBand.top + mcy;
+
+    }
+
+    /* mark whether we need to invalidate this band and trace */
+    if ((lpBand->rcoldBand.left !=lpBand->rcBand.left) ||
+        (lpBand->rcoldBand.top !=lpBand->rcBand.top) ||
+        (lpBand->rcoldBand.right !=lpBand->rcBand.right) ||
+        (lpBand->rcoldBand.bottom !=lpBand->rcBand.bottom)) {
+        lpBand->fDraw |= NTF_INVALIDATE;
+        TRACE("band %d row=%d: changed to (%d,%d)-(%d,%d) from (%d,%d)-(%d,%d)\n",
+          i, lpBand->iRow,
+          lpBand->rcBand.left, lpBand->rcBand.top,
+          lpBand->rcBand.right, lpBand->rcBand.bottom,
+          lpBand->rcoldBand.left, lpBand->rcoldBand.top,
+          lpBand->rcoldBand.right, lpBand->rcoldBand.bottom);
+    }
+    else
+        TRACE("band %d row=%d: unchanged (%d,%d)-(%d,%d)\n",
+          i, lpBand->iRow,
+          lpBand->rcBand.left, lpBand->rcBand.top,
+          lpBand->rcBand.right, lpBand->rcBand.bottom);
     }
 }
@@ -622 +623 @@
 static void
 REBAR_AdjustBands (REBAR_INFO *infoPtr, UINT rowstart, UINT rowend,
-                   INT maxx, INT mcy)
+           INT maxx, INT mcy)
      /* Function: This routine distributes the extra space in a row. */
      /*  See algorithm below.                                        */
@@ -634 +635 @@
 
     TRACE("start=%u, end=%u, max x=%d, max y=%d\n",
-          rowstart, rowend, maxx, mcy);
+      rowstart, rowend, maxx, mcy);
 
     /* *******************  Phase 1  ************************ */
@@ -642 +643 @@
     /*         or band's ->ccx reached.                       */
     /*  If any band modified, add any space left to last band */
-    /*  adjusted.                                             */ 
+    /*  adjusted.                                             */
     /*                                                        */
     /* ****************************************************** */
@@ -650 +651 @@
     last_adjusted = 0;
     for (i=(INT)rowstart; i<=(INT)rowend; i++) {
-        lpBand = &infoPtr->bands[i];
-        if (HIDDENBAND(lpBand)) continue;
-        xsep = (x == 0) ? 0 : SEP_WIDTH;
-        curwidth = rcBw(lpBand);
-
-        /* set new left/top point */
-        if (infoPtr->dwStyle & CCS_VERT)
-            lpBand->rcBand.top = x + xsep;
-        else
-            lpBand->rcBand.left = x + xsep;
-
-        /* compute new width */
-        if (lpBand->hwndChild && extra) {
-            /* set to the "current" band size less the header */
-            fudge = lpBand->ccx;
-            last_adjusted = i;
-            if ((lpBand->fMask & RBBIM_SIZE) && (lpBand->cx > 0) &&
-                (fudge > curwidth)) {
-                TRACE("adjusting band %d by %d, fudge=%d, curwidth=%d, extra=%d\n",
-                      i, fudge-curwidth, fudge, curwidth, extra);
-                if ((fudge - curwidth) > extra)
-                    fudge = curwidth + extra;
-                extra -= (fudge - curwidth);
-                curwidth = fudge;
-            }
-            else {
-                TRACE("adjusting band %d by %d, fudge=%d, curwidth=%d\n",
-                      i, extra, fudge, curwidth);
-                curwidth += extra;
-                extra = 0;
-            }
-        }
-
-        /* set new right/bottom point */
-        if (infoPtr->dwStyle & CCS_VERT)
-            lpBand->rcBand.bottom = lpBand->rcBand.top + curwidth;
-        else
-            lpBand->rcBand.right = lpBand->rcBand.left + curwidth;
-        TRACE("Phase 1 band %d, (%d,%d)-(%d,%d), orig x=%d, xsep=%d\n",
-              i, lpBand->rcBand.left, lpBand->rcBand.top,
-              lpBand->rcBand.right, lpBand->rcBand.bottom, x, xsep);
-        x = rcBrb(lpBand);
+    lpBand = &infoPtr->bands[i];
+    if (HIDDENBAND(lpBand)) continue;
+    xsep = (x == 0) ? 0 : SEP_WIDTH;
+    curwidth = rcBw(lpBand);
+
+    /* set new left/top point */
+    if (infoPtr->dwStyle & CCS_VERT)
+        lpBand->rcBand.top = x + xsep;
+    else
+        lpBand->rcBand.left = x + xsep;
+
+    /* compute new width */
+    if (lpBand->hwndChild && extra) {
+        /* set to the "current" band size less the header */
+        fudge = lpBand->ccx;
+        last_adjusted = i;
+        if ((lpBand->fMask & RBBIM_SIZE) && (lpBand->cx > 0) &&
+        (fudge > curwidth)) {
+        TRACE("adjusting band %d by %d, fudge=%d, curwidth=%d, extra=%d\n",
+              i, fudge-curwidth, fudge, curwidth, extra);
+        if ((fudge - curwidth) > extra)
+            fudge = curwidth + extra;
+        extra -= (fudge - curwidth);
+        curwidth = fudge;
+        }
+        else {
+        TRACE("adjusting band %d by %d, fudge=%d, curwidth=%d\n",
+              i, extra, fudge, curwidth);
+        curwidth += extra;
+        extra = 0;
+        }
+    }
+
+    /* set new right/bottom point */
+    if (infoPtr->dwStyle & CCS_VERT)
+        lpBand->rcBand.bottom = lpBand->rcBand.top + curwidth;
+    else
+        lpBand->rcBand.right = lpBand->rcBand.left + curwidth;
+    TRACE("Phase 1 band %d, (%d,%d)-(%d,%d), orig x=%d, xsep=%d\n",
+          i, lpBand->rcBand.left, lpBand->rcBand.top,
+          lpBand->rcBand.right, lpBand->rcBand.bottom, x, xsep);
+    x = rcBrb(lpBand);
     }
     if ((x >= maxx) || last_adjusted) {
-        if (x > maxx) {
-            ERR("Phase 1 failed, x=%d, maxx=%d, start=%u, end=%u\n", 
-                x, maxx,  rowstart, rowend);
-        }
-        /* done, so spread extra space */
-        if (x < maxx) {
-            fudge = maxx - x;
-            TRACE("Need to spread %d on last adjusted band %d\n",
-                fudge, last_adjusted);
-            for (i=(INT)last_adjusted; i<=(INT)rowend; i++) {
-                lpBand = &infoPtr->bands[i];
-                if (HIDDENBAND(lpBand)) continue;
-
-                /* set right/bottom point */
-                if (i != last_adjusted) {
-                    if (infoPtr->dwStyle & CCS_VERT)
-                        lpBand->rcBand.top += fudge;
-                    else
-                        lpBand->rcBand.left += fudge;
-                }
-
-                /* set left/bottom point */
-                if (infoPtr->dwStyle & CCS_VERT)
-                    lpBand->rcBand.bottom += fudge;
-                else
-                    lpBand->rcBand.right += fudge;
-            }
-        }
-        TRACE("Phase 1 succeeded, used x=%d\n", x);
-        REBAR_FixVert (infoPtr, rowstart, rowend, mcy);
-        return;
+    if (x > maxx) {
+        ERR("Phase 1 failed, x=%d, maxx=%d, start=%u, end=%u\n",
+        x, maxx,  rowstart, rowend);
+    }
+    /* done, so spread extra space */
+    if (x < maxx) {
+        fudge = maxx - x;
+        TRACE("Need to spread %d on last adjusted band %d\n",
+        fudge, last_adjusted);
+        for (i=(INT)last_adjusted; i<=(INT)rowend; i++) {
+        lpBand = &infoPtr->bands[i];
+        if (HIDDENBAND(lpBand)) continue;
+
+        /* set right/bottom point */
+        if (i != last_adjusted) {
+            if (infoPtr->dwStyle & CCS_VERT)
+            lpBand->rcBand.top += fudge;
+            else
+            lpBand->rcBand.left += fudge;
+        }
+
+        /* set left/bottom point */
+        if (infoPtr->dwStyle & CCS_VERT)
+            lpBand->rcBand.bottom += fudge;
+        else
+            lpBand->rcBand.right += fudge;
+        }
+    }
+    TRACE("Phase 1 succeeded, used x=%d\n", x);
+    REBAR_FixVert (infoPtr, rowstart, rowend, mcy);
+    return;
     }
 
@@ -736 +737 @@
     x = 0;
     for (i=(INT)rowstart; i<=(INT)rowend; i++) {
-        lpBand = &infoPtr->bands[i];
-        if (HIDDENBAND(lpBand)) continue;
-        xsep = (x == 0) ? 0 : SEP_WIDTH;
-        curwidth = rcBw(lpBand);
-
-        /* set new left/top point */
-        if (infoPtr->dwStyle & CCS_VERT)
-            lpBand->rcBand.top = x + xsep;
-        else
-            lpBand->rcBand.left = x + xsep;
-
-        /* compute new width */
-        if (extra) {
-            curwidth += extra;
-            extra = 0;
-        }
-
-        /* set new right/bottom point */
-        if (infoPtr->dwStyle & CCS_VERT)
-            lpBand->rcBand.bottom = lpBand->rcBand.top + curwidth;
-        else
-            lpBand->rcBand.right = lpBand->rcBand.left + curwidth;
-        TRACE("Phase 2 band %d, (%d,%d)-(%d,%d), orig x=%d, xsep=%d\n",
-              i, lpBand->rcBand.left, lpBand->rcBand.top,
-              lpBand->rcBand.right, lpBand->rcBand.bottom, x, xsep);
-        x = rcBrb(lpBand);
+    lpBand = &infoPtr->bands[i];
+    if (HIDDENBAND(lpBand)) continue;
+    xsep = (x == 0) ? 0 : SEP_WIDTH;
+    curwidth = rcBw(lpBand);
+
+    /* set new left/top point */
+    if (infoPtr->dwStyle & CCS_VERT)
+        lpBand->rcBand.top = x + xsep;
+    else
+        lpBand->rcBand.left = x + xsep;
+
+    /* compute new width */
+    if (extra) {
+        curwidth += extra;
+        extra = 0;
+    }
+
+    /* set new right/bottom point */
+    if (infoPtr->dwStyle & CCS_VERT)
+        lpBand->rcBand.bottom = lpBand->rcBand.top + curwidth;
+    else
+        lpBand->rcBand.right = lpBand->rcBand.left + curwidth;
+    TRACE("Phase 2 band %d, (%d,%d)-(%d,%d), orig x=%d, xsep=%d\n",
+          i, lpBand->rcBand.left, lpBand->rcBand.top,
+          lpBand->rcBand.right, lpBand->rcBand.bottom, x, xsep);
+    x = rcBrb(lpBand);
     }
     if (x >= maxx) {
-        if (x > maxx) {
-            ERR("Phase 2 failed, x=%d, maxx=%d, start=%u, end=%u\n", 
-                x, maxx,  rowstart, rowend);
-        }
-        /* done, so spread extra space */
-        TRACE("Phase 2 succeeded, used x=%d\n", x);
-        REBAR_FixVert (infoPtr, rowstart, rowend, mcy);
-        return;
+    if (x > maxx) {
+        ERR("Phase 2 failed, x=%d, maxx=%d, start=%u, end=%u\n",
+        x, maxx,  rowstart, rowend);
+    }
+    /* done, so spread extra space */
+    TRACE("Phase 2 succeeded, used x=%d\n", x);
+    REBAR_FixVert (infoPtr, rowstart, rowend, mcy);
+    return;
     }
 
@@ -781 +782 @@
     lpBand = &infoPtr->bands[rowstart];
     ERR("Serious problem adjusting row %d, start band %d, end band %d\n",
-        lpBand->iRow, rowstart, rowend);
+    lpBand->iRow, rowstart, rowend);
     REBAR_DumpBand (infoPtr);
     return;
@@ -805 +806 @@
       if (HIDDENBAND(lpBand)) {
           SetRect (&lpBand->rcChild,
-                   lpBand->rcBand.right, lpBand->rcBand.top,
-                   lpBand->rcBand.right, lpBand->rcBand.bottom);
-          continue;
+           lpBand->rcBand.right, lpBand->rcBand.top,
+           lpBand->rcBand.right, lpBand->rcBand.bottom);
+      continue;
       }
 
@@ -814 +815 @@
       /* set initial gripper rectangle */
       SetRect (&lpBand->rcGripper, lpBand->rcBand.left, lpBand->rcBand.top,
-               lpBand->rcBand.left, lpBand->rcBand.bottom);
+           lpBand->rcBand.left, lpBand->rcBand.bottom);
 
       /* calculate gripper rectangle */
       if ( lpBand->fStatus & HAS_GRIPPER) {
-          lpBand->fDraw |= DRAW_GRIPPER;
-          lpBand->rcGripper.left   += REBAR_PRE_GRIPPER;
-          lpBand->rcGripper.right  = lpBand->rcGripper.left + GRIPPER_WIDTH;
-          lpBand->rcGripper.top    += 2;
-          lpBand->rcGripper.bottom -= 2;
-
-          SetRect (&lpBand->rcCapImage,
-                   lpBand->rcGripper.right+REBAR_ALWAYS_SPACE, lpBand->rcBand.top,
-                   lpBand->rcGripper.right+REBAR_ALWAYS_SPACE, lpBand->rcBand.bottom);
+      lpBand->fDraw |= DRAW_GRIPPER;
+      lpBand->rcGripper.left   += REBAR_PRE_GRIPPER;
+      lpBand->rcGripper.right  = lpBand->rcGripper.left + GRIPPER_WIDTH;
+      lpBand->rcGripper.top    += 2;
+      lpBand->rcGripper.bottom -= 2;
+
+      SetRect (&lpBand->rcCapImage,
+           lpBand->rcGripper.right+REBAR_ALWAYS_SPACE, lpBand->rcBand.top,
+           lpBand->rcGripper.right+REBAR_ALWAYS_SPACE, lpBand->rcBand.bottom);
       }
       else {  /* no gripper will be drawn */
-          xoff = 0;
-          if (lpBand->fStatus & (HAS_IMAGE | HAS_TEXT))
-              /* if no gripper but either image or text, then leave space */
-              xoff = REBAR_ALWAYS_SPACE;
-          SetRect (&lpBand->rcCapImage, 
-                   lpBand->rcBand.left+xoff, lpBand->rcBand.top,
-                   lpBand->rcBand.left+xoff, lpBand->rcBand.bottom);
+      xoff = 0;
+      if (lpBand->fStatus & (HAS_IMAGE | HAS_TEXT))
+          /* if no gripper but either image or text, then leave space */
+          xoff = REBAR_ALWAYS_SPACE;
+      SetRect (&lpBand->rcCapImage,
+           lpBand->rcBand.left+xoff, lpBand->rcBand.top,
+           lpBand->rcBand.left+xoff, lpBand->rcBand.bottom);
       }
 
       /* image is visible */
       if (lpBand->fStatus & HAS_IMAGE) {
-          lpBand->fDraw |= DRAW_IMAGE;
-          lpBand->rcCapImage.right  += infoPtr->imageSize.cx;
-          lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy;
-
-          /* set initial caption text rectangle */
-          SetRect (&lpBand->rcCapText,
-                   lpBand->rcCapImage.right+REBAR_POST_IMAGE, lpBand->rcBand.top+1,
-                   lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.bottom-1);
-          /* update band height 
-          if (lpBand->uMinHeight < infoPtr->imageSize.cy + 2) {
-              lpBand->uMinHeight = infoPtr->imageSize.cy + 2;
-              lpBand->rcBand.bottom = lpBand->rcBand.top + lpBand->uMinHeight;
-          }  */
+      lpBand->fDraw |= DRAW_IMAGE;
+      lpBand->rcCapImage.right  += infoPtr->imageSize.cx;
+      lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy;
+
+      /* set initial caption text rectangle */
+      SetRect (&lpBand->rcCapText,
+           lpBand->rcCapImage.right+REBAR_POST_IMAGE, lpBand->rcBand.top+1,
+           lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.bottom-1);
+      /* update band height
+      if (lpBand->uMinHeight < infoPtr->imageSize.cy + 2) {
+          lpBand->uMinHeight = infoPtr->imageSize.cy + 2;
+          lpBand->rcBand.bottom = lpBand->rcBand.top + lpBand->uMinHeight;
+      }  */
       }
       else {
-          /* set initial caption text rectangle */
-          SetRect (&lpBand->rcCapText, lpBand->rcCapImage.right, lpBand->rcBand.top+1,
-                   lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.bottom-1);
+      /* set initial caption text rectangle */
+      SetRect (&lpBand->rcCapText, lpBand->rcCapImage.right, lpBand->rcBand.top+1,
+           lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.bottom-1);
       }
 
       /* text is visible */
       if (lpBand->fStatus & HAS_TEXT) {
-          lpBand->fDraw |= DRAW_TEXT;
-          lpBand->rcCapText.right = max(lpBand->rcCapText.left, 
-                                        lpBand->rcCapText.right-REBAR_POST_TEXT);
+      lpBand->fDraw |= DRAW_TEXT;
+      lpBand->rcCapText.right = max(lpBand->rcCapText.left,
+                    lpBand->rcCapText.right-REBAR_POST_TEXT);
       }
 
       /* set initial child window rectangle if there is a child */
       if (lpBand->fMask & RBBIM_CHILD) {
-          xoff = lpBand->offChild.cx;
-          yoff = lpBand->offChild.cy;
-          SetRect (&lpBand->rcChild,
-                   lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.top+yoff,
-                   lpBand->rcBand.right-xoff, lpBand->rcBand.bottom-yoff);
+      xoff = lpBand->offChild.cx;
+      yoff = lpBand->offChild.cy;
+      SetRect (&lpBand->rcChild,
+           lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.top+yoff,
+           lpBand->rcBand.right-xoff, lpBand->rcBand.bottom-yoff);
       }
       else {
           SetRect (&lpBand->rcChild,
-                   lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.top,
-                   lpBand->rcBand.right, lpBand->rcBand.bottom);
+           lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.top,
+           lpBand->rcBand.right, lpBand->rcBand.bottom);
       }
 
       /* flag if notify required and invalidate rectangle */
-      if (notify && 
-          ((oldChild.right-oldChild.left != lpBand->rcChild.right-lpBand->rcChild.left) ||
-           (oldChild.bottom-oldChild.top != lpBand->rcChild.bottom-lpBand->rcChild.top))) {
-          TRACE("Child rectangle changed for band %u\n", i);
-          TRACE("    from (%d,%d)-(%d,%d)  to (%d,%d)-(%d,%d)\n",
-                oldChild.left, oldChild.top,
-                oldChild.right, oldChild.bottom,
-                lpBand->rcChild.left, lpBand->rcChild.top,
-                lpBand->rcChild.right, lpBand->rcChild.bottom);
+      if (notify &&
+      ((oldChild.right-oldChild.left != lpBand->rcChild.right-lpBand->rcChild.left) ||
+       (oldChild.bottom-oldChild.top != lpBand->rcChild.bottom-lpBand->rcChild.top))) {
+      TRACE("Child rectangle changed for band %u\n", i);
+      TRACE("    from (%d,%d)-(%d,%d)  to (%d,%d)-(%d,%d)\n",
+        oldChild.left, oldChild.top,
+            oldChild.right, oldChild.bottom,
+        lpBand->rcChild.left, lpBand->rcChild.top,
+            lpBand->rcChild.right, lpBand->rcChild.bottom);
       }
       if (lpBand->fDraw & NTF_INVALIDATE) {
-          TRACE("invalidating (%d,%d)-(%d,%d)\n",
-                lpBand->rcBand.left, 
-                lpBand->rcBand.top,
-                lpBand->rcBand.right + ((lpBand->fDraw & DRAW_RIGHTSEP) ? SEP_WIDTH_SIZE : 0), 
-                lpBand->rcBand.bottom + ((lpBand->fDraw & DRAW_BOTTOMSEP) ? SEP_WIDTH_SIZE : 0));
-          lpBand->fDraw &= ~NTF_INVALIDATE;
-          work = lpBand->rcBand;
-          if (lpBand->fDraw & DRAW_RIGHTSEP) work.right += SEP_WIDTH_SIZE;
-          if (lpBand->fDraw & DRAW_BOTTOMSEP) work.bottom += SEP_WIDTH_SIZE;
-          InvalidateRect(infoPtr->hwndSelf, &work, TRUE);
+      TRACE("invalidating (%d,%d)-(%d,%d)\n",
+        lpBand->rcBand.left,
+        lpBand->rcBand.top,
+        lpBand->rcBand.right + ((lpBand->fDraw & DRAW_RIGHTSEP) ? SEP_WIDTH_SIZE : 0),
+        lpBand->rcBand.bottom + ((lpBand->fDraw & DRAW_BOTTOMSEP) ? SEP_WIDTH_SIZE : 0));
+      lpBand->fDraw &= ~NTF_INVALIDATE;
+      work = lpBand->rcBand;
+      if (lpBand->fDraw & DRAW_RIGHTSEP) work.right += SEP_WIDTH_SIZE;
+      if (lpBand->fDraw & DRAW_BOTTOMSEP) work.bottom += SEP_WIDTH_SIZE;
+      InvalidateRect(infoPtr->hwndSelf, &work, TRUE);
       }
 
@@ -925 +926 @@
 
     for(i=rstart; i<rend; i++){
-        lpBand = &infoPtr->bands[i];
-        if (HIDDENBAND(lpBand)) continue;
-        oldChild = lpBand->rcChild;
-
-        /* set initial gripper rectangle */
-        SetRect (&lpBand->rcGripper, lpBand->rcBand.left, lpBand->rcBand.top,
-                 lpBand->rcBand.right, lpBand->rcBand.top);
-
-        /* calculate gripper rectangle */
-        if (lpBand->fStatus & HAS_GRIPPER) {
-            lpBand->fDraw |= DRAW_GRIPPER;
-
-            if (infoPtr->dwStyle & RBS_VERTICALGRIPPER) {
-                /*  vertical gripper  */
-                lpBand->rcGripper.left   += 3;
-                lpBand->rcGripper.right  = lpBand->rcGripper.left + GRIPPER_WIDTH;
-                lpBand->rcGripper.top    += REBAR_PRE_GRIPPER;
-                lpBand->rcGripper.bottom = lpBand->rcGripper.top + GRIPPER_HEIGHT;
-
-                /* initialize Caption image rectangle  */
-                SetRect (&lpBand->rcCapImage, lpBand->rcBand.left,
-                         lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE,
-                         lpBand->rcBand.right,
-                         lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE);
-            }
-            else {
-                /*  horizontal gripper  */
-                lpBand->rcGripper.left   += 3;
-                lpBand->rcGripper.right  -= 3;
-                lpBand->rcGripper.top    += REBAR_PRE_GRIPPER;
-                lpBand->rcGripper.bottom  = lpBand->rcGripper.top + GRIPPER_WIDTH;
-
-                /* initialize Caption image rectangle  */
-                SetRect (&lpBand->rcCapImage, lpBand->rcBand.left,
-                         lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE,
-                         lpBand->rcBand.right,
-                         lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE);
-            }
-        }
-        else {  /* no gripper will be drawn */
-            xoff = 0;
-            if (lpBand->fStatus & (HAS_IMAGE | HAS_TEXT))
-                /* if no gripper but either image or text, then leave space */
-                xoff = REBAR_ALWAYS_SPACE;
-            /* initialize Caption image rectangle  */
-            SetRect (&lpBand->rcCapImage, 
-                     lpBand->rcBand.left, lpBand->rcBand.top+xoff,
-                     lpBand->rcBand.right, lpBand->rcBand.top+xoff);
-        }
-
-        /* image is visible */
-        if (lpBand->fStatus & HAS_IMAGE) {
-            lpBand->fDraw |= DRAW_IMAGE;
-
-            lpBand->rcCapImage.right  = lpBand->rcCapImage.left + infoPtr->imageSize.cx;
-            lpBand->rcCapImage.bottom += infoPtr->imageSize.cy;
-
-            /* set initial caption text rectangle */
-            SetRect (&lpBand->rcCapText, 
-                     lpBand->rcBand.left, lpBand->rcCapImage.bottom+REBAR_POST_IMAGE,
-                     lpBand->rcBand.right, lpBand->rcBand.top+lpBand->cxHeader);
-            /* update band height *
-               if (lpBand->uMinHeight < infoPtr->imageSize.cx + 2) {
-               lpBand->uMinHeight = infoPtr->imageSize.cx + 2;
-               lpBand->rcBand.right = lpBand->rcBand.left + lpBand->uMinHeight;
-               } */
-        }
-        else {
-            /* set initial caption text rectangle */
-            SetRect (&lpBand->rcCapText, 
-                     lpBand->rcBand.left, lpBand->rcCapImage.bottom,
-                     lpBand->rcBand.right, lpBand->rcBand.top+lpBand->cxHeader);
-        }
-
-        /* text is visible */
-        if (lpBand->fStatus & HAS_TEXT) {
-            lpBand->fDraw |= DRAW_TEXT;
-            lpBand->rcCapText.bottom = max(lpBand->rcCapText.top,
-                                           lpBand->rcCapText.bottom-REBAR_POST_TEXT);
-        }
-
-        /* set initial child window rectangle if there is a child */
-        if (lpBand->fMask & RBBIM_CHILD) {
-            yoff = lpBand->offChild.cx;
-            xoff = lpBand->offChild.cy;
-            SetRect (&lpBand->rcChild,
-                     lpBand->rcBand.left+xoff, lpBand->rcBand.top+lpBand->cxHeader,
-                     lpBand->rcBand.right-xoff, lpBand->rcBand.bottom-yoff);
-        }
-        else {
-            SetRect (&lpBand->rcChild,
-                     lpBand->rcBand.left, lpBand->rcBand.top+lpBand->cxHeader,
-                     lpBand->rcBand.right, lpBand->rcBand.bottom);
-        }
-
-        /* flag if notify required and invalidate rectangle */
-        if (notify && 
-            ((oldChild.right-oldChild.left != lpBand->rcChild.right-lpBand->rcChild.left) ||
-             (oldChild.bottom-oldChild.top != lpBand->rcChild.bottom-lpBand->rcChild.top))) {
-            TRACE("Child rectangle changed for band %u\n", i);
-            TRACE("    from (%d,%d)-(%d,%d)  to (%d,%d)-(%d,%d)\n",
-                  oldChild.left, oldChild.top,
-                  oldChild.right, oldChild.bottom,
-                  lpBand->rcChild.left, lpBand->rcChild.top,
-                  lpBand->rcChild.right, lpBand->rcChild.bottom);
-        }
-        if (lpBand->fDraw & NTF_INVALIDATE) {
-            TRACE("invalidating (%d,%d)-(%d,%d)\n",
-                  lpBand->rcBand.left, 
-                  lpBand->rcBand.top,
-                  lpBand->rcBand.right + ((lpBand->fDraw & DRAW_BOTTOMSEP) ? SEP_WIDTH_SIZE : 0), 
-                  lpBand->rcBand.bottom + ((lpBand->fDraw & DRAW_RIGHTSEP) ? SEP_WIDTH_SIZE : 0));
-            lpBand->fDraw &= ~NTF_INVALIDATE;
-            work = lpBand->rcBand;
-            if (lpBand->fDraw & DRAW_RIGHTSEP) work.bottom += SEP_WIDTH_SIZE;
-            if (lpBand->fDraw & DRAW_BOTTOMSEP) work.right += SEP_WIDTH_SIZE;
-            InvalidateRect(infoPtr->hwndSelf, &work, TRUE);
-        }
+    lpBand = &infoPtr->bands[i];
+    if (HIDDENBAND(lpBand)) continue;
+    oldChild = lpBand->rcChild;
+
+    /* set initial gripper rectangle */
+    SetRect (&lpBand->rcGripper, lpBand->rcBand.left, lpBand->rcBand.top,
+         lpBand->rcBand.right, lpBand->rcBand.top);
+
+    /* calculate gripper rectangle */
+    if (lpBand->fStatus & HAS_GRIPPER) {
+        lpBand->fDraw |= DRAW_GRIPPER;
+
+        if (infoPtr->dwStyle & RBS_VERTICALGRIPPER) {
+        /*  vertical gripper  */
+        lpBand->rcGripper.left   += 3;
+        lpBand->rcGripper.right  = lpBand->rcGripper.left + GRIPPER_WIDTH;
+        lpBand->rcGripper.top    += REBAR_PRE_GRIPPER;
+        lpBand->rcGripper.bottom = lpBand->rcGripper.top + GRIPPER_HEIGHT;
+
+        /* initialize Caption image rectangle  */
+        SetRect (&lpBand->rcCapImage, lpBand->rcBand.left,
+             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE,
+             lpBand->rcBand.right,
+             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE);
+        }
+        else {
+        /*  horizontal gripper  */
+        lpBand->rcGripper.left   += 3;
+        lpBand->rcGripper.right  -= 3;
+        lpBand->rcGripper.top    += REBAR_PRE_GRIPPER;
+        lpBand->rcGripper.bottom  = lpBand->rcGripper.top + GRIPPER_WIDTH;
+
+        /* initialize Caption image rectangle  */
+        SetRect (&lpBand->rcCapImage, lpBand->rcBand.left,
+             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE,
+             lpBand->rcBand.right,
+             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE);
+        }
+    }
+    else {  /* no gripper will be drawn */
+        xoff = 0;
+        if (lpBand->fStatus & (HAS_IMAGE | HAS_TEXT))
+        /* if no gripper but either image or text, then leave space */
+        xoff = REBAR_ALWAYS_SPACE;
+        /* initialize Caption image rectangle  */
+        SetRect (&lpBand->rcCapImage,
+             lpBand->rcBand.left, lpBand->rcBand.top+xoff,
+             lpBand->rcBand.right, lpBand->rcBand.top+xoff);
+    }
+
+    /* image is visible */
+    if (lpBand->fStatus & HAS_IMAGE) {
+        lpBand->fDraw |= DRAW_IMAGE;
+
+        lpBand->rcCapImage.right  = lpBand->rcCapImage.left + infoPtr->imageSize.cx;
+        lpBand->rcCapImage.bottom += infoPtr->imageSize.cy;
+
+        /* set initial caption text rectangle */
+        SetRect (&lpBand->rcCapText,
+             lpBand->rcBand.left, lpBand->rcCapImage.bottom+REBAR_POST_IMAGE,
+             lpBand->rcBand.right, lpBand->rcBand.top+lpBand->cxHeader);
+        /* update band height *
+           if (lpBand->uMinHeight < infoPtr->imageSize.cx + 2) {
+           lpBand->uMinHeight = infoPtr->imageSize.cx + 2;
+           lpBand->rcBand.right = lpBand->rcBand.left + lpBand->uMinHeight;
+           } */
+    }
+    else {
+        /* set initial caption text rectangle */
+        SetRect (&lpBand->rcCapText,
+             lpBand->rcBand.left, lpBand->rcCapImage.bottom,
+             lpBand->rcBand.right, lpBand->rcBand.top+lpBand->cxHeader);
+    }
+
+    /* text is visible */
+    if (lpBand->fStatus & HAS_TEXT) {
+        lpBand->fDraw |= DRAW_TEXT;
+        lpBand->rcCapText.bottom = max(lpBand->rcCapText.top,
+                       lpBand->rcCapText.bottom-REBAR_POST_TEXT);
+    }
+
+    /* set initial child window rectangle if there is a child */
+    if (lpBand->fMask & RBBIM_CHILD) {
+        yoff = lpBand->offChild.cx;
+        xoff = lpBand->offChild.cy;
+        SetRect (&lpBand->rcChild,
+             lpBand->rcBand.left+xoff, lpBand->rcBand.top+lpBand->cxHeader,
+             lpBand->rcBand.right-xoff, lpBand->rcBand.bottom-yoff);
+    }
+    else {
+        SetRect (&lpBand->rcChild,
+             lpBand->rcBand.left, lpBand->rcBand.top+lpBand->cxHeader,
+             lpBand->rcBand.right, lpBand->rcBand.bottom);
+    }
+
+    /* flag if notify required and invalidate rectangle */
+    if (notify &&
+        ((oldChild.right-oldChild.left != lpBand->rcChild.right-lpBand->rcChild.left) ||
+         (oldChild.bottom-oldChild.top != lpBand->rcChild.bottom-lpBand->rcChild.top))) {
+        TRACE("Child rectangle changed for band %u\n", i);
+        TRACE("    from (%d,%d)-(%d,%d)  to (%d,%d)-(%d,%d)\n",
+          oldChild.left, oldChild.top,
+          oldChild.right, oldChild.bottom,
+          lpBand->rcChild.left, lpBand->rcChild.top,
+          lpBand->rcChild.right, lpBand->rcChild.bottom);
+    }
+    if (lpBand->fDraw & NTF_INVALIDATE) {
+        TRACE("invalidating (%d,%d)-(%d,%d)\n",
+          lpBand->rcBand.left,
+          lpBand->rcBand.top,
+          lpBand->rcBand.right + ((lpBand->fDraw & DRAW_BOTTOMSEP) ? SEP_WIDTH_SIZE : 0),
+          lpBand->rcBand.bottom + ((lpBand->fDraw & DRAW_RIGHTSEP) ? SEP_WIDTH_SIZE : 0));
+        lpBand->fDraw &= ~NTF_INVALIDATE;
+        work = lpBand->rcBand;
+        if (lpBand->fDraw & DRAW_RIGHTSEP) work.bottom += SEP_WIDTH_SIZE;
+        if (lpBand->fDraw & DRAW_BOTTOMSEP) work.right += SEP_WIDTH_SIZE;
+        InvalidateRect(infoPtr->hwndSelf, &work, TRUE);
+    }
 
     }
@@ -1063 +1064 @@
 
     TRACE( " old [%ld x %ld], new [%ld x %ld], client [%d x %d]\n",
-           infoPtr->oldSize.cx, infoPtr->oldSize.cy,
-           infoPtr->calcSize.cx, infoPtr->calcSize.cy,
-           rc.right, rc.bottom);
+       infoPtr->oldSize.cx, infoPtr->oldSize.cy,
+       infoPtr->calcSize.cx, infoPtr->calcSize.cy,
+       rc.right, rc.bottom);
 
     /* If we need to shrink client, then skip size test */
     if ((infoPtr->calcSize.cy >= rc.bottom) &&
-        (infoPtr->calcSize.cx >= rc.right)) {
-
-        /* if size did not change then skip process */
-        if ((infoPtr->oldSize.cx == infoPtr->calcSize.cx) &&
-            (infoPtr->oldSize.cy == infoPtr->calcSize.cy) &&
-            !(infoPtr->fStatus & RESIZE_ANYHOW))
-            {
-                TRACE("skipping reset\n");
-                return;
-            }
+    (infoPtr->calcSize.cx >= rc.right)) {
+
+    /* if size did not change then skip process */
+    if ((infoPtr->oldSize.cx == infoPtr->calcSize.cx) &&
+        (infoPtr->oldSize.cy == infoPtr->calcSize.cy) &&
+        !(infoPtr->fStatus & RESIZE_ANYHOW))
+        {
+        TRACE("skipping reset\n");
+        return;
+        }
     }
 
@@ -1094 +1095 @@
 #if 0
     if (GetWindowLongA (infoPtr->hwndSelf, GWL_STYLE) & WS_BORDER) {
-        InflateRect (&rc, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
+    InflateRect (&rc, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
     }
 #endif
 
     TRACE("setting to (0,0)-(%d,%d)\n",
-          rc.right - rc.left, rc.bottom - rc.top);
+      rc.right - rc.left, rc.bottom - rc.top);
     SetWindowPos (infoPtr->hwndSelf, 0, 0, 0,
-                    rc.right - rc.left, rc.bottom - rc.top,
-                    SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
+            rc.right - rc.left, rc.bottom - rc.top,
+            SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
 }
 
@@ -1120 +1121 @@
 
     for (i = start; i < endplus; i++) {
-        lpBand = &infoPtr->bands[i];
-
-        if (HIDDENBAND(lpBand)) continue;
-        if (lpBand->hwndChild) {
-            TRACE("hwndChild = %x\n", lpBand->hwndChild);
-
-            /* Always geterate the RBN_CHILDSIZE even it child
-                   did not change */
-            rbcz.uBand = i;
-            rbcz.wID = lpBand->wID;
-            rbcz.rcChild = lpBand->rcChild;
-            rbcz.rcBand = lpBand->rcBand;
-            rbcz.rcBand.left += lpBand->cxHeader;
-            REBAR_Notify ((NMHDR *)&rbcz, infoPtr, RBN_CHILDSIZE);
-            if (!EqualRect (&lpBand->rcChild, &rbcz.rcChild)) {
-                TRACE("Child rect changed by NOTIFY for band %u\n", i);
-                TRACE("    from (%d,%d)-(%d,%d)  to (%d,%d)-(%d,%d)\n",
-                      lpBand->rcChild.left, lpBand->rcChild.top,
-                      lpBand->rcChild.right, lpBand->rcChild.bottom,
-                      rbcz.rcChild.left, rbcz.rcChild.top,
-                      rbcz.rcChild.right, rbcz.rcChild.bottom);
-            }
-
-            GetClassNameA (lpBand->hwndChild, szClassName, 40);
-            if (!lstrcmpA (szClassName, "ComboBox") ||
-                !lstrcmpA (szClassName, WC_COMBOBOXEXA)) {
-                INT nEditHeight, yPos;
-                RECT rc;
-
-                /* special placement code for combo or comboex box */
-
-
-                /* get size of edit line */
-                GetWindowRect (lpBand->hwndChild, &rc);
-                nEditHeight = rc.bottom - rc.top;
-                yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2;
-
-                /* center combo box inside child area */
-                TRACE("moving child (Combo(Ex)) %04x to (%d,%d) for (%d,%d)\n",
-                      lpBand->hwndChild,
-                      lpBand->rcChild.left, yPos,
-                      lpBand->rcChild.right - lpBand->rcChild.left,
-                      nEditHeight);
-                deferpos = DeferWindowPos (deferpos, lpBand->hwndChild, HWND_TOP,
-                                           lpBand->rcChild.left,
-                                           /*lpBand->rcChild.top*/ yPos,
-                                           lpBand->rcChild.right - lpBand->rcChild.left,
-                                           nEditHeight,
-                                           SWP_NOZORDER);
-                if (!deferpos)
-                    ERR("DeferWindowPos returned NULL\n");
-            }
-            else {
-                TRACE("moving child (Other) %04x to (%d,%d) for (%d,%d)\n",
-                      lpBand->hwndChild,
-                      lpBand->rcChild.left, lpBand->rcChild.top,
-                      lpBand->rcChild.right - lpBand->rcChild.left,
-                      lpBand->rcChild.bottom - lpBand->rcChild.top);
-                deferpos = DeferWindowPos (deferpos, lpBand->hwndChild, HWND_TOP,
-                                           lpBand->rcChild.left,
-                                           lpBand->rcChild.top,
-                                           lpBand->rcChild.right - lpBand->rcChild.left,
-                                           lpBand->rcChild.bottom - lpBand->rcChild.top,
-                                           SWP_NOZORDER);
-                if (!deferpos)
-                    ERR("DeferWindowPos returned NULL\n");
-            }
-        }
+    lpBand = &infoPtr->bands[i];
+
+    if (HIDDENBAND(lpBand)) continue;
+    if (lpBand->hwndChild) {
+        TRACE("hwndChild = %x\n", lpBand->hwndChild);
+
+        /* Always geterate the RBN_CHILDSIZE even it child
+           did not change */
+        rbcz.uBand = i;
+        rbcz.wID = lpBand->wID;
+        rbcz.rcChild = lpBand->rcChild;
+        rbcz.rcBand = lpBand->rcBand;
+        rbcz.rcBand.left += lpBand->cxHeader;
+        REBAR_Notify ((NMHDR *)&rbcz, infoPtr, RBN_CHILDSIZE);
+        if (!EqualRect (&lpBand->rcChild, &rbcz.rcChild)) {
+        TRACE("Child rect changed by NOTIFY for band %u\n", i);
+        TRACE("    from (%d,%d)-(%d,%d)  to (%d,%d)-(%d,%d)\n",
+              lpBand->rcChild.left, lpBand->rcChild.top,
+              lpBand->rcChild.right, lpBand->rcChild.bottom,
+              rbcz.rcChild.left, rbcz.rcChild.top,
+              rbcz.rcChild.right, rbcz.rcChild.bottom);
+        }
+
+        GetClassNameA (lpBand->hwndChild, szClassName, 40);
+        if (!lstrcmpA (szClassName, "ComboBox") ||
+        !lstrcmpA (szClassName, WC_COMBOBOXEXA)) {
+        INT nEditHeight, yPos;
+        RECT rc;
+
+        /* special placement code for combo or comboex box */
+
+
+        /* get size of edit line */
+        GetWindowRect (lpBand->hwndChild, &rc);
+        nEditHeight = rc.bottom - rc.top;
+        yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2;
+
+        /* center combo box inside child area */
+        TRACE("moving child (Combo(Ex)) %04x to (%d,%d) for (%d,%d)\n",
+              lpBand->hwndChild,
+              lpBand->rcChild.left, yPos,
+              lpBand->rcChild.right - lpBand->rcChild.left,
+              nEditHeight);
+        deferpos = DeferWindowPos (deferpos, lpBand->hwndChild, HWND_TOP,
+                       lpBand->rcChild.left,
+                       /*lpBand->rcChild.top*/ yPos,
+                       lpBand->rcChild.right - lpBand->rcChild.left,
+                       nEditHeight,
+                       SWP_NOZORDER);
+        if (!deferpos)
+            ERR("DeferWindowPos returned NULL\n");
+        }
+        else {
+        TRACE("moving child (Other) %04x to (%d,%d) for (%d,%d)\n",
+              lpBand->hwndChild,
+              lpBand->rcChild.left, lpBand->rcChild.top,
+              lpBand->rcChild.right - lpBand->rcChild.left,
+              lpBand->rcChild.bottom - lpBand->rcChild.top);
+        deferpos = DeferWindowPos (deferpos, lpBand->hwndChild, HWND_TOP,
+                       lpBand->rcChild.left,
+                       lpBand->rcChild.top,
+                       lpBand->rcChild.right - lpBand->rcChild.left,
+                       lpBand->rcChild.bottom - lpBand->rcChild.top,
+                       SWP_NOZORDER);
+        if (!deferpos)
+            ERR("DeferWindowPos returned NULL\n");
+        }
+    }
     }
     if (!EndDeferWindowPos(deferpos))
@@ -1212 +1213 @@
 
     if (!(infoPtr->fStatus & BAND_NEEDS_LAYOUT)) {
-        TRACE("no layout done. No band changed.\n");
-        REBAR_DumpBand (infoPtr);
-        return;
+    TRACE("no layout done. No band changed.\n");
+    REBAR_DumpBand (infoPtr);
+    return;
     }
     infoPtr->fStatus &= ~BAND_NEEDS_LAYOUT;
@@ -1221 +1222 @@
     GetClientRect (infoPtr->hwndSelf, &rcClient);
     TRACE("Client is (%d,%d)-(%d,%d)\n",
-          rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
+      rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
 
     if (lpRect) {
-        rcAdj = *lpRect;
-        TRACE("adjustment rect is (%d,%d)-(%d,%d)\n",
-              rcAdj.left, rcAdj.top, rcAdj.right, rcAdj.bottom);
+    rcAdj = *lpRect;
+    TRACE("adjustment rect is (%d,%d)-(%d,%d)\n",
+          rcAdj.left, rcAdj.top, rcAdj.right, rcAdj.bottom);
     }
     else {
@@ -1243 +1244 @@
 
     if (!infoPtr->DoRedraw && (clientcx == 0) && (clientcy == 0)) {
-        ERR("no redraw and client is zero, skip layout\n");
-        infoPtr->fStatus |= BAND_NEEDS_LAYOUT;
-        return;
+    ERR("no redraw and client is zero, skip layout\n");
+    infoPtr->fStatus |= BAND_NEEDS_LAYOUT;
+    return;
     }
 
     /* save height of original control */
-    if (infoPtr->dwStyle & CCS_VERT) 
+    if (infoPtr->dwStyle & CCS_VERT)
         origheight = infoPtr->calcSize.cx;
     else
@@ -1258 +1259 @@
 
     TRACE("band loop constants, clientcx=%d, clientcy=%d\n",
-          clientcx, clientcy);
+      clientcx, clientcy);
     x = 0;
     y = 0;
@@ -1268 +1269 @@
 
     for (i = 0; i < infoPtr->uNumBands; i++) {
-        lpBand = &infoPtr->bands[i];
-        lpBand->fDraw = 0;
-        lpBand->iRow = row;
-
-        if (HIDDENBAND(lpBand)) continue;
-
-        lpBand->rcoldBand = lpBand->rcBand;
-
-        /* separator from previous band */
-        cxsep = ( ((infoPtr->dwStyle & CCS_VERT) ? y : x)==0) ? 0 : SEP_WIDTH;  
-
-        /* Header: includes gripper, text, image */
-        cx = lpBand->cxHeader;   
-        if (lpBand->fStyle & RBBS_FIXEDSIZE) cx = lpBand->lcx;
-
-        if (infoPtr->dwStyle & CCS_VERT)
-            dobreak = (y + cx + cxsep > adjcy);
+    lpBand = &infoPtr->bands[i];
+    lpBand->fDraw = 0;
+    lpBand->iRow = row;
+
+    if (HIDDENBAND(lpBand)) continue;
+
+    lpBand->rcoldBand = lpBand->rcBand;
+
+    /* separator from previous band */
+    cxsep = ( ((infoPtr->dwStyle & CCS_VERT) ? y : x)==0) ? 0 : SEP_WIDTH;
+
+    /* Header: includes gripper, text, image */
+    cx = lpBand->cxHeader;
+    if (lpBand->fStyle & RBBS_FIXEDSIZE) cx = lpBand->lcx;
+
+    if (infoPtr->dwStyle & CCS_VERT)
+        dobreak = (y + cx + cxsep > adjcy);
         else
-            dobreak = (x + cx + cxsep > adjcx);
-
-        /* This is the check for whether we need to start a new row */
-        if ( ( (lpBand->fStyle & RBBS_BREAK) && (i != 0) ) ||
-             ( ((infoPtr->dwStyle & CCS_VERT) ? (y != 0) : (x != 0)) && dobreak)) {
-
-            for (j = rowstart; j < i; j++) {
-                REBAR_BAND *lpB;
-                lpB = &infoPtr->bands[j];
-                if (infoPtr->dwStyle & CCS_VERT) {
-                    lpB->rcBand.right  = lpB->rcBand.left + mcy;
-                }
-                else {
-                    lpB->rcBand.bottom = lpB->rcBand.top + mcy;
-                }
-            }
-
-            TRACE("Spliting to new row %d on band %u\n", row+1, i);
-            if (infoPtr->dwStyle & CCS_VERT) {
-                y = 0;
-                x += (mcy + SEP_WIDTH);
-            }
-            else {
-                x = 0;
-                y += (mcy + SEP_WIDTH);
-            }
-
-            mcy = 0;
-            cxsep = 0;
-            row++;
-            lpBand->iRow = row;
-            prevBand = NULL;
-            rowstart = i;
-        }
-
-        if (mcy < lpBand->lcy + REBARSPACE) mcy = lpBand->lcy + REBARSPACE;
-
-        /* if boundary rect specified then limit mcy */
-        if (lpRect) {
-            if (infoPtr->dwStyle & CCS_VERT) {
-                if (x+mcy > adjcx) {
-                    mcy = adjcx - x;
-                    TRACE("row %u limiting mcy=%d, adjcx=%d, x=%d\n",
-                          i, mcy, adjcx, x);
-                }
-            }
-            else {
-                if (y+mcy > adjcy) {
-                    mcy = adjcy - y;
-                    TRACE("row %u limiting mcy=%d, adjcy=%d, y=%d\n",
-                          i, mcy, adjcy, y);
-                }
-            }
-        }
-
-        TRACE("band %u, row %d, x=%d, y=%d, cxsep=%d, cx=%d\n",
-              i, row,
-              x, y, cxsep, cx);
-        if (infoPtr->dwStyle & CCS_VERT) {
-            /* bound the bottom side if we have a bounding rectangle */
-            rightx = clientcx;
-            bottomy = (lpRect) ? min(clientcy, y+cxsep+cx) : y+cxsep+cx;
-            lpBand->rcBand.left   = x;
-            lpBand->rcBand.right  = x + min(mcy, lpBand->lcy+REBARSPACE);
-            lpBand->rcBand.top    = min(bottomy, y + cxsep);
-            lpBand->rcBand.bottom = bottomy;
-            lpBand->uMinHeight = lpBand->lcy;
-            y = bottomy;
-        }
-        else {
-            /* bound the right side if we have a bounding rectangle */
-            rightx = (lpRect) ? min(clientcx, x+cxsep+cx) : x+cxsep+cx;
-            bottomy = clientcy;
-            lpBand->rcBand.left   = min(rightx, x + cxsep);
-            lpBand->rcBand.right  = rightx;
-            lpBand->rcBand.top    = y;
-            lpBand->rcBand.bottom = y + min(mcy, lpBand->lcy+REBARSPACE);
-            lpBand->uMinHeight = lpBand->lcy;
-            x = rightx;
-        }
-        TRACE("band %u, row %d, (%d,%d)-(%d,%d)\n",
-              i, row,
-              lpBand->rcBand.left, lpBand->rcBand.top,
-              lpBand->rcBand.right, lpBand->rcBand.bottom);
-        prevBand = lpBand;
+        dobreak = (x + cx + cxsep > adjcx);
+
+    /* This is the check for whether we need to start a new row */
+    if ( ( (lpBand->fStyle & RBBS_BREAK) && (i != 0) ) ||
+         ( ((infoPtr->dwStyle & CCS_VERT) ? (y != 0) : (x != 0)) && dobreak)) {
+
+        for (j = rowstart; j < i; j++) {
+        REBAR_BAND *lpB;
+        lpB = &infoPtr->bands[j];
+        if (infoPtr->dwStyle & CCS_VERT) {
+            lpB->rcBand.right  = lpB->rcBand.left + mcy;
+        }
+        else {
+            lpB->rcBand.bottom = lpB->rcBand.top + mcy;
+        }
+        }
+
+        TRACE("Spliting to new row %d on band %u\n", row+1, i);
+        if (infoPtr->dwStyle & CCS_VERT) {
+        y = 0;
+        x += (mcy + SEP_WIDTH);
+        }
+        else {
+        x = 0;
+        y += (mcy + SEP_WIDTH);
+        }
+
+        mcy = 0;
+        cxsep = 0;
+        row++;
+        lpBand->iRow = row;
+        prevBand = NULL;
+        rowstart = i;
+    }
+
+    if (mcy < lpBand->lcy + REBARSPACE) mcy = lpBand->lcy + REBARSPACE;
+
+    /* if boundary rect specified then limit mcy */
+    if (lpRect) {
+        if (infoPtr->dwStyle & CCS_VERT) {
+            if (x+mcy > adjcx) {
+            mcy = adjcx - x;
+            TRACE("row %u limiting mcy=%d, adjcx=%d, x=%d\n",
+              i, mcy, adjcx, x);
+        }
+        }
+        else {
+            if (y+mcy > adjcy) {
+            mcy = adjcy - y;
+            TRACE("row %u limiting mcy=%d, adjcy=%d, y=%d\n",
+              i, mcy, adjcy, y);
+        }
+        }
+    }
+
+    TRACE("band %u, row %d, x=%d, y=%d, cxsep=%d, cx=%d\n",
+          i, row,
+          x, y, cxsep, cx);
+    if (infoPtr->dwStyle & CCS_VERT) {
+        /* bound the bottom side if we have a bounding rectangle */
+        rightx = clientcx;
+        bottomy = (lpRect) ? min(clientcy, y+cxsep+cx) : y+cxsep+cx;
+        lpBand->rcBand.left   = x;
+        lpBand->rcBand.right  = x + min(mcy, lpBand->lcy+REBARSPACE);
+        lpBand->rcBand.top    = min(bottomy, y + cxsep);
+        lpBand->rcBand.bottom = bottomy;
+        lpBand->uMinHeight = lpBand->lcy;
+        y = bottomy;
+    }
+    else {
+        /* bound the right side if we have a bounding rectangle */
+        rightx = (lpRect) ? min(clientcx, x+cxsep+cx) : x+cxsep+cx;
+        bottomy = clientcy;
+        lpBand->rcBand.left   = min(rightx, x + cxsep);
+        lpBand->rcBand.right  = rightx;
+        lpBand->rcBand.top    = y;
+        lpBand->rcBand.bottom = y + min(mcy, lpBand->lcy+REBARSPACE);
+        lpBand->uMinHeight = lpBand->lcy;
+        x = rightx;
+    }
+    TRACE("band %u, row %d, (%d,%d)-(%d,%d)\n",
+          i, row,
+          lpBand->rcBand.left, lpBand->rcBand.top,
+          lpBand->rcBand.right, lpBand->rcBand.bottom);
+    prevBand = lpBand;
 
     } /* for (i = 0; i < infoPtr->uNumBands... */
@@ -1380 +1381 @@
 
     for (j = rowstart; j < infoPtr->uNumBands; j++) {
-        lpBand = &infoPtr->bands[j];
-        if (infoPtr->dwStyle & CCS_VERT) {
-            lpBand->rcBand.right  = lpBand->rcBand.left + mcy;
-        }
-        else {
-            lpBand->rcBand.bottom = lpBand->rcBand.top + mcy;
-        }
+    lpBand = &infoPtr->bands[j];
+    if (infoPtr->dwStyle & CCS_VERT) {
+        lpBand->rcBand.right  = lpBand->rcBand.left + mcy;
+    }
+    else {
+        lpBand->rcBand.bottom = lpBand->rcBand.top + mcy;
+    }
     }
 
@@ -1399 +1400 @@
     mmcy = 0;
     if (!(infoPtr->dwStyle & RBS_VARHEIGHT)) {
-        INT xy;
-
-        /* get the max height of all bands */
-        for (i=0; i<infoPtr->uNumBands; i++) {
-            lpBand = &infoPtr->bands[i];
-            if (HIDDENBAND(lpBand)) continue;
-            if (infoPtr->dwStyle & CCS_VERT)
-                mmcy = max(mmcy, lpBand->rcBand.right - lpBand->rcBand.left);
-            else
-                mmcy = max(mmcy, lpBand->rcBand.bottom - lpBand->rcBand.top);
-        }
-
-        /* now adjust all rectangles by using the height found above */
-        xy = 0;
-        row = 1;
-        for (i=0; i<infoPtr->uNumBands; i++) {
-            lpBand = &infoPtr->bands[i];
-            if (HIDDENBAND(lpBand)) continue;
-            if (lpBand->iRow != row)
-                xy += (mmcy + SEP_WIDTH);
-            if (infoPtr->dwStyle & CCS_VERT) {
-                lpBand->rcBand.left = xy;
-                lpBand->rcBand.right = xy + mmcy;
-            }
-            else {
-                lpBand->rcBand.top = xy;
-                lpBand->rcBand.bottom = xy + mmcy;
-            }
-        }
-
-        /* set the x/y values to the correct maximum */
-        if (infoPtr->dwStyle & CCS_VERT)
-            x = xy + mmcy;
-        else
-            y = xy + mmcy;
+    INT xy;
+
+    /* get the max height of all bands */
+    for (i=0; i<infoPtr->uNumBands; i++) {
+        lpBand = &infoPtr->bands[i];
+        if (HIDDENBAND(lpBand)) continue;
+        if (infoPtr->dwStyle & CCS_VERT)
+        mmcy = max(mmcy, lpBand->rcBand.right - lpBand->rcBand.left);
+        else
+        mmcy = max(mmcy, lpBand->rcBand.bottom - lpBand->rcBand.top);
+    }
+
+    /* now adjust all rectangles by using the height found above */
+    xy = 0;
+    row = 1;
+    for (i=0; i<infoPtr->uNumBands; i++) {
+        lpBand = &infoPtr->bands[i];
+        if (HIDDENBAND(lpBand)) continue;
+        if (lpBand->iRow != row)
+        xy += (mmcy + SEP_WIDTH);
+        if (infoPtr->dwStyle & CCS_VERT) {
+        lpBand->rcBand.left = xy;
+        lpBand->rcBand.right = xy + mmcy;
+        }
+        else {
+        lpBand->rcBand.top = xy;
+        lpBand->rcBand.bottom = xy + mmcy;
+        }
+    }
+
+    /* set the x/y values to the correct maximum */
+    if (infoPtr->dwStyle & CCS_VERT)
+        x = xy + mmcy;
+    else
+        y = xy + mmcy;
     }
 
@@ -1445 +1446 @@
     if (lpRect) {
         INT i, j, prev_rh, new_rh, adj_rh, prev_idx, current_idx;
-        REBAR_BAND *prev, *current, *walk;
+    REBAR_BAND *prev, *current, *walk;
 
 /* FIXME:  problem # 2 */
-        if (((infoPtr->dwStyle & CCS_VERT) ? 
+    if (((infoPtr->dwStyle & CCS_VERT) ?
 #if PROBLEM2
-             (x < adjcx) : (y < adjcy)
+         (x < adjcx) : (y < adjcy)
 #else
-             (adjcx - x > 4) : (adjcy - y > 4)
+         (adjcx - x > 4) : (adjcy - y > 4)
 #endif
-             ) &&
-            (infoPtr->uNumBands > 1)) {
-            for (i=(INT)infoPtr->uNumBands-2; i>=0; i--) {
-                TRACE("adjcx=%d, adjcy=%d, x=%d, y=%d\n",
-                      adjcx, adjcy, x, y);
-
-                /* find the current band (starts at i+1) */
-                current = &infoPtr->bands[i+1];
-                current_idx = i+1;
-                while (HIDDENBAND(current)) {
-                    i--;
-                    if (i < 0) break; /* out of bands */
-                    current = &infoPtr->bands[i+1];
-                    current_idx = i+1;
-                }
-                if (i < 0) break; /* out of bands */
-
-                /* now find the prev band (starts at i) */
-                prev = &infoPtr->bands[i];
-                prev_idx = i;
-                while (HIDDENBAND(prev)) {
-                    i--;
-                    if (i < 0) break; /* out of bands */
-                    prev = &infoPtr->bands[i];
-                    prev_idx = i;
-                }
-                if (i < 0) break; /* out of bands */
-
-                prev_rh = ircBw(prev);
-                if (prev->iRow == current->iRow) {
-                    new_rh = (infoPtr->dwStyle & RBS_VARHEIGHT) ?
-                        current->lcy + REBARSPACE :
-                        mmcy;
-                    adj_rh = new_rh + SEP_WIDTH;
-                    infoPtr->uNumRows++;
-                    current->fDraw |= NTF_INVALIDATE;
-                    current->iRow++;
-                    if (infoPtr->dwStyle & CCS_VERT) {
-                        current->rcBand.top = 0;
-                        current->rcBand.bottom = clientcy;
-                        current->rcBand.left += (prev_rh + SEP_WIDTH);
-                        current->rcBand.right = current->rcBand.left + new_rh;
-                        x += adj_rh;
-                    }
-                    else {
-                        current->rcBand.left = 0;
-                        current->rcBand.right = clientcx;
-                        current->rcBand.top += (prev_rh + SEP_WIDTH);
-                        current->rcBand.bottom = current->rcBand.top + new_rh;
-                        y += adj_rh;
-                    }
-                    TRACE("moving band %d to own row at (%d,%d)-(%d,%d)\n",
-                          current_idx,
-                          current->rcBand.left, current->rcBand.top,
-                          current->rcBand.right, current->rcBand.bottom);
-                    TRACE("prev band %d at (%d,%d)-(%d,%d)\n",
-                          prev_idx,
-                          prev->rcBand.left, prev->rcBand.top,
-                          prev->rcBand.right, prev->rcBand.bottom);
-                    TRACE("values: prev_rh=%d, new_rh=%d, adj_rh=%d\n",
-                          prev_rh, new_rh, adj_rh);
-                    /* for bands below current adjust row # and top/bottom */
-                    for (j = current_idx+1; j<infoPtr->uNumBands; j++) {
-                        walk = &infoPtr->bands[j];
-                        if (HIDDENBAND(walk)) continue;
-                        walk->fDraw |= NTF_INVALIDATE;
-                        walk->iRow++;
-                        if (infoPtr->dwStyle & CCS_VERT) {
-                            walk->rcBand.left += adj_rh;
-                            walk->rcBand.right += adj_rh;
-                        }
-                        else {
-                            walk->rcBand.top += adj_rh;
-                            walk->rcBand.bottom += adj_rh;
-                        }
-                    }
-                    if ((infoPtr->dwStyle & CCS_VERT) ? (x >= adjcx) : (y >= adjcy)) 
-                        break; /* all done */
-                }
-            }
-        }
+         ) &&
+        (infoPtr->uNumBands > 1)) {
+        for (i=(INT)infoPtr->uNumBands-2; i>=0; i--) {
+        TRACE("adjcx=%d, adjcy=%d, x=%d, y=%d\n",
+              adjcx, adjcy, x, y);
+
+        /* find the current band (starts at i+1) */
+        current = &infoPtr->bands[i+1];
+        current_idx = i+1;
+        while (HIDDENBAND(current)) {
+            i--;
+            if (i < 0) break; /* out of bands */
+            current = &infoPtr->bands[i+1];
+            current_idx = i+1;
+        }
+        if (i < 0) break; /* out of bands */
+
+        /* now find the prev band (starts at i) */
+            prev = &infoPtr->bands[i];
+        prev_idx = i;
+        while (HIDDENBAND(prev)) {
+            i--;
+            if (i < 0) break; /* out of bands */
+            prev = &infoPtr->bands[i];
+            prev_idx = i;
+        }
+        if (i < 0) break; /* out of bands */
+
+        prev_rh = ircBw(prev);
+        if (prev->iRow == current->iRow) {
+            new_rh = (infoPtr->dwStyle & RBS_VARHEIGHT) ?
+            current->lcy + REBARSPACE :
+            mmcy;
+            adj_rh = new_rh + SEP_WIDTH;
+            infoPtr->uNumRows++;
+            current->fDraw |= NTF_INVALIDATE;
+            current->iRow++;
+            if (infoPtr->dwStyle & CCS_VERT) {
+                current->rcBand.top = 0;
+            current->rcBand.bottom = clientcy;
+            current->rcBand.left += (prev_rh + SEP_WIDTH);
+            current->rcBand.right = current->rcBand.left + new_rh;
+            x += adj_rh;
+            }
+            else {
+                current->rcBand.left = 0;
+            current->rcBand.right = clientcx;
+            current->rcBand.top += (prev_rh + SEP_WIDTH);
+            current->rcBand.bottom = current->rcBand.top + new_rh;
+            y += adj_rh;
+            }
+            TRACE("moving band %d to own row at (%d,%d)-(%d,%d)\n",
+              current_idx,
+              current->rcBand.left, current->rcBand.top,
+              current->rcBand.right, current->rcBand.bottom);
+            TRACE("prev band %d at (%d,%d)-(%d,%d)\n",
+              prev_idx,
+              prev->rcBand.left, prev->rcBand.top,
+              prev->rcBand.right, prev->rcBand.bottom);
+            TRACE("values: prev_rh=%d, new_rh=%d, adj_rh=%d\n",
+              prev_rh, new_rh, adj_rh);
+            /* for bands below current adjust row # and top/bottom */
+            for (j = current_idx+1; j<infoPtr->uNumBands; j++) {
+                walk = &infoPtr->bands[j];
+            if (HIDDENBAND(walk)) continue;
+            walk->fDraw |= NTF_INVALIDATE;
+            walk->iRow++;
+            if (infoPtr->dwStyle & CCS_VERT) {
+                walk->rcBand.left += adj_rh;
+                walk->rcBand.right += adj_rh;
+            }
+            else {
+                walk->rcBand.top += adj_rh;
+                walk->rcBand.bottom += adj_rh;
+            }
+            }
+            if ((infoPtr->dwStyle & CCS_VERT) ? (x >= adjcx) : (y >= adjcy))
+                break; /* all done */
+        }
+        }
+    }
     }
 
@@ -1545 +1546 @@
     /*   clientcy/clientcx     height/width of client area           */
 
-    /* **** FIXME FIXME FIXME 
+    /* **** FIXME FIXME FIXME
      *   this does not take into account that more than one band
      *   is in a row!!!!!!!!!
@@ -1551 +1552 @@
 
     if (((infoPtr->dwStyle & CCS_VERT) ? clientcx > x : clientcy > y) &&
-        infoPtr->uNumBands) {
-        INT diff, i, j;
-
-        diff = (infoPtr->dwStyle & CCS_VERT) ? clientcx - x : clientcy - y;
-        for (i = infoPtr->uNumBands-1; i >= 0; i--) {
-            lpBand = &infoPtr->bands[i];
-            if(HIDDENBAND(lpBand)) continue;
-            if (!lpBand->fMask & RBBS_VARIABLEHEIGHT) continue;
-            if (((INT)lpBand->cyMaxChild < 1) || 
-                ((INT)lpBand->cyIntegral < 1)) {
-                if (lpBand->cyMaxChild + lpBand->cyIntegral == 0) continue;
-                ERR("band %u RBBS_VARIABLEHEIGHT set but cyMax=%d, cyInt=%d\n",
-                    i, lpBand->cyMaxChild, lpBand->cyIntegral);
-                continue;
-            }
-            /* j is now the maximum height/width in the client area */
-            j = ((diff / lpBand->cyIntegral) * lpBand->cyIntegral) + 
-                ircBw(lpBand);
-            if (j > lpBand->cyMaxChild + REBARSPACE) 
-                j = lpBand->cyMaxChild + REBARSPACE;
-            diff -= (j - ircBw(lpBand));
-            if (infoPtr->dwStyle & CCS_VERT)
-                lpBand->rcBand.right = lpBand->rcBand.left + j;
-            else
-                lpBand->rcBand.bottom = lpBand->rcBand.top + j;
-            TRACE("P2a band %d, row %d changed to (%d,%d)-(%d,%d)\n",
-                  i, lpBand->iRow,
-                  lpBand->rcBand.left, lpBand->rcBand.top,
-                  lpBand->rcBand.right, lpBand->rcBand.bottom);
-            if (diff <= 0) break;
-        }
-        if (diff < 0) {
-            ERR("allocated more than available, diff=%d\n", diff);
-            diff = 0;
-        }
-        if (infoPtr->dwStyle & CCS_VERT)
-            x = clientcx - diff;
-        else
-            y = clientcy - diff;
+    infoPtr->uNumBands) {
+    INT diff, i, j;
+
+    diff = (infoPtr->dwStyle & CCS_VERT) ? clientcx - x : clientcy - y;
+    for (i = infoPtr->uNumBands-1; i >= 0; i--) {
+        lpBand = &infoPtr->bands[i];
+        if(HIDDENBAND(lpBand)) continue;
+        if (!lpBand->fMask & RBBS_VARIABLEHEIGHT) continue;
+        if (((INT)lpBand->cyMaxChild < 1) ||
+        ((INT)lpBand->cyIntegral < 1)) {
+        if (lpBand->cyMaxChild + lpBand->cyIntegral == 0) continue;
+        ERR("band %u RBBS_VARIABLEHEIGHT set but cyMax=%d, cyInt=%d\n",
+            i, lpBand->cyMaxChild, lpBand->cyIntegral);
+        continue;
+        }
+        /* j is now the maximum height/width in the client area */
+        j = ((diff / lpBand->cyIntegral) * lpBand->cyIntegral) +
+        ircBw(lpBand);
+        if (j > lpBand->cyMaxChild + REBARSPACE)
+        j = lpBand->cyMaxChild + REBARSPACE;
+        diff -= (j - ircBw(lpBand));
+        if (infoPtr->dwStyle & CCS_VERT)
+        lpBand->rcBand.right = lpBand->rcBand.left + j;
+        else
+        lpBand->rcBand.bottom = lpBand->rcBand.top + j;
+        TRACE("P2a band %d, row %d changed to (%d,%d)-(%d,%d)\n",
+          i, lpBand->iRow,
+          lpBand->rcBand.left, lpBand->rcBand.top,
+          lpBand->rcBand.right, lpBand->rcBand.bottom);
+        if (diff <= 0) break;
+    }
+    if (diff < 0) {
+        ERR("allocated more than available, diff=%d\n", diff);
+        diff = 0;
+    }
+    if (infoPtr->dwStyle & CCS_VERT)
+        x = clientcx - diff;
+    else
+        y = clientcy - diff;
     }
 
@@ -1598 +1599 @@
 
     if (infoPtr->uNumBands) {
-        INT bandnum, bandnum_start, bandnum_end;
-
-        /* If RBS_BANDBORDERS set then indicate to draw bottom separator */
-        /* on all bands in all rows but last row.                        */
-        /* Also indicate to draw the right separator for each band in    */
-        /* each row but the rightmost band.                              */
-        if (infoPtr->dwStyle & RBS_BANDBORDERS) {
-            REBAR_BAND *prevband;
-            INT currow;
-
-            prevband = NULL;
-            currow = -1;
-            for (i = 0; i < infoPtr->uNumBands; i++) {
-                lpBand = &infoPtr->bands[i];
-                if (HIDDENBAND(lpBand)) continue;
-
-                if (lpBand->iRow < infoPtr->uNumRows) 
-                    lpBand->fDraw |= DRAW_BOTTOMSEP;
-
-                if (lpBand->iRow != currow) prevband = NULL;
-                currow = lpBand->iRow;
-                if (prevband) prevband->fDraw |= DRAW_RIGHTSEP;
-                prevband = lpBand;
-            }
-        }
-
-        /* Distribute the extra space on the horizontal and adjust  */
-        /* all bands in row to same height.                         */
-        bandnum = 0;
-        for (i=1; i<=infoPtr->uNumRows; i++) {
-            bandnum_start = -1;
-            bandnum_end = -1;
-            mcy = 0;
-            TRACE("processing row %d, starting band %d\n", i, bandnum);
-            while (TRUE) {
-                lpBand = &infoPtr->bands[bandnum];
-                if ((bandnum >= infoPtr->uNumBands) ||
-                    ((lpBand->iRow != i) &&
-                     !HIDDENBAND(lpBand))) {
-                    if ((bandnum_start == -1) ||
-                        (bandnum_end == -1)) {
-                        ERR("logic error? bands=%d, rows=%d, start=%d, end=%d\n",
-                            infoPtr->uNumBands, infoPtr->uNumRows, 
-                            (INT)bandnum_start, (INT)bandnum_end);
-                        ERR("  current row=%d, band=%d\n",
-                            i, bandnum);
-                        break;
-                    }
-                    REBAR_AdjustBands (infoPtr, bandnum_start, bandnum_end,
-                                       (infoPtr->dwStyle & CCS_VERT) ? 
-                                       clientcy : clientcx, mcy);
-                    break;
-                }
-                if (!HIDDENBAND(lpBand)) {
-                    if (bandnum_start == -1) bandnum_start = bandnum;
-                    if (bandnum_end < bandnum) bandnum_end = bandnum;
-                    if (mcy < ircBw(lpBand)) 
-                        mcy = ircBw(lpBand);
-                }
-                bandnum++;
-                TRACE("point 1, bandnum=%d\n", bandnum);
-            }
-            TRACE("point 2, i=%d, numrows=%d, bandnum=%d\n",
-                  i, infoPtr->uNumRows, bandnum);
-        }
-        TRACE("point 3\n");
-
-        /* Calculate the other rectangles in each band */
-        if (infoPtr->dwStyle & CCS_VERT) {
-            REBAR_CalcVertBand (infoPtr, 0, infoPtr->uNumBands,
-                                notify);
-        }
-        else {
-            REBAR_CalcHorzBand (infoPtr, 0, infoPtr->uNumBands, 
-                                notify);
-        }
+    INT bandnum, bandnum_start, bandnum_end;
+
+    /* If RBS_BANDBORDERS set then indicate to draw bottom separator */
+    /* on all bands in all rows but last row.                        */
+    /* Also indicate to draw the right separator for each band in    */
+    /* each row but the rightmost band.                              */
+    if (infoPtr->dwStyle & RBS_BANDBORDERS) {
+        REBAR_BAND *prevband;
+        INT currow;
+
+        prevband = NULL;
+        currow = -1;
+        for (i = 0; i < infoPtr->uNumBands; i++) {
+            lpBand = &infoPtr->bands[i];
+        if (HIDDENBAND(lpBand)) continue;
+
+        if (lpBand->iRow < infoPtr->uNumRows)
+            lpBand->fDraw |= DRAW_BOTTOMSEP;
+
+        if (lpBand->iRow != currow) prevband = NULL;
+        currow = lpBand->iRow;
+        if (prevband) prevband->fDraw |= DRAW_RIGHTSEP;
+        prevband = lpBand;
+        }
+    }
+
+    /* Distribute the extra space on the horizontal and adjust  */
+    /* all bands in row to same height.                         */
+    bandnum = 0;
+    for (i=1; i<=infoPtr->uNumRows; i++) {
+        bandnum_start = -1;
+        bandnum_end = -1;
+        mcy = 0;
+        TRACE("processing row %d, starting band %d\n", i, bandnum);
+        while (TRUE) {
+        lpBand = &infoPtr->bands[bandnum];
+        if ((bandnum >= infoPtr->uNumBands) ||
+            ((lpBand->iRow != i) &&
+             !HIDDENBAND(lpBand))) {
+            if ((bandnum_start == -1) ||
+            (bandnum_end == -1)) {
+            ERR("logic error? bands=%d, rows=%d, start=%d, end=%d\n",
+                infoPtr->uNumBands, infoPtr->uNumRows,
+                (INT)bandnum_start, (INT)bandnum_end);
+            ERR("  current row=%d, band=%d\n",
+                i, bandnum);
+            break;
+            }
+            REBAR_AdjustBands (infoPtr, bandnum_start, bandnum_end,
+                       (infoPtr->dwStyle & CCS_VERT) ?
+                       clientcy : clientcx, mcy);
+            break;
+        }
+        if (!HIDDENBAND(lpBand)) {
+            if (bandnum_start == -1) bandnum_start = bandnum;
+            if (bandnum_end < bandnum) bandnum_end = bandnum;
+            if (mcy < ircBw(lpBand))
+            mcy = ircBw(lpBand);
+        }
+        bandnum++;
+        TRACE("point 1, bandnum=%d\n", bandnum);
+        }
+        TRACE("point 2, i=%d, numrows=%d, bandnum=%d\n",
+          i, infoPtr->uNumRows, bandnum);
+    }
+    TRACE("point 3\n");
+
+    /* Calculate the other rectangles in each band */
+    if (infoPtr->dwStyle & CCS_VERT) {
+        REBAR_CalcVertBand (infoPtr, 0, infoPtr->uNumBands,
+                notify);
+    }
+    else {
+        REBAR_CalcHorzBand (infoPtr, 0, infoPtr->uNumBands,
+                notify);
+    }
     }
 
@@ -1681 +1682 @@
     infoPtr->oldSize = infoPtr->calcSize;
     if (infoPtr->dwStyle & CCS_VERT) {
-        infoPtr->calcSize.cx = x;
-        infoPtr->calcSize.cy = clientcy;
-        TRACE("vert, notify=%d, x=%d, origheight=%d\n",
-              notify, x, origheight);
-        if (notify && (x != origheight)) infoPtr->fStatus |= NTF_HGHTCHG;
+    infoPtr->calcSize.cx = x;
+    infoPtr->calcSize.cy = clientcy;
+    TRACE("vert, notify=%d, x=%d, origheight=%d\n",
+          notify, x, origheight);
+    if (notify && (x != origheight)) infoPtr->fStatus |= NTF_HGHTCHG;
     }
     else {
-        infoPtr->calcSize.cx = clientcx;
-        infoPtr->calcSize.cy = y;
-        TRACE("horz, notify=%d, y=%d, origheight=%d\n",
-              notify, y, origheight);
-        if (notify && (y != origheight)) infoPtr->fStatus |= NTF_HGHTCHG; 
+    infoPtr->calcSize.cx = clientcx;
+    infoPtr->calcSize.cy = y;
+    TRACE("horz, notify=%d, y=%d, origheight=%d\n",
+          notify, y, origheight);
+    if (notify && (y != origheight)) infoPtr->fStatus |= NTF_HGHTCHG;
     }
 
@@ -1749 +1750 @@
     /* calculate gripper rectangle */
     if (  (!(lpBand->fStyle & RBBS_NOGRIPPER)) &&
-          ( (lpBand->fStyle & RBBS_GRIPPERALWAYS) || 
-            ( !(lpBand->fStyle & RBBS_FIXEDSIZE) && (infoPtr->uNumBands > 1)))
+      ( (lpBand->fStyle & RBBS_GRIPPERALWAYS) ||
+        ( !(lpBand->fStyle & RBBS_FIXEDSIZE) && (infoPtr->uNumBands > 1)))
        ) {
-        lpBand->fStatus |= HAS_GRIPPER;
+    lpBand->fStatus |= HAS_GRIPPER;
         if (infoPtr->dwStyle & CCS_VERT)
-            if (infoPtr->dwStyle & RBS_VERTICALGRIPPER)
+        if (infoPtr->dwStyle & RBS_VERTICALGRIPPER)
                 header += (GRIPPER_HEIGHT + REBAR_PRE_GRIPPER);
             else
-                header += (GRIPPER_WIDTH + REBAR_PRE_GRIPPER);
+            header += (GRIPPER_WIDTH + REBAR_PRE_GRIPPER);
         else
             header += (REBAR_PRE_GRIPPER + GRIPPER_WIDTH);
@@ -1766 +1767 @@
     /* image is visible */
     if ((lpBand->fMask & RBBIM_IMAGE) && (infoPtr->himl)) {
-        lpBand->fStatus |= HAS_IMAGE;
+    lpBand->fStatus |= HAS_IMAGE;
         if (infoPtr->dwStyle & CCS_VERT) {
-           header += (infoPtr->imageSize.cy + REBAR_POST_IMAGE);
-           lpBand->lcy = infoPtr->imageSize.cx + 2;
-        }
-        else {
-           header += (infoPtr->imageSize.cx + REBAR_POST_IMAGE);
-           lpBand->lcy = infoPtr->imageSize.cy + 2;
-        }
+       header += (infoPtr->imageSize.cy + REBAR_POST_IMAGE);
+       lpBand->lcy = infoPtr->imageSize.cx + 2;
+    }
+    else {
+       header += (infoPtr->imageSize.cx + REBAR_POST_IMAGE);
+       lpBand->lcy = infoPtr->imageSize.cy + 2;
+    }
     }
 
     /* text is visible */
     if ((lpBand->fMask & RBBIM_TEXT) && (lpBand->lpText)) {
-        HDC hdc = GetDC (0);
-        HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
-        SIZE size;
-
-        lpBand->fStatus |= HAS_TEXT;
-        GetTextExtentPoint32W (hdc, lpBand->lpText,
-                               lstrlenW (lpBand->lpText), &size);
-        header += ((infoPtr->dwStyle & CCS_VERT) ? (size.cy + REBAR_POST_TEXT) : (size.cx + REBAR_POST_TEXT));
-        textheight = (infoPtr->dwStyle & CCS_VERT) ? 0 : size.cy;
-
-        SelectObject (hdc, hOldFont);
-        ReleaseDC (0, hdc);
+    HDC hdc = GetDC (0);
+    HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
+    SIZE size;
+
+    lpBand->fStatus |= HAS_TEXT;
+    GetTextExtentPoint32W (hdc, lpBand->lpText,
+                   lstrlenW (lpBand->lpText), &size);
+    header += ((infoPtr->dwStyle & CCS_VERT) ? (size.cy + REBAR_POST_TEXT) : (size.cx + REBAR_POST_TEXT));
+    textheight = (infoPtr->dwStyle & CCS_VERT) ? 0 : size.cy;
+
+    SelectObject (hdc, hOldFont);
+    ReleaseDC (0, hdc);
     }
 
     /* if no gripper but either image or text, then leave space */
     if ((lpBand->fStatus & (HAS_IMAGE | HAS_TEXT)) &&
-        !(lpBand->fStatus & HAS_GRIPPER)) {
-        header += REBAR_ALWAYS_SPACE;
+    !(lpBand->fStatus & HAS_GRIPPER)) {
+    header += REBAR_ALWAYS_SPACE;
     }
 
@@ -1810 +1811 @@
     lpBand->ccy = lpBand->lcy;
     if (lpBand->fMask & RBBIM_CHILDSIZE) {
-        if (!(lpBand->fStyle & RBBS_FIXEDSIZE)) {
-            lpBand->offChild.cx = 4;
-            lpBand->offChild.cy = 2;
+    if (!(lpBand->fStyle & RBBS_FIXEDSIZE)) {
+        lpBand->offChild.cx = 4;
+        lpBand->offChild.cy = 2;
         }
         lpBand->lcx = lpBand->cxMinChild;
 
-        /* Set the .cy values for CHILDSIZE case */
+    /* Set the .cy values for CHILDSIZE case */
         lpBand->lcy = max(lpBand->lcy, lpBand->cyMinChild);
-        lpBand->ccy = lpBand->lcy;
+    lpBand->ccy = lpBand->lcy;
         lpBand->hcy = lpBand->lcy;
         if (lpBand->cyMaxChild != 0xffffffff) {
-            lpBand->hcy = lpBand->cyMaxChild;
-        }
-        if (lpBand->cyChild != 0xffffffff)
-            lpBand->ccy = max (lpBand->cyChild, lpBand->lcy);
+        lpBand->hcy = lpBand->cyMaxChild;
+        }
+    if (lpBand->cyChild != 0xffffffff)
+        lpBand->ccy = max (lpBand->cyChild, lpBand->lcy);
 
         TRACE("_CHILDSIZE\n");
@@ -1851 +1852 @@
 
     if (lprbbi->fMask & RBBIM_STYLE)
-        lpBand->fStyle = lprbbi->fStyle;
+    lpBand->fStyle = lprbbi->fStyle;
 
     if (lprbbi->fMask & RBBIM_COLORS) {
-        lpBand->clrFore = lprbbi->clrFore;
-        lpBand->clrBack = lprbbi->clrBack;
+    lpBand->clrFore = lprbbi->clrFore;
+    lpBand->clrBack = lprbbi->clrBack;
     }
 
     if (lprbbi->fMask & RBBIM_IMAGE)
-        lpBand->iImage = lprbbi->iImage;
+    lpBand->iImage = lprbbi->iImage;
 
     if (lprbbi->fMask & RBBIM_CHILD) {
-        if (lprbbi->hwndChild) {
-            lpBand->hwndChild = lprbbi->hwndChild;
-            lpBand->hwndPrevParent =
-                SetParent (lpBand->hwndChild, hwnd);
-            /* below in trace fro WinRAR */
-            ShowWindow(lpBand->hwndChild, SW_SHOWNOACTIVATE | SW_SHOWNORMAL);
-            /* above in trace fro WinRAR */
-        }
-        else {
-            TRACE("child: 0x%x  prev parent: 0x%x\n",
-                   lpBand->hwndChild, lpBand->hwndPrevParent);
-            lpBand->hwndChild = 0;
-            lpBand->hwndPrevParent = 0;
-        }
+    if (lprbbi->hwndChild) {
+        lpBand->hwndChild = lprbbi->hwndChild;
+        lpBand->hwndPrevParent =
+        SetParent (lpBand->hwndChild, hwnd);
+        /* below in trace fro WinRAR */
+        ShowWindow(lpBand->hwndChild, SW_SHOWNOACTIVATE | SW_SHOWNORMAL);
+        /* above in trace fro WinRAR */
+    }
+    else {
+        TRACE("child: 0x%x  prev parent: 0x%x\n",
+           lpBand->hwndChild, lpBand->hwndPrevParent);
+        lpBand->hwndChild = 0;
+        lpBand->hwndPrevParent = 0;
+    }
     }
 
     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
-        lpBand->cxMinChild = lprbbi->cxMinChild;
-        lpBand->cyMinChild = lprbbi->cyMinChild;
-        if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
-            lpBand->cyChild    = lprbbi->cyChild;
-            lpBand->cyMaxChild = lprbbi->cyMaxChild;
-            lpBand->cyIntegral = lprbbi->cyIntegral;
-        }
-        else { /* special case - these should be zeroed out since   */
-               /* RBBIM_CHILDSIZE added these in WIN32_IE >= 0x0400 */
-            lpBand->cyChild    = 0;
-            lpBand->cyMaxChild = 0;
-            lpBand->cyIntegral = 0;
-        }
+    lpBand->cxMinChild = lprbbi->cxMinChild;
+    lpBand->cyMinChild = lprbbi->cyMinChild;
+    if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
+        lpBand->cyChild    = lprbbi->cyChild;
+        lpBand->cyMaxChild = lprbbi->cyMaxChild;
+        lpBand->cyIntegral = lprbbi->cyIntegral;
+    }
+    else { /* special case - these should be zeroed out since   */
+           /* RBBIM_CHILDSIZE added these in WIN32_IE >= 0x0400 */
+        lpBand->cyChild    = 0;
+        lpBand->cyMaxChild = 0;
+        lpBand->cyIntegral = 0;
+    }
     }
 
     if (lprbbi->fMask & RBBIM_SIZE)
-        lpBand->cx = lprbbi->cx;
+    lpBand->cx = lprbbi->cx;
 
     if (lprbbi->fMask & RBBIM_BACKGROUND)
-        lpBand->hbmBack = lprbbi->hbmBack;
+    lpBand->hbmBack = lprbbi->hbmBack;
 
     if (lprbbi->fMask & RBBIM_ID)
-        lpBand->wID = lprbbi->wID;
+    lpBand->wID = lprbbi->wID;
 
     /* check for additional data */
     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
-        if (lprbbi->fMask & RBBIM_IDEALSIZE)
-            lpBand->cxIdeal = lprbbi->cxIdeal;
-
-        if (lprbbi->fMask & RBBIM_LPARAM)
-            lpBand->lParam = lprbbi->lParam;
-
-        if (lprbbi->fMask & RBBIM_HEADERSIZE)
-            lpBand->cxHeader = lprbbi->cxHeader;
+    if (lprbbi->fMask & RBBIM_IDEALSIZE)
+        lpBand->cxIdeal = lprbbi->cxIdeal;
+
+    if (lprbbi->fMask & RBBIM_LPARAM)
+        lpBand->lParam = lprbbi->lParam;
+
+    if (lprbbi->fMask & RBBIM_HEADERSIZE)
+        lpBand->cxHeader = lprbbi->cxHeader;
     }
 }
@@ -1932 +1933 @@
     for(i=0; i<infoPtr->uNumBands; i++) {
         lpBand = &infoPtr->bands[i];
-        if (HIDDENBAND(lpBand)) continue;
-
-        /* draw band separator between rows */
-        if (lpBand->iRow != oldrow) {
-            oldrow = lpBand->iRow;
-            if (lpBand->fDraw & DRAW_BOTTOMSEP) {
-                RECT rcRowSep;
-                rcRowSep = lpBand->rcBand;
-                if (infoPtr->dwStyle & CCS_VERT) {
-                    rcRowSep.right += SEP_WIDTH_SIZE;
-                    rcRowSep.bottom = infoPtr->calcSize.cy;
-                    DrawEdge (hdc, &rcRowSep, EDGE_ETCHED, BF_RIGHT);
-                }
-                else {
-                    rcRowSep.bottom += SEP_WIDTH_SIZE;
-                    rcRowSep.right = infoPtr->calcSize.cx;
-                    DrawEdge (hdc, &rcRowSep, EDGE_ETCHED, BF_BOTTOM);
-                }
-                TRACE ("drawing band separator bottom (%d,%d)-(%d,%d)\n",
-                       rcRowSep.left, rcRowSep.top,
-                       rcRowSep.right, rcRowSep.bottom);
-            }
-        }
-
-        /* draw band separator between bands in a row */
-        if (lpBand->fDraw & DRAW_RIGHTSEP) {
-            RECT rcSep;
-            rcSep = lpBand->rcBand;
-            if (infoPtr->dwStyle & CCS_VERT) {
-                rcSep.bottom += SEP_WIDTH_SIZE;
-                DrawEdge (hdc, &rcSep, EDGE_ETCHED, BF_BOTTOM);
-            }
-            else {
-                rcSep.right += SEP_WIDTH_SIZE;
-                DrawEdge (hdc, &rcSep, EDGE_ETCHED, BF_RIGHT);
-            }
-            TRACE("drawing band separator right (%d,%d)-(%d,%d)\n",
-                  rcSep.left, rcSep.top, rcSep.right, rcSep.bottom);
-        }
-
-        /* draw the actual background */
-        if (lpBand->clrBack != CLR_NONE)
-            new = lpBand->clrBack;
-        else
-            new = infoPtr->clrBtnFace;
-        rect = lpBand->rcBand;
-        old = SetBkColor (hdc, new);
-        TRACE("%s backround color=0x%06lx, band (%d,%d)-(%d,%d), clip (%d,%d)-(%d,%d)\n",
-              (lpBand->clrBack == CLR_NONE) ? "std" : "",
-              new,
-              lpBand->rcBand.left,lpBand->rcBand.top,
-              lpBand->rcBand.right,lpBand->rcBand.bottom,
-              clip->left, clip->top,
-              clip->right, clip->bottom);
-        ExtTextOutA (hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, 0);
-        SetBkColor (hdc, old);
+    if (HIDDENBAND(lpBand)) continue;
+
+    /* draw band separator between rows */
+    if (lpBand->iRow != oldrow) {
+        oldrow = lpBand->iRow;
+        if (lpBand->fDraw & DRAW_BOTTOMSEP) {
+        RECT rcRowSep;
+        rcRowSep = lpBand->rcBand;
+        if (infoPtr->dwStyle & CCS_VERT) {
+            rcRowSep.right += SEP_WIDTH_SIZE;
+            rcRowSep.bottom = infoPtr->calcSize.cy;
+            DrawEdge (hdc, &rcRowSep, EDGE_ETCHED, BF_RIGHT);
+        }
+        else {
+            rcRowSep.bottom += SEP_WIDTH_SIZE;
+            rcRowSep.right = infoPtr->calcSize.cx;
+            DrawEdge (hdc, &rcRowSep, EDGE_ETCHED, BF_BOTTOM);
+        }
+        TRACE ("drawing band separator bottom (%d,%d)-(%d,%d)\n",
+               rcRowSep.left, rcRowSep.top,
+               rcRowSep.right, rcRowSep.bottom);
+        }
+    }
+
+    /* draw band separator between bands in a row */
+    if (lpBand->fDraw & DRAW_RIGHTSEP) {
+        RECT rcSep;
+        rcSep = lpBand->rcBand;
+        if (infoPtr->dwStyle & CCS_VERT) {
+        rcSep.bottom += SEP_WIDTH_SIZE;
+        DrawEdge (hdc, &rcSep, EDGE_ETCHED, BF_BOTTOM);
+        }
+        else {
+        rcSep.right += SEP_WIDTH_SIZE;
+        DrawEdge (hdc, &rcSep, EDGE_ETCHED, BF_RIGHT);
+        }
+        TRACE("drawing band separator right (%d,%d)-(%d,%d)\n",
+          rcSep.left, rcSep.top, rcSep.right, rcSep.bottom);
+    }
+
+    /* draw the actual background */
+    if (lpBand->clrBack != CLR_NONE)
+        new = lpBand->clrBack;
+    else
+        new = infoPtr->clrBtnFace;
+    rect = lpBand->rcBand;
+    old = SetBkColor (hdc, new);
+    TRACE("%s backround color=0x%06lx, band (%d,%d)-(%d,%d), clip (%d,%d)-(%d,%d)\n",
+          (lpBand->clrBack == CLR_NONE) ? "std" : "",
+          new,
+          lpBand->rcBand.left,lpBand->rcBand.top,
+          lpBand->rcBand.right,lpBand->rcBand.bottom,
+          clip->left, clip->top,
+          clip->right, clip->bottom);
+    ExtTextOutA (hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, 0);
+    SetBkColor (hdc, old);
     }
     return TRUE;
@@ -2004 +2005 @@
     if (PtInRect (&rect, *lpPt))
     {
-        if (infoPtr->uNumBands == 0) {
-            *pFlags = RBHT_NOWHERE;
-            if (pBand)
-                *pBand = -1;
-            TRACE("NOWHERE\n");
-            return;
-        }
-        else {
-            /* somewhere inside */
-            infoPtr->ihitBand = -1;
-            for (iCount = 0; iCount < infoPtr->uNumBands; iCount++) {
-                lpBand = &infoPtr->bands[iCount];
-                if (HIDDENBAND(lpBand)) continue;
-                if (PtInRect (&lpBand->rcBand, *lpPt)) {
-                    if (pBand)
-                        *pBand = iCount;
-                    if (PtInRect (&lpBand->rcGripper, *lpPt)) {
-                        *pFlags = RBHT_GRABBER;
-                        infoPtr->ihitBand = iCount;
-                        TRACE("ON GRABBER %d\n", iCount);
-                        return;
-                    }
-                    else if (PtInRect (&lpBand->rcCapImage, *lpPt)) {
-                        *pFlags = RBHT_CAPTION;
-                        TRACE("ON CAPTION %d\n", iCount);
-                        return;
-                    }
-                    else if (PtInRect (&lpBand->rcCapText, *lpPt)) {
-                        *pFlags = RBHT_CAPTION;
-                        TRACE("ON CAPTION %d\n", iCount);
-                        return;
-                    }
-                    else if (PtInRect (&lpBand->rcChild, *lpPt)) {
-                        *pFlags = RBHT_CLIENT;
-                        TRACE("ON CLIENT %d\n", iCount);
-                        return;
-                    }
-                    else {
-                        *pFlags = RBHT_NOWHERE;
-                        TRACE("NOWHERE %d\n", iCount);
-                        return;
-                    }
-                }
-            }
-
-            *pFlags = RBHT_NOWHERE;
-            if (pBand)
-                *pBand = -1;
-
-            TRACE("NOWHERE\n");
-            return;
-        }
+    if (infoPtr->uNumBands == 0) {
+        *pFlags = RBHT_NOWHERE;
+        if (pBand)
+        *pBand = -1;
+        TRACE("NOWHERE\n");
+        return;
     }
     else {
-        *pFlags = RBHT_NOWHERE;
-        if (pBand)
-            *pBand = -1;
-        TRACE("NOWHERE\n");
-        return;
+        /* somewhere inside */
+        infoPtr->ihitBand = -1;
+        for (iCount = 0; iCount < infoPtr->uNumBands; iCount++) {
+        lpBand = &infoPtr->bands[iCount];
+        if (HIDDENBAND(lpBand)) continue;
+        if (PtInRect (&lpBand->rcBand, *lpPt)) {
+            if (pBand)
+            *pBand = iCount;
+            if (PtInRect (&lpBand->rcGripper, *lpPt)) {
+            *pFlags = RBHT_GRABBER;
+            infoPtr->ihitBand = iCount;
+            TRACE("ON GRABBER %d\n", iCount);
+            return;
+            }
+            else if (PtInRect (&lpBand->rcCapImage, *lpPt)) {
+            *pFlags = RBHT_CAPTION;
+            TRACE("ON CAPTION %d\n", iCount);
+            return;
+            }
+            else if (PtInRect (&lpBand->rcCapText, *lpPt)) {
+            *pFlags = RBHT_CAPTION;
+            TRACE("ON CAPTION %d\n", iCount);
+            return;
+            }
+            else if (PtInRect (&lpBand->rcChild, *lpPt)) {
+            *pFlags = RBHT_CLIENT;
+            TRACE("ON CLIENT %d\n", iCount);
+            return;
+            }
+            else {
+            *pFlags = RBHT_NOWHERE;
+            TRACE("NOWHERE %d\n", iCount);
+            return;
+            }
+        }
+        }
+
+        *pFlags = RBHT_NOWHERE;
+        if (pBand)
+        *pBand = -1;
+
+        TRACE("NOWHERE\n");
+        return;
+    }
+    }
+    else {
+    *pFlags = RBHT_NOWHERE;
+    if (pBand)
+        *pBand = -1;
+    TRACE("NOWHERE\n");
+    return;
     }
 
@@ -2091 +2092 @@
         /* if this band is not shrinkable, then just move it */
         Leadjust = Readjust = movement;
-        ret = movement;
+    ret = movement;
     }
     else {
         if (movement < 0) {
-            /* Drag to left */
-            if (avail <= abs(movement)) {
-                Readjust = movement;
-                Leadjust = movement + avail;
-                ret = Leadjust;
-            }
-            else {
-                Readjust = movement;
-                Leadjust = 0;
-                ret = 0;
-            }
-        }
-        else {
-            /* Drag to right */
-            if (avail <= abs(movement)) {
-                Leadjust = movement;
-                Readjust = movement - avail;
-                ret = Readjust;
-            }
-            else {
-                Leadjust = movement;
-                Readjust = 0;
-                ret = 0;
-            }
-        }
+        /* Drag to left */
+        if (avail <= abs(movement)) {
+            Readjust = movement;
+        Leadjust = movement + avail;
+        ret = Leadjust;
+        }
+        else {
+            Readjust = movement;
+        Leadjust = 0;
+        ret = 0;
+        }
+    }
+    else {
+        /* Drag to right */
+        if (avail <= abs(movement)) {
+            Leadjust = movement;
+        Readjust = movement - avail;
+        ret = Readjust;
+        }
+        else {
+            Leadjust = movement;
+        Readjust = 0;
+        ret = 0;
+        }
+    }
     }
 
@@ -2125 +2126 @@
     if (rcBlt(band) + Leadjust < 0) {
         ERR("adjustment will fail, band %d: left=%d, right=%d, move=%d, rtn=%d\n",
-            i, Leadjust, Readjust, movement, ret);
+        i, Leadjust, Readjust, movement, ret);
     }
 
@@ -2132 +2133 @@
 
     TRACE("band %d:  left=%d, right=%d, move=%d, rtn=%d, rcBand=(%d,%d)-(%d,%d)\n",
-          i, Leadjust, Readjust, movement, ret,
-          band->rcBand.left, band->rcBand.top,
-          band->rcBand.right, band->rcBand.bottom);
+      i, Leadjust, Readjust, movement, ret,
+      band->rcBand.left, band->rcBand.top,
+      band->rcBand.right, band->rcBand.bottom);
     return ret;
 }
@@ -2157 +2158 @@
 
     if (!(infoPtr->fStatus & BEGIN_DRAG_ISSUED)) {
-        if (REBAR_Notify_NMREBAR (infoPtr, -1, RBN_BEGINDRAG)) {
-            /* Notify returned TRUE - abort drag */
-            infoPtr->dragStart.x = 0;
-            infoPtr->dragStart.y = 0;
-            infoPtr->dragNow = infoPtr->dragStart;
-            infoPtr->ihitBand = -1;
-            ReleaseCapture ();
-            return ;
-        }
-        infoPtr->fStatus |= BEGIN_DRAG_ISSUED;
+    if (REBAR_Notify_NMREBAR (infoPtr, -1, RBN_BEGINDRAG)) {
+        /* Notify returned TRUE - abort drag */
+        infoPtr->dragStart.x = 0;
+        infoPtr->dragStart.y = 0;
+        infoPtr->dragNow = infoPtr->dragStart;
+        infoPtr->ihitBand = -1;
+        ReleaseCapture ();
+        return ;
+    }
+    infoPtr->fStatus |= BEGIN_DRAG_ISSUED;
     }
 
@@ -2176 +2177 @@
     for (i=0; i<infoPtr->uNumBands; i++) {
         band = &infoPtr->bands[i];
-        if (HIDDENBAND(band)) continue;
-        if (band->iRow == hitBand->iRow) {
-            imaxdBand = i;
-            if (imindBand == -1) imindBand = i;
-            /* minimum size of each band is size of header plus            */
-            /* size of minimum child plus offset of child from header plus */
-            /* a one to separate each band.                                */
-            if (i < ihitBand)
-                LHeaderSum += (band->lcx + SEP_WIDTH);
-            else 
-                RHeaderSum += (band->lcx + SEP_WIDTH);
-
-        }
+    if (HIDDENBAND(band)) continue;
+    if (band->iRow == hitBand->iRow) {
+        imaxdBand = i;
+        if (imindBand == -1) imindBand = i;
+        /* minimum size of each band is size of header plus            */
+        /* size of minimum child plus offset of child from header plus */
+        /* a one to separate each band.                                */
+        if (i < ihitBand)
+            LHeaderSum += (band->lcx + SEP_WIDTH);
+        else
+            RHeaderSum += (band->lcx + SEP_WIDTH);
+
+    }
     }
     if (RHeaderSum) RHeaderSum -= SEP_WIDTH; /* no separator afterlast band */
@@ -2200 +2201 @@
     /* limit movement to inside adjustable bands - Left */
     if ( (ptsmove->x < mindBand->rcBand.left) ||
-         (ptsmove->x > maxdBand->rcBand.right) ||
-         (ptsmove->y < mindBand->rcBand.top) ||
-         (ptsmove->y > maxdBand->rcBand.bottom))
+     (ptsmove->x > maxdBand->rcBand.right) ||
+     (ptsmove->y < mindBand->rcBand.top) ||
+     (ptsmove->y > maxdBand->rcBand.bottom))
         return; /* should swap bands */
 
     if (infoPtr->dwStyle & CCS_VERT)
         movement = ptsmove->y - ((hitBand->rcBand.top+REBAR_PRE_GRIPPER) -
-                             infoPtr->ihitoffset);
+                 infoPtr->ihitoffset);
     else
         movement = ptsmove->x - ((hitBand->rcBand.left+REBAR_PRE_GRIPPER) -
-                             infoPtr->ihitoffset);
+                 infoPtr->ihitoffset);
     infoPtr->dragNow = *ptsmove;
 
     TRACE("before: movement=%d (%d,%d), imindBand=%d, ihitBand=%d, imaxdBand=%d, LSum=%d, RSum=%d\n",
-          movement, ptsmove->x, ptsmove->y, imindBand, ihitBand,
-          imaxdBand, LHeaderSum, RHeaderSum);
+      movement, ptsmove->x, ptsmove->y, imindBand, ihitBand,
+      imaxdBand, LHeaderSum, RHeaderSum);
     REBAR_DumpBand (infoPtr);
 
-    if (movement < 0) {  
+    if (movement < 0) {
 
         /* ***  Drag left/up *** */
         compress = rcBlt(hitBand) - rcBlt(mindBand) -
-                   LHeaderSum;
-        if (compress < abs(movement)) {
-            TRACE("limiting left drag, was %d changed to %d\n",
-                  movement, -compress);
-            movement = -compress;
-        }
+               LHeaderSum;
+    if (compress < abs(movement)) {
+        TRACE("limiting left drag, was %d changed to %d\n",
+          movement, -compress);
+        movement = -compress;
+    }
 
         for (i=ihitBand; i>=imindBand; i--) {
-            band = &infoPtr->bands[i];
-            if (HIDDENBAND(band)) continue;
-            if (i == ihitBand) {
-                LEADJ(band, movement)
-            }
-            else 
-                movement = REBAR_Shrink (infoPtr, band, movement, i);
-            band->ccx = rcBw(band);
-        }
+        band = &infoPtr->bands[i];
+        if (HIDDENBAND(band)) continue;
+        if (i == ihitBand) {
+        LEADJ(band, movement)
+        }
+        else
+            movement = REBAR_Shrink (infoPtr, band, movement, i);
+        band->ccx = rcBw(band);
+    }
     }
     else {
-        BOOL first = TRUE;
+    BOOL first = TRUE;
 
         /* ***  Drag right/down *** */
         compress = rcBrb(maxdBand) - rcBlt(hitBand) -
-                   RHeaderSum;
-        if (compress < abs(movement)) {
-            TRACE("limiting right drag, was %d changed to %d\n",
-                  movement, compress);
-            movement = compress;
-        }
+               RHeaderSum;
+    if (compress < abs(movement)) {
+        TRACE("limiting right drag, was %d changed to %d\n",
+          movement, compress);
+        movement = compress;
+    }
         for (i=ihitBand-1; i<=imaxdBand; i++) {
-            band = &infoPtr->bands[i];
-            if (HIDDENBAND(band)) continue;
-            if (first) {
-                first = FALSE;
-                READJ(band, movement)
-            }
-            else 
-                movement = REBAR_Shrink (infoPtr, band, movement, i);
-            band->ccx = rcBw(band);
-        }
+        band = &infoPtr->bands[i];
+        if (HIDDENBAND(band)) continue;
+        if (first) {
+        first = FALSE;
+        READJ(band, movement)
+        }
+        else
+            movement = REBAR_Shrink (infoPtr, band, movement, i);
+        band->ccx = rcBw(band);
+    }
     }
 
     /* recompute all rectangles */
     if (infoPtr->dwStyle & CCS_VERT) {
-        REBAR_CalcVertBand (infoPtr, imindBand, imaxdBand+1,
-                            FALSE);
+    REBAR_CalcVertBand (infoPtr, imindBand, imaxdBand+1,
+                FALSE);
     }
     else {
-        REBAR_CalcHorzBand (infoPtr, imindBand, imaxdBand+1, 
-                            FALSE);
+    REBAR_CalcHorzBand (infoPtr, imindBand, imaxdBand+1,
+                FALSE);
     }
 
     TRACE("bands after adjustment, see band # %d, %d\n",
-          imindBand, imaxdBand);
+      imindBand, imaxdBand);
     REBAR_DumpBand (infoPtr);
 
-    SetRect (&newrect, 
-             mindBand->rcBand.left,
-             mindBand->rcBand.top,
-             maxdBand->rcBand.right,
-             maxdBand->rcBand.bottom);
+    SetRect (&newrect,
+         mindBand->rcBand.left,
+         mindBand->rcBand.top,
+         maxdBand->rcBand.right,
+         maxdBand->rcBand.bottom);
 
     REBAR_MoveChildWindows (infoPtr, imindBand, imaxdBand+1);
@@ -2304 +2305 @@
 
     if (uBand >= infoPtr->uNumBands)
-        return FALSE;
+    return FALSE;
 
     TRACE("deleting band %u!\n", uBand);
@@ -2311 +2312 @@
 
     if (infoPtr->uNumBands == 1) {
-        TRACE(" simple delete!\n");
-        if ((lpBand->fMask & RBBIM_CHILD) && lpBand->hwndChild)
-            childhwnd = lpBand->hwndChild;
-        COMCTL32_Free (infoPtr->bands);
-        infoPtr->bands = NULL;
-        infoPtr->uNumBands = 0;
+    TRACE(" simple delete!\n");
+    if ((lpBand->fMask & RBBIM_CHILD) && lpBand->hwndChild)
+        childhwnd = lpBand->hwndChild;
+    COMCTL32_Free (infoPtr->bands);
+    infoPtr->bands = NULL;
+    infoPtr->uNumBands = 0;
     }
     else {
-        REBAR_BAND *oldBands = infoPtr->bands;
+    REBAR_BAND *oldBands = infoPtr->bands;
         TRACE("complex delete! [uBand=%u]\n", uBand);
 
-        if ((lpBand->fMask & RBBIM_CHILD) && lpBand->hwndChild)
-            childhwnd = lpBand->hwndChild;
-
-        infoPtr->uNumBands--;
-        infoPtr->bands = COMCTL32_Alloc (sizeof (REBAR_BAND) * infoPtr->uNumBands);
+    if ((lpBand->fMask & RBBIM_CHILD) && lpBand->hwndChild)
+        childhwnd = lpBand->hwndChild;
+
+    infoPtr->uNumBands--;
+    infoPtr->bands = COMCTL32_Alloc (sizeof (REBAR_BAND) * infoPtr->uNumBands);
         if (uBand > 0) {
             memcpy (&infoPtr->bands[0], &oldBands[0],
@@ -2337 +2338 @@
         }
 
-        COMCTL32_Free (oldBands);
+    COMCTL32_Free (oldBands);
     }
 
@@ -2369 +2370 @@
 
     if (!lParam)
-        return 0;
+    return 0;
     if ((UINT)wParam >= infoPtr->uNumBands)
-        return 0;
+    return 0;
 
     lpBand = &infoPtr->bands[(UINT)wParam];
@@ -2381 +2382 @@
     /* style.  -  GA                                                   */
     if (infoPtr->dwStyle & RBS_BANDBORDERS) {
-        if (infoPtr->dwStyle & CCS_VERT) {
-            lpRect->left = 1;
-            lpRect->top = lpBand->cxHeader + 4;
-            lpRect->right = 1;
-            lpRect->bottom = 0;
-        }
-        else {
-            lpRect->left = lpBand->cxHeader + 4;
-            lpRect->top = 1;
-            lpRect->right = 0;
-            lpRect->bottom = 1;
-        }
+    if (infoPtr->dwStyle & CCS_VERT) {
+        lpRect->left = 1;
+        lpRect->top = lpBand->cxHeader + 4;
+        lpRect->right = 1;
+        lpRect->bottom = 0;
     }
     else {
-        lpRect->left = lpBand->cxHeader;
+        lpRect->left = lpBand->cxHeader + 4;
+        lpRect->top = 1;
+        lpRect->right = 0;
+        lpRect->bottom = 1;
+    }
+    }
+    else {
+    lpRect->left = lpBand->cxHeader;
     }
     return 0;
@@ -2417 +2418 @@
 
     if (lprbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
-        return FALSE;
+    return FALSE;
     if ((UINT)wParam >= infoPtr->uNumBands)
-        return FALSE;
+    return FALSE;
 
     TRACE("index %u\n", (UINT)wParam);
@@ -2429 +2430 @@
 
     if (lprbbi->fMask & RBBIM_STYLE)
-        lprbbi->fStyle = lpBand->fStyle;
+    lprbbi->fStyle = lpBand->fStyle;
 
     if (lprbbi->fMask & RBBIM_COLORS) {
-        lprbbi->clrFore = lpBand->clrFore;
-        lprbbi->clrBack = lpBand->clrBack;
-        if (lprbbi->clrBack == CLR_NONE)
-            lprbbi->clrBack = infoPtr->clrBtnFace;
+    lprbbi->clrFore = lpBand->clrFore;
+    lprbbi->clrBack = lpBand->clrBack;
+    if (lprbbi->clrBack == CLR_NONE)
+        lprbbi->clrBack = infoPtr->clrBtnFace;
     }
 
@@ -2445 +2446 @@
               lprbbi->lpText[lprbbi->cch-1] = 0;
       }
-      else 
-        *lprbbi->lpText = 0;
+      else
+    *lprbbi->lpText = 0;
     }
 
     if (lprbbi->fMask & RBBIM_IMAGE) {
       if (lpBand->fMask & RBBIM_IMAGE)
-        lprbbi->iImage = lpBand->iImage;
+    lprbbi->iImage = lpBand->iImage;
       else
-        lprbbi->iImage = -1;
+    lprbbi->iImage = -1;
     }
 
     if (lprbbi->fMask & RBBIM_CHILD)
-        lprbbi->hwndChild = lpBand->hwndChild;
+    lprbbi->hwndChild = lpBand->hwndChild;
 
     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
-        lprbbi->cxMinChild = lpBand->cxMinChild;
-        lprbbi->cyMinChild = lpBand->cyMinChild;
-        if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
-            lprbbi->cyChild    = lpBand->cyChild;
-            lprbbi->cyMaxChild = lpBand->cyMaxChild;
-            lprbbi->cyIntegral = lpBand->cyIntegral;
-        }
+    lprbbi->cxMinChild = lpBand->cxMinChild;
+    lprbbi->cyMinChild = lpBand->cyMinChild;
+    if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
+        lprbbi->cyChild    = lpBand->cyChild;
+        lprbbi->cyMaxChild = lpBand->cyMaxChild;
+        lprbbi->cyIntegral = lpBand->cyIntegral;
+    }
     }
 
     if (lprbbi->fMask & RBBIM_SIZE)
-        lprbbi->cx = lpBand->cx;
+    lprbbi->cx = lpBand->cx;
 
     if (lprbbi->fMask & RBBIM_BACKGROUND)
-        lprbbi->hbmBack = lpBand->hbmBack;
+    lprbbi->hbmBack = lpBand->hbmBack;
 
     if (lprbbi->fMask & RBBIM_ID)
-        lprbbi->wID = lpBand->wID;
+    lprbbi->wID = lpBand->wID;
 
     /* check for additional data */
     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
-        if (lprbbi->fMask & RBBIM_IDEALSIZE)
-            lprbbi->cxIdeal = lpBand->cxIdeal;
-
-        if (lprbbi->fMask & RBBIM_LPARAM)
-            lprbbi->lParam = lpBand->lParam;
-
-        if (lprbbi->fMask & RBBIM_HEADERSIZE)
-            lprbbi->cxHeader = lpBand->cxHeader;
+    if (lprbbi->fMask & RBBIM_IDEALSIZE)
+        lprbbi->cxIdeal = lpBand->cxIdeal;
+
+    if (lprbbi->fMask & RBBIM_LPARAM)
+        lprbbi->lParam = lpBand->lParam;
+
+    if (lprbbi->fMask & RBBIM_HEADERSIZE)
+        lprbbi->cxHeader = lpBand->cxHeader;
     }
 
@@ -2503 +2504 @@
 
     if (lprbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
-        return FALSE;
+    return FALSE;
     if ((UINT)wParam >= infoPtr->uNumBands)
-        return FALSE;
+    return FALSE;
 
     TRACE("index %u\n", (UINT)wParam);
@@ -2515 +2516 @@
 
     if (lprbbi->fMask & RBBIM_STYLE)
-        lprbbi->fStyle = lpBand->fStyle;
+    lprbbi->fStyle = lpBand->fStyle;
 
     if (lprbbi->fMask & RBBIM_COLORS) {
-        lprbbi->clrFore = lpBand->clrFore;
-        lprbbi->clrBack = lpBand->clrBack;
-        if (lprbbi->clrBack == CLR_NONE)
-            lprbbi->clrBack = infoPtr->clrBtnFace;
+    lprbbi->clrFore = lpBand->clrFore;
+    lprbbi->clrBack = lpBand->clrBack;
+    if (lprbbi->clrBack == CLR_NONE)
+        lprbbi->clrBack = infoPtr->clrBtnFace;
     }
 
     if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) {
       if (lpBand->lpText && (lpBand->fMask & RBBIM_TEXT))
-        lstrcpynW (lprbbi->lpText, lpBand->lpText, lprbbi->cch);
-      else 
-        *lprbbi->lpText = 0;
+    lstrcpynW (lprbbi->lpText, lpBand->lpText, lprbbi->cch);
+      else
+    *lprbbi->lpText = 0;
     }
 
     if (lprbbi->fMask & RBBIM_IMAGE) {
       if (lpBand->fMask & RBBIM_IMAGE)
-        lprbbi->iImage = lpBand->iImage;
+    lprbbi->iImage = lpBand->iImage;
       else
-        lprbbi->iImage = -1;
+    lprbbi->iImage = -1;
     }
 
     if (lprbbi->fMask & RBBIM_CHILD)
-        lprbbi->hwndChild = lpBand->hwndChild;
+    lprbbi->hwndChild = lpBand->hwndChild;
 
     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
-        lprbbi->cxMinChild = lpBand->cxMinChild;
-        lprbbi->cyMinChild = lpBand->cyMinChild;
-        if (lprbbi->cbSize >= sizeof (REBARBANDINFOW)) {
-            lprbbi->cyChild    = lpBand->cyChild;
-            lprbbi->cyMaxChild = lpBand->cyMaxChild;
-            lprbbi->cyIntegral = lpBand->cyIntegral;
-        }
+    lprbbi->cxMinChild = lpBand->cxMinChild;
+    lprbbi->cyMinChild = lpBand->cyMinChild;
+    if (lprbbi->cbSize >= sizeof (REBARBANDINFOW)) {
+        lprbbi->cyChild    = lpBand->cyChild;
+        lprbbi->cyMaxChild = lpBand->cyMaxChild;
+        lprbbi->cyIntegral = lpBand->cyIntegral;
+    }
     }
 
     if (lprbbi->fMask & RBBIM_SIZE)
-        lprbbi->cx = lpBand->cx;
+    lprbbi->cx = lpBand->cx;
 
     if (lprbbi->fMask & RBBIM_BACKGROUND)
-        lprbbi->hbmBack = lpBand->hbmBack;
+    lprbbi->hbmBack = lpBand->hbmBack;
 
     if (lprbbi->fMask & RBBIM_ID)
-        lprbbi->wID = lpBand->wID;
+    lprbbi->wID = lpBand->wID;
 
     /* check for additional data */
     if (lprbbi->cbSize >= sizeof (REBARBANDINFOW)) {
-        if (lprbbi->fMask & RBBIM_IDEALSIZE)
-            lprbbi->cxIdeal = lpBand->cxIdeal;
-
-        if (lprbbi->fMask & RBBIM_LPARAM)
-            lprbbi->lParam = lpBand->lParam;
-
-        if (lprbbi->fMask & RBBIM_HEADERSIZE)
-            lprbbi->cxHeader = lpBand->cxHeader;
+    if (lprbbi->fMask & RBBIM_IDEALSIZE)
+        lprbbi->cxIdeal = lpBand->cxIdeal;
+
+    if (lprbbi->fMask & RBBIM_LPARAM)
+        lprbbi->lParam = lpBand->lParam;
+
+    if (lprbbi->fMask & RBBIM_HEADERSIZE)
+        lprbbi->cxHeader = lpBand->cxHeader;
     }
 
@@ -2597 +2598 @@
 
     if (lpInfo == NULL)
-        return FALSE;
+    return FALSE;
 
     if (lpInfo->cbSize < sizeof (REBARINFO))
-        return FALSE;
+    return FALSE;
 
     TRACE("getting bar info!\n");
 
     if (infoPtr->himl) {
-        lpInfo->himl = infoPtr->himl;
-        lpInfo->fMask |= RBIM_IMAGELIST;
+    lpInfo->himl = infoPtr->himl;
+    lpInfo->fMask |= RBIM_IMAGELIST;
     }
 
@@ -2648 +2649 @@
 
     if ((iBand < 0) && ((UINT)iBand >= infoPtr->uNumBands))
-        return FALSE;
+    return FALSE;
     if (!lprc)
-        return FALSE;
+    return FALSE;
 
     lpBand = &infoPtr->bands[iBand];
@@ -2656 +2657 @@
 
     TRACE("band %d, (%d,%d)-(%d,%d)\n", iBand,
-          lprc->left, lprc->top, lprc->right, lprc->bottom);
+      lprc->left, lprc->top, lprc->right, lprc->bottom);
 
     return TRUE;
@@ -2680 +2681 @@
 
     for (i=0; i<infoPtr->uNumBands; i++) {
-        lpBand = &infoPtr->bands[i];
-        if (HIDDENBAND(lpBand)) continue;
-        if (lpBand->iRow != iRow) continue;
-        if (infoPtr->dwStyle & CCS_VERT)
-            j = lpBand->rcBand.right - lpBand->rcBand.left;
-        else
-            j = lpBand->rcBand.bottom - lpBand->rcBand.top;
-        if (j > ret) ret = j;
+    lpBand = &infoPtr->bands[i];
+    if (HIDDENBAND(lpBand)) continue;
+    if (lpBand->iRow != iRow) continue;
+    if (infoPtr->dwStyle & CCS_VERT)
+        j = lpBand->rcBand.right - lpBand->rcBand.left;
+    else
+        j = lpBand->rcBand.bottom - lpBand->rcBand.top;
+    if (j > ret) ret = j;
     }
 
@@ -2715 +2716 @@
 REBAR_GetUnicodeFormat (REBAR_INFO *infoPtr)
 {
-    TRACE("%s hwnd=0x%x\n", 
-          infoPtr->bUnicode ? "TRUE" : "FALSE", infoPtr->hwndSelf);
+    TRACE("%s hwnd=0x%x\n",
+      infoPtr->bUnicode ? "TRUE" : "FALSE", infoPtr->hwndSelf);
 
     return infoPtr->bUnicode;
@@ -2733 +2734 @@
 REBAR_HitTest (REBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 {
-    LPRBHITTESTINFO lprbht = (LPRBHITTESTINFO)lParam; 
+    LPRBHITTESTINFO lprbht = (LPRBHITTESTINFO)lParam;
 
     if (!lprbht)
-        return -1;
+    return -1;
 
     REBAR_InternalHitTest (infoPtr, &lprbht->pt, &lprbht->flags, &lprbht->iBand);
@@ -2750 +2751 @@
 
     if (infoPtr == NULL)
-        return -1;
+    return -1;
 
     if (infoPtr->uNumBands < 1)
-        return -1;
+    return -1;
 
     for (i = 0; i < infoPtr->uNumBands; i++) {
-        if (infoPtr->bands[i].wID == (UINT)wParam) {
-            TRACE("id %u is band %u found!\n", (UINT)wParam, i);
-            return i;
-        }
+    if (infoPtr->bands[i].wID == (UINT)wParam) {
+        TRACE("id %u is band %u found!\n", (UINT)wParam, i);
+        return i;
+    }
     }
 
@@ -2775 +2776 @@
 
     if (infoPtr == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
-        return FALSE;
+    return FALSE;
 
     /* trace the index as signed to see the -1 */
@@ -2786 +2787 @@
 
     if (infoPtr->uNumBands == 0) {
-        infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
-        uIndex = 0;
+    infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
+    uIndex = 0;
     }
     else {
-        REBAR_BAND *oldBands = infoPtr->bands;
-        infoPtr->bands =
-            (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
-        if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
-            uIndex = infoPtr->uNumBands;
-
-        /* pre insert copy */
-        if (uIndex > 0) {
-            memcpy (&infoPtr->bands[0], &oldBands[0],
-                    uIndex * sizeof(REBAR_BAND));
-        }
-
-        /* post copy */
-        if (uIndex < infoPtr->uNumBands - 1) {
-            memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
-                    (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
-        }
-
-        COMCTL32_Free (oldBands);
+    REBAR_BAND *oldBands = infoPtr->bands;
+    infoPtr->bands =
+        (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
+    if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
+        uIndex = infoPtr->uNumBands;
+
+    /* pre insert copy */
+    if (uIndex > 0) {
+        memcpy (&infoPtr->bands[0], &oldBands[0],
+            uIndex * sizeof(REBAR_BAND));
+    }
+
+    /* post copy */
+    if (uIndex < infoPtr->uNumBands - 1) {
+        memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
+            (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
+    }
+
+    COMCTL32_Free (oldBands);
     }
 
@@ -2831 +2832 @@
             lpBand->lpText = (LPWSTR)COMCTL32_Alloc (len*sizeof(WCHAR));
             MultiByteToWideChar( CP_ACP, 0, lprbbi->lpText, -1, lpBand->lpText, len );
-        }
+    }
     }
 
@@ -2837 +2838 @@
     /* On insert of second band, revalidate band 1 to possible add gripper */
     if (infoPtr->uNumBands == 2)
-        REBAR_ValidateBand (infoPtr, &infoPtr->bands[0]);
+    REBAR_ValidateBand (infoPtr, &infoPtr->bands[0]);
 
     REBAR_DumpBand (infoPtr);
@@ -2855 +2856 @@
 
     if (infoPtr == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
-        return FALSE;
+    return FALSE;
 
     /* trace the index as signed to see the -1 */
@@ -2866 +2867 @@
 
     if (infoPtr->uNumBands == 0) {
-        infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
-        uIndex = 0;
+    infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
+    uIndex = 0;
     }
     else {
-        REBAR_BAND *oldBands = infoPtr->bands;
-        infoPtr->bands =
-            (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
-        if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
-            uIndex = infoPtr->uNumBands;
-
-        /* pre insert copy */
-        if (uIndex > 0) {
-            memcpy (&infoPtr->bands[0], &oldBands[0],
-                    uIndex * sizeof(REBAR_BAND));
-        }
-
-        /* post copy */
-        if (uIndex < infoPtr->uNumBands - 1) {
-            memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
-                    (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
-        }
-
-        COMCTL32_Free (oldBands);
+    REBAR_BAND *oldBands = infoPtr->bands;
+    infoPtr->bands =
+        (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
+    if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
+        uIndex = infoPtr->uNumBands;
+
+    /* pre insert copy */
+    if (uIndex > 0) {
+        memcpy (&infoPtr->bands[0], &oldBands[0],
+            uIndex * sizeof(REBAR_BAND));
+    }
+
+    /* post copy */
+    if (uIndex < infoPtr->uNumBands - 1) {
+        memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
+            (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
+    }
+
+    COMCTL32_Free (oldBands);
     }
 
@@ -2907 +2908 @@
     lpBand->lpText = NULL;
     if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) {
-        INT len = lstrlenW (lprbbi->lpText);
-        if (len > 0) {
-            lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            strcpyW (lpBand->lpText, lprbbi->lpText);
-        }
+    INT len = lstrlenW (lprbbi->lpText);
+    if (len > 0) {
+        lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
+        strcpyW (lpBand->lpText, lprbbi->lpText);
+    }
     }
 
@@ -2917 +2918 @@
     /* On insert of second band, revalidate band 1 to possible add gripper */
     if (infoPtr->uNumBands == 2)
-        REBAR_ValidateBand (infoPtr, &infoPtr->bands[0]);
+    REBAR_ValidateBand (infoPtr, &infoPtr->bands[0]);
 
     REBAR_DumpBand (infoPtr);
@@ -2931 +2932 @@
 {
     FIXME("(uBand = %u fIdeal = %s) stub\n",
-           (UINT)wParam, lParam ? "TRUE" : "FALSE");
+       (UINT)wParam, lParam ? "TRUE" : "FALSE");
 
     return 0;
@@ -2954 +2955 @@
     /* Validate */
     if ((infoPtr->uNumBands == 0) ||
-        ((INT)uBand < 0) || (uBand >= infoPtr->uNumBands)) {
-        /* error !!! */
-        ERR("Illegal MinimizeBand, requested=%d, current band count=%d\n",
-              (INT)uBand, infoPtr->uNumBands);
-        return FALSE;
+    ((INT)uBand < 0) || (uBand >= infoPtr->uNumBands)) {
+    /* error !!! */
+    ERR("Illegal MinimizeBand, requested=%d, current band count=%d\n",
+          (INT)uBand, infoPtr->uNumBands);
+        return FALSE;
     }
 
@@ -2965 +2966 @@
 
     if (infoPtr->dwStyle & CCS_VERT)
-        movement = lpBand->rcBand.bottom - lpBand->rcBand.top -
-            lpBand->cxHeader;
+    movement = lpBand->rcBand.bottom - lpBand->rcBand.top -
+        lpBand->cxHeader;
     else
-        movement = lpBand->rcBand.right - lpBand->rcBand.left -
-            lpBand->cxHeader;
+    movement = lpBand->rcBand.right - lpBand->rcBand.left -
+        lpBand->cxHeader;
     if (movement < 0) {
-        ERR("something is wrong, band=(%d,%d)-(%d,%d), cxheader=%d\n",
-            lpBand->rcBand.left, lpBand->rcBand.top,
-            lpBand->rcBand.right, lpBand->rcBand.bottom,
-            lpBand->cxHeader);
-        return FALSE;
+    ERR("something is wrong, band=(%d,%d)-(%d,%d), cxheader=%d\n",
+        lpBand->rcBand.left, lpBand->rcBand.top,
+        lpBand->rcBand.right, lpBand->rcBand.bottom,
+        lpBand->cxHeader);
+    return FALSE;
     }
 
@@ -2985 +2986 @@
     for (i=0; i<infoPtr->uNumBands; i++) {
         band = &infoPtr->bands[i];
-        if (HIDDENBAND(band)) continue;
-        if (band->iRow == lpBand->iRow) {
-            imaxdBand = i;
-            if (imindBand == -1) imindBand = i;
-        }
+    if (HIDDENBAND(band)) continue;
+    if (band->iRow == lpBand->iRow) {
+        imaxdBand = i;
+        if (imindBand == -1) imindBand = i;
+    }
     }
 
@@ -2995 +2996 @@
     /* next visible band                                        */
     if (imindBand == uBand) {
-        band = NULL;
-        movement = -movement;
-        /* find the first visible band to the right of the selected band */
-        for (i=uBand+1; i<=imaxdBand; i++) {
-            band = &infoPtr->bands[i];
-            if (!HIDDENBAND(band)) {
-                iprevBand = i;
-                LEADJ(band, movement);
-                band->ccx = rcBw(band);
-                break;
-            }
-        }
-        /* what case is this */
-        if (iprevBand == -1) {
-            ERR("no previous visible band\n");
-            return FALSE;
-        }
-        startBand = uBand;
-        endBand = iprevBand;
-        SetRect (&newrect, 
-                 lpBand->rcBand.left,
-                 lpBand->rcBand.top,
-                 band->rcBand.right,
-                 band->rcBand.bottom);
+    band = NULL;
+    movement = -movement;
+    /* find the first visible band to the right of the selected band */
+    for (i=uBand+1; i<=imaxdBand; i++) {
+        band = &infoPtr->bands[i];
+        if (!HIDDENBAND(band)) {
+        iprevBand = i;
+        LEADJ(band, movement);
+        band->ccx = rcBw(band);
+        break;
+        }
+    }
+    /* what case is this */
+    if (iprevBand == -1) {
+        ERR("no previous visible band\n");
+        return FALSE;
+    }
+    startBand = uBand;
+    endBand = iprevBand;
+    SetRect (&newrect,
+         lpBand->rcBand.left,
+         lpBand->rcBand.top,
+         band->rcBand.right,
+         band->rcBand.bottom);
     }
     /* otherwise expand previous visible band                   */
     else {
-        band = NULL;
-        /* find the first visible band to the left of the selected band */
-        for (i=uBand-1; i>=imindBand; i--) {
-            band = &infoPtr->bands[i];
-            if (!HIDDENBAND(band)) {
-                iprevBand = i;
-                READJ(band, movement);
-                band->ccx = rcBw(band);
-                break;
-            }
-        }
-        /* what case is this */
-        if (iprevBand == -1) {
-            ERR("no previous visible band\n");
-            return FALSE;
-        }
-        startBand = iprevBand;
-        endBand = uBand;
-        SetRect (&newrect, 
-                 band->rcBand.left,
-                 band->rcBand.top,
-                 lpBand->rcBand.right,
-                 lpBand->rcBand.bottom);
+    band = NULL;
+    /* find the first visible band to the left of the selected band */
+    for (i=uBand-1; i>=imindBand; i--) {
+        band = &infoPtr->bands[i];
+        if (!HIDDENBAND(band)) {
+        iprevBand = i;
+        READJ(band, movement);
+        band->ccx = rcBw(band);
+        break;
+        }
+    }
+    /* what case is this */
+    if (iprevBand == -1) {
+        ERR("no previous visible band\n");
+        return FALSE;
+    }
+    startBand = iprevBand;
+    endBand = uBand;
+    SetRect (&newrect,
+         band->rcBand.left,
+         band->rcBand.top,
+         lpBand->rcBand.right,
+         lpBand->rcBand.bottom);
     }
 
@@ -3051 +3052 @@
     /* recompute all rectangles */
     if (infoPtr->dwStyle & CCS_VERT) {
-        REBAR_CalcVertBand (infoPtr, startBand, endBand+1,
-                            FALSE);
+    REBAR_CalcVertBand (infoPtr, startBand, endBand+1,
+                FALSE);
     }
     else {
-        REBAR_CalcHorzBand (infoPtr, startBand, endBand+1, 
-                            FALSE);
+    REBAR_CalcHorzBand (infoPtr, startBand, endBand+1,
+                FALSE);
     }
 
     TRACE("bands after minimize, see band # %d, %d\n",
-          startBand, endBand);
+      startBand, endBand);
     REBAR_DumpBand (infoPtr);
 
@@ -3081 +3082 @@
     /* Validate */
     if ((infoPtr->uNumBands == 0) ||
-        ((INT)uFrom < 0) || (uFrom >= infoPtr->uNumBands) ||
-        ((INT)uTo < 0)   || (uTo >= infoPtr->uNumBands)) {
-        /* error !!! */
-        ERR("Illegal MoveBand, from=%d, to=%d, current band count=%d\n",
-              (INT)uFrom, (INT)uTo, infoPtr->uNumBands);
-        return FALSE;
+    ((INT)uFrom < 0) || (uFrom >= infoPtr->uNumBands) ||
+    ((INT)uTo < 0)   || (uTo >= infoPtr->uNumBands)) {
+    /* error !!! */
+    ERR("Illegal MoveBand, from=%d, to=%d, current band count=%d\n",
+          (INT)uFrom, (INT)uTo, infoPtr->uNumBands);
+        return FALSE;
     }
 
@@ -3094 +3095 @@
     /* close up rest of bands (psuedo delete) */
     if (uFrom < infoPtr->uNumBands - 1) {
-        memcpy (&oldBands[uFrom], &oldBands[uFrom+1],
-                (infoPtr->uNumBands - uFrom - 1) * sizeof(REBAR_BAND));
+    memcpy (&oldBands[uFrom], &oldBands[uFrom+1],
+        (infoPtr->uNumBands - uFrom - 1) * sizeof(REBAR_BAND));
     }
 
     /* allocate new space and copy rest of bands into it */
     infoPtr->bands =
-        (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands)*sizeof(REBAR_BAND));
+    (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands)*sizeof(REBAR_BAND));
 
     /* pre insert copy */
     if (uTo > 0) {
-        memcpy (&infoPtr->bands[0], &oldBands[0],
-                uTo * sizeof(REBAR_BAND));
+    memcpy (&infoPtr->bands[0], &oldBands[0],
+        uTo * sizeof(REBAR_BAND));
     }
 
@@ -3113 +3114 @@
     /* post copy */
     if (uTo < infoPtr->uNumBands - 1) {
-        memcpy (&infoPtr->bands[uTo+1], &oldBands[uTo],
-                (infoPtr->uNumBands - uTo - 1) * sizeof(REBAR_BAND));
+    memcpy (&infoPtr->bands[uTo+1], &oldBands[uTo],
+        (infoPtr->uNumBands - uTo - 1) * sizeof(REBAR_BAND));
     }
 
@@ -3143 +3144 @@
 
     if (lprbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
-        return FALSE;
+    return FALSE;
     if ((UINT)wParam >= infoPtr->uNumBands)
-        return FALSE;
+    return FALSE;
 
     TRACE("index %u\n", (UINT)wParam);
@@ -3157 +3158 @@
     REBAR_CommonSetupBand (infoPtr->hwndSelf, lprbbi, lpBand);
     if (lprbbi->fMask & RBBIM_TEXT) {
-        if (lpBand->lpText) {
-            COMCTL32_Free (lpBand->lpText);
-            lpBand->lpText = NULL;
-        }
-        if (lprbbi->lpText) {
+    if (lpBand->lpText) {
+        COMCTL32_Free (lpBand->lpText);
+        lpBand->lpText = NULL;
+    }
+    if (lprbbi->lpText) {
             INT len = MultiByteToWideChar( CP_ACP, 0, lprbbi->lpText, -1, NULL, 0 );
             lpBand->lpText = (LPWSTR)COMCTL32_Alloc (len*sizeof(WCHAR));
             MultiByteToWideChar( CP_ACP, 0, lprbbi->lpText, -1, lpBand->lpText, len );
-        }
+    }
     }
 
@@ -3173 +3174 @@
 
     if (lprbbi->fMask & (RBBIM_CHILDSIZE | RBBIM_SIZE))
-          REBAR_Layout (infoPtr, NULL, TRUE, FALSE);
+      REBAR_Layout (infoPtr, NULL, TRUE, FALSE);
 
     return TRUE;
@@ -3186 +3187 @@
 
     if (lprbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
-        return FALSE;
+    return FALSE;
     if ((UINT)wParam >= infoPtr->uNumBands)
-        return FALSE;
+    return FALSE;
 
     TRACE("index %u\n", (UINT)wParam);
@@ -3200 +3201 @@
     REBAR_CommonSetupBand (infoPtr->hwndSelf, (LPREBARBANDINFOA)lprbbi, lpBand);
     if (lprbbi->fMask & RBBIM_TEXT) {
-        if (lpBand->lpText) {
-            COMCTL32_Free (lpBand->lpText);
-            lpBand->lpText = NULL;
-        }
-        if (lprbbi->lpText) {
-            INT len = lstrlenW (lprbbi->lpText);
-            lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            strcpyW (lpBand->lpText, lprbbi->lpText);
-        }
+    if (lpBand->lpText) {
+        COMCTL32_Free (lpBand->lpText);
+        lpBand->lpText = NULL;
+    }
+    if (lprbbi->lpText) {
+        INT len = lstrlenW (lprbbi->lpText);
+        lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
+        strcpyW (lpBand->lpText, lprbbi->lpText);
+    }
     }
 
@@ -3230 +3231 @@
 
     if (lpInfo == NULL)
-        return FALSE;
+    return FALSE;
 
     if (lpInfo->cbSize < sizeof (REBARINFO))
-        return FALSE;
+    return FALSE;
 
     TRACE("setting bar info!\n");
 
     if (lpInfo->fMask & RBIM_IMAGELIST) {
-        infoPtr->himl = lpInfo->himl;
-        if (infoPtr->himl) {
+    infoPtr->himl = lpInfo->himl;
+    if (infoPtr->himl) {
             INT cx, cy;
-            ImageList_GetIconSize (infoPtr->himl, &cx, &cy);
-            infoPtr->imageSize.cx = cx;
-            infoPtr->imageSize.cy = cy;
-        }
-        else {
-            infoPtr->imageSize.cx = 0;
-            infoPtr->imageSize.cy = 0;
-        }
-        TRACE("new image cx=%ld, cy=%ld\n", infoPtr->imageSize.cx,
-              infoPtr->imageSize.cy);
+        ImageList_GetIconSize (infoPtr->himl, &cx, &cy);
+        infoPtr->imageSize.cx = cx;
+        infoPtr->imageSize.cy = cy;
+    }
+    else {
+        infoPtr->imageSize.cx = 0;
+        infoPtr->imageSize.cy = 0;
+    }
+    TRACE("new image cx=%ld, cy=%ld\n", infoPtr->imageSize.cx,
+          infoPtr->imageSize.cy);
     }
 
@@ -3256 +3257 @@
     for (i=0; i<infoPtr->uNumBands; i++) {
         lpBand = &infoPtr->bands[i];
-        REBAR_ValidateBand (infoPtr, lpBand);
+    REBAR_ValidateBand (infoPtr, lpBand);
     }
 
@@ -3314 +3315 @@
     BOOL bTemp = infoPtr->bUnicode;
 
-    TRACE("to %s hwnd=0x%04x, was %s\n", 
-          ((BOOL)wParam) ? "TRUE" : "FALSE", infoPtr->hwndSelf,
-          (bTemp) ? "TRUE" : "FALSE");
+    TRACE("to %s hwnd=0x%04x, was %s\n",
+      ((BOOL)wParam) ? "TRUE" : "FALSE", infoPtr->hwndSelf,
+      (bTemp) ? "TRUE" : "FALSE");
 
     infoPtr->bUnicode = (BOOL)wParam;
- 
+
    return bTemp;
 }
@@ -3330 +3331 @@
 
     if (iVersion > COMCTL32_VERSION)
-        return -1;
+    return -1;
 
     infoPtr->iVersion = iVersion;
@@ -3346 +3347 @@
 
     if (((INT)wParam < 0) || ((INT)wParam > infoPtr->uNumBands))
-        return FALSE;
+    return FALSE;
 
     lpBand = &infoPtr->bands[(INT)wParam];
 
     if ((BOOL)lParam) {
-        TRACE("show band %d\n", (INT)wParam);
-        lpBand->fStyle = lpBand->fStyle & ~RBBS_HIDDEN;
-        if (IsWindow (lpBand->hwndChild))
-            ShowWindow (lpBand->hwndChild, SW_SHOW);
+    TRACE("show band %d\n", (INT)wParam);
+    lpBand->fStyle = lpBand->fStyle & ~RBBS_HIDDEN;
+    if (IsWindow (lpBand->hwndChild))
+        ShowWindow (lpBand->hwndChild, SW_SHOW);
     }
     else {
-        TRACE("hide band %d\n", (INT)wParam);
-        lpBand->fStyle = lpBand->fStyle | RBBS_HIDDEN;
-        if (IsWindow (lpBand->hwndChild))
-            ShowWindow (lpBand->hwndChild, SW_HIDE);
+    TRACE("hide band %d\n", (INT)wParam);
+    lpBand->fStyle = lpBand->fStyle | RBBS_HIDDEN;
+    if (IsWindow (lpBand->hwndChild))
+        ShowWindow (lpBand->hwndChild, SW_HIDE);
     }
 
@@ -3379 +3380 @@
 
     TRACE("[%d %d %d %d]\n",
-          lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
+      lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
 
     /*  what is going on???? */
     GetWindowRect(infoPtr->hwndSelf, &t1);
     TRACE("window rect [%d %d %d %d]\n",
-          t1.left, t1.top, t1.right, t1.bottom);
+      t1.left, t1.top, t1.right, t1.bottom);
     GetClientRect(infoPtr->hwndSelf, &t1);
     TRACE("client rect [%d %d %d %d]\n",
-          t1.left, t1.top, t1.right, t1.bottom);
+      t1.left, t1.top, t1.right, t1.bottom);
 
     /* force full _Layout processing */
@@ -3406 +3407 @@
 
     if (TRACE_ON(rebar)) {
-        GetWindowRect(infoPtr->hwndSelf, &wnrc1);
-        GetClientRect(infoPtr->hwndSelf, &clrc1);
-        TRACE("window=(%d,%d)-(%d,%d) client=(%d,%d)-(%d,%d) cs=(%d,%d %dx%d)\n",
-              wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
-              clrc1.left, clrc1.top, clrc1.right, clrc1.bottom,
-              cs->x, cs->y, cs->cx, cs->cy);
+    GetWindowRect(infoPtr->hwndSelf, &wnrc1);
+    GetClientRect(infoPtr->hwndSelf, &clrc1);
+    TRACE("window=(%d,%d)-(%d,%d) client=(%d,%d)-(%d,%d) cs=(%d,%d %dx%d)\n",
+          wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
+          clrc1.left, clrc1.top, clrc1.right, clrc1.bottom,
+          cs->x, cs->y, cs->cx, cs->cy);
     }
 
@@ -3428 +3429 @@
     /* free rebar bands */
     if ((infoPtr->uNumBands > 0) && infoPtr->bands) {
-        /* clean up each band */
-        for (i = 0; i < infoPtr->uNumBands; i++) {
-            lpBand = &infoPtr->bands[i];
-
-            /* delete text strings */
-            if (lpBand->lpText) {
-                COMCTL32_Free (lpBand->lpText);
-                lpBand->lpText = NULL;
-            }
-            /* destroy child window */
-            DestroyWindow (lpBand->hwndChild);
-        }
-
-        /* free band array */
-        COMCTL32_Free (infoPtr->bands);
-        infoPtr->bands = NULL;
+    /* clean up each band */
+    for (i = 0; i < infoPtr->uNumBands; i++) {
+        lpBand = &infoPtr->bands[i];
+
+        /* delete text strings */
+        if (lpBand->lpText) {
+        COMCTL32_Free (lpBand->lpText);
+        lpBand->lpText = NULL;
+        }
+        /* destroy child window */
+        DestroyWindow (lpBand->hwndChild);
+    }
+
+    /* free band array */
+    COMCTL32_Free (infoPtr->bands);
+    infoPtr->bands = NULL;
     }
 
@@ -3522 +3523 @@
     if (infoPtr->fStatus & BEGIN_DRAG_ISSUED) {
         REBAR_Notify((NMHDR *) &layout, infoPtr, RBN_LAYOUTCHANGED);
-        REBAR_Notify_NMREBAR (infoPtr, ihitBand, RBN_ENDDRAG);
-        infoPtr->fStatus &= ~BEGIN_DRAG_ISSUED;
+    REBAR_Notify_NMREBAR (infoPtr, ihitBand, RBN_ENDDRAG);
+    infoPtr->fStatus &= ~BEGIN_DRAG_ISSUED;
     }
 
@@ -3547 +3548 @@
     /* if mouse did not move much, exit */
     if ((abs(ptsmove.x - infoPtr->dragNow.x) <= mindragx) &&
-        (abs(ptsmove.y - infoPtr->dragNow.y) <= mindragy)) return 0;
+    (abs(ptsmove.y - infoPtr->dragNow.y) <= mindragy)) return 0;
 
     band1 = &infoPtr->bands[infoPtr->ihitBand-1];
@@ -3554 +3555 @@
     /* Test for valid drag case - must not be first band in row */
     if (infoPtr->dwStyle & CCS_VERT) {
-        if ((ptsmove.x < band2->rcBand.left) ||
-            (ptsmove.x > band2->rcBand.right) ||
-            ((infoPtr->ihitBand > 0) && (band1->iRow != band2->iRow))) {
-            FIXME("Cannot drag to other rows yet!!\n");
-        }
-        else {
-            REBAR_HandleLRDrag (infoPtr, &ptsmove);
-        }
+    if ((ptsmove.x < band2->rcBand.left) ||
+        (ptsmove.x > band2->rcBand.right) ||
+        ((infoPtr->ihitBand > 0) && (band1->iRow != band2->iRow))) {
+        FIXME("Cannot drag to other rows yet!!\n");
     }
     else {
-        if ((ptsmove.y < band2->rcBand.top) ||
-            (ptsmove.y > band2->rcBand.bottom) ||
-            ((infoPtr->ihitBand > 0) && (band1->iRow != band2->iRow))) {
-            FIXME("Cannot drag to other rows yet!!\n");
-        }
-        else {
-            REBAR_HandleLRDrag (infoPtr, &ptsmove);
-        }
+        REBAR_HandleLRDrag (infoPtr, &ptsmove);
+    }
+    }
+    else {
+    if ((ptsmove.y < band2->rcBand.top) ||
+        (ptsmove.y > band2->rcBand.bottom) ||
+        ((infoPtr->ihitBand > 0) && (band1->iRow != band2->iRow))) {
+        FIXME("Cannot drag to other rows yet!!\n");
+    }
+    else {
+        REBAR_HandleLRDrag (infoPtr, &ptsmove);
+    }
     }
     return 0;
@@ -3588 +3589 @@
 #if 0
     if (GetWindowLongA (infoPtr->hwndSelf, GWL_STYLE) & WS_BORDER) {
-        ((LPRECT)lParam)->left   += GetSystemMetrics(SM_CXEDGE);
-        ((LPRECT)lParam)->top    += GetSystemMetrics(SM_CYEDGE);
-        ((LPRECT)lParam)->right  -= GetSystemMetrics(SM_CXEDGE);
-        ((LPRECT)lParam)->bottom -= GetSystemMetrics(SM_CYEDGE);
+    ((LPRECT)lParam)->left   += GetSystemMetrics(SM_CXEDGE);
+    ((LPRECT)lParam)->top    += GetSystemMetrics(SM_CYEDGE);
+    ((LPRECT)lParam)->right  -= GetSystemMetrics(SM_CXEDGE);
+    ((LPRECT)lParam)->bottom -= GetSystemMetrics(SM_CYEDGE);
     }
 #endif
@@ -3608 +3609 @@
 
     if (infoPtr != NULL) {
-        ERR("Strange info structure pointer *not* NULL\n");
-        return FALSE;
+    ERR("Strange info structure pointer *not* NULL\n");
+    return FALSE;
     }
 
     if (TRACE_ON(rebar)) {
-        GetWindowRect(hwnd, &wnrc1);
-        GetClientRect(hwnd, &clrc1);
-        TRACE("window=(%d,%d)-(%d,%d) client=(%d,%d)-(%d,%d) cs=(%d,%d %dx%d)\n",
-              wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
-              clrc1.left, clrc1.top, clrc1.right, clrc1.bottom,
-              cs->x, cs->y, cs->cx, cs->cy);
+    GetWindowRect(hwnd, &wnrc1);
+    GetClientRect(hwnd, &clrc1);
+    TRACE("window=(%d,%d)-(%d,%d) client=(%d,%d)-(%d,%d) cs=(%d,%d %dx%d)\n",
+          wnrc1.left, wnrc1.top, wnrc1.right, wnrc1.bottom,
+          clrc1.left, clrc1.top, clrc1.right, clrc1.bottom,
+          cs->x, cs->y, cs->cx, cs->cy);
     }
 
@@ -3646 +3647 @@
     /* issue WM_NOTIFYFORMAT to get unicode status of parent */
     i = SendMessageA(REBAR_GetNotifyParent (infoPtr),
-                     WM_NOTIFYFORMAT, hwnd, NF_QUERY);
+             WM_NOTIFYFORMAT, hwnd, NF_QUERY);
     if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
-        ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
-            i);
-        i = NFR_ANSI;
+    ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
+        i);
+    i = NFR_ANSI;
     }
     infoPtr->NtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
@@ -3659 +3660 @@
 
 /* native does:
-            GetSysColor (numerous);
-            GetSysColorBrush (numerous) (see WM_SYSCOLORCHANGE);
-            GetStockObject (SYSTEM_FONT);
-           *SetWindowLong (hwnd, 0, info ptr);
-           *WM_NOTIFYFORMAT;
-           *SetWindowLong (hwnd, GWL_STYLE, style+0x10000001);
+        GetSysColor (numerous);
+        GetSysColorBrush (numerous) (see WM_SYSCOLORCHANGE);
+        GetStockObject (SYSTEM_FONT);
+       *SetWindowLong (hwnd, 0, info ptr);
+       *WM_NOTIFYFORMAT;
+       *SetWindowLong (hwnd, GWL_STYLE, style+0x10000001);
                                     WS_VISIBLE = 0x10000000;
                                     CCS_TOP    = 0x00000001;
-            SystemParametersInfo (SPI_GETNONCLIENTMETRICS...);
-            CreateFontIndirect (lfCaptionFont from above);
-            GetDC ();
-            SelectObject (hdc, fontabove);
-            GetTextMetrics (hdc, );    guessing is tmHeight
-            SelectObject (hdc, oldfont);
-            ReleaseDC ();
-            GetWindowRect ();
-            MapWindowPoints (0, parent, rectabove, 2);
-            GetWindowRect ();
-            GetClientRect ();
-            ClientToScreen (clientrect);
-            SetWindowPos (hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER);
+        SystemParametersInfo (SPI_GETNONCLIENTMETRICS...);
+        CreateFontIndirect (lfCaptionFont from above);
+        GetDC ();
+        SelectObject (hdc, fontabove);
+        GetTextMetrics (hdc, );    guessing is tmHeight
+        SelectObject (hdc, oldfont);
+        ReleaseDC ();
+        GetWindowRect ();
+        MapWindowPoints (0, parent, rectabove, 2);
+        GetWindowRect ();
+        GetClientRect ();
+        ClientToScreen (clientrect);
+        SetWindowPos (hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER);
  */
     return TRUE;
@@ -3707 +3708 @@
     clpt = pt;
     ScreenToClient (infoPtr->hwndSelf, &clpt);
-    REBAR_InternalHitTest (infoPtr, &clpt, &scrap, 
-                           (INT *)&nmmouse.dwItemSpec);
+    REBAR_InternalHitTest (infoPtr, &clpt, &scrap,
+               (INT *)&nmmouse.dwItemSpec);
     nmmouse.dwItemData = 0;
     nmmouse.pt = clpt;
     nmmouse.dwHitInfo = 0;
     if ((i = REBAR_Notify((NMHDR *) &nmmouse, infoPtr, NM_NCHITTEST))) {
-        TRACE("notify changed return value from %ld to %d\n",
-              ret, i); 
-        ret = (LRESULT) i;
+    TRACE("notify changed return value from %ld to %d\n",
+          ret, i);
+    ret = (LRESULT) i;
     }
     TRACE("returning %ld, client point (%ld,%ld)\n", ret, clpt.x, clpt.y);
@@ -3729 +3730 @@
 
     if (infoPtr->dwStyle & WS_MINIMIZE)
-        return 0; /* Nothing to do */
+    return 0; /* Nothing to do */
 
     DefWindowProcA (infoPtr->hwndSelf, WM_NCPAINT, wParam, lParam);
 
     if (!(hdc = GetDCEx( infoPtr->hwndSelf, 0, DCX_USESTYLE | DCX_WINDOW )))
-        return 0;
+    return 0;
 
     if (infoPtr->dwStyle & WS_BORDER) {
-        GetWindowRect (infoPtr->hwndSelf, &rcWindow);
-        OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
-        TRACE("rect (%d,%d)-(%d,%d)\n",
-              rcWindow.left, rcWindow.top,
-              rcWindow.right, rcWindow.bottom);
-        /* see comments in _NCCalcSize for reason this is not done */
-        /* DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_RECT); */
-        DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP | BF_BOTTOM);
+    GetWindowRect (infoPtr->hwndSelf, &rcWindow);
+    OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
+    TRACE("rect (%d,%d)-(%d,%d)\n",
+          rcWindow.left, rcWindow.top,
+          rcWindow.right, rcWindow.bottom);
+    /* see comments in _NCCalcSize for reason this is not done */
+    /* DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_RECT); */
+    DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP | BF_BOTTOM);
     }
 
@@ -3759 +3760 @@
 
     if (lParam == NF_REQUERY) {
-        i = SendMessageA(REBAR_GetNotifyParent (infoPtr),
-                         WM_NOTIFYFORMAT, infoPtr->hwndSelf, NF_QUERY);
-        if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
-            ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
-                i);
-            i = NFR_ANSI;
-        }
-        infoPtr->NtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
-        return (LRESULT)i;
+    i = SendMessageA(REBAR_GetNotifyParent (infoPtr),
+             WM_NOTIFYFORMAT, infoPtr->hwndSelf, NF_QUERY);
+    if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
+        ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
+        i);
+        i = NFR_ANSI;
+    }
+    infoPtr->NtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
+    return (LRESULT)i;
     }
     return (LRESULT)((infoPtr->bUnicode) ? NFR_UNICODE : NFR_ANSI);
@@ -3784 +3785 @@
 
     TRACE("painting (%d,%d)-(%d,%d) client (%d,%d)-(%d,%d)\n",
-          ps.rcPaint.left, ps.rcPaint.top,
-          ps.rcPaint.right, ps.rcPaint.bottom,
-          rc.left, rc.top, rc.right, rc.bottom);
+      ps.rcPaint.left, ps.rcPaint.top,
+      ps.rcPaint.right, ps.rcPaint.bottom,
+      rc.left, rc.top, rc.right, rc.bottom);
 
     if (ps.fErase) {
-        /* Erase area of paint if requested */
+    /* Erase area of paint if requested */
         REBAR_InternalEraseBkGnd (infoPtr, wParam, lParam, &ps.rcPaint);
     }
@@ -3795 +3796 @@
     REBAR_Refresh (infoPtr, hdc);
     if (!wParam)
-        EndPaint (infoPtr->hwndSelf, &ps);
+    EndPaint (infoPtr->hwndSelf, &ps);
     return 0;
 }
@@ -3814 +3815 @@
 
     if (flags == RBHT_GRABBER) {
-        if ((infoPtr->dwStyle & CCS_VERT) &&
-            !(infoPtr->dwStyle & RBS_VERTICALGRIPPER))
-            SetCursor (infoPtr->hcurVert);
-        else
-            SetCursor (infoPtr->hcurHorz);
+    if ((infoPtr->dwStyle & CCS_VERT) &&
+        !(infoPtr->dwStyle & RBS_VERTICALGRIPPER))
+        SetCursor (infoPtr->hcurVert);
+    else
+        SetCursor (infoPtr->hcurHorz);
     }
     else if (flags != RBHT_CLIENT)
-        SetCursor (infoPtr->hcurArrow);
+    SetCursor (infoPtr->hcurArrow);
 
     return 0;
@@ -3839 +3840 @@
     for (i=0; i<infoPtr->uNumBands; i++) {
         lpBand = &infoPtr->bands[i];
-        REBAR_ValidateBand (infoPtr, lpBand);
+    REBAR_ValidateBand (infoPtr, lpBand);
     }
 
@@ -3860 +3861 @@
       *
       * Documentation:
-      *  According to testing V4.71 of COMCTL32 returns the 
+      *  According to testing V4.71 of COMCTL32 returns the
       *  *previous* status of the redraw flag (either 0 or -1)
       *  instead of the MSDN documented value of 0 if handled
@@ -3868 +3869 @@
     BOOL oldredraw = infoPtr->DoRedraw;
 
-    TRACE("set to %s, fStatus=%08x\n", 
-          (wParam) ? "TRUE" : "FALSE", infoPtr->fStatus);
+    TRACE("set to %s, fStatus=%08x\n",
+      (wParam) ? "TRUE" : "FALSE", infoPtr->fStatus);
     infoPtr->DoRedraw = (BOOL) wParam;
     if (wParam) {
-        if (infoPtr->fStatus & BAND_NEEDS_REDRAW) {
-            REBAR_MoveChildWindows (infoPtr, 0, infoPtr->uNumBands);
-            REBAR_ForceResize (infoPtr);
-            InvalidateRect (infoPtr->hwndSelf, 0, TRUE);
-        }
-        infoPtr->fStatus &= ~BAND_NEEDS_REDRAW;
+    if (infoPtr->fStatus & BAND_NEEDS_REDRAW) {
+        REBAR_MoveChildWindows (infoPtr, 0, infoPtr->uNumBands);
+        REBAR_ForceResize (infoPtr);
+        InvalidateRect (infoPtr->hwndSelf, 0, TRUE);
+    }
+    infoPtr->fStatus &= ~BAND_NEEDS_REDRAW;
     }
     return (oldredraw) ? -1 : 0;
@@ -3890 +3891 @@
     /* auto resize deadlock check */
     if (infoPtr->fStatus & AUTO_RESIZE) {
-        infoPtr->fStatus &= ~AUTO_RESIZE;
-        TRACE("AUTO_RESIZE was set, reset, fStatus=%08x lparam=%08lx\n",
-              infoPtr->fStatus, lParam);
-        return 0;
+    infoPtr->fStatus &= ~AUTO_RESIZE;
+    TRACE("AUTO_RESIZE was set, reset, fStatus=%08x lparam=%08lx\n",
+          infoPtr->fStatus, lParam);
+    return 0;
     }
 
     if (infoPtr->fStatus & CREATE_RUNNING) {
-        /* still in CreateWindow */
-        RECT rcWin;
-
-        TRACE("still in CreateWindow\n");
-        infoPtr->fStatus &= ~CREATE_RUNNING;
-        GetWindowRect ( infoPtr->hwndSelf, &rcWin);
-        TRACE("win rect (%d,%d)-(%d,%d)\n",
-              rcWin.left, rcWin.top, rcWin.right, rcWin.bottom);
-
-        if ((lParam == 0) && (rcWin.right-rcWin.left == 0) && 
-            (rcWin.bottom-rcWin.top == 0)) {
-            /* native control seems to do this */
-            GetClientRect (GetParent(infoPtr->hwndSelf), &rcClient);
-            TRACE("sizing rebar, message and client zero, parent client (%d,%d)\n", 
-                  rcClient.right, rcClient.bottom);
-        }
-        else {
-            INT cx, cy;
-
-            cx = rcWin.right - rcWin.left;
-            cy = rcWin.bottom - rcWin.top;
-            if ((cx == LOWORD(lParam)) && (cy == HIWORD(lParam))) {
-                return 0;
-            }
-
-            /* do the actual WM_SIZE request */
-            GetClientRect (infoPtr->hwndSelf, &rcClient);
-            TRACE("sizing rebar from (%ld,%ld) to (%d,%d), client (%d,%d)\n", 
-                  infoPtr->calcSize.cx, infoPtr->calcSize.cy,
-                  LOWORD(lParam), HIWORD(lParam),
-                  rcClient.right, rcClient.bottom);
-        }
+    /* still in CreateWindow */
+    RECT rcWin;
+
+    TRACE("still in CreateWindow\n");
+    infoPtr->fStatus &= ~CREATE_RUNNING;
+    GetWindowRect ( infoPtr->hwndSelf, &rcWin);
+    TRACE("win rect (%d,%d)-(%d,%d)\n",
+          rcWin.left, rcWin.top, rcWin.right, rcWin.bottom);
+
+    if ((lParam == 0) && (rcWin.right-rcWin.left == 0) &&
+        (rcWin.bottom-rcWin.top == 0)) {
+        /* native control seems to do this */
+        GetClientRect (GetParent(infoPtr->hwndSelf), &rcClient);
+        TRACE("sizing rebar, message and client zero, parent client (%d,%d)\n",
+          rcClient.right, rcClient.bottom);
     }
     else {
-        /* Handle cases when outside of the CreateWindow process */
-
-        GetClientRect (infoPtr->hwndSelf, &rcClient);
-        if ((lParam == 0) && (rcClient.right + rcClient.bottom != 0) &&
-            (infoPtr->dwStyle & RBS_AUTOSIZE)) {
-            /* on a WM_SIZE to zero and current client not zero and AUTOSIZE */
-            /* native seems to use the current client rect for the size      */
-            infoPtr->fStatus |= BAND_NEEDS_LAYOUT;
-            TRACE("sizing rebar to client (%d,%d) size is zero but AUTOSIZE set\n", 
-                  rcClient.right, rcClient.bottom);
-        }
-        else {
-            TRACE("sizing rebar from (%ld,%ld) to (%d,%d), client (%d,%d)\n", 
-                  infoPtr->calcSize.cx, infoPtr->calcSize.cy,
-                  LOWORD(lParam), HIWORD(lParam),
-                  rcClient.right, rcClient.bottom);
-        }
+        INT cx, cy;
+
+        cx = rcWin.right - rcWin.left;
+        cy = rcWin.bottom - rcWin.top;
+        if ((cx == LOWORD(lParam)) && (cy == HIWORD(lParam))) {
+        return 0;
+        }
+
+        /* do the actual WM_SIZE request */
+        GetClientRect (infoPtr->hwndSelf, &rcClient);
+        TRACE("sizing rebar from (%ld,%ld) to (%d,%d), client (%d,%d)\n",
+          infoPtr->calcSize.cx, infoPtr->calcSize.cy,
+          LOWORD(lParam), HIWORD(lParam),
+          rcClient.right, rcClient.bottom);
+    }
+    }
+    else {
+    /* Handle cases when outside of the CreateWindow process */
+
+    GetClientRect (infoPtr->hwndSelf, &rcClient);
+    if ((lParam == 0) && (rcClient.right + rcClient.bottom != 0) &&
+        (infoPtr->dwStyle & RBS_AUTOSIZE)) {
+        /* on a WM_SIZE to zero and current client not zero and AUTOSIZE */
+        /* native seems to use the current client rect for the size      */
+        infoPtr->fStatus |= BAND_NEEDS_LAYOUT;
+        TRACE("sizing rebar to client (%d,%d) size is zero but AUTOSIZE set\n",
+          rcClient.right, rcClient.bottom);
+    }
+    else {
+        TRACE("sizing rebar from (%ld,%ld) to (%d,%d), client (%d,%d)\n",
+          infoPtr->calcSize.cx, infoPtr->calcSize.cy,
+          LOWORD(lParam), HIWORD(lParam),
+          rcClient.right, rcClient.bottom);
+    }
     }
 
     if (infoPtr->dwStyle & RBS_AUTOSIZE) {
-        NMRBAUTOSIZE autosize;
-
-        GetClientRect(infoPtr->hwndSelf, &autosize.rcTarget);
-        autosize.fChanged = 0;  /* ??? */
-        autosize.rcActual = autosize.rcTarget;  /* ??? */
-        REBAR_Notify((NMHDR *) &autosize, infoPtr, RBN_AUTOSIZE);
-        TRACE("RBN_AUTOSIZE client=(%d,%d), lp=%08lx\n", 
-              autosize.rcTarget.right, autosize.rcTarget.bottom, lParam);
+    NMRBAUTOSIZE autosize;
+
+    GetClientRect(infoPtr->hwndSelf, &autosize.rcTarget);
+    autosize.fChanged = 0;  /* ??? */
+    autosize.rcActual = autosize.rcTarget;  /* ??? */
+    REBAR_Notify((NMHDR *) &autosize, infoPtr, RBN_AUTOSIZE);
+    TRACE("RBN_AUTOSIZE client=(%d,%d), lp=%08lx\n",
+          autosize.rcTarget.right, autosize.rcTarget.bottom, lParam);
     }
 
     if ((infoPtr->calcSize.cx != rcClient.right) ||
-        (infoPtr->calcSize.cy != rcClient.bottom))
-        infoPtr->fStatus |= BAND_NEEDS_LAYOUT;
+    (infoPtr->calcSize.cy != rcClient.bottom))
+    infoPtr->fStatus |= BAND_NEEDS_LAYOUT;
 
     REBAR_Layout (infoPtr, &rcClient, TRUE, TRUE);
@@ -3978 +3979 @@
 
     TRACE("current style=%08lx, styleOld=%08lx, style being set to=%08lx\n",
-          infoPtr->dwStyle, ss->styleOld, ss->styleNew);
+      infoPtr->dwStyle, ss->styleOld, ss->styleNew);
     infoPtr->dwStyle = ss->styleNew;
 
@@ -3990 +3991 @@
     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 
-    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", 
-          hwnd, uMsg, /* SPY_GetMsgName(uMsg), */ wParam, lParam);
+    TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n",
+      hwnd, uMsg, /* SPY_GetMsgName(uMsg), */ wParam, lParam);
     if (!infoPtr && (uMsg != WM_NCCREATE))
-            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     switch (uMsg)
     {
-/*      case RB_BEGINDRAG: */
-
-        case RB_DELETEBAND:
-            return REBAR_DeleteBand (infoPtr, wParam, lParam);
-
-/*      case RB_DRAGMOVE: */
-/*      case RB_ENDDRAG: */
-
-        case RB_GETBANDBORDERS:
-            return REBAR_GetBandBorders (infoPtr, wParam, lParam);
-
-        case RB_GETBANDCOUNT:
-            return REBAR_GetBandCount (infoPtr);
-
-        case RB_GETBANDINFO:    /* obsoleted after IE3, but we have to
-                                   support it anyway. */
-        case RB_GETBANDINFOA:
-            return REBAR_GetBandInfoA (infoPtr, wParam, lParam);
-
-        case RB_GETBANDINFOW:
-            return REBAR_GetBandInfoW (infoPtr, wParam, lParam);
-
-        case RB_GETBARHEIGHT:
-            return REBAR_GetBarHeight (infoPtr, wParam, lParam);
-
-        case RB_GETBARINFO:
-            return REBAR_GetBarInfo (infoPtr, wParam, lParam);
-
-        case RB_GETBKCOLOR:
-            return REBAR_GetBkColor (infoPtr);
-
-/*      case RB_GETCOLORSCHEME: */
-/*      case RB_GETDROPTARGET: */
-
-        case RB_GETPALETTE:
-            return REBAR_GetPalette (infoPtr, wParam, lParam);
-
-        case RB_GETRECT:
-            return REBAR_GetRect (infoPtr, wParam, lParam);
-
-        case RB_GETROWCOUNT:
-            return REBAR_GetRowCount (infoPtr);
-
-        case RB_GETROWHEIGHT:
-            return REBAR_GetRowHeight (infoPtr, wParam, lParam);
-
-        case RB_GETTEXTCOLOR:
-            return REBAR_GetTextColor (infoPtr);
-
-        case RB_GETTOOLTIPS:
-            return REBAR_GetToolTips (infoPtr);
-
-        case RB_GETUNICODEFORMAT:
-            return REBAR_GetUnicodeFormat (infoPtr);
-
-        case CCM_GETVERSION:
-            return REBAR_GetVersion (infoPtr);
-
-        case RB_HITTEST:
-            return REBAR_HitTest (infoPtr, wParam, lParam);
-
-        case RB_IDTOINDEX:
-            return REBAR_IdToIndex (infoPtr, wParam, lParam);
-
-        case RB_INSERTBANDA:
-            return REBAR_InsertBandA (infoPtr, wParam, lParam);
-
-        case RB_INSERTBANDW:
-            return REBAR_InsertBandW (infoPtr, wParam, lParam);
-
-        case RB_MAXIMIZEBAND:
-            return REBAR_MaximizeBand (infoPtr, wParam, lParam);
-
-        case RB_MINIMIZEBAND:
-            return REBAR_MinimizeBand (infoPtr, wParam, lParam);
-
-        case RB_MOVEBAND:
-            return REBAR_MoveBand (infoPtr, wParam, lParam);
-
-        case RB_SETBANDINFOA:
-            return REBAR_SetBandInfoA (infoPtr, wParam, lParam);
-
-        case RB_SETBANDINFOW:
-            return REBAR_SetBandInfoW (infoPtr, wParam, lParam);
-
-        case RB_SETBARINFO:
-            return REBAR_SetBarInfo (infoPtr, wParam, lParam);
-
-        case RB_SETBKCOLOR:
-            return REBAR_SetBkColor (infoPtr, wParam, lParam);
-
-/*      case RB_SETCOLORSCHEME: */
-/*      case RB_SETPALETTE: */
-/*          return REBAR_GetPalette (infoPtr, wParam, lParam); */
-
-        case RB_SETPARENT:
-            return REBAR_SetParent (infoPtr, wParam, lParam);
-
-        case RB_SETTEXTCOLOR:
-            return REBAR_SetTextColor (infoPtr, wParam, lParam);
-
-/*      case RB_SETTOOLTIPS: */
-
-        case RB_SETUNICODEFORMAT:
-            return REBAR_SetUnicodeFormat (infoPtr, wParam);
-
-        case CCM_SETVERSION:
-            return REBAR_SetVersion (infoPtr, (INT)wParam);
-
-        case RB_SHOWBAND:
-            return REBAR_ShowBand (infoPtr, wParam, lParam);
-
-        case RB_SIZETORECT:
-            return REBAR_SizeToRect (infoPtr, wParam, lParam);
+/*  case RB_BEGINDRAG: */
+
+    case RB_DELETEBAND:
+        return REBAR_DeleteBand (infoPtr, wParam, lParam);
+
+/*  case RB_DRAGMOVE: */
+/*  case RB_ENDDRAG: */
+
+    case RB_GETBANDBORDERS:
+        return REBAR_GetBandBorders (infoPtr, wParam, lParam);
+
+    case RB_GETBANDCOUNT:
+        return REBAR_GetBandCount (infoPtr);
+
+    case RB_GETBANDINFO:    /* obsoleted after IE3, but we have to
+                   support it anyway. */
+    case RB_GETBANDINFOA:
+        return REBAR_GetBandInfoA (infoPtr, wParam, lParam);
+
+    case RB_GETBANDINFOW:
+        return REBAR_GetBandInfoW (infoPtr, wParam, lParam);
+
+    case RB_GETBARHEIGHT:
+        return REBAR_GetBarHeight (infoPtr, wParam, lParam);
+
+    case RB_GETBARINFO:
+        return REBAR_GetBarInfo (infoPtr, wParam, lParam);
+
+    case RB_GETBKCOLOR:
+        return REBAR_GetBkColor (infoPtr);
+
+/*  case RB_GETCOLORSCHEME: */
+/*  case RB_GETDROPTARGET: */
+
+    case RB_GETPALETTE:
+        return REBAR_GetPalette (infoPtr, wParam, lParam);
+
+    case RB_GETRECT:
+        return REBAR_GetRect (infoPtr, wParam, lParam);
+
+    case RB_GETROWCOUNT:
+        return REBAR_GetRowCount (infoPtr);
+
+    case RB_GETROWHEIGHT:
+        return REBAR_GetRowHeight (infoPtr, wParam, lParam);
+
+    case RB_GETTEXTCOLOR:
+        return REBAR_GetTextColor (infoPtr);
+
+    case RB_GETTOOLTIPS:
+        return REBAR_GetToolTips (infoPtr);
+
+    case RB_GETUNICODEFORMAT:
+        return REBAR_GetUnicodeFormat (infoPtr);
+
+    case CCM_GETVERSION:
+        return REBAR_GetVersion (infoPtr);
+
+    case RB_HITTEST:
+        return REBAR_HitTest (infoPtr, wParam, lParam);
+
+    case RB_IDTOINDEX:
+        return REBAR_IdToIndex (infoPtr, wParam, lParam);
+
+    case RB_INSERTBANDA:
+        return REBAR_InsertBandA (infoPtr, wParam, lParam);
+
+    case RB_INSERTBANDW:
+        return REBAR_InsertBandW (infoPtr, wParam, lParam);
+
+    case RB_MAXIMIZEBAND:
+        return REBAR_MaximizeBand (infoPtr, wParam, lParam);
+
+    case RB_MINIMIZEBAND:
+        return REBAR_MinimizeBand (infoPtr, wParam, lParam);
+
+    case RB_MOVEBAND:
+        return REBAR_MoveBand (infoPtr, wParam, lParam);
+
+    case RB_SETBANDINFOA:
+        return REBAR_SetBandInfoA (infoPtr, wParam, lParam);
+
+    case RB_SETBANDINFOW:
+        return REBAR_SetBandInfoW (infoPtr, wParam, lParam);
+
+    case RB_SETBARINFO:
+        return REBAR_SetBarInfo (infoPtr, wParam, lParam);
+
+    case RB_SETBKCOLOR:
+        return REBAR_SetBkColor (infoPtr, wParam, lParam);
+
+/*  case RB_SETCOLORSCHEME: */
+/*  case RB_SETPALETTE: */
+/*      return REBAR_GetPalette (infoPtr, wParam, lParam); */
+
+    case RB_SETPARENT:
+        return REBAR_SetParent (infoPtr, wParam, lParam);
+
+    case RB_SETTEXTCOLOR:
+        return REBAR_SetTextColor (infoPtr, wParam, lParam);
+
+/*  case RB_SETTOOLTIPS: */
+
+    case RB_SETUNICODEFORMAT:
+        return REBAR_SetUnicodeFormat (infoPtr, wParam);
+
+    case CCM_SETVERSION:
+        return REBAR_SetVersion (infoPtr, (INT)wParam);
+
+    case RB_SHOWBAND:
+        return REBAR_ShowBand (infoPtr, wParam, lParam);
+
+    case RB_SIZETORECT:
+        return REBAR_SizeToRect (infoPtr, wParam, lParam);
 
 
 /*    Messages passed to parent */
-        case WM_COMMAND:
-        case WM_DRAWITEM:
-        case WM_NOTIFY:
-            if (infoPtr->NtfUnicode)
-                return SendMessageW (REBAR_GetNotifyParent (infoPtr),
-                                     uMsg, wParam, lParam);
-            else
-                return SendMessageA (REBAR_GetNotifyParent (infoPtr),
-                                     uMsg, wParam, lParam);
+    case WM_COMMAND:
+    case WM_DRAWITEM:
+    case WM_NOTIFY:
+        if (infoPtr->NtfUnicode)
+        return SendMessageW (REBAR_GetNotifyParent (infoPtr),
+                     uMsg, wParam, lParam);
+        else
+        return SendMessageA (REBAR_GetNotifyParent (infoPtr),
+                     uMsg, wParam, lParam);
 
 
 /*      case WM_CHARTOITEM:     supported according to ControlSpy */
 
-        case WM_CREATE:
-            return REBAR_Create (infoPtr, wParam, lParam);
-
-        case WM_DESTROY:
-            return REBAR_Destroy (infoPtr, wParam, lParam);
+    case WM_CREATE:
+        return REBAR_Create (infoPtr, wParam, lParam);
+
+    case WM_DESTROY:
+        return REBAR_Destroy (infoPtr, wParam, lParam);
 
         case WM_ERASEBKGND:
-            return REBAR_EraseBkGnd (infoPtr, wParam, lParam);
-
-        case WM_GETFONT:
-            return REBAR_GetFont (infoPtr, wParam, lParam);
+        return REBAR_EraseBkGnd (infoPtr, wParam, lParam);
+
+    case WM_GETFONT:
+        return REBAR_GetFont (infoPtr, wParam, lParam);
 
 /*      case WM_LBUTTONDBLCLK:  supported according to ControlSpy */
 
-        case WM_LBUTTONDOWN:
-            return REBAR_LButtonDown (infoPtr, wParam, lParam);
-
-        case WM_LBUTTONUP:
-            return REBAR_LButtonUp (infoPtr, wParam, lParam);
+    case WM_LBUTTONDOWN:
+        return REBAR_LButtonDown (infoPtr, wParam, lParam);
+
+    case WM_LBUTTONUP:
+        return REBAR_LButtonUp (infoPtr, wParam, lParam);
 
 /*      case WM_MEASUREITEM:    supported according to ControlSpy */
 
-        case WM_MOUSEMOVE:
-            return REBAR_MouseMove (infoPtr, wParam, lParam);
-
-        case WM_NCCALCSIZE:
-            return REBAR_NCCalcSize (infoPtr, wParam, lParam);
+    case WM_MOUSEMOVE:
+        return REBAR_MouseMove (infoPtr, wParam, lParam);
+
+    case WM_NCCALCSIZE:
+        return REBAR_NCCalcSize (infoPtr, wParam, lParam);
 
         case WM_NCCREATE:
-            return REBAR_NCCreate (hwnd, wParam, lParam);
+        return REBAR_NCCreate (hwnd, wParam, lParam);
 
         case WM_NCHITTEST:
-            return REBAR_NCHitTest (infoPtr, wParam, lParam);
-
-        case WM_NCPAINT:
-            return REBAR_NCPaint (infoPtr, wParam, lParam);
+        return REBAR_NCHitTest (infoPtr, wParam, lParam);
+
+    case WM_NCPAINT:
+        return REBAR_NCPaint (infoPtr, wParam, lParam);
 
         case WM_NOTIFYFORMAT:
-            return REBAR_NotifyFormat (infoPtr, wParam, lParam);
-
-        case WM_PAINT:
-            return REBAR_Paint (infoPtr, wParam, lParam);
+        return REBAR_NotifyFormat (infoPtr, wParam, lParam);
+
+    case WM_PAINT:
+        return REBAR_Paint (infoPtr, wParam, lParam);
 
 /*      case WM_PALETTECHANGED: supported according to ControlSpy */
@@ -4175 +4176 @@
 /*      case WM_RBUTTONUP:      supported according to ControlSpy */
 
-        case WM_SETCURSOR:
-            return REBAR_SetCursor (infoPtr, wParam, lParam);
-
-        case WM_SETFONT:
-            return REBAR_SetFont (infoPtr, wParam, lParam);
+    case WM_SETCURSOR:
+        return REBAR_SetCursor (infoPtr, wParam, lParam);
+
+    case WM_SETFONT:
+        return REBAR_SetFont (infoPtr, wParam, lParam);
 
         case WM_SETREDRAW:
-            return REBAR_SetRedraw (infoPtr, wParam, lParam);
-
-        case WM_SIZE:
-            return REBAR_Size (infoPtr, wParam, lParam);
+        return REBAR_SetRedraw (infoPtr, wParam, lParam);
+
+    case WM_SIZE:
+        return REBAR_Size (infoPtr, wParam, lParam);
 
         case WM_STYLECHANGED:
-            return REBAR_StyleChanged (infoPtr, wParam, lParam);
+        return REBAR_StyleChanged (infoPtr, wParam, lParam);
 
 /*      case WM_SYSCOLORCHANGE: supported according to ControlSpy */
 /*      "Applications that have brushes using the existing system colors
-         should delete those brushes and recreate them using the new 
+         should delete those brushes and recreate them using the new
          system colors."  per MSDN                                */
 
 /*      case WM_VKEYTOITEM:     supported according to ControlSpy */
-/*      case WM_WININICHANGE: */
-
-        default:
-            if (uMsg >= WM_USER)
-                ERR("unknown msg %04x wp=%08x lp=%08lx\n",
-                     uMsg, wParam, lParam);
+/*  case WM_WININICHANGE: */
+
+    default:
+        if (uMsg >= WM_USER)
+        ERR("unknown msg %04x wp=%08x lp=%08lx\n",
+             uMsg, wParam, lParam);
 #ifdef __WIN32OS2__
             return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
 #else
-            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
 #endif
     }
@@ -4225 +4226 @@
     wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
     wndClass.lpszClassName = REBARCLASSNAMEA;
- 
+
     RegisterClassA (&wndClass);
 

trunk/src/comctl32/status.c

@@ +1 @@
+/* $Id: status.c,v 1.23 2001-09-05 12:05:02 bird Exp $ */
 /*
  * Interface code to StatusWindow widget/control
@@ -26 +27 @@
 typedef struct
 {
-    INT x;
-    INT style;
-    RECT        bound;
-    LPWSTR      text;
+    INT x;
+    INT style;
+    RECT    bound;
+    LPWSTR  text;
     HICON     hIcon;
 } STATUSWINDOWPART;
@@ -48 +49 @@
     COLORREF            clrBk;     /* background color */
     BOOL              bUnicode;  /* unicode flag */
-    STATUSWINDOWPART    part0;     /* simple window */
+    STATUSWINDOWPART    part0;     /* simple window */
     STATUSWINDOWPART   *parts;
 } STATUSWINDOWINFO;
@@ -93 +94 @@
     SelectObject (hdc, GetSysColorPen (COLOR_3DSHADOW));
     for (i = 1; i < 11; i += 4) {
-        MoveToEx (hdc, pt.x - i, pt.y, NULL);
-        LineTo (hdc, pt.x, pt.y - i);
-
-        MoveToEx (hdc, pt.x - i-1, pt.y, NULL);
-        LineTo (hdc, pt.x, pt.y - i-1);
+    MoveToEx (hdc, pt.x - i, pt.y, NULL);
+    LineTo (hdc, pt.x, pt.y - i);
+
+    MoveToEx (hdc, pt.x - i-1, pt.y, NULL);
+    LineTo (hdc, pt.x, pt.y - i-1);
     }
 
     SelectObject (hdc, GetSysColorPen (COLOR_3DHIGHLIGHT));
     for (i = 3; i < 13; i += 4) {
-        MoveToEx (hdc, pt.x - i, pt.y, NULL);
-        LineTo (hdc, pt.x, pt.y - i);
+    MoveToEx (hdc, pt.x - i, pt.y, NULL);
+    LineTo (hdc, pt.x, pt.y - i);
     }
 
@@ -110 +111 @@
 
 
-static void 
+static void
 STATUSBAR_DrawPart (HDC hdc, STATUSWINDOWPART *part)
 {
@@ -126 +127 @@
     /* draw the icon */
     if (part->hIcon) {
-        INT cy = r.bottom - r.top;
-
-        r.left += 2;
-        DrawIconEx (hdc, r.left, r.top, part->hIcon, cy, cy, 0, 0, DI_NORMAL);
-        r.left += cy;
+    INT cy = r.bottom - r.top;
+
+    r.left += 2;
+    DrawIconEx (hdc, r.left, r.top, part->hIcon, cy, cy, 0, 0, DI_NORMAL);
+    r.left += cy;
     }
 
@@ -139 +140 @@
       UINT align = DT_LEFT;
       if (*p == L'\t') {
-        p++;
-        align = DT_CENTER;
-
-        if (*p == L'\t') {
-          p++;
-          align = DT_RIGHT;
-        }
+    p++;
+    align = DT_CENTER;
+
+    if (*p == L'\t') {
+      p++;
+      align = DT_RIGHT;
+    }
       }
       r.left += 3;
@@ -151 +152 @@
       DrawTextW (hdc, p, -1, &r, align|DT_VCENTER|DT_SINGLELINE);
       if (oldbkmode != TRANSPARENT)
-        SetBkMode(hdc, oldbkmode);
+    SetBkMode(hdc, oldbkmode);
     }
 }
@@ -169 +170 @@
 
     if (infoPtr->clrBk != CLR_DEFAULT)
-        hbrBk = CreateSolidBrush (infoPtr->clrBk);
+    hbrBk = CreateSolidBrush (infoPtr->clrBk);
     else
-        hbrBk = GetSysColorBrush (COLOR_3DFACE);
+    hbrBk = GetSysColorBrush (COLOR_3DFACE);
     FillRect(hdc, &part->bound, hbrBk);
 
@@ -177 +178 @@
 
     if (part->style & SBT_OWNERDRAW) {
-        DRAWITEMSTRUCT dis;
-
-        dis.CtlID = GetWindowLongA (hwnd, GWL_ID);
-        dis.itemID = itemID;
-        dis.hwndItem = hwnd;
-        dis.hDC = hdc;
-        dis.rcItem = part->bound;
-        dis.itemData = (INT)part->text;
-        SendMessageA (GetParent (hwnd), WM_DRAWITEM,
-                (WPARAM)dis.CtlID, (LPARAM)&dis);
+    DRAWITEMSTRUCT dis;
+
+    dis.CtlID = GetWindowLongA (hwnd, GWL_ID);
+    dis.itemID = itemID;
+    dis.hwndItem = hwnd;
+    dis.hDC = hdc;
+    dis.rcItem = part->bound;
+    dis.itemData = (INT)part->text;
+    SendMessageA (GetParent (hwnd), WM_DRAWITEM,
+        (WPARAM)dis.CtlID, (LPARAM)&dis);
     } else
-        STATUSBAR_DrawPart (hdc, part);
+    STATUSBAR_DrawPart (hdc, part);
 
     SelectObject (hdc, hOldFont);
 
     if (infoPtr->clrBk != CLR_DEFAULT)
-        DeleteObject (hbrBk);
+    DeleteObject (hbrBk);
 
     if (GetWindowLongA (hwnd, GWL_STYLE) & SBARS_SIZEGRIP) {
-        RECT rect;
-
-        GetClientRect (hwnd, &rect);
-        STATUSBAR_DrawSizeGrip (hdc, &rect);
+    RECT rect;
+
+    GetClientRect (hwnd, &rect);
+    STATUSBAR_DrawSizeGrip (hdc, &rect);
     }
 }
@@ -221 +222 @@
 
     if (infoPtr->clrBk != CLR_DEFAULT)
-        hbrBk = CreateSolidBrush (infoPtr->clrBk);
+    hbrBk = CreateSolidBrush (infoPtr->clrBk);
     else
-        hbrBk = GetSysColorBrush (COLOR_3DFACE);
+    hbrBk = GetSysColorBrush (COLOR_3DFACE);
     FillRect(hdc, &rect, hbrBk);
 
@@ -229 +230 @@
 
     if (infoPtr->simple) {
-        STATUSBAR_RefreshPart (infoPtr, hwnd, &infoPtr->part0, hdc, 0);
+    STATUSBAR_RefreshPart (infoPtr, hwnd, &infoPtr->part0, hdc, 0);
     } else {
-        for (i = 0; i < infoPtr->numParts; i++) {
-            if (infoPtr->parts[i].style & SBT_OWNERDRAW) {
-                DRAWITEMSTRUCT dis;
-
-                dis.CtlID = GetWindowLongA (hwnd, GWL_ID);
-                dis.itemID = i;
-                dis.hwndItem = hwnd;
-                dis.hDC = hdc;
-                dis.rcItem = infoPtr->parts[i].bound;
-                dis.itemData = (INT)infoPtr->parts[i].text;
-                SendMessageA (GetParent (hwnd), WM_DRAWITEM,
-                        (WPARAM)dis.CtlID, (LPARAM)&dis);
-            } else
-                STATUSBAR_RefreshPart (infoPtr, hwnd, &infoPtr->parts[i], hdc, i);
-        }
+    for (i = 0; i < infoPtr->numParts; i++) {
+        if (infoPtr->parts[i].style & SBT_OWNERDRAW) {
+        DRAWITEMSTRUCT dis;
+
+        dis.CtlID = GetWindowLongA (hwnd, GWL_ID);
+        dis.itemID = i;
+        dis.hwndItem = hwnd;
+        dis.hDC = hdc;
+        dis.rcItem = infoPtr->parts[i].bound;
+        dis.itemData = (INT)infoPtr->parts[i].text;
+        SendMessageA (GetParent (hwnd), WM_DRAWITEM,
+            (WPARAM)dis.CtlID, (LPARAM)&dis);
+        } else
+        STATUSBAR_RefreshPart (infoPtr, hwnd, &infoPtr->parts[i], hdc, i);
+    }
     }
 
@@ -251 +252 @@
 
     if (infoPtr->clrBk != CLR_DEFAULT)
-        DeleteObject (hbrBk);
+    DeleteObject (hbrBk);
 
     if (GetWindowLongA(hwnd, GWL_STYLE) & SBARS_SIZEGRIP)
-        STATUSBAR_DrawSizeGrip (hdc, &rect);
+    STATUSBAR_DrawSizeGrip (hdc, &rect);
 
     return TRUE;
@@ -265 +266 @@
     STATUSWINDOWPART *part;
     RECT rect, *r;
-    int i;
+    int i;
 
     /* get our window size */
@@ -278 +279 @@
     /* set bounds for non-simple rectangles */
     for (i = 0; i < infoPtr->numParts; i++) {
-        part = &infoPtr->parts[i];
-        r = &infoPtr->parts[i].bound;
-        r->top = rect.top;
-        r->bottom = rect.bottom;
-        if (i == 0)
-            r->left = 0;
-        else
-            r->left = infoPtr->parts[i-1].bound.right + HORZ_GAP;
-        if (part->x == -1)
-            r->right = rect.right;
-        else
-            r->right = part->x;
-
-        if (infoPtr->hwndToolTip) {
-            TTTOOLINFOA ti;
-
-            ti.cbSize = sizeof(TTTOOLINFOA);
-            ti.hwnd = hwnd;
-            ti.uId = i;
-            ti.rect = *r;
-            SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
-                            0, (LPARAM)&ti);
-        }
+    part = &infoPtr->parts[i];
+    r = &infoPtr->parts[i].bound;
+    r->top = rect.top;
+    r->bottom = rect.bottom;
+    if (i == 0)
+        r->left = 0;
+    else
+        r->left = infoPtr->parts[i-1].bound.right + HORZ_GAP;
+    if (part->x == -1)
+        r->right = rect.right;
+    else
+        r->right = part->x;
+
+    if (infoPtr->hwndToolTip) {
+        TTTOOLINFOA ti;
+
+        ti.cbSize = sizeof(TTTOOLINFOA);
+        ti.hwnd = hwnd;
+        ti.uId = i;
+        ti.rect = *r;
+        SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
+                0, (LPARAM)&ti);
+    }
     }
 }
@@ -307 +308 @@
 static VOID
 STATUSBAR_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
-                      WPARAM wParam, LPARAM lParam)
+              WPARAM wParam, LPARAM lParam)
 {
     MSG msg;
@@ -345 +346 @@
     TRACE("%d\n", nPart);
     if ((nPart < -1) || (nPart >= infoPtr->numParts))
-        return 0;
+    return 0;
 
     if (nPart == -1)
@@ -365 +366 @@
     parts = (LPINT) lParam;
     if (parts) {
-        for (i = 0; i < num_parts; i++) {
-            parts[i] = infoPtr->parts[i].x;
-        }
+    for (i = 0; i < num_parts; i++) {
+        parts[i] = infoPtr->parts[i].x;
+    }
     }
     return (infoPtr->numParts);
@@ -376 +377 @@
 STATUSBAR_GetRect (STATUSWINDOWINFO *infoPtr, HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-    int nPart;
+    int nPart;
     LPRECT  rect;
 
@@ -383 +384 @@
     rect = (LPRECT) lParam;
     if (infoPtr->simple)
-        *rect = infoPtr->part0.bound;
+    *rect = infoPtr->part0.bound;
     else
-        *rect = infoPtr->parts[nPart].bound;
+    *rect = infoPtr->parts[nPart].bound;
     return TRUE;
 }
@@ -400 +401 @@
     TRACE("part %d\n", nPart);
     if (infoPtr->simple)
-        part = &infoPtr->part0;
+    part = &infoPtr->part0;
     else
 #ifdef __WIN32OS2__
     {
         if (nPart >= infoPtr->numParts)
-            return FALSE;
-        part = &infoPtr->parts[nPart];
+        return FALSE;
+    part = &infoPtr->parts[nPart];
     }
 #else
-        part = &infoPtr->parts[nPart];
+    part = &infoPtr->parts[nPart];
 #endif
 
     if (part->style & SBT_OWNERDRAW)
-        result = (LRESULT)part->text;
+    result = (LRESULT)part->text;
     else {
         DWORD len = part->text ? WideCharToMultiByte( CP_ACP, 0, part->text, -1,
@@ -435 +436 @@
     TRACE("part %d\n", nPart);
     if (infoPtr->simple)
-        part = &infoPtr->part0;
+    part = &infoPtr->part0;
     else
 #ifdef __WIN32OS2__
     {
         if (nPart >= infoPtr->numParts)
-            return FALSE;
-        part = &infoPtr->parts[nPart];
+        return FALSE;
+    part = &infoPtr->parts[nPart];
     }
 #else
-        part = &infoPtr->parts[nPart];
+    part = &infoPtr->parts[nPart];
 #endif
 
     if (part->style & SBT_OWNERDRAW)
-        result = (LRESULT)part->text;
+    result = (LRESULT)part->text;
     else {
-        result = part->text ? strlenW (part->text) : 0;
-        result |= (part->style << 16);
-        if (part->text && lParam)
-            strcpyW ((LPWSTR)lParam, part->text);
+    result = part->text ? strlenW (part->text) : 0;
+    result |= (part->style << 16);
+    if (part->text && lParam)
+        strcpyW ((LPWSTR)lParam, part->text);
     }
     return result;
@@ -471 +472 @@
 
     if (infoPtr->simple)
-        part = &infoPtr->part0;
+    part = &infoPtr->part0;
     else
 #ifdef __WIN32OS2__
     {
         if (nPart >= infoPtr->numParts)
-            return FALSE;
-        part = &infoPtr->parts[nPart];
+        return FALSE;
+    part = &infoPtr->parts[nPart];
     }
 #else
-        part = &infoPtr->parts[nPart];
+    part = &infoPtr->parts[nPart];
 #endif
 
     if (part->text)
-        result = strlenW(part->text);
+    result = strlenW(part->text);
     else
-        result = 0;
+    result = 0;
 
     result |= (part->style << 16);
@@ -526 +527 @@
         buf[0]=0;
 
-        if (infoPtr->hwndToolTip) {
-            TTTOOLINFOW ti;
-            ti.cbSize = sizeof(TTTOOLINFOW);
-            ti.hwnd = hwnd;
-            ti.uId = LOWORD(wParam);
+    if (infoPtr->hwndToolTip) {
+        TTTOOLINFOW ti;
+        ti.cbSize = sizeof(TTTOOLINFOW);
+        ti.hwnd = hwnd;
+        ti.uId = LOWORD(wParam);
             ti.lpszText = buf;
-            SendMessageW(infoPtr->hwndToolTip, TTM_GETTEXTW, 0, (LPARAM)&ti);
-        }
-        lstrcpynW(tip, buf, HIWORD(wParam));
+        SendMessageW(infoPtr->hwndToolTip, TTM_GETTEXTW, 0, (LPARAM)&ti);
+    }
+    lstrcpynW(tip, buf, HIWORD(wParam));
     }
 
@@ -575 +576 @@
 
     if ((nPart < -1) || (nPart >= infoPtr->numParts))
-        return FALSE;
+    return FALSE;
 
     TRACE("setting part %d, icon %lx\n",nPart,lParam);
 
     if (nPart == -1) {
-        if (infoPtr->part0.hIcon == (HICON)lParam) /* same as - no redraw */
-            return TRUE;
-        infoPtr->part0.hIcon = (HICON)lParam;
-        if (infoPtr->simple)
+    if (infoPtr->part0.hIcon == (HICON)lParam) /* same as - no redraw */
+        return TRUE;
+    infoPtr->part0.hIcon = (HICON)lParam;
+    if (infoPtr->simple)
             InvalidateRect(hwnd, &infoPtr->part0.bound, FALSE);
     } else {
-        if (infoPtr->parts[nPart].hIcon == (HICON)lParam) /* same as - no redraw */
-            return TRUE;
-
-        infoPtr->parts[nPart].hIcon = (HICON)lParam;
-        if (!(infoPtr->simple))
+    if (infoPtr->parts[nPart].hIcon == (HICON)lParam) /* same as - no redraw */
+        return TRUE;
+
+    infoPtr->parts[nPart].hIcon = (HICON)lParam;
+    if (!(infoPtr->simple))
             InvalidateRect(hwnd, &infoPtr->parts[nPart].bound, FALSE);
     }
@@ -603 +604 @@
     TRACE("\n");
     if (IsWindowVisible (hwnd)) {
-        HWND parent = GetParent (hwnd);
-        INT  width, x, y;
-        RECT parent_rect;
-
-        GetClientRect (parent, &parent_rect);
-        infoPtr->height = (INT)wParam + VERT_BORDER;
-        width = parent_rect.right - parent_rect.left;
-        x = parent_rect.left;
-        y = parent_rect.bottom - infoPtr->height;
-        MoveWindow (hwnd, parent_rect.left,
-                      parent_rect.bottom - infoPtr->height,
-                      width, infoPtr->height, TRUE);
-        STATUSBAR_SetPartBounds (infoPtr, hwnd);
+    HWND parent = GetParent (hwnd);
+    INT  width, x, y;
+    RECT parent_rect;
+
+    GetClientRect (parent, &parent_rect);
+    infoPtr->height = (INT)wParam + VERT_BORDER;
+    width = parent_rect.right - parent_rect.left;
+    x = parent_rect.left;
+    y = parent_rect.bottom - infoPtr->height;
+    MoveWindow (hwnd, parent_rect.left,
+              parent_rect.bottom - infoPtr->height,
+              width, infoPtr->height, TRUE);
+    STATUSBAR_SetPartBounds (infoPtr, hwnd);
     }
 
@@ -627 +628 @@
     STATUSWINDOWPART *tmp;
     LPINT parts;
-    int i;
-    int oldNumParts;
+    int i;
+    int oldNumParts;
 
     TRACE("(%d,%p)\n",wParam,(LPVOID)lParam);
@@ -634 +635 @@
     /* FIXME: should return FALSE sometimes (maybe when wParam == 0 ?) */
     if (infoPtr->simple)
-        infoPtr->simple = FALSE;
+    infoPtr->simple = FALSE;
 
     oldNumParts = infoPtr->numParts;
@@ -640 +641 @@
     parts = (LPINT) lParam;
     if (oldNumParts > infoPtr->numParts) {
-        for (i = infoPtr->numParts ; i < oldNumParts; i++) {
-            if (infoPtr->parts[i].text && !(infoPtr->parts[i].style & SBT_OWNERDRAW))
-                COMCTL32_Free (infoPtr->parts[i].text);
-        }
+    for (i = infoPtr->numParts ; i < oldNumParts; i++) {
+        if (infoPtr->parts[i].text && !(infoPtr->parts[i].style & SBT_OWNERDRAW))
+        COMCTL32_Free (infoPtr->parts[i].text);
+    }
     }
     if (oldNumParts < infoPtr->numParts) {
-        tmp = COMCTL32_Alloc (sizeof(STATUSWINDOWPART) * infoPtr->numParts);
-        for (i = 0; i < oldNumParts; i++) {
-            tmp[i] = infoPtr->parts[i];
-        }
-        if (infoPtr->parts)
-            COMCTL32_Free (infoPtr->parts);
-        infoPtr->parts = tmp;
+    tmp = COMCTL32_Alloc (sizeof(STATUSWINDOWPART) * infoPtr->numParts);
+    for (i = 0; i < oldNumParts; i++) {
+        tmp[i] = infoPtr->parts[i];
+    }
+    if (infoPtr->parts)
+        COMCTL32_Free (infoPtr->parts);
+    infoPtr->parts = tmp;
     }
     if (oldNumParts == infoPtr->numParts) {
-        for (i=0;i<oldNumParts;i++)
-            if (infoPtr->parts[i].x != parts[i])
-                break;
-        if (i==oldNumParts) /* Unchanged? no need to redraw! */
-            return TRUE;
-    }
-    
+    for (i=0;i<oldNumParts;i++)
+        if (infoPtr->parts[i].x != parts[i])
+        break;
+    if (i==oldNumParts) /* Unchanged? no need to redraw! */
+        return TRUE;
+    }
+
     for (i = 0; i < infoPtr->numParts; i++)
-        infoPtr->parts[i].x = parts[i];
+    infoPtr->parts[i].x = parts[i];
 
     if (infoPtr->hwndToolTip) {
-        INT nTipCount =
-            SendMessageA (infoPtr->hwndToolTip, TTM_GETTOOLCOUNT, 0, 0);
-
-        if (nTipCount < infoPtr->numParts) {
-            /* add tools */
-            TTTOOLINFOA ti;
-            INT i;
-
-            ZeroMemory (&ti, sizeof(TTTOOLINFOA));
-            ti.cbSize = sizeof(TTTOOLINFOA);
-            ti.hwnd = hwnd;
-            for (i = nTipCount; i < infoPtr->numParts; i++) {
-                TRACE("add tool %d\n", i);
-                ti.uId = i;
-                SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
-                                0, (LPARAM)&ti);
-            }
-        }
-        else if (nTipCount > infoPtr->numParts) {
-            /* delete tools */
-            INT i;
-
-            for (i = nTipCount - 1; i >= infoPtr->numParts; i--) {
-                FIXME("delete tool %d\n", i);
-            }
-        }
+    INT nTipCount =
+        SendMessageA (infoPtr->hwndToolTip, TTM_GETTOOLCOUNT, 0, 0);
+
+    if (nTipCount < infoPtr->numParts) {
+        /* add tools */
+        TTTOOLINFOA ti;
+        INT i;
+
+        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
+        ti.cbSize = sizeof(TTTOOLINFOA);
+        ti.hwnd = hwnd;
+        for (i = nTipCount; i < infoPtr->numParts; i++) {
+        TRACE("add tool %d\n", i);
+        ti.uId = i;
+        SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
+                0, (LPARAM)&ti);
+        }
+    }
+    else if (nTipCount > infoPtr->numParts) {
+        /* delete tools */
+        INT i;
+
+        for (i = nTipCount - 1; i >= infoPtr->numParts; i--) {
+        FIXME("delete tool %d\n", i);
+        }
+    }
     }
     STATUSBAR_SetPartBounds (infoPtr, hwnd);
@@ -703 +704 @@
 {
     STATUSWINDOWPART *part=NULL;
-    int nPart;
-    int style;
+    int nPart;
+    int style;
     LPSTR text;
-    BOOL        changed = FALSE;
+    BOOL    changed = FALSE;
 
     text = (LPSTR) lParam;
@@ -715 +716 @@
 
     if (nPart==255)
-        part = &infoPtr->part0;
+    part = &infoPtr->part0;
     else if (!infoPtr->simple && infoPtr->parts!=NULL)
 #ifdef __WIN32OS2__
     {
         if (nPart >= infoPtr->numParts)
-            return FALSE;
-        part = &infoPtr->parts[nPart];
+        return FALSE;
+    part = &infoPtr->parts[nPart];
     }
 #else
-        part = &infoPtr->parts[nPart];
+    part = &infoPtr->parts[nPart];
 #endif
     if (!part) return FALSE;
 
     if (part->style != style)
-        changed = TRUE;
+    changed = TRUE;
 
     part->style = style;
     if (style & SBT_OWNERDRAW) {
-        if (part->text == (LPWSTR)text)
-            return TRUE;
-        part->text = (LPWSTR)text;
+    if (part->text == (LPWSTR)text)
+        return TRUE;
+    part->text = (LPWSTR)text;
     } else {
-        LPWSTR ntext;
-
-        /* check if text is unchanged -> no need to redraw */
-        if (text) {
+    LPWSTR ntext;
+
+    /* check if text is unchanged -> no need to redraw */
+    if (text) {
             DWORD len = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 );
-            LPWSTR tmptext = COMCTL32_Alloc(len*sizeof(WCHAR));
+        LPWSTR tmptext = COMCTL32_Alloc(len*sizeof(WCHAR));
             MultiByteToWideChar( CP_ACP, 0, text, -1, tmptext, len );
 
-            if (!changed && part->text && !lstrcmpW(tmptext,part->text)) {
-                COMCTL32_Free(tmptext);
-                return TRUE;
-            }
-            ntext = tmptext;
-        } else {
-            if (!changed && !part->text) 
-                return TRUE;
-            ntext = 0;
-        }
-
-        if (part->text)
-            COMCTL32_Free (part->text);
-        part->text = ntext;
+        if (!changed && part->text && !lstrcmpW(tmptext,part->text)) {
+        COMCTL32_Free(tmptext);
+        return TRUE;
+        }
+        ntext = tmptext;
+    } else {
+        if (!changed && !part->text)
+        return TRUE;
+        ntext = 0;
+    }
+
+    if (part->text)
+        COMCTL32_Free (part->text);
+    part->text = ntext;
     }
     InvalidateRect(hwnd, &part->bound, FALSE);
@@ -780 +781 @@
     TRACE("part %d -> '%s' with style %04x\n", nPart, debugstr_w(text), style);
     if ((infoPtr->simple) || (infoPtr->parts==NULL) || (nPart==255))
-        part = &infoPtr->part0;
+    part = &infoPtr->part0;
     else
 #ifdef __WIN32OS2__
     {
         if (nPart >= infoPtr->numParts)
-            return FALSE;
-        part = &infoPtr->parts[nPart];
+        return FALSE;
+    part = &infoPtr->parts[nPart];
     }
 #else
-        part = &infoPtr->parts[nPart];
+    part = &infoPtr->parts[nPart];
 #endif
     if (!part) return FALSE;
@@ -801 +802 @@
     if (style & SBT_OWNERDRAW)
     {
-        part->text = text;
+    part->text = text;
         bRedraw = TRUE;
     } else if(!text)
@@ -813 +814 @@
     } else if(!part->text || strcmpW(part->text, text)) /* see if the new string differs from the existing string */
     {
-        if(part->text) COMCTL32_Free(part->text);
+    if(part->text) COMCTL32_Free(part->text);
 
         len = strlenW(text);
         part->text = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
-        strcpyW(part->text, text);
+    strcpyW(part->text, text);
         bRedraw = TRUE;
     }
@@ -833 +834 @@
     TRACE("part %d: \"%s\"\n", (INT)wParam, (LPSTR)lParam);
     if (infoPtr->hwndToolTip) {
-        TTTOOLINFOA ti;
-        ti.cbSize = sizeof(TTTOOLINFOA);
-        ti.hwnd = hwnd;
-        ti.uId = (INT)wParam;
-        ti.hinst = 0;
-        ti.lpszText = (LPSTR)lParam;
-        SendMessageA (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTA,
-                        0, (LPARAM)&ti);
+    TTTOOLINFOA ti;
+    ti.cbSize = sizeof(TTTOOLINFOA);
+    ti.hwnd = hwnd;
+    ti.uId = (INT)wParam;
+    ti.hinst = 0;
+    ti.lpszText = (LPSTR)lParam;
+    SendMessageA (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTA,
+            0, (LPARAM)&ti);
     }
 
@@ -852 +853 @@
     TRACE("part %d: \"%s\"\n", (INT)wParam, (LPSTR)lParam);
     if (infoPtr->hwndToolTip) {
-        TTTOOLINFOW ti;
-        ti.cbSize = sizeof(TTTOOLINFOW);
-        ti.hwnd = hwnd;
-        ti.uId = (INT)wParam;
-        ti.hinst = 0;
-        ti.lpszText = (LPWSTR)lParam;
-        SendMessageW (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTW,
-                        0, (LPARAM)&ti);
+    TTTOOLINFOW ti;
+    ti.cbSize = sizeof(TTTOOLINFOW);
+    ti.hwnd = hwnd;
+    ti.uId = (INT)wParam;
+    ti.hinst = 0;
+    ti.lpszText = (LPWSTR)lParam;
+    SendMessageW (infoPtr->hwndToolTip, TTM_UPDATETIPTEXTW,
+            0, (LPARAM)&ti);
     }
 
@@ -885 +886 @@
     TRACE("(is simple: %d)\n", wParam);
     if (infoPtr->simple == wParam) /* no need to change */
-        return TRUE;
+    return TRUE;
 
     infoPtr->simple = (BOOL)wParam;
@@ -905 +906 @@
     NONCLIENTMETRICSA nclm;
     DWORD dwStyle;
-    RECT        rect;
-    int         width, len;
-    HDC hdc;
+    RECT    rect;
+    int         width, len;
+    HDC hdc;
     STATUSWINDOWINFO *infoPtr;
 
@@ -951 +952 @@
 
     if (IsWindowUnicode (hwnd)) {
-        infoPtr->bUnicode = TRUE;
-        if (lpCreate->lpszName &&
-            (len = strlenW ((LPCWSTR)lpCreate->lpszName))) {
-            infoPtr->parts[0].text = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
-            strcpyW (infoPtr->parts[0].text, (LPCWSTR)lpCreate->lpszName);
-        }
+    infoPtr->bUnicode = TRUE;
+    if (lpCreate->lpszName &&
+        (len = strlenW ((LPCWSTR)lpCreate->lpszName))) {
+        infoPtr->parts[0].text = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
+        strcpyW (infoPtr->parts[0].text, (LPCWSTR)lpCreate->lpszName);
+    }
     }
     else {
-        if (lpCreate->lpszName &&
-            (len = strlen((LPCSTR)lpCreate->lpszName))) {
+    if (lpCreate->lpszName &&
+        (len = strlen((LPCSTR)lpCreate->lpszName))) {
             DWORD lenW = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)lpCreate->lpszName, -1, NULL, 0 );
-            infoPtr->parts[0].text = COMCTL32_Alloc (lenW*sizeof(WCHAR));
+        infoPtr->parts[0].text = COMCTL32_Alloc (lenW*sizeof(WCHAR));
             MultiByteToWideChar( CP_ACP, 0, (LPCSTR)lpCreate->lpszName, -1,
                                  infoPtr->parts[0].text, lenW );
-        }
+    }
     }
 
@@ -977 +978 @@
 #endif
     if ((hdc = GetDC (0))) {
-        TEXTMETRICA tm;
-        HFONT hOldFont;
-
-        hOldFont = SelectObject (hdc,infoPtr->hDefaultFont);
-        GetTextMetricsA(hdc, &tm);
-        infoPtr->textHeight = tm.tmHeight;
-        SelectObject (hdc, hOldFont);
-        ReleaseDC(0, hdc);
+    TEXTMETRICA tm;
+    HFONT hOldFont;
+
+    hOldFont = SelectObject (hdc,infoPtr->hDefaultFont);
+    GetTextMetricsA(hdc, &tm);
+    infoPtr->textHeight = tm.tmHeight;
+    SelectObject (hdc, hOldFont);
+    ReleaseDC(0, hdc);
     }
 
     if (dwStyle & SBT_TOOLTIPS) {
-        infoPtr->hwndToolTip =
-            CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
-                               CW_USEDEFAULT, CW_USEDEFAULT,
-                               CW_USEDEFAULT, CW_USEDEFAULT,
-                             hwnd, 0,
-                             GetWindowLongA (hwnd, GWL_HINSTANCE), NULL);
-
-        if (infoPtr->hwndToolTip) {
-            NMTOOLTIPSCREATED nmttc;
-
-            nmttc.hdr.hwndFrom = hwnd;
-            nmttc.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
-            nmttc.hdr.code = NM_TOOLTIPSCREATED;
-            nmttc.hwndToolTips = infoPtr->hwndToolTip;
-
-            SendMessageA (lpCreate->hwndParent, WM_NOTIFY,
-                            (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
-        }
+    infoPtr->hwndToolTip =
+        CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
+                   CW_USEDEFAULT, CW_USEDEFAULT,
+                   CW_USEDEFAULT, CW_USEDEFAULT,
+                 hwnd, 0,
+                 GetWindowLongA (hwnd, GWL_HINSTANCE), NULL);
+
+    if (infoPtr->hwndToolTip) {
+        NMTOOLTIPSCREATED nmttc;
+
+        nmttc.hdr.hwndFrom = hwnd;
+        nmttc.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
+        nmttc.hdr.code = NM_TOOLTIPSCREATED;
+        nmttc.hwndToolTips = infoPtr->hwndToolTip;
+
+        SendMessageA (lpCreate->hwndParent, WM_NOTIFY,
+                (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
+    }
     }
 
@@ -1014 +1015 @@
         infoPtr->height = infoPtr->textHeight + 4 + VERT_BORDER;
         SetWindowPos(hwnd, 0, lpCreate->x, lpCreate->y - 1,
-                        width, infoPtr->height, SWP_NOZORDER);
+            width, infoPtr->height, SWP_NOZORDER);
         STATUSBAR_SetPartBounds (infoPtr, hwnd);
     }
@@ -1025 +1026 @@
 STATUSBAR_WMDestroy (STATUSWINDOWINFO *infoPtr, HWND hwnd)
 {
-    int i;
+    int i;
 
     TRACE("\n");
     for (i = 0; i < infoPtr->numParts; i++) {
-        if (infoPtr->parts[i].text && !(infoPtr->parts[i].style & SBT_OWNERDRAW))
-            COMCTL32_Free (infoPtr->parts[i].text);
+    if (infoPtr->parts[i].text && !(infoPtr->parts[i].style & SBT_OWNERDRAW))
+        COMCTL32_Free (infoPtr->parts[i].text);
     }
     if (infoPtr->part0.text && !(infoPtr->part0.style & SBT_OWNERDRAW))
-        COMCTL32_Free (infoPtr->part0.text);
+    COMCTL32_Free (infoPtr->part0.text);
     COMCTL32_Free (infoPtr->parts);
 
     /* delete default font */
     if (infoPtr->hDefaultFont)
-        DeleteObject (infoPtr->hDefaultFont);
+    DeleteObject (infoPtr->hDefaultFont);
 
     /* delete tool tip control */
     if (infoPtr->hwndToolTip)
-        DestroyWindow (infoPtr->hwndToolTip);
+    DestroyWindow (infoPtr->hwndToolTip);
 
     COMCTL32_Free (infoPtr);
@@ -1074 +1075 @@
 
     if (wParam > len) {
-        if (infoPtr->bUnicode)
-            strcpyW ((LPWSTR)lParam, infoPtr->parts[0].text);
-        else
+    if (infoPtr->bUnicode)
+        strcpyW ((LPWSTR)lParam, infoPtr->parts[0].text);
+    else
             WideCharToMultiByte( CP_ACP, 0, infoPtr->parts[0].text, -1,
                                  (LPSTR)lParam, len+1, NULL, NULL );
-        return len;
+    return len;
     }
 
@@ -1090 +1091 @@
 {
     if (infoPtr->hwndToolTip)
-        STATUSBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                              WM_MOUSEMOVE, wParam, lParam);
+    STATUSBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
+                  WM_MOUSEMOVE, wParam, lParam);
     return 0;
 }
@@ -1100 +1101 @@
 {
     if (GetWindowLongA (hwnd, GWL_STYLE) & SBARS_SIZEGRIP) {
-        RECT  rect;
-        POINT pt;
-
-        GetClientRect (hwnd, &rect);
-
-        pt.x = (INT)LOWORD(lParam);
-        pt.y = (INT)HIWORD(lParam);
-        ScreenToClient (hwnd, &pt);
-
-        rect.left = rect.right - 13;
-        rect.top += 2;
-
-        if (PtInRect (&rect, pt))
-            return HTBOTTOMRIGHT;
+    RECT  rect;
+    POINT pt;
+
+    GetClientRect (hwnd, &rect);
+
+    pt.x = (INT)LOWORD(lParam);
+    pt.y = (INT)HIWORD(lParam);
+    ScreenToClient (hwnd, &pt);
+
+    rect.left = rect.right - 13;
+    rect.top += 2;
+
+    if (PtInRect (&rect, pt))
+        return HTBOTTOMRIGHT;
     }
 
@@ -1149 +1150 @@
     STATUSBAR_Refresh (infoPtr, hwnd, hdc);
     if (!wParam)
-        EndPaint (hwnd, &ps);
+    EndPaint (hwnd, &ps);
 
     return 0;
@@ -1194 +1195 @@
     TRACE("\n");
     if (infoPtr->numParts == 0)
-        return FALSE;
+    return FALSE;
 
     part = &infoPtr->parts[0];
@@ -1202 +1203 @@
     part->text = 0;
     if (infoPtr->bUnicode) {
-        if (lParam && (len = strlenW((LPCWSTR)lParam))) {
-            part->text = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
-            strcpyW (part->text, (LPCWSTR)lParam);
-        }
+    if (lParam && (len = strlenW((LPCWSTR)lParam))) {
+        part->text = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
+        strcpyW (part->text, (LPCWSTR)lParam);
+    }
     }
     else {
-        if (lParam && (len = lstrlenA((LPCSTR)lParam))) {
+    if (lParam && (len = lstrlenA((LPCSTR)lParam))) {
             DWORD lenW = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)lParam, -1, NULL, 0 );
             part->text = COMCTL32_Alloc (lenW*sizeof(WCHAR));
             MultiByteToWideChar( CP_ACP, 0, (LPCSTR)lParam, -1, part->text, lenW );
-        }
+    }
     }
 
@@ -1240 +1241 @@
     {
         if (flags == SIZE_RESTORED) {
-            /* width and height don't apply */
-            GetClientRect (infoPtr->hwndParent, &parent_rect);
-            width = parent_rect.right - parent_rect.left;
-            x = parent_rect.left;
-            y = parent_rect.bottom - infoPtr->height;
-            MoveWindow (hwnd, parent_rect.left, 
-                      parent_rect.bottom - infoPtr->height,
-                      width, infoPtr->height, TRUE);
-            STATUSBAR_SetPartBounds (infoPtr, hwnd);
+        /* width and height don't apply */
+        GetClientRect (infoPtr->hwndParent, &parent_rect);
+        width = parent_rect.right - parent_rect.left;
+        x = parent_rect.left;
+        y = parent_rect.bottom - infoPtr->height;
+        MoveWindow (hwnd, parent_rect.left,
+              parent_rect.bottom - infoPtr->height,
+              width, infoPtr->height, TRUE);
+        STATUSBAR_SetPartBounds (infoPtr, hwnd);
         }
-        return 0; /* FIXME: ok to return here ? */
+    return 0; /* FIXME: ok to return here ? */
     }
 
@@ -1283 +1284 @@
 
     switch (msg) {
-        case SB_GETBORDERS:
-            return STATUSBAR_GetBorders (lParam);
-
-        case SB_GETICON:
-            return STATUSBAR_GetIcon (infoPtr, hwnd, wParam);
-
-        case SB_GETPARTS:
-            return STATUSBAR_GetParts (infoPtr, hwnd, wParam, lParam);
-
-        case SB_GETRECT:
-            return STATUSBAR_GetRect (infoPtr, hwnd, wParam, lParam);
-
-        case SB_GETTEXTA:
-            return STATUSBAR_GetTextA (infoPtr, hwnd, wParam, lParam);
-
-        case SB_GETTEXTW:
-            return STATUSBAR_GetTextW (infoPtr, hwnd, wParam, lParam);
-
-        case SB_GETTEXTLENGTHA:
-        case SB_GETTEXTLENGTHW:
-            return STATUSBAR_GetTextLength (infoPtr, hwnd, wParam);
-
-        case SB_GETTIPTEXTA:
-            return STATUSBAR_GetTipTextA (infoPtr, hwnd, wParam, lParam);
-
-        case SB_GETTIPTEXTW:
-            return STATUSBAR_GetTipTextW (infoPtr, hwnd, wParam, lParam);
-
-        case SB_GETUNICODEFORMAT:
-            return STATUSBAR_GetUnicodeFormat (infoPtr, hwnd);
-
-        case SB_ISSIMPLE:
-            return STATUSBAR_IsSimple (infoPtr, hwnd);
-
-        case SB_SETBKCOLOR:
-            return STATUSBAR_SetBkColor (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETICON:
-            return STATUSBAR_SetIcon (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETMINHEIGHT:
-            return STATUSBAR_SetMinHeight (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETPARTS:       
-            return STATUSBAR_SetParts (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETTEXTA:
-            return STATUSBAR_SetTextA (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETTEXTW:
-            return STATUSBAR_SetTextW (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETTIPTEXTA:
-            return STATUSBAR_SetTipTextA (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETTIPTEXTW:
-            return STATUSBAR_SetTipTextW (infoPtr, hwnd, wParam, lParam);
-
-        case SB_SETUNICODEFORMAT:
-            return STATUSBAR_SetUnicodeFormat (infoPtr, hwnd, wParam);
-
-        case SB_SIMPLE:
-            return STATUSBAR_Simple (infoPtr, hwnd, wParam, lParam);
-
-
-        case WM_CREATE:
-            return STATUSBAR_WMCreate (hwnd, wParam, lParam);
-
-        case WM_DESTROY:
-            return STATUSBAR_WMDestroy (infoPtr, hwnd);
-
-        case WM_GETFONT:
+    case SB_GETBORDERS:
+        return STATUSBAR_GetBorders (lParam);
+
+    case SB_GETICON:
+        return STATUSBAR_GetIcon (infoPtr, hwnd, wParam);
+
+    case SB_GETPARTS:
+        return STATUSBAR_GetParts (infoPtr, hwnd, wParam, lParam);
+
+    case SB_GETRECT:
+        return STATUSBAR_GetRect (infoPtr, hwnd, wParam, lParam);
+
+    case SB_GETTEXTA:
+        return STATUSBAR_GetTextA (infoPtr, hwnd, wParam, lParam);
+
+    case SB_GETTEXTW:
+        return STATUSBAR_GetTextW (infoPtr, hwnd, wParam, lParam);
+
+    case SB_GETTEXTLENGTHA:
+    case SB_GETTEXTLENGTHW:
+        return STATUSBAR_GetTextLength (infoPtr, hwnd, wParam);
+
+    case SB_GETTIPTEXTA:
+        return STATUSBAR_GetTipTextA (infoPtr, hwnd, wParam, lParam);
+
+    case SB_GETTIPTEXTW:
+        return STATUSBAR_GetTipTextW (infoPtr, hwnd, wParam, lParam);
+
+    case SB_GETUNICODEFORMAT:
+        return STATUSBAR_GetUnicodeFormat (infoPtr, hwnd);
+
+    case SB_ISSIMPLE:
+        return STATUSBAR_IsSimple (infoPtr, hwnd);
+
+    case SB_SETBKCOLOR:
+        return STATUSBAR_SetBkColor (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETICON:
+        return STATUSBAR_SetIcon (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETMINHEIGHT:
+        return STATUSBAR_SetMinHeight (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETPARTS:
+        return STATUSBAR_SetParts (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETTEXTA:
+        return STATUSBAR_SetTextA (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETTEXTW:
+        return STATUSBAR_SetTextW (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETTIPTEXTA:
+        return STATUSBAR_SetTipTextA (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETTIPTEXTW:
+        return STATUSBAR_SetTipTextW (infoPtr, hwnd, wParam, lParam);
+
+    case SB_SETUNICODEFORMAT:
+        return STATUSBAR_SetUnicodeFormat (infoPtr, hwnd, wParam);
+
+    case SB_SIMPLE:
+        return STATUSBAR_Simple (infoPtr, hwnd, wParam, lParam);
+
+
+    case WM_CREATE:
+        return STATUSBAR_WMCreate (hwnd, wParam, lParam);
+
+    case WM_DESTROY:
+        return STATUSBAR_WMDestroy (infoPtr, hwnd);
+
+    case WM_GETFONT:
             return STATUSBAR_WMGetFont (infoPtr, hwnd);
 
-        case WM_GETTEXT:
+    case WM_GETTEXT:
             return STATUSBAR_WMGetText (infoPtr, hwnd, wParam, lParam);
 
-        case WM_GETTEXTLENGTH:
-            return STATUSBAR_GetTextLength (infoPtr, hwnd, 0);
-
-        case WM_LBUTTONDBLCLK:
+    case WM_GETTEXTLENGTH:
+        return STATUSBAR_GetTextLength (infoPtr, hwnd, 0);
+
+    case WM_LBUTTONDBLCLK:
             return STATUSBAR_SendNotify (hwnd, NM_DBLCLK);
 
-        case WM_LBUTTONUP:
-            return STATUSBAR_SendNotify (hwnd, NM_CLICK);
-
-        case WM_MOUSEMOVE:
+    case WM_LBUTTONUP:
+        return STATUSBAR_SendNotify (hwnd, NM_CLICK);
+
+    case WM_MOUSEMOVE:
             return STATUSBAR_WMMouseMove (infoPtr, hwnd, wParam, lParam);
 
-        case WM_NCHITTEST:
+    case WM_NCHITTEST:
             return STATUSBAR_WMNCHitTest (hwnd, wParam, lParam);
 
-        case WM_NCLBUTTONDOWN:
-            return STATUSBAR_WMNCLButtonDown (hwnd, wParam, lParam);
-
-        case WM_NCLBUTTONUP:
-            return STATUSBAR_WMNCLButtonUp (hwnd, wParam, lParam);
-
-        case WM_PAINT:
-            return STATUSBAR_WMPaint (infoPtr, hwnd, wParam);
-
-        case WM_RBUTTONDBLCLK:
-            return STATUSBAR_SendNotify (hwnd, NM_RDBLCLK);
-
-        case WM_RBUTTONUP:
-            return STATUSBAR_SendNotify (hwnd, NM_RCLICK);
-
-        case WM_SETFONT:
-            return STATUSBAR_WMSetFont (infoPtr, hwnd, wParam, lParam);
-
-        case WM_SETTEXT:
-            return STATUSBAR_WMSetText (infoPtr, hwnd, wParam, lParam);
-
-        case WM_SIZE:
-            return STATUSBAR_WMSize (infoPtr, hwnd, wParam, lParam);
-
-        default:
-            if (msg >= WM_USER)
-                ERR("unknown msg %04x wp=%04x lp=%08lx\n",
-                     msg, wParam, lParam);
+    case WM_NCLBUTTONDOWN:
+        return STATUSBAR_WMNCLButtonDown (hwnd, wParam, lParam);
+
+    case WM_NCLBUTTONUP:
+        return STATUSBAR_WMNCLButtonUp (hwnd, wParam, lParam);
+
+    case WM_PAINT:
+        return STATUSBAR_WMPaint (infoPtr, hwnd, wParam);
+
+    case WM_RBUTTONDBLCLK:
+        return STATUSBAR_SendNotify (hwnd, NM_RDBLCLK);
+
+    case WM_RBUTTONUP:
+        return STATUSBAR_SendNotify (hwnd, NM_RCLICK);
+
+    case WM_SETFONT:
+        return STATUSBAR_WMSetFont (infoPtr, hwnd, wParam, lParam);
+
+    case WM_SETTEXT:
+        return STATUSBAR_WMSetText (infoPtr, hwnd, wParam, lParam);
+
+    case WM_SIZE:
+        return STATUSBAR_WMSize (infoPtr, hwnd, wParam, lParam);
+
+    default:
+        if (msg >= WM_USER)
+        ERR("unknown msg %04x wp=%04x lp=%08lx\n",
+             msg, wParam, lParam);
 #ifdef __WIN32OS2__
             return defComCtl32ProcA (hwnd, msg, wParam, lParam);
 #else
-            return DefWindowProcA (hwnd, msg, wParam, lParam);
+        return DefWindowProcA (hwnd, msg, wParam, lParam);
 #endif
     }
@@ -1432 +1433 @@
     wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
     wndClass.lpszClassName = STATUSCLASSNAMEA;
- 
+
     RegisterClassA (&wndClass);
 }

trunk/src/comctl32/tab.c

@@ +1 @@
+/* $Id: tab.c,v 1.21 2001-09-05 12:05:02 bird Exp $ */
 /*
  * Tab control
@@ -36 +37 @@
   LPARAM lParam;
   RECT   rect;    /* bounding rectangle of the item relative to the
-                   * leftmost item (the leftmost item, 0, would have a 
-                   * "left" member of 0 in this rectangle) 
-                   *  
+           * leftmost item (the leftmost item, 0, would have a
+           * "left" member of 0 in this rectangle)
+                   *
                    * additionally the top member hold the row number
                    * and bottom is unused and should be 0 */
@@ -49 +50 @@
 #endif
   UINT       uNumItem;        /* number of tab items */
-  UINT       uNumRows;        /* number of tab rows */
+  UINT       uNumRows;        /* number of tab rows */
   INT        tabHeight;       /* height of the tab row */
   INT        tabWidth;        /* width of tabs */
@@ -57 +58 @@
   HWND       hwndToolTip;     /* handle to tab's tooltip */
   INT        leftmostVisible; /* Used for scrolling, this member contains
-                               * the index of the first visible item */
+                   * the index of the first visible item */
   INT        iSelected;       /* the currently selected item */
   INT        iHotTracked;     /* the highlighted item under the mouse */
@@ -63 +64 @@
   TAB_ITEM*  items;           /* pointer to an array of TAB_ITEM's */
   BOOL       DoRedraw;        /* flag for redrawing when tab contents is changed*/
-  BOOL       needsScrolling;  /* TRUE if the size of the tabs is greater than 
-                               * the size of the control */
-  BOOL       fSizeSet;        /* was the size of the tabs explicitly set? */
+  BOOL       needsScrolling;  /* TRUE if the size of the tabs is greater than
+                   * the size of the control */
+  BOOL       fSizeSet;        /* was the size of the tabs explicitly set? */
   BOOL       bUnicode;        /* Unicode control? */
   HWND       hwndUpDown;      /* Updown control used for scrolling */
@@ -81 +82 @@
 #define CONTROL_BORDER_SIZEX    2
 #define CONTROL_BORDER_SIZEY    2
-#define BUTTON_SPACINGX         4 
+#define BUTTON_SPACINGX         4
 #define BUTTON_SPACINGY         4
 #define FLAT_BTN_SPACINGX       8
@@ -137 +138 @@
 {
     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
- 
+
     return infoPtr->iSelected;
 }
@@ -145 +146 @@
 {
     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
- 
+
     return infoPtr->uFocus;
 }
@@ -164 +165 @@
   INT iItem = (INT)wParam;
   INT prevItem;
- 
+
   prevItem = -1;
   if ((iItem >= 0) && (iItem < infoPtr->uNumItem)) {
@@ -180 +181 @@
   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
   INT iItem=(INT) wParam;
- 
+
   if ((iItem < 0) || (iItem >= infoPtr->uNumItem)) return 0;
 
   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BUTTONS) {
     FIXME("Should set input focus\n");
-  } else { 
+  } else {
     int oldFocus = infoPtr->uFocus;
     if (infoPtr->iSelected != iItem || infoPtr->uFocus == -1 ) {
@@ -232 +233 @@
   RECT tmpItemRect,clientRect;
   LONG        lStyle  = GetWindowLongA(hwnd, GWL_STYLE);
-  
+
   /* Perform a sanity check and a trivial visibility check. */
   if ( (infoPtr->uNumItem <= 0) ||
@@ -245 +246 @@
   if (itemRect == NULL)
     itemRect = &tmpItemRect;
-  
+
   /* Retrieve the unmodified item rect. */
   *itemRect = infoPtr->items[itemIndex].rect;
@@ -280 +281 @@
   else if(!(lStyle & TCS_VERTICAL) && !(lStyle & TCS_BOTTOM)) /* not TCS_BOTTOM and not TCS_VERTICAL */
   {
-    itemRect->bottom = clientRect.top + 
+    itemRect->bottom = clientRect.top +
                       infoPtr->tabHeight +
                       itemRect->top * (infoPtr->tabHeight - 2) +
                       ((lStyle & TCS_BUTTONS) ? itemRect->top * BUTTON_SPACINGY : 0);
-    itemRect->top = clientRect.top + 
+    itemRect->top = clientRect.top +
                    SELECTED_TAB_OFFSET +
                    itemRect->top * (infoPtr->tabHeight - 2) +
@@ -291 +292 @@
 
   /*
-   * "scroll" it to make sure the item at the very left of the 
+   * "scroll" it to make sure the item at the very left of the
    * tab control is the leftmost visible tab.
    */
@@ -297 +298 @@
   {
     OffsetRect(itemRect,
-             0,
-             -(clientRect.bottom - infoPtr->items[infoPtr->leftmostVisible].rect.bottom));
+         0,
+         -(clientRect.bottom - infoPtr->items[infoPtr->leftmostVisible].rect.bottom));
 
     /*
@@ -305 +306 @@
      */
     OffsetRect(itemRect,
-             0,
-             -SELECTED_TAB_OFFSET);
+         0,
+         -SELECTED_TAB_OFFSET);
 
   } else
   {
     OffsetRect(itemRect,
-             -infoPtr->items[infoPtr->leftmostVisible].rect.left, 
-             0);
+         -infoPtr->items[infoPtr->leftmostVisible].rect.left,
+         0);
 
     /*
@@ -319 +320 @@
      */
     OffsetRect(itemRect,
-             SELECTED_TAB_OFFSET,
-             0);
+         SELECTED_TAB_OFFSET,
+         0);
   }
 
@@ -336 +337 @@
     /* If it also a bit higher. */
     if ((lStyle & TCS_BOTTOM) && !(lStyle & TCS_VERTICAL))
-    {      
+    {
       selectedRect->top -= 2; /* the border is thicker on the bottom */
       selectedRect->bottom += SELECTED_TAB_OFFSET;
@@ -362 +363 @@
 static BOOL TAB_GetItemRect(HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
-  return TAB_InternalGetItemRect(hwnd, TAB_GetInfoPtr(hwnd), (INT)wParam, 
+  return TAB_InternalGetItemRect(hwnd, TAB_GetInfoPtr(hwnd), (INT)wParam,
                                  (LPRECT)lParam, (LPRECT)NULL);
 }
@@ -372 +373 @@
  */
 static LRESULT TAB_KeyUp(
-  HWND   hwnd, 
+  HWND   hwnd,
   WPARAM keyCode)
 {
@@ -387 +388 @@
       break;
   }
-  
+
   /*
    * If we changed to a valid item, change the selection
@@ -416 +417 @@
  */
 static LRESULT TAB_FocusChanging(
-  HWND   hwnd, 
-  UINT   uMsg, 
-  WPARAM wParam, 
+  HWND   hwnd,
+  UINT   uMsg,
+  WPARAM wParam,
   LPARAM lParam)
 {
@@ -429 +430 @@
    */
   isVisible = TAB_InternalGetItemRect(hwnd,
-                                      infoPtr,
-                                      infoPtr->uFocus,
-                                      NULL,
-                                      &selectedRect);
-  
+                      infoPtr,
+                      infoPtr->uFocus,
+                      NULL,
+                      &selectedRect);
+
   /*
    * If the rectangle is not completely invisible, invalidate that
@@ -451 +452 @@
 static HWND TAB_InternalHitTest (
   HWND      hwnd,
-  TAB_INFO* infoPtr, 
-  POINT     pt, 
+  TAB_INFO* infoPtr,
+  POINT     pt,
   UINT*     flags)
 
 {
   RECT rect;
-  int iCount; 
-  
+  int iCount;
+
   for (iCount = 0; iCount < infoPtr->uNumItem; iCount++)
   {
@@ -479 +480 @@
   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
   LPTCHITTESTINFO lptest = (LPTCHITTESTINFO) lParam;
-  
+
   return TAB_InternalHitTest (hwnd, infoPtr, lptest->pt, &lptest->flags);
 }
@@ -521 +522 @@
   if (infoPtr->hwndToolTip)
     TAB_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                    WM_LBUTTONDOWN, wParam, lParam);
+            WM_LBUTTONDOWN, wParam, lParam);
 
   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_FOCUSONBUTTONDOWN ) {
@@ -529 +530 @@
   if (infoPtr->hwndToolTip)
     TAB_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                    WM_LBUTTONDOWN, wParam, lParam);
-  
+            WM_LBUTTONDOWN, wParam, lParam);
+
   pt.x = (INT)LOWORD(lParam);
   pt.y = (INT)HIWORD(lParam);
-  
+
   newItem = TAB_InternalHitTest (hwnd, infoPtr, pt, &dummy);
-  
+
   TRACE("On Tab, item %d\n", newItem);
 
@@ -619 +620 @@
     ** overlaps.  Note also that the case where the cursor stayed within our
     ** window but has moved off the hot-tracked tab will be handled by the
-    ** WM_MOUSEMOVE event. 
+    ** WM_MOUSEMOVE event.
     */
     if (!GetCursorPos(&pt) || WindowFromPoint(pt) != hwnd)
@@ -721 +722 @@
     if (item >= 0)
     {
-        /* Mark new hot-tracked to be redrawn to look highlighted */
+    /* Mark new hot-tracked to be redrawn to look highlighted */
       if (out_redrawEnter != NULL)
         *out_redrawEnter = item;
@@ -743 +744 @@
   if (infoPtr->hwndToolTip)
     TAB_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                    WM_LBUTTONDOWN, wParam, lParam);
+            WM_LBUTTONDOWN, wParam, lParam);
 
   /* Determine which tab to highlight.  Redraw tabs which change highlight
@@ -764 +765 @@
  */
 static LRESULT TAB_AdjustRect(
-  HWND   hwnd, 
-  WPARAM fLarger, 
+  HWND   hwnd,
+  WPARAM fLarger,
   LPRECT prc)
 {
@@ -845 +846 @@
  */
 static LRESULT TAB_OnHScroll(
-  HWND    hwnd, 
+  HWND    hwnd,
   int     nScrollCode,
   int     nPos,
@@ -871 +872 @@
  * TAB_SetupScrolling
  *
- * This method will check the current scrolling state and make sure the 
+ * This method will check the current scrolling state and make sure the
  * scrolling control is displayed (or not).
  */
@@ -930 +931 @@
     {
       infoPtr->hwndUpDown = CreateWindowA("msctls_updown32",
-                                          "",
-                                          WS_VISIBLE | WS_CHILD | UDS_HORZ,
-                                          controlPos.left, controlPos.top,
-                                          controlPos.right - controlPos.left,
-                                          controlPos.bottom - controlPos.top,
-                                          hwnd,
-                                          (HMENU)NULL, 
-                                          (HINSTANCE)NULL, 
-                                          NULL);        
+                      "",
+                      WS_VISIBLE | WS_CHILD | UDS_HORZ,
+                      controlPos.left, controlPos.top,
+                      controlPos.right - controlPos.left,
+                      controlPos.bottom - controlPos.top,
+                      hwnd,
+                      (HMENU)NULL,
+                      (HINSTANCE)NULL,
+                      NULL);
     }
     else
     {
-      SetWindowPos(infoPtr->hwndUpDown, 
-                   (HWND)NULL,
-                   controlPos.left, controlPos.top,
-                   controlPos.right - controlPos.left,
-                   controlPos.bottom - controlPos.top,
-                   SWP_SHOWWINDOW | SWP_NOZORDER);                 
+      SetWindowPos(infoPtr->hwndUpDown,
+           (HWND)NULL,
+           controlPos.left, controlPos.top,
+           controlPos.right - controlPos.left,
+           controlPos.bottom - controlPos.top,
+           SWP_SHOWWINDOW | SWP_NOZORDER);
     }
 
@@ -1010 +1011 @@
    * a font.
    */
-  hdc = GetDC(hwnd); 
-    
+  hdc = GetDC(hwnd);
+
   hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
   hOldFont = SelectObject (hdc, hFont);
@@ -1022 +1023 @@
 
   /* if TCS_VERTICAL then swap the height and width so this code places the
-     tabs along the top of the rectangle and we can just rotate them after 
+     tabs along the top of the rectangle and we can just rotate them after
      rather than duplicate all of the below code */
   if(lStyle & TCS_VERTICAL)
@@ -1054 +1055 @@
 
     /*
-     * Make sure there is enough space for the letters + icon + growing the 
-     * selected item + extra space for the selected item.   
+     * Make sure there is enough space for the letters + icon + growing the
+     * selected item + extra space for the selected item.
      */
     infoPtr->tabHeight = item_height + 2 * VERTICAL_ITEM_PADDING +
@@ -1085 +1086 @@
        * for button style tabs */
       if (lStyle & TCS_BUTTONS)
-              size.cx = max(size.cx, 2 * (infoPtr->tabHeight - 2));
+          size.cx = max(size.cx, 2 * (infoPtr->tabHeight - 2));
 
       /* Add the icon width */
@@ -1095 +1096 @@
 
       infoPtr->items[curItem].rect.right = infoPtr->items[curItem].rect.left +
-                                           size.cx + icon_width + 
+                                           size.cx + icon_width +
                                            num * HORIZONTAL_ITEM_PADDING;
     }
@@ -1114 +1115 @@
                                       infoPtr->items[curItem].rect.left;
 
-        infoPtr->items[curItem].rect.left = 0;
+    infoPtr->items[curItem].rect.left = 0;
         curItemRowCount++;
     }
@@ -1122 +1123 @@
 
     TRACE("TextSize: %li\n", size.cx);
-    TRACE("Rect: T %i, L %i, B %i, R %i\n", 
-          infoPtr->items[curItem].rect.top,
-          infoPtr->items[curItem].rect.left,
-          infoPtr->items[curItem].rect.bottom,
-          infoPtr->items[curItem].rect.right);  
+    TRACE("Rect: T %i, L %i, B %i, R %i\n",
+      infoPtr->items[curItem].rect.top,
+      infoPtr->items[curItem].rect.left,
+      infoPtr->items[curItem].rect.bottom,
+      infoPtr->items[curItem].rect.right);
 
     /*
@@ -1152 +1153 @@
     /* Don't need scrolling, then update infoPtr->leftmostVisible */
     if(!infoPtr->needsScrolling)
-      infoPtr->leftmostVisible = 0; 
+      infoPtr->leftmostVisible = 0;
 
     TAB_SetupScrolling(hwnd, infoPtr, &clientRect);
@@ -1193 +1194 @@
 
           /* shift the item to the left side of the clientRect */
-          infoPtr->items[iItm].rect.right -= 
+          infoPtr->items[iItm].rect.right -=
             infoPtr->items[iItm].rect.left;
           infoPtr->items[iItm].rect.left = 0;
@@ -1202 +1203 @@
           infoPtr->items[iItm].rect.top = iRow;
           if (lStyle & TCS_BUTTONS)
-          {
+      {
             curItemLeftPos = infoPtr->items[iItm].rect.right + 1;
             if (lStyle & TCS_FLATBUTTONS)
-              curItemLeftPos += FLAT_BTN_SPACINGX;
-          }
+          curItemLeftPos += FLAT_BTN_SPACINGX;
+      }
           else
             curItemLeftPos = infoPtr->items[iItm].rect.right;
       }
-          
+
       /*
        * Justify the rows
@@ -1217 +1218 @@
          while(iIndexStart < infoPtr->uNumItem)
         {
-        /* 
+        /*
          * find the indexs of the row
          */
         /* find the first item on the next row */
         for (iIndexEnd=iIndexStart;
-             (iIndexEnd < infoPtr->uNumItem) && 
-               (infoPtr->items[iIndexEnd].rect.top ==
+             (iIndexEnd < infoPtr->uNumItem) &&
+           (infoPtr->items[iIndexEnd].rect.top ==
                 infoPtr->items[iIndexStart].rect.top) ;
             iIndexEnd++)
         /* intentionaly blank */;
 
-        /* 
+        /*
          * we need to justify these tabs so they fill the whole given
          * client area
@@ -1246 +1247 @@
            widthDiff = widthDiff / iCount;
            /* add widthDiff/iCount, or extra space/items on row, to each item on this row */
-           for (iIndex=iIndexStart,iCount=0; iIndex < iIndexEnd; 
+           for (iIndex=iIndexStart,iCount=0; iIndex < iIndexEnd;
                 iIndex++,iCount++)
            {
@@ -1297 +1298 @@
  * This method is used to draw the interior (text and icon) of a single tab
  * into the tab control.
- */         
+ */
 static void
 TAB_DrawItemInterior
@@ -1390 +1391 @@
     id = GetWindowLongA( hwnd, GWL_ID );
 
-    /* 
+    /*
      * put together the DRAWITEMSTRUCT
      */
-    dis.CtlType    = ODT_TAB;   
-    dis.CtlID      = id;                
-    dis.itemID     = iItem;             
-    dis.itemAction = ODA_DRAWENTIRE;    
+    dis.CtlType    = ODT_TAB;
+    dis.CtlID      = id;
+    dis.itemID     = iItem;
+    dis.itemAction = ODA_DRAWENTIRE;
     if ( iItem == infoPtr->iSelected )
-      dis.itemState = ODS_SELECTED;     
-    else                                
-      dis.itemState = 0;                
-    dis.hwndItem = hwnd;                /* */
-    dis.hDC      = hdc;         
-    dis.rcItem   = *drawRect;           /* */
+      dis.itemState = ODS_SELECTED;
+    else
+      dis.itemState = 0;
+    dis.hwndItem = hwnd;        /* */
+    dis.hDC      = hdc;
+    dis.rcItem   = *drawRect;       /* */
     dis.itemData = infoPtr->items[iItem].lParam;
 
@@ -1538 +1539 @@
     if(lStyle & TCS_VERTICAL)
     {
-      if (!GetObjectA((infoPtr->hFont) ? 
+      if (!GetObjectA((infoPtr->hFont) ?
                 infoPtr->hFont : GetStockObject(SYSTEM_FONT),
                 sizeof(LOGFONTA),&logfont))
@@ -1545 +1546 @@
 
         lstrcpyA(logfont.lfFaceName, "Arial");
-        logfont.lfHeight = -MulDiv(iPointSize, GetDeviceCaps(hdc, LOGPIXELSY), 
+        logfont.lfHeight = -MulDiv(iPointSize, GetDeviceCaps(hdc, LOGPIXELSY),
                                     72);
         logfont.lfWeight = FW_NORMAL;
@@ -1604 +1605 @@
  *
  * This method is used to draw a single tab into the tab control.
- */         
+ */
 static void TAB_DrawItem(
-  HWND hwnd, 
-  HDC  hdc, 
+  HWND hwnd,
+  HDC  hdc,
   INT  iItem)
 {
@@ -1621 +1622 @@
    */
   isVisible = TAB_InternalGetItemRect(hwnd,
-                                      infoPtr,
-                                      iItem,
-                                      &itemRect,
-                                      &selectedRect);
+                      infoPtr,
+                      iItem,
+                      &itemRect,
+                      &selectedRect);
 
   if (isVisible)
   {
-    HBRUSH hbr       = CreateSolidBrush (GetSysColor(COLOR_BTNFACE));    
+    HBRUSH hbr       = CreateSolidBrush (GetSysColor(COLOR_BTNFACE));
     HPEN   hwPen     = GetSysColorPen (COLOR_3DHILIGHT);
     HPEN hbPen  = GetSysColorPen (COLOR_3DDKSHADOW);
@@ -1645 +1646 @@
       /* Separators between flat buttons */
       /* FIXME: test and correct this if necessary for TCS_FLATBUTTONS style */
-      if (lStyle & TCS_FLATBUTTONS) 
+      if (lStyle & TCS_FLATBUTTONS)
       {
         int x = r.right + FLAT_BTN_SPACINGX - 2;
@@ -1669 +1670 @@
         /* Background color */
         if (!((lStyle & TCS_OWNERDRAWFIXED) && infoPtr->fSizeSet))
-        {
+    {
               COLORREF bk = GetSysColor(COLOR_3DHILIGHT);
               DeleteObject(hbr);
@@ -1685 +1686 @@
 
               deleteBrush = FALSE;
-        }
+    }
 
         /* Erase the background */
@@ -1704 +1705 @@
         LineTo   (hdc, r.right, r.bottom);
         LineTo   (hdc, r.right, r.top + 1);
-        
+
         /* shadow */
         SelectObject(hdc, hbPen);
@@ -1721 +1722 @@
         FillRect(hdc, &r, hbr);
 
-        if (!(lStyle & TCS_FLATBUTTONS))
-        {
+    if (!(lStyle & TCS_FLATBUTTONS))
+    {
           /* highlight */
           MoveToEx (hdc, r.left, r.bottom, NULL);
           LineTo   (hdc, r.left, r.top);
           LineTo   (hdc, r.right, r.top);
-         
+
           /* shadow */
           SelectObject(hdc, hbPen);
@@ -1738 +1739 @@
           LineTo   (hdc, r.right - 1, r.bottom - 1);
           LineTo   (hdc, r.left + 1, r.bottom - 1);
-        }
+    }
       }
     }
@@ -1745 +1746 @@
       /* Background color */
       DeleteObject(hbr);
-      hbr = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));    
+      hbr = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
 
       /* We draw a rectangle of different sizes depending on the selection
@@ -1756 +1757 @@
       /*
        * Erase the background.
-       * This is necessary when drawing the selected item since it is larger 
-       * than the others, it might overlap with stuff already drawn by the 
+       * This is necessary when drawing the selected item since it is larger
+       * than the others, it might overlap with stuff already drawn by the
        * other tabs
-       */     
+       */
       FillRect(hdc, &r, hbr);
 
@@ -1770 +1771 @@
       r.right--;
       r.bottom--;
-      
+
       holdPen = SelectObject (hdc, hwPen);
       if(lStyle & TCS_VERTICAL)
@@ -1859 +1860 @@
       }
     }
-  
+
     /* This modifies r to be the text rectangle. */
 {
@@ -1868 +1869 @@
     /* Draw the focus rectangle */
     if (((lStyle & TCS_FOCUSNEVER) == 0) &&
-         (GetFocus() == hwnd) &&
-         (iItem == infoPtr->uFocus) )
+     (GetFocus() == hwnd) &&
+     (iItem == infoPtr->uFocus) )
     {
       r = itemRect;
@@ -1888 +1889 @@
  * This method is used to draw the raised border around the tab control
  * "content" area.
- */         
+ */
 static void TAB_DrawBorder (HWND hwnd, HDC hdc)
 {
@@ -1957 +1958 @@
  *
  * This method repaints the tab control..
- */             
+ */
 static void TAB_Refresh (HWND hwnd, HDC hdc)
 {
@@ -1971 +1972 @@
   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BUTTONS)
   {
-    for (i = 0; i < infoPtr->uNumItem; i++) 
+    for (i = 0; i < infoPtr->uNumItem; i++)
       TAB_DrawItem (hwnd, hdc, i);
   }
@@ -1977 +1978 @@
   {
     /* Draw all the non selected item first */
-    for (i = 0; i < infoPtr->uNumItem; i++) 
+    for (i = 0; i < infoPtr->uNumItem; i++)
     {
       if (i != infoPtr->iSelected)
-        TAB_DrawItem (hwnd, hdc, i);
+    TAB_DrawItem (hwnd, hdc, i);
     }
 
@@ -2011 +2012 @@
 {
     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
-  
+
   infoPtr->DoRedraw=(BOOL) wParam;
   return 0;
@@ -2017 +2018 @@
 
 static LRESULT TAB_EraseBackground(
-  HWND hwnd, 
+  HWND hwnd,
   HDC  givenDC)
 {
@@ -2207 +2208 @@
   HDC hdc;
   PAINTSTRUCT ps;
-    
+
   hdc = wParam== 0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
   TAB_Refresh (hwnd, hdc);
-    
+
   if(!wParam)
     EndPaint (hwnd, &ps);
@@ -2219 +2220 @@
 static LRESULT
 TAB_InsertItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
-{    
+{
   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
   TCITEMA *pti;
   INT iItem;
   RECT rect;
-  
+
   GetClientRect (hwnd, &rect);
   TRACE("Rect: %x T %i, L %i, B %i, R %i\n", hwnd,
-        rect.top, rect.left, rect.bottom, rect.right);  
-  
+        rect.top, rect.left, rect.bottom, rect.right);
+
   pti = (TCITEMA *)lParam;
   iItem = (INT)wParam;
-  
+
   if (iItem < 0) return -1;
   if (iItem > infoPtr->uNumItem)
     iItem = infoPtr->uNumItem;
-  
+
   if (infoPtr->uNumItem == 0) {
     infoPtr->items = COMCTL32_Alloc (sizeof (TAB_ITEM));
@@ -2243 +2244 @@
   else {
     TAB_ITEM *oldItems = infoPtr->items;
-    
+
     infoPtr->uNumItem++;
     infoPtr->items = COMCTL32_Alloc (sizeof (TAB_ITEM) * infoPtr->uNumItem);
-    
+
     /* pre insert copy */
     if (iItem > 0) {
       memcpy (&infoPtr->items[0], &oldItems[0],
-              iItem * sizeof(TAB_ITEM));
-    }
-    
+          iItem * sizeof(TAB_ITEM));
+    }
+
     /* post insert copy */
     if (iItem < infoPtr->uNumItem - 1) {
       memcpy (&infoPtr->items[iItem+1], &oldItems[iItem],
-              (infoPtr->uNumItem - iItem - 1) * sizeof(TAB_ITEM));
-      
+          (infoPtr->uNumItem - iItem - 1) * sizeof(TAB_ITEM));
+
     }
 
@@ -2265 +2266 @@
     COMCTL32_Free (oldItems);
   }
-  
+
   infoPtr->items[iItem].mask = pti->mask;
   if (pti->mask & TCIF_TEXT)
@@ -2272 +2273 @@
   if (pti->mask & TCIF_IMAGE)
     infoPtr->items[iItem].iImage = pti->iImage;
-  
+
   if (pti->mask & TCIF_PARAM)
     infoPtr->items[iItem].lParam = pti->lParam;
-  
+
   TAB_SetItemBounds(hwnd);
   TAB_InvalidateTabArea(hwnd, infoPtr);
-  
+
   TRACE("[%04x]: added item %d '%s'\n",
-        hwnd, iItem, debugstr_w(infoPtr->items[iItem].pszText));
+    hwnd, iItem, debugstr_w(infoPtr->items[iItem].pszText));
 
   return iItem;
@@ -2319 +2320 @@
     if (iItem > 0) {
       memcpy (&infoPtr->items[0], &oldItems[0],
-              iItem * sizeof(TAB_ITEM));
+          iItem * sizeof(TAB_ITEM));
     }
 
@@ -2325 +2326 @@
     if (iItem < infoPtr->uNumItem - 1) {
       memcpy (&infoPtr->items[iItem+1], &oldItems[iItem],
-              (infoPtr->uNumItem - iItem - 1) * sizeof(TAB_ITEM));
-
-  }
-  
+          (infoPtr->uNumItem - iItem - 1) * sizeof(TAB_ITEM));
+
+  }
+
     if (iItem <= infoPtr->iSelected)
       infoPtr->iSelected++;
@@ -2341 +2342 @@
   if (pti->mask & TCIF_IMAGE)
     infoPtr->items[iItem].iImage = pti->iImage;
-  
+
   if (pti->mask & TCIF_PARAM)
     infoPtr->items[iItem].lParam = pti->lParam;
-  
+
   TAB_SetItemBounds(hwnd);
   TAB_InvalidateTabArea(hwnd, infoPtr);
-  
+
   TRACE("[%04x]: added item %d '%s'\n",
-        hwnd, iItem, debugstr_w(infoPtr->items[iItem].pszText));
+    hwnd, iItem, debugstr_w(infoPtr->items[iItem].pszText));
 
   return iItem;
@@ -2355 +2356 @@
 
 
-static LRESULT 
+static LRESULT
 TAB_SetItemSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -2373 +2374 @@
 }
 
-static LRESULT 
+static LRESULT
 TAB_SetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
-  TCITEMA *tabItem; 
+  TCITEMA *tabItem;
   TAB_ITEM *wineItem;
   INT    iItem;
@@ -2395 +2396 @@
     wineItem->lParam = tabItem->lParam;
 
-  if (tabItem->mask & TCIF_RTLREADING) 
+  if (tabItem->mask & TCIF_RTLREADING)
     FIXME("TCIF_RTLREADING\n");
 
-  if (tabItem->mask & TCIF_STATE) 
+  if (tabItem->mask & TCIF_STATE)
     wineItem->dwState = tabItem->dwState;
 
@@ -2451 +2452 @@
 
 
-static LRESULT 
+static LRESULT
 TAB_GetItemCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -2460 +2461 @@
 
 
-static LRESULT 
+static LRESULT
 TAB_GetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -2476 +2477 @@
   wineItem = &infoPtr->items[iItem];
 
-  if (tabItem->mask & TCIF_IMAGE) 
+  if (tabItem->mask & TCIF_IMAGE)
     tabItem->iImage = wineItem->iImage;
 
-  if (tabItem->mask & TCIF_PARAM) 
+  if (tabItem->mask & TCIF_PARAM)
     tabItem->lParam = wineItem->lParam;
 
-  if (tabItem->mask & TCIF_RTLREADING) 
+  if (tabItem->mask & TCIF_RTLREADING)
     FIXME("TCIF_RTLREADING\n");
 
-  if (tabItem->mask & TCIF_STATE) 
+  if (tabItem->mask & TCIF_STATE)
     tabItem->dwState = wineItem->dwState;
 
-  if (tabItem->mask & TCIF_TEXT) 
+  if (tabItem->mask & TCIF_TEXT)
    Str_GetPtrWtoA (wineItem->pszText, tabItem->pszText, tabItem->cchTextMax);
 
@@ -2495 +2496 @@
 
 
-static LRESULT 
+static LRESULT
 TAB_GetItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -2530 +2531 @@
 
 
-static LRESULT 
+static LRESULT
 TAB_DeleteItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -2540 +2541 @@
   {
     TAB_ITEM *oldItems = infoPtr->items;
-    
+
     infoPtr->uNumItem--;
     infoPtr->items = COMCTL32_Alloc(sizeof (TAB_ITEM) * infoPtr->uNumItem);
-    
-    if (iItem > 0) 
+
+    if (iItem > 0)
       memcpy(&infoPtr->items[0], &oldItems[0], iItem * sizeof(TAB_ITEM));
-    
-    if (iItem < infoPtr->uNumItem) 
+
+    if (iItem < infoPtr->uNumItem)
       memcpy(&infoPtr->items[iItem], &oldItems[iItem + 1],
               (infoPtr->uNumItem - iItem) * sizeof(TAB_ITEM));
-    
+
     COMCTL32_Free(oldItems);
 
@@ -2556 +2557 @@
     if ((iItem == infoPtr->iSelected) && (iItem > 0))
       infoPtr->iSelected--;
-      
+
     if (iItem < infoPtr->iSelected)
       infoPtr->iSelected--;
@@ -2573 +2574 @@
 }
 
-static LRESULT 
+static LRESULT
 TAB_DeleteAllItems (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -2584 +2585 @@
     KillTimer(hwnd, TAB_HOTTRACK_TIMER);
   infoPtr->iHotTracked = -1;
- 
+
   TAB_SetItemBounds(hwnd);
   TAB_InvalidateTabArea(hwnd,infoPtr);
@@ -2605 +2606 @@
 {
   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
-  
+
   TRACE("%x %lx\n",wParam, lParam);
-  
+
   infoPtr->hFont = (HFONT)wParam;
-  
+
   TAB_SetItemBounds(hwnd);
 
@@ -2676 +2677 @@
     cx=LOWORD (lParam);
     cy=HIWORD (lParam);
-    if (GetWindowLongA(hwnd, GWL_STYLE) & CCS_NORESIZE) 
+    if (GetWindowLongA(hwnd, GWL_STYLE) & CCS_NORESIZE)
         uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
 
@@ -2695 +2696 @@
 
 
-static LRESULT 
+static LRESULT
 TAB_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
 {
@@ -2711 +2712 @@
 
   SetWindowLongA(hwnd, 0, (DWORD)infoPtr);
-   
+
   infoPtr->uNumItem        = 0;
   infoPtr->uNumRows        = 0;
@@ -2719 +2720 @@
   infoPtr->iSelected       = -1;
   infoPtr->iHotTracked     = -1;
-  infoPtr->uFocus          = -1;  
+  infoPtr->uFocus          = -1;
   infoPtr->hwndToolTip     = 0;
   infoPtr->DoRedraw        = TRUE;
@@ -2725 +2726 @@
   infoPtr->hwndUpDown      = 0;
   infoPtr->leftmostVisible = 0;
-  infoPtr->fSizeSet        = FALSE;
-  infoPtr->bUnicode        = IsWindowUnicode (hwnd);
-  
-  TRACE("Created tab control, hwnd [%04x]\n", hwnd); 
-
-  /* The tab control always has the WS_CLIPSIBLINGS style. Even 
-     if you don't specify it in CreateWindow. This is necessary in 
+  infoPtr->fSizeSet    = FALSE;
+  infoPtr->bUnicode    = IsWindowUnicode (hwnd);
+
+  TRACE("Created tab control, hwnd [%04x]\n", hwnd);
+
+  /* The tab control always has the WS_CLIPSIBLINGS style. Even
+     if you don't specify it in CreateWindow. This is necessary in
      order for paint to work correctly. This follows windows behaviour. */
   dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
@@ -2740 +2741 @@
     infoPtr->hwndToolTip =
       CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
-                       CW_USEDEFAULT, CW_USEDEFAULT,
-                       CW_USEDEFAULT, CW_USEDEFAULT,
-                       hwnd, 0, 0, 0);
-    
+               CW_USEDEFAULT, CW_USEDEFAULT,
+               CW_USEDEFAULT, CW_USEDEFAULT,
+               hwnd, 0, 0, 0);
+
     /* Send NM_TOOLTIPSCREATED notification */
     if (infoPtr->hwndToolTip) {
       NMTOOLTIPSCREATED nmttc;
-      
+
       nmttc.hdr.hwndFrom = hwnd;
       nmttc.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
       nmttc.hdr.code = NM_TOOLTIPSCREATED;
       nmttc.hwndToolTips = infoPtr->hwndToolTip;
-      
+
       SendMessageA (GetParent (hwnd), WM_NOTIFY,
-                    (WPARAM)GetWindowLongA(hwnd, GWL_ID), (LPARAM)&nmttc);
-    }
-  }  
-    
+            (WPARAM)GetWindowLongA(hwnd, GWL_ID), (LPARAM)&nmttc);
+    }
+  }
+
   /*
    * We need to get text information so we need a DC and we need to select
    * a font.
    */
-  hdc = GetDC(hwnd); 
+  hdc = GetDC(hwnd);
   hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));
 
@@ -2769 +2770 @@
 
   /*
-   * Make sure there is enough space for the letters + growing the 
-   * selected item + extra space for the selected item.   
+   * Make sure there is enough space for the letters + growing the
+   * selected item + extra space for the selected item.
    */
   infoPtr->tabHeight = fontMetrics.tmHeight + 2 * VERTICAL_ITEM_PADDING +
@@ -2796 +2797 @@
     for (iItem = 0; iItem < infoPtr->uNumItem; iItem++) {
       if (infoPtr->items[iItem].pszText)
-        COMCTL32_Free (infoPtr->items[iItem].pszText);
+    COMCTL32_Free (infoPtr->items[iItem].pszText);
     }
     COMCTL32_Free (infoPtr->items);
   }
-  
-  if (infoPtr->hwndToolTip) 
+
+  if (infoPtr->hwndToolTip)
     DestroyWindow (infoPtr->hwndToolTip);
- 
+
   if (infoPtr->hwndUpDown)
     DestroyWindow(infoPtr->hwndUpDown);
@@ -2827 +2828 @@
     case TCM_GETIMAGELIST:
       return TAB_GetImageList (hwnd, wParam, lParam);
-      
+
     case TCM_SETIMAGELIST:
       return TAB_SetImageList (hwnd, wParam, lParam);
-      
+
     case TCM_GETITEMCOUNT:
       return TAB_GetItemCount (hwnd, wParam, lParam);
-      
+
     case TCM_GETITEMA:
       return TAB_GetItemA (hwnd, wParam, lParam);
-      
+
     case TCM_GETITEMW:
       return TAB_GetItemW (hwnd, wParam, lParam);
-      
+
     case TCM_SETITEMA:
       return TAB_SetItemA (hwnd, wParam, lParam);
-      
+
     case TCM_SETITEMW:
       return TAB_SetItemW (hwnd, wParam, lParam);
-      
+
     case TCM_DELETEITEM:
       return TAB_DeleteItem (hwnd, wParam, lParam);
-      
+
     case TCM_DELETEALLITEMS:
      return TAB_DeleteAllItems (hwnd, wParam, lParam);
-     
+
     case TCM_GETITEMRECT:
      return TAB_GetItemRect (hwnd, wParam, lParam);
-      
+
     case TCM_GETCURSEL:
       return TAB_GetCurSel (hwnd);
-      
+
     case TCM_HITTEST:
       return TAB_HitTest (hwnd, wParam, lParam);
-      
+
     case TCM_SETCURSEL:
       return TAB_SetCurSel (hwnd, wParam);
-      
+
     case TCM_INSERTITEMA:
       return TAB_InsertItemA (hwnd, wParam, lParam);
-      
+
     case TCM_INSERTITEMW:
       return TAB_InsertItemW (hwnd, wParam, lParam);
-      
+
     case TCM_SETITEMEXTRA:
       FIXME("Unimplemented msg TCM_SETITEMEXTRA\n");
       return 0;
-      
+
     case TCM_ADJUSTRECT:
       return TAB_AdjustRect (hwnd, (BOOL)wParam, (LPRECT)lParam);
-      
+
     case TCM_SETITEMSIZE:
       return TAB_SetItemSize (hwnd, wParam, lParam);
-      
+
     case TCM_REMOVEIMAGE:
       FIXME("Unimplemented msg TCM_REMOVEIMAGE\n");
       return 0;
-      
+
     case TCM_SETPADDING:
       FIXME("Unimplemented msg TCM_SETPADDING\n");
       return 0;
-      
+
     case TCM_GETROWCOUNT:
       return TAB_GetRowCount(hwnd);
@@ -2900 +2901 @@
       FIXME("Unimplemented msg TCM_HIGHLIGHTITEM\n");
       return 0;
-      
+
     case TCM_GETTOOLTIPS:
       return TAB_GetToolTips (hwnd, wParam, lParam);
-      
+
     case TCM_SETTOOLTIPS:
       return TAB_SetToolTips (hwnd, wParam, lParam);
-      
+
     case TCM_GETCURFOCUS:
       return TAB_GetCurFocus (hwnd);
-      
+
     case TCM_SETCURFOCUS:
       return TAB_SetCurFocus (hwnd, wParam);
-      
+
     case TCM_SETMINTABWIDTH:
       FIXME("Unimplemented msg TCM_SETMINTABWIDTH\n");
       return 0;
-      
+
     case TCM_DESELECTALL:
       FIXME("Unimplemented msg TCM_DESELECTALL\n");
       return 0;
-      
+
     case TCM_GETEXTENDEDSTYLE:
       FIXME("Unimplemented msg TCM_GETEXTENDEDSTYLE\n");
@@ -2931 +2932 @@
     case WM_GETFONT:
       return TAB_GetFont (hwnd, wParam, lParam);
-      
+
     case WM_SETFONT:
       return TAB_SetFont (hwnd, wParam, lParam);
-      
+
     case WM_CREATE:
       return TAB_Create (hwnd, wParam, lParam);
-      
+
     case WM_NCDESTROY:
       return TAB_Destroy (hwnd, wParam, lParam);
-      
+
     case WM_GETDLGCODE:
       return DLGC_WANTARROWS | DLGC_WANTCHARS;
-      
+
     case WM_LBUTTONDOWN:
       return TAB_LButtonDown (hwnd, wParam, lParam);
-      
+
     case WM_LBUTTONUP:
       return TAB_LButtonUp (hwnd, wParam, lParam);
-      
+
     case WM_RBUTTONDOWN:
       return TAB_RButtonDown (hwnd, wParam, lParam);
-      
+
     case WM_MOUSEMOVE:
       return TAB_MouseMove (hwnd, wParam, lParam);
-      
+
     case WM_ERASEBKGND:
       return TAB_EraseBackground (hwnd, (HDC)wParam);
@@ -2964 +2965 @@
     case WM_SIZE:
       return TAB_Size (hwnd, wParam, lParam);
-      
+
     case WM_SETREDRAW:
       return TAB_SetRedraw (hwnd, wParam);
@@ -2975 +2976 @@
       InvalidateRect(hwnd, NULL, TRUE);
       return 0;
-      
+
     case WM_KILLFOCUS:
     case WM_SETFOCUS:
@@ -2987 +2988 @@
     default:
       if (uMsg >= WM_USER)
-        WARN("unknown msg %04x wp=%08x lp=%08lx\n",
-             uMsg, wParam, lParam);
+    WARN("unknown msg %04x wp=%08x lp=%08lx\n",
+         uMsg, wParam, lParam);
 #ifdef __WIN32OS2__
       return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
@@ -3013 +3014 @@
   wndClass.hbrBackground = (HBRUSH)NULL;
   wndClass.lpszClassName = WC_TABCONTROLA;
-  
+
   RegisterClassA (&wndClass);
 }

trunk/src/comctl32/toolbar.c

@@ +1 @@
+/* $Id: toolbar.c,v 1.29 2001-09-05 12:05:03 bird Exp $ */
 /*
  * Toolbar control
@@ -62 +63 @@
     INT nRow;
     RECT rect;
-} TBUTTON_INFO; 
+} TBUTTON_INFO;
 
 #ifdef __WIN32OS2__
@@ -131 +132 @@
 #define TOP_BORDER         2
 #define BOTTOM_BORDER      2
-#define DDARROW_WIDTH      11 
+#define DDARROW_WIDTH      11
 
 #define TOOLBAR_GetInfoPtr(hwnd) ((TOOLBAR_INFO *)GetWindowLongA(hwnd,0))
@@ -147 +148 @@
     else if ((btnPtr->iString >= 0) && (btnPtr->iString < infoPtr->nNumStrings))
         lpText = infoPtr->strings[btnPtr->iString];
-    
+
     return lpText;
 }
 
-static BOOL 
+static BOOL
 TOOLBAR_IsValidBitmapIndex(TOOLBAR_INFO *infoPtr, INT index)
 {
@@ -195 +196 @@
  * Draw the text string for this button.
  * note: infoPtr->himlDis *SHOULD* be non-zero when infoPtr->himlDef
- *      is non-zero, so we can simply check himlDef to see if we have
+ *  is non-zero, so we can simply check himlDef to see if we have
  *      an image list
  */
 static void
 TOOLBAR_DrawString (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
-                    HDC hdc, INT nState, DWORD dwStyle)
+            HDC hdc, INT nState, DWORD dwStyle)
 {
     RECT   rcText = btnPtr->rect;
@@ -219 +220 @@
     if (lpText) {
 
-        InflateRect (&rcText, -3, -3);
-
-        if (himl && TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap)) {
-                if ((dwStyle & TBSTYLE_LIST) &&
-                    ((btnPtr->fsStyle & TBSTYLE_AUTOSIZE) == 0) &&
-                    (btnPtr->iBitmap != I_IMAGENONE)) {
-                    rcText.left += infoPtr->nBitmapWidth;
-                }
-                else {
-                    rcText.top += infoPtr->nBitmapHeight;
-                }
-        }
-
-        if (nState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
-            OffsetRect (&rcText, 1, 1);
-
-        hOldFont = SelectObject (hdc, infoPtr->hFont);
-        nOldBkMode = SetBkMode (hdc, TRANSPARENT);
-        if (!(nState & TBSTATE_ENABLED)) {
-            clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DHILIGHT));
-            OffsetRect (&rcText, 1, 1);
-            DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
-            SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
-            OffsetRect (&rcText, -1, -1);
-            DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
-        }
-        else if (nState & TBSTATE_INDETERMINATE) {
-            clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
-            DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
-        }
-        else {
-            clrOld = SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
-            DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
-        }
-
-        SetTextColor (hdc, clrOld);
-        SelectObject (hdc, hOldFont);
-        if (nOldBkMode != TRANSPARENT)
-            SetBkMode (hdc, nOldBkMode);
+    InflateRect (&rcText, -3, -3);
+
+    if (himl && TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap)) {
+        if ((dwStyle & TBSTYLE_LIST) &&
+            ((btnPtr->fsStyle & TBSTYLE_AUTOSIZE) == 0) &&
+            (btnPtr->iBitmap != I_IMAGENONE)) {
+            rcText.left += infoPtr->nBitmapWidth;
+        }
+        else {
+            rcText.top += infoPtr->nBitmapHeight;
+        }
+    }
+
+    if (nState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
+        OffsetRect (&rcText, 1, 1);
+
+    hOldFont = SelectObject (hdc, infoPtr->hFont);
+    nOldBkMode = SetBkMode (hdc, TRANSPARENT);
+    if (!(nState & TBSTATE_ENABLED)) {
+        clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DHILIGHT));
+        OffsetRect (&rcText, 1, 1);
+        DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
+        SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
+        OffsetRect (&rcText, -1, -1);
+        DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
+    }
+    else if (nState & TBSTATE_INDETERMINATE) {
+        clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
+        DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
+    }
+    else {
+        clrOld = SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
+        DrawTextW (hdc, lpText, -1, &rcText, infoPtr->dwDTFlags);
+    }
+
+    SetTextColor (hdc, clrOld);
+    SelectObject (hdc, hOldFont);
+    if (nOldBkMode != TRANSPARENT)
+        SetBkMode (hdc, nOldBkMode);
     }
 }
@@ -275 +276 @@
 static void
 TOOLBAR_DrawMasked (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
-                    HDC hdc, INT x, INT y)
+            HDC hdc, INT x, INT y)
 {
     /* FIXME: this function is a hack since it uses image list
-              internals directly */
+          internals directly */
 
     HIMAGELIST himl = infoPtr->himlDef;
@@ -286 +287 @@
 
     if (!himl)
-        return;
+    return;
 
     /* create new dc's */
@@ -301 +302 @@
     SetTextColor (hdcImageList, RGB(0, 0, 0));
     BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
-              hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
+          hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
 
     /* draw the new mask */
     SelectObject (hdc, GetSysColorBrush (COLOR_3DHILIGHT));
     BitBlt (hdc, x+1, y+1, himl->cx, himl->cy,
-              hdcMask, 0, 0, 0xB8074A);
+          hdcMask, 0, 0, 0xB8074A);
 
     SelectObject (hdc, GetSysColorBrush (COLOR_3DSHADOW));
     BitBlt (hdc, x, y, himl->cx, himl->cy,
-              hdcMask, 0, 0, 0xB8074A);
+          hdcMask, 0, 0, 0xB8074A);
 
     DeleteObject (hbmMask);
@@ -324 +325 @@
     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
     BOOL hasDropDownArrow = TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle) &&
-                            (btnPtr->fsStyle & TBSTYLE_DROPDOWN);
+                        (btnPtr->fsStyle & TBSTYLE_DROPDOWN);
     RECT rc, rcArrow, rcBitmap;
 
     if (btnPtr->fsState & TBSTATE_HIDDEN)
-        return;
+    return;
 
     rc = btnPtr->rect;
@@ -338 +339 @@
     if (hasDropDownArrow)
     {
-        if (dwStyle & TBSTYLE_FLAT)
+    if (dwStyle & TBSTYLE_FLAT)
             rc.right = max(rc.left, rc.right - DDARROW_WIDTH);
-        else
+    else
             rc.right = max(rc.left, rc.right - DDARROW_WIDTH - 2);
-        rcArrow.left = rc.right; 
+    rcArrow.left = rc.right;
     }
 
@@ -363 +364 @@
         /* when drawing the vertical bar...      */
         if ((dwStyle & TBSTYLE_FLAT) /* && (btnPtr->iBitmap == 0) */)
-            TOOLBAR_DrawFlatSeparator (&rc, hdc);
-        return;
+        TOOLBAR_DrawFlatSeparator (&rc, hdc);
+    return;
     }
 
     /* disabled */
     if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
-        if (!(dwStyle & TBSTYLE_FLAT))
-        {
-            DrawEdge (hdc, &rc, EDGE_RAISED,
-                      BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
+    if (!(dwStyle & TBSTYLE_FLAT))
+    {
+        DrawEdge (hdc, &rc, EDGE_RAISED,
+              BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
             if (hasDropDownArrow)
             DrawEdge (hdc, &rcArrow, EDGE_RAISED,
-                      BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
-        }
-        
+              BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
+    }
+
         if (hasDropDownArrow)
-        {
-            TOOLBAR_DrawArrow(hdc, rcArrow.left+1, rcArrow.top+1, COLOR_3DHIGHLIGHT);
-            TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_3DSHADOW);
-        }
-
-        if (infoPtr->himlDis && 
+    {
+        TOOLBAR_DrawArrow(hdc, rcArrow.left+1, rcArrow.top+1, COLOR_3DHIGHLIGHT);
+        TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_3DSHADOW);
+    }
+
+    if (infoPtr->himlDis &&
             TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap))
-            ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
-                        rcBitmap.left, rcBitmap.top, ILD_NORMAL);
-        else
-            TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rcBitmap.left, rcBitmap.top);
-
-        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
-        return;
+        ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
+            rcBitmap.left, rcBitmap.top, ILD_NORMAL);
+    else
+        TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rcBitmap.left, rcBitmap.top);
+
+    TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
+    return;
     }
 
     /* pressed TBSTYLE_BUTTON */
     if (btnPtr->fsState & TBSTATE_PRESSED) {
-        if (dwStyle & TBSTYLE_FLAT)
-        {
-            DrawEdge (hdc, &rc, BDR_SUNKENOUTER, BF_RECT | BF_MIDDLE | BF_ADJUST);
+    if (dwStyle & TBSTYLE_FLAT)
+    {
+        DrawEdge (hdc, &rc, BDR_SUNKENOUTER, BF_RECT | BF_MIDDLE | BF_ADJUST);
             if (hasDropDownArrow)
-            DrawEdge (hdc, &rcArrow, BDR_SUNKENOUTER, BF_RECT | BF_MIDDLE | BF_ADJUST);
-        }
-        else
-        {
-            DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
+        DrawEdge (hdc, &rcArrow, BDR_SUNKENOUTER, BF_RECT | BF_MIDDLE | BF_ADJUST);
+    }
+    else
+    {
+        DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
             if (hasDropDownArrow)
-            DrawEdge (hdc, &rcArrow, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
-        }
+        DrawEdge (hdc, &rcArrow, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
+    }
 
         if (hasDropDownArrow)
-            TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_WINDOWFRAME);
+        TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_WINDOWFRAME);
 
         if (TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap))
-            ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
-                        rcBitmap.left + 1, rcBitmap.top + 1, ILD_NORMAL);
-
-        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
-        return;
+        ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
+            rcBitmap.left + 1, rcBitmap.top + 1, ILD_NORMAL);
+
+    TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
+    return;
     }
 
     /* checked TBSTYLE_CHECK */
     if ((btnPtr->fsStyle & TBSTYLE_CHECK) &&
-        (btnPtr->fsState & TBSTATE_CHECKED)) {
-        if (dwStyle & TBSTYLE_FLAT)
-            DrawEdge (hdc, &rc, BDR_SUNKENOUTER,
-                        BF_RECT | BF_MIDDLE | BF_ADJUST);
-        else
-            DrawEdge (hdc, &rc, EDGE_SUNKEN,
-                        BF_RECT | BF_MIDDLE | BF_ADJUST);
-
-        TOOLBAR_DrawPattern (hdc, &rc);
-        
+    (btnPtr->fsState & TBSTATE_CHECKED)) {
+    if (dwStyle & TBSTYLE_FLAT)
+        DrawEdge (hdc, &rc, BDR_SUNKENOUTER,
+            BF_RECT | BF_MIDDLE | BF_ADJUST);
+    else
+        DrawEdge (hdc, &rc, EDGE_SUNKEN,
+            BF_RECT | BF_MIDDLE | BF_ADJUST);
+
+    TOOLBAR_DrawPattern (hdc, &rc);
+
         if (TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap))
-            ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
-                        rcBitmap.left + 1, rcBitmap.top + 1, ILD_NORMAL);
-        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
-        return;
-    }
-
-    /* indeterminate */ 
+        ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
+            rcBitmap.left + 1, rcBitmap.top + 1, ILD_NORMAL);
+    TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
+    return;
+    }
+
+    /* indeterminate */
     if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
-        DrawEdge (hdc, &rc, EDGE_RAISED,
-                    BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
-
-        TOOLBAR_DrawPattern (hdc, &rc);
-        TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rcBitmap.left, rcBitmap.top);
-        TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
-        return;
+    DrawEdge (hdc, &rc, EDGE_RAISED,
+            BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
+
+    TOOLBAR_DrawPattern (hdc, &rc);
+    TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rcBitmap.left, rcBitmap.top);
+    TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle);
+    return;
     }
 
@@ -454 +455 @@
     if (dwStyle & TBSTYLE_FLAT)
     {
-        if (btnPtr->bHot)
-        {
-            DrawEdge (hdc, &rc, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
+    if (btnPtr->bHot)
+    {
+        DrawEdge (hdc, &rc, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
             if (hasDropDownArrow)
-            DrawEdge (hdc, &rcArrow, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
-        }
+        DrawEdge (hdc, &rcArrow, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
+    }
         else
-        {
+    {
             FrameRect(hdc, &rc, GetSysColorBrush(COLOR_BTNFACE));
             if (hasDropDownArrow)
             FrameRect(hdc, &rcArrow, GetSysColorBrush(COLOR_BTNFACE));
-        }
+    }
 
         if (hasDropDownArrow)
-            TOOLBAR_DrawArrow(hdc, rcArrow.left+1, rcArrow.top, COLOR_WINDOWFRAME);
-
-        if (btnPtr->bHot && infoPtr->himlHot &&
+        TOOLBAR_DrawArrow(hdc, rcArrow.left+1, rcArrow.top, COLOR_WINDOWFRAME);
+
+    if (btnPtr->bHot && infoPtr->himlHot &&
             TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap))
-            ImageList_Draw (infoPtr->himlHot, btnPtr->iBitmap, hdc,
-                        rcBitmap.left, rcBitmap.top, ILD_NORMAL);
-        else if (TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap))
-            ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
-                        rcBitmap.left, rcBitmap.top, ILD_NORMAL);
+        ImageList_Draw (infoPtr->himlHot, btnPtr->iBitmap, hdc,
+            rcBitmap.left, rcBitmap.top, ILD_NORMAL);
+    else if (TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap))
+        ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
+            rcBitmap.left, rcBitmap.top, ILD_NORMAL);
     }
     else
     {
-        DrawEdge (hdc, &rc, EDGE_RAISED,
-                BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
+    DrawEdge (hdc, &rc, EDGE_RAISED,
+        BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 
         if (hasDropDownArrow)
-        {
-            DrawEdge (hdc, &rcArrow, EDGE_RAISED,
-                    BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
-            TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_WINDOWFRAME);
-        }
+    {
+        DrawEdge (hdc, &rcArrow, EDGE_RAISED,
+            BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
+        TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_WINDOWFRAME);
+    }
 
         if (TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap))
-            ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
-                        rcBitmap.left, rcBitmap.top, ILD_NORMAL);
+        ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
+            rcBitmap.left, rcBitmap.top, ILD_NORMAL);
     }
 
@@ -537 +538 @@
     if (!(btnPtr->fsState & TBSTATE_HIDDEN) &&
          (btnPtr->iString > -1) &&
-         (btnPtr->iString < infoPtr->nNumStrings)) 
+         (btnPtr->iString < infoPtr->nNumStrings))
     {
         LPWSTR lpText = infoPtr->strings[btnPtr->iString];
@@ -577 +578 @@
 
 /***********************************************************************
-*               TOOLBAR_WrapToolbar
+*       TOOLBAR_WrapToolbar
 *
-* This function walks through the buttons and seperators in the 
-* toolbar, and sets the TBSTATE_WRAP flag only on those items where 
-* wrapping should occur based on the width of the toolbar window.  
-* It does *not* calculate button placement itself.  That task 
-* takes place in TOOLBAR_CalcToolbar. If the program wants to manage 
-* the toolbar wrapping on it's own, it can use the TBSTYLE_WRAPPABLE 
+* This function walks through the buttons and seperators in the
+* toolbar, and sets the TBSTATE_WRAP flag only on those items where
+* wrapping should occur based on the width of the toolbar window.
+* It does *not* calculate button placement itself.  That task
+* takes place in TOOLBAR_CalcToolbar. If the program wants to manage
+* the toolbar wrapping on it's own, it can use the TBSTYLE_WRAPPABLE
 * flag, and set the TBSTATE_WRAP flags manually on the appropriate items.
-*/ 
+*/
 
 static void
@@ -597 +598 @@
     BOOL bWrap, bButtonWrap;
 
-    /*  When the toolbar window style is not TBSTYLE_WRAPABLE,  */ 
-    /*  no layout is necessary. Applications may use this style */
-    /*  to perform their own layout on the toolbar.             */
+    /*  When the toolbar window style is not TBSTYLE_WRAPABLE,  */
+    /*  no layout is necessary. Applications may use this style */
+    /*  to perform their own layout on the toolbar.         */
     if( !(dwStyle & TBSTYLE_WRAPABLE) )
-        return;
+    return;
 
     btnPtr = infoPtr->buttons;
@@ -616 +617 @@
     for (i = 0; i < infoPtr->nNumButtons; i++ )
     {
-        bWrap = FALSE;
-        btnPtr[i].fsState &= ~TBSTATE_WRAP;
-        
-        if (btnPtr[i].fsState & TBSTATE_HIDDEN)
-            continue;
-
-        /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
-        /* it is the actual width of the separator. This is used for */
-        /* custom controls in toolbars.                              */
-        if (btnPtr[i].fsStyle & TBSTYLE_SEP)
-            cx = (btnPtr[i].iBitmap > 0) ?  
-                        btnPtr[i].iBitmap : SEPARATOR_WIDTH;
-        else
-            cx = infoPtr->nButtonWidth;
-
-        /* Two or more adjacent separators form a separator group.   */ 
-        /* The first separator in a group should be wrapped to the   */
-        /* next row if the previous wrapping is on a button.         */
-        if( bButtonWrap &&
-                (btnPtr[i].fsStyle & TBSTYLE_SEP) && 
-                (i + 1 < infoPtr->nNumButtons ) &&
-                (btnPtr[i + 1].fsStyle & TBSTYLE_SEP) ) 
-        {
-            btnPtr[i].fsState |= TBSTATE_WRAP;
-            x = infoPtr->nIndent;
-            i++;
-            bButtonWrap = FALSE;
-            continue;
-        }
-
-        /* The layout makes sure the bitmap is visible, but not the button. */
-        if ( x + cx - (infoPtr->nButtonWidth - infoPtr->nBitmapWidth) / 2 
-                 > infoPtr->nWidth ) 
-        {
-            BOOL bFound = FALSE;
-
-            /*  If the current button is a separator and not hidden,  */ 
-            /*  go to the next until it reaches a non separator.      */
-            /*  Wrap the last separator if it is before a button.     */
-            while( ( (btnPtr[i].fsStyle & TBSTYLE_SEP) || 
-                        (btnPtr[i].fsState & TBSTATE_HIDDEN) ) && 
-                        i < infoPtr->nNumButtons )
-            {
-                i++;
-                bFound = TRUE;
-            }
-    
-            if( bFound && i < infoPtr->nNumButtons )
-            {
-                i--;
-                btnPtr[i].fsState |= TBSTATE_WRAP;
-                x = infoPtr->nIndent;
-                bButtonWrap = FALSE;
-                continue;
-            }
-            else if ( i >= infoPtr->nNumButtons)
-                break;
-
-            /*  If the current button is not a separator, find the last  */ 
-            /*  separator and wrap it.                                   */
-            for ( j = i - 1; j >= 0  &&  !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
-            {
-                if ((btnPtr[j].fsStyle & TBSTYLE_SEP) &&
-                        !(btnPtr[j].fsState & TBSTATE_HIDDEN))
-                {
-                    bFound = TRUE; 
-                    i = j; 
-                    x = infoPtr->nIndent;
-                    btnPtr[j].fsState |= TBSTATE_WRAP;
-                    bButtonWrap = FALSE; 
-                    break;
-                }
-            }
-
-            /*  If no separator available for wrapping, wrap one of     */
-            /*  non-hidden previous button.                             */
-            if (!bFound)
-            {
-                for ( j = i - 1; 
-                        j >= 0 && !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
-                {
-                    if (btnPtr[j].fsState & TBSTATE_HIDDEN) 
-                        continue;
-
-                    bFound = TRUE; 
-                    i = j; 
-                    x = infoPtr->nIndent;
-                    btnPtr[j].fsState |= TBSTATE_WRAP;
-                    bButtonWrap = TRUE;
-                    break;
-                }
-            }
-
-            /* If all above failed, wrap the current button. */
-            if (!bFound)  
-            {
-                btnPtr[i].fsState |= TBSTATE_WRAP;
-                bFound = TRUE;
-                x = infoPtr->nIndent;
-                if (btnPtr[i].fsState & TBSTYLE_SEP )
-                    bButtonWrap = FALSE;
-                else
-                    bButtonWrap = TRUE;
-            }               
-        }
-        else
-            x += cx;
+    bWrap = FALSE;
+    btnPtr[i].fsState &= ~TBSTATE_WRAP;
+
+    if (btnPtr[i].fsState & TBSTATE_HIDDEN)
+        continue;
+
+    /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
+    /* it is the actual width of the separator. This is used for */
+    /* custom controls in toolbars.                              */
+    if (btnPtr[i].fsStyle & TBSTYLE_SEP)
+        cx = (btnPtr[i].iBitmap > 0) ?
+            btnPtr[i].iBitmap : SEPARATOR_WIDTH;
+    else
+        cx = infoPtr->nButtonWidth;
+
+    /* Two or more adjacent separators form a separator group.   */
+    /* The first separator in a group should be wrapped to the   */
+    /* next row if the previous wrapping is on a button.         */
+    if( bButtonWrap &&
+        (btnPtr[i].fsStyle & TBSTYLE_SEP) &&
+        (i + 1 < infoPtr->nNumButtons ) &&
+        (btnPtr[i + 1].fsStyle & TBSTYLE_SEP) )
+    {
+        btnPtr[i].fsState |= TBSTATE_WRAP;
+        x = infoPtr->nIndent;
+        i++;
+        bButtonWrap = FALSE;
+        continue;
+    }
+
+    /* The layout makes sure the bitmap is visible, but not the button. */
+    if ( x + cx - (infoPtr->nButtonWidth - infoPtr->nBitmapWidth) / 2
+         > infoPtr->nWidth )
+    {
+        BOOL bFound = FALSE;
+
+        /*  If the current button is a separator and not hidden,  */
+        /*  go to the next until it reaches a non separator.      */
+        /*  Wrap the last separator if it is before a button.     */
+        while( ( (btnPtr[i].fsStyle & TBSTYLE_SEP) ||
+            (btnPtr[i].fsState & TBSTATE_HIDDEN) ) &&
+            i < infoPtr->nNumButtons )
+        {
+        i++;
+        bFound = TRUE;
+        }
+
+        if( bFound && i < infoPtr->nNumButtons )
+        {
+        i--;
+        btnPtr[i].fsState |= TBSTATE_WRAP;
+        x = infoPtr->nIndent;
+        bButtonWrap = FALSE;
+        continue;
+        }
+        else if ( i >= infoPtr->nNumButtons)
+        break;
+
+        /*  If the current button is not a separator, find the last  */
+        /*  separator and wrap it.                   */
+        for ( j = i - 1; j >= 0  &&  !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
+        {
+        if ((btnPtr[j].fsStyle & TBSTYLE_SEP) &&
+            !(btnPtr[j].fsState & TBSTATE_HIDDEN))
+        {
+            bFound = TRUE;
+            i = j;
+            x = infoPtr->nIndent;
+            btnPtr[j].fsState |= TBSTATE_WRAP;
+            bButtonWrap = FALSE;
+            break;
+        }
+        }
+
+        /*  If no separator available for wrapping, wrap one of     */
+        /*  non-hidden previous button.                     */
+        if (!bFound)
+        {
+        for ( j = i - 1;
+            j >= 0 && !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
+        {
+            if (btnPtr[j].fsState & TBSTATE_HIDDEN)
+            continue;
+
+            bFound = TRUE;
+            i = j;
+            x = infoPtr->nIndent;
+            btnPtr[j].fsState |= TBSTATE_WRAP;
+            bButtonWrap = TRUE;
+            break;
+        }
+        }
+
+        /* If all above failed, wrap the current button. */
+        if (!bFound)
+        {
+        btnPtr[i].fsState |= TBSTATE_WRAP;
+        bFound = TRUE;
+        x = infoPtr->nIndent;
+        if (btnPtr[i].fsState & TBSTYLE_SEP )
+            bButtonWrap = FALSE;
+        else
+            bButtonWrap = TRUE;
+        }
+    }
+    else
+        x += cx;
     }
 }
@@ -728 +729 @@
 
 /***********************************************************************
-*               TOOLBAR_CalcToolbar
+*       TOOLBAR_CalcToolbar
 *
-* This function calculates button and separator placement. It first 
-* calculates the button sizes, gets the toolbar window width and then 
-* calls TOOLBAR_WrapToolbar to determine which buttons we need to wrap 
+* This function calculates button and separator placement. It first
+* calculates the button sizes, gets the toolbar window width and then
+* calls TOOLBAR_WrapToolbar to determine which buttons we need to wrap
 * on. It assigns a new location to each item and sends this location to
-* the tooltip window if appropriate. Finally, it updates the rcBound 
-* rect and calculates the new required toolbar window height. 
-*/  
+* the tooltip window if appropriate. Finally, it updates the rcBound
+* rect and calculates the new required toolbar window height.
+*/
 
 static void
@@ -755 +756 @@
     if (dwStyle & TBSTYLE_LIST)
     {
-        infoPtr->nButtonHeight = max(infoPtr->nBitmapHeight, sizeString.cy) + 6;
-        infoPtr->nButtonWidth = infoPtr->nBitmapWidth + sizeString.cx + 6;
+    infoPtr->nButtonHeight = max(infoPtr->nBitmapHeight, sizeString.cy) + 6;
+    infoPtr->nButtonWidth = infoPtr->nBitmapWidth + sizeString.cx + 6;
     }
     else {
         for (i = 0; i < infoPtr->nNumButtons && !usesBitmaps; i++)
         {
-            if (TOOLBAR_IsValidBitmapIndex(infoPtr,infoPtr->buttons[i].iBitmap))
-                usesBitmaps = TRUE;
+        if (TOOLBAR_IsValidBitmapIndex(infoPtr,infoPtr->buttons[i].iBitmap))
+            usesBitmaps = TRUE;
         }
 
@@ -768 +769 @@
         {
             if (usesBitmaps)
-              infoPtr->nButtonHeight = sizeString.cy +
+          infoPtr->nButtonHeight = sizeString.cy +
                   infoPtr->nBitmapHeight + 6;
-            else 
+            else
                 infoPtr->nButtonHeight = sizeString.cy + 6;
         }
         else if (infoPtr->nButtonHeight < infoPtr->nBitmapHeight + 6)
-            infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
+        infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
 
         if (sizeString.cx > infoPtr->nBitmapWidth)
-            infoPtr->nButtonWidth = sizeString.cx + 6;
+        infoPtr->nButtonWidth = sizeString.cx + 6;
         else if (infoPtr->nButtonWidth < infoPtr->nBitmapWidth + 6)
-            infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
+        infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
     }
 
@@ -793 +794 @@
 
    /*
-    * We will set the height below, and we set the width on entry 
-    * so we do not reset them here.. 
+    * We will set the height below, and we set the width on entry
+    * so we do not reset them here..
     */
 #if 0
@@ -829 +830 @@
     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++ )
     {
-        bWrap = FALSE;
-        if (btnPtr->fsState & TBSTATE_HIDDEN)
-        {
-            SetRectEmpty (&btnPtr->rect);
-            continue;
-        }
-
-            /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
-            /* it is the actual width of the separator. This is used for */
-            /* custom controls in toolbars.                              */
-        if (btnPtr->fsStyle & TBSTYLE_SEP)
-                cx = (btnPtr->iBitmap > 0) ?
-                     btnPtr->iBitmap : SEPARATOR_WIDTH;
-        else
-        {
-            if (btnPtr->fsStyle & TBSTYLE_AUTOSIZE) 
+    bWrap = FALSE;
+    if (btnPtr->fsState & TBSTATE_HIDDEN)
+    {
+        SetRectEmpty (&btnPtr->rect);
+        continue;
+    }
+
+        /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
+        /* it is the actual width of the separator. This is used for */
+        /* custom controls in toolbars.                              */
+    if (btnPtr->fsStyle & TBSTYLE_SEP)
+        cx = (btnPtr->iBitmap > 0) ?
+             btnPtr->iBitmap : SEPARATOR_WIDTH;
+    else
+    {
+            if (btnPtr->fsStyle & TBSTYLE_AUTOSIZE)
             {
               SIZE sz;
@@ -851 +852 @@
             }
             else
-              cx = infoPtr->nButtonWidth;
-
-            if (hasDropDownArrows && (btnPtr->fsStyle & TBSTYLE_DROPDOWN))
-              cx += DDARROW_WIDTH; 
-        }
-        cy = infoPtr->nHeight;
-
-        if (btnPtr->fsState & TBSTATE_WRAP )
-                    bWrap = TRUE;
-
-        SetRect (&btnPtr->rect, x, y, x + cx, y + cy);
-
-        if (infoPtr->rcBound.left > x)
-            infoPtr->rcBound.left = x;
-        if (infoPtr->rcBound.right < x + cx)
-            infoPtr->rcBound.right = x + cx;
-        if (infoPtr->rcBound.bottom < y + cy)
-            infoPtr->rcBound.bottom = y + cy;
-
-        /* Set the toolTip only for non-hidden, non-separator button */
-        if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP )) 
-        {
-            TTTOOLINFOA ti;
-
-            ZeroMemory (&ti, sizeof(TTTOOLINFOA));
-            ti.cbSize = sizeof(TTTOOLINFOA);
-            ti.hwnd = hwnd;
-            ti.uId = btnPtr->idCommand;
-            ti.rect = btnPtr->rect;
-            SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
-                            0, (LPARAM)&ti);
-        }
-
-        /* btnPtr->nRow is zero based. The space between the rows is    */
-        /* also considered as a row.                                    */
-        btnPtr->nRow = nRows + nSepRows;
-        if( bWrap )
-        {
-            if ( !(btnPtr->fsStyle & TBSTYLE_SEP) )
-                y += cy;
-            else 
-            {   
-                /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
-                /* it is the actual width of the separator. This is used for */
-                /* custom controls in toolbars.                              */
-                y += cy + ( (btnPtr->iBitmap > 0 ) ? 
-                        btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 /3; 
-             
-                /* nSepRows is used to calculate the extra height follwoing  */          
-                /* the last row.                                             */
-                nSepRows++;
-            }
-            x = infoPtr->nIndent;
-                nRows++;
-        }
-        else
-            x += cx;
+          cx = infoPtr->nButtonWidth;
+
+        if (hasDropDownArrows && (btnPtr->fsStyle & TBSTYLE_DROPDOWN))
+          cx += DDARROW_WIDTH;
+    }
+    cy = infoPtr->nHeight;
+
+    if (btnPtr->fsState & TBSTATE_WRAP )
+            bWrap = TRUE;
+
+    SetRect (&btnPtr->rect, x, y, x + cx, y + cy);
+
+    if (infoPtr->rcBound.left > x)
+        infoPtr->rcBound.left = x;
+    if (infoPtr->rcBound.right < x + cx)
+        infoPtr->rcBound.right = x + cx;
+    if (infoPtr->rcBound.bottom < y + cy)
+        infoPtr->rcBound.bottom = y + cy;
+
+    /* Set the toolTip only for non-hidden, non-separator button */
+    if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP ))
+    {
+        TTTOOLINFOA ti;
+
+        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
+        ti.cbSize = sizeof(TTTOOLINFOA);
+        ti.hwnd = hwnd;
+        ti.uId = btnPtr->idCommand;
+        ti.rect = btnPtr->rect;
+        SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
+                0, (LPARAM)&ti);
+    }
+
+    /* btnPtr->nRow is zero based. The space between the rows is    */
+    /* also considered as a row.                    */
+    btnPtr->nRow = nRows + nSepRows;
+    if( bWrap )
+    {
+        if ( !(btnPtr->fsStyle & TBSTYLE_SEP) )
+            y += cy;
+        else
+        {
+        /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
+        /* it is the actual width of the separator. This is used for */
+        /* custom controls in toolbars.                  */
+        y += cy + ( (btnPtr->iBitmap > 0 ) ?
+            btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 /3;
+
+        /* nSepRows is used to calculate the extra height follwoing  */
+        /* the last row.                         */
+        nSepRows++;
+        }
+        x = infoPtr->nIndent;
+        nRows++;
+    }
+    else
+        x += cx;
     }
 
@@ -913 +914 @@
     infoPtr->nRows = nRows + nSepRows + 1;
 
-    /* nSepRows * (infoPtr->nBitmapHeight + 1) is the space following   */
-    /* the last row.                                                    */
-    infoPtr->nHeight = TOP_BORDER + (nRows + 1) * infoPtr->nButtonHeight + 
-                        nSepRows * (SEPARATOR_WIDTH * 2 / 3) +
-                        nSepRows * (infoPtr->nBitmapHeight + 1) + 
-                        BOTTOM_BORDER; 
+    /* nSepRows * (infoPtr->nBitmapHeight + 1) is the space following   */
+    /* the last row.                            */
+    infoPtr->nHeight = TOP_BORDER + (nRows + 1) * infoPtr->nButtonHeight +
+                nSepRows * (SEPARATOR_WIDTH * 2 / 3) +
+            nSepRows * (infoPtr->nBitmapHeight + 1) +
+            BOTTOM_BORDER;
     TRACE("toolbar height %d, button width %d\n", infoPtr->nHeight, infoPtr->nButtonWidth);
 }
@@ -929 +930 @@
     TBUTTON_INFO *btnPtr;
     INT i;
-    
+
     btnPtr = infoPtr->buttons;
     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
-        if (btnPtr->fsState & TBSTATE_HIDDEN)
-            continue;
-
-        if (btnPtr->fsStyle & TBSTYLE_SEP) {
-            if (PtInRect (&btnPtr->rect, *lpPt)) {
-                TRACE(" ON SEPARATOR %d!\n", i);
-                return -i;
-            }
-        }
-        else {
-            if (PtInRect (&btnPtr->rect, *lpPt)) {
-                TRACE(" ON BUTTON %d!\n", i);
-                return i;
-            }
-        }
+    if (btnPtr->fsState & TBSTATE_HIDDEN)
+        continue;
+
+    if (btnPtr->fsStyle & TBSTYLE_SEP) {
+        if (PtInRect (&btnPtr->rect, *lpPt)) {
+        TRACE(" ON SEPARATOR %d!\n", i);
+        return -i;
+        }
+    }
+    else {
+        if (PtInRect (&btnPtr->rect, *lpPt)) {
+        TRACE(" ON BUTTON %d!\n", i);
+        return i;
+        }
+    }
     }
 
@@ -962 +963 @@
     btnPtr = infoPtr->buttons;
     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
-        if (btnPtr->idCommand == idCommand) {
-            TRACE("command=%d index=%d\n", idCommand, i);
-            return i;
-        }
+    if (btnPtr->idCommand == idCommand) {
+        TRACE("command=%d index=%d\n", idCommand, i);
+        return i;
+    }
     }
     TRACE("no index found for command=%d\n", idCommand);
@@ -979 +980 @@
 
     if ((nIndex < 0) || (nIndex > infoPtr->nNumButtons))
-        return -1;
+    return -1;
 
     /* check index button */
     btnPtr = &infoPtr->buttons[nIndex];
     if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
-        if (btnPtr->fsState & TBSTATE_CHECKED)
-            return nIndex;
+    if (btnPtr->fsState & TBSTATE_CHECKED)
+        return nIndex;
     }
 
@@ -991 +992 @@
     nRunIndex = nIndex - 1;
     while (nRunIndex >= 0) {
-        btnPtr = &infoPtr->buttons[nRunIndex];
-        if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
-            if (btnPtr->fsState & TBSTATE_CHECKED)
-                return nRunIndex;
-        }
-        else
-            break;
-        nRunIndex--;
+    btnPtr = &infoPtr->buttons[nRunIndex];
+    if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
+        if (btnPtr->fsState & TBSTATE_CHECKED)
+        return nRunIndex;
+    }
+    else
+        break;
+    nRunIndex--;
     }
 
@@ -1004 +1005 @@
     nRunIndex = nIndex + 1;
     while (nRunIndex < infoPtr->nNumButtons) {
-        btnPtr = &infoPtr->buttons[nRunIndex];  
-        if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
-            if (btnPtr->fsState & TBSTATE_CHECKED)
-                return nRunIndex;
-        }
-        else
-            break;
-        nRunIndex++;
+    btnPtr = &infoPtr->buttons[nRunIndex];
+    if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
+        if (btnPtr->fsState & TBSTATE_CHECKED)
+        return nRunIndex;
+    }
+    else
+        break;
+    nRunIndex++;
     }
 
@@ -1020 +1021 @@
 static VOID
 TOOLBAR_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
-                    WPARAM wParam, LPARAM lParam)
+            WPARAM wParam, LPARAM lParam)
 {
     MSG msg;
@@ -1049 +1050 @@
     switch (uMsg)
     {
-        case WM_INITDIALOG:
-            custInfo = (PCUSTDLG_INFO)lParam;
-            SetWindowLongA (hwnd, DWL_USER, (DWORD)custInfo);
-
-            if (custInfo)
-            {
-                char Buffer[256];
-                int i = 0;
-                int index;
-
-                /* send TBN_QUERYINSERT notification */
-                nmtb.hdr.hwndFrom = hwnd;
-                nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                nmtb.hdr.code     = TBN_QUERYINSERT;
-                nmtb.iItem = custInfo->tbInfo->nNumButtons;
-
-                if (!SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                   (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
-                    return FALSE;
-
-                /* add items to 'toolbar buttons' list and check if removable */
-                for (i = 0; i < custInfo->tbInfo->nNumButtons; i++)
-                {
-                    btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
-                    memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
-                    btnInfo->btn.fsStyle = TBSTYLE_SEP;
-                    btnInfo->bVirtual = FALSE;
-                    LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
-
-                    /* send TBN_QUERYDELETE notification */
-                    nmtb.hdr.hwndFrom = hwnd;
-                    nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                    nmtb.hdr.code     = TBN_QUERYDELETE;
-                    nmtb.iItem = i;
-
-                    btnInfo->bRemovable = SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                                        (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
-
-                    index = (int)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, 0);
-                    SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
-                }
-
-                /* insert separator button into 'available buttons' list */
-                btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
-                memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
-                btnInfo->btn.fsStyle = TBSTYLE_SEP;
-                btnInfo->bVirtual = FALSE;
-                btnInfo->bRemovable = TRUE;
-                LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
-                index = (int)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)btnInfo);
-                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
-
-                /* insert all buttons into dsa */
-                for (i = 0;; i++)
-                {
-                    /* send TBN_GETBUTTONINFO notification */
-                    nmtb.hdr.hwndFrom = hwnd;
-                    nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                    nmtb.hdr.code     = TBN_GETBUTTONINFOA;
-                    nmtb.iItem = i;
-                    nmtb.pszText = Buffer;
-                    nmtb.cchText = 256;
-
-                    if (!SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                       (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
-                        break;
-
-                    TRACE("style: %x\n", nmtb.tbButton.fsStyle);                
-
-                    /* insert button into the apropriate list */
-                    index = TOOLBAR_GetButtonIndex (custInfo->tbInfo, nmtb.tbButton.idCommand);
-                    if (index == -1)
-                    {
-                        btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
-                        memcpy (&btnInfo->btn, &nmtb.tbButton, sizeof(TBBUTTON));
-                        btnInfo->bVirtual = FALSE;
-                        btnInfo->bRemovable = TRUE;
-                        if (!(nmtb.tbButton.fsStyle & TBSTYLE_SEP))
-                            strcpy (btnInfo->text, nmtb.pszText);
-
-                        index = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, 0);
-                        SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
-                    }
-                    else
-                    {
-                        btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
-                        memcpy (&btnInfo->btn, &nmtb.tbButton, sizeof(TBBUTTON));
-                        if (!(nmtb.tbButton.fsStyle & TBSTYLE_SEP))
-                            strcpy (btnInfo->text, nmtb.pszText);
-
-                        SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
-                    }
-                }
-
-                /* select first item in the 'available' list */
-                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, 0, 0);
-
-                /* append 'virtual' separator button to the 'toolbar buttons' list */
-                btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
-                memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
-                btnInfo->btn.fsStyle = TBSTYLE_SEP;
-                btnInfo->bVirtual = TRUE;
-                btnInfo->bRemovable = FALSE;
-                LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
-                index = (int)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)btnInfo);
-                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
-
-                /* select last item in the 'toolbar' list */
-                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index, 0);
-                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETTOPINDEX, index, 0);
-
-                /* set focus and disable buttons */
-                PostMessageA (hwnd, WM_USER, 0, 0);
-            }
-            return TRUE;
-
-        case WM_USER:
-            EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
-            EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
-            EnableWindow (GetDlgItem (hwnd,IDC_REMOVE_BTN), FALSE);
-            SetFocus (GetDlgItem (hwnd, IDC_TOOLBARBTN_LBOX));
-            return TRUE;
-
-        case WM_CLOSE:
-            EndDialog(hwnd, FALSE);
-            return TRUE;
-
-        case WM_COMMAND:
-            switch (LOWORD(wParam))
-            {
-                case IDC_TOOLBARBTN_LBOX:
-                    if (HIWORD(wParam) == LBN_SELCHANGE)
-                    {
-                        PCUSTOMBUTTON btnInfo;
-                        NMTOOLBARA nmtb;
-                        int count;
-                        int index;
-
-                        count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
-                        index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
-
-                        /* send TBN_QUERYINSERT notification */
-                        nmtb.hdr.hwndFrom = hwnd;
-                        nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                        nmtb.hdr.code     = TBN_QUERYINSERT;
-                        nmtb.iItem = index;
-
-                        SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                      (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
-
-                        /* get list box item */
-                        btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
-
-                        if (index == (count - 1))
-                        {
-                            /* last item (virtual separator) */
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
-                        }
-                        else if (index == (count - 2))
-                        {
-                            /* second last item (last non-virtual item) */
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
-                        }
-                        else if (index == 0)
-                        {
-                            /* first item */
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
-                        }
-                        else
-                        {
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
-                            EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
-                        }
-
-                        EnableWindow (GetDlgItem (hwnd,IDC_REMOVE_BTN), btnInfo->bRemovable);
-                    }
-                    break;
-
-                case IDC_MOVEUP_BTN:
-                    {
-                        PCUSTOMBUTTON btnInfo;
-                        int index;
-                        int count;
-
-                        count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
-                        index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
-                        TRACE("Move up: index %d\n", index);
-
-                        /* send TBN_QUERYINSERT notification */
-                        nmtb.hdr.hwndFrom = hwnd;
-                        nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                        nmtb.hdr.code     = TBN_QUERYINSERT;
-                        nmtb.iItem = index;
-
-                        if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                          (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
-                        {
-                            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
-
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index-1, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index-1, (LPARAM)btnInfo);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index-1 , 0);
-
-                            if (index <= 1)
-                                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
-                            else if (index >= (count - 3))
-                                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
-
-                            SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
-                            SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index-1, (LPARAM)&(btnInfo->btn));
-                        }
-                    }
-                    break;
-
-                case IDC_MOVEDN_BTN: /* move down */
-                    {
-                        PCUSTOMBUTTON btnInfo;
-                        int index;
-                        int count;
-
-                        count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
-                        index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
-                        TRACE("Move up: index %d\n", index);
-
-                        /* send TBN_QUERYINSERT notification */
-                        nmtb.hdr.hwndFrom = hwnd;
-                        nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                        nmtb.hdr.code     = TBN_QUERYINSERT;
-                        nmtb.iItem = index;
-
-                        if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                          (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
-                        {
-                            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
-
-                            /* move button down */
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index+1, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index+1, (LPARAM)btnInfo);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index+1 , 0);
-
-                            if (index == 0)
-                                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
-                            else if (index >= (count - 3))
-                                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
-
-                            SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
-                            SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index+1, (LPARAM)&(btnInfo->btn));
-                        }
-                    }
-                    break;
-
-                case IDC_REMOVE_BTN: /* remove button */
-                    {
-                        PCUSTOMBUTTON btnInfo;
-                        int index;
-
-                        index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
-                        TRACE("Remove: index %d\n", index);
-
-                        /* send TBN_QUERYDELETE notification */
-                        nmtb.hdr.hwndFrom = hwnd;
-                        nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                        nmtb.hdr.code     = TBN_QUERYDELETE;
-                        nmtb.iItem = index;
-
-                        if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                          (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
-                        {
-                            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index , 0);
-
-                            SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
-
-                            /* insert into 'available button' list */
-                            if (!(btnInfo->btn.fsStyle & TBSTYLE_SEP))
-                            {
-                                index = (int)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, 0);
-                                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
-                            }
-                            else
-                                COMCTL32_Free (btnInfo);
-                        }
-                    }
-                    break;
-
-                case IDOK: /* Add button */
-                    {
-                        int index;
-                        int count;
-
-                        count = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCOUNT, 0, 0);
-                        index = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCURSEL, 0, 0);
-                        TRACE("Add: index %d\n", index);
-
-                        /* send TBN_QUERYINSERT notification */
-                        nmtb.hdr.hwndFrom = hwnd;
-                        nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-                        nmtb.hdr.code     = TBN_QUERYINSERT;
-                        nmtb.iItem = index;
-
-                        if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
-                                          (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
-                        {
-                            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETITEMDATA, index, 0);
-
-                            if (index != 0)
-                            {
-                                /* remove from 'available buttons' list */
-                                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_DELETESTRING, index, 0);
-                                if (index == count-1)
-                                    SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, index-1 , 0);
-                                else
-                                    SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, index , 0);
-                            }
-                            else
-                            {
-                                PCUSTOMBUTTON btnNew;
-
-                                /* duplicate 'separator' button */
-                                btnNew = (PCUSTOMBUTTON)COMCTL32_Alloc (sizeof(CUSTOMBUTTON));
-                                memcpy (btnNew, btnInfo, sizeof(CUSTOMBUTTON));
-                                btnInfo = btnNew;
-                            }
-
-                            /* insert into 'toolbar button' list */
-                            index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index, 0);
-                            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
-
-                            SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index, (LPARAM)&(btnInfo->btn));
-                        }
-                    }
-                    break;
-
-                case IDCANCEL:
-                    EndDialog(hwnd, FALSE);
-                    break;
-            }
-            return TRUE;
-
-        case WM_DESTROY:
-            {
-                int count;
-                int i;
-
-                /* delete items from 'toolbar buttons' listbox*/
-                count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
-                for (i = 0; i < count; i++)
-                {
-                    btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, i, 0);
-                    COMCTL32_Free(btnInfo);
-                    SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, 0, 0);
-                }
-                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_RESETCONTENT, 0, 0);
-
-
-                /* delete items from 'available buttons' listbox*/
-                count = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCOUNT, 0, 0);
-                for (i = 0; i < count; i++)
-                {
-                    btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETITEMDATA, i, 0);
-                    COMCTL32_Free(btnInfo);
-                    SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, i, 0);
-                }
-                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_RESETCONTENT, 0, 0);
+    case WM_INITDIALOG:
+        custInfo = (PCUSTDLG_INFO)lParam;
+        SetWindowLongA (hwnd, DWL_USER, (DWORD)custInfo);
+
+        if (custInfo)
+        {
+        char Buffer[256];
+        int i = 0;
+        int index;
+
+        /* send TBN_QUERYINSERT notification */
+        nmtb.hdr.hwndFrom = hwnd;
+        nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+        nmtb.hdr.code     = TBN_QUERYINSERT;
+        nmtb.iItem = custInfo->tbInfo->nNumButtons;
+
+        if (!SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                   (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
+            return FALSE;
+
+        /* add items to 'toolbar buttons' list and check if removable */
+        for (i = 0; i < custInfo->tbInfo->nNumButtons; i++)
+        {
+            btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
+            memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
+            btnInfo->btn.fsStyle = TBSTYLE_SEP;
+            btnInfo->bVirtual = FALSE;
+            LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
+
+            /* send TBN_QUERYDELETE notification */
+            nmtb.hdr.hwndFrom = hwnd;
+            nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+            nmtb.hdr.code     = TBN_QUERYDELETE;
+            nmtb.iItem = i;
+
+            btnInfo->bRemovable = SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                            (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
+
+            index = (int)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, 0);
+            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
+        }
+
+        /* insert separator button into 'available buttons' list */
+        btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
+        memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
+        btnInfo->btn.fsStyle = TBSTYLE_SEP;
+        btnInfo->bVirtual = FALSE;
+        btnInfo->bRemovable = TRUE;
+        LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
+        index = (int)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)btnInfo);
+        SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
+
+        /* insert all buttons into dsa */
+        for (i = 0;; i++)
+        {
+            /* send TBN_GETBUTTONINFO notification */
+            nmtb.hdr.hwndFrom = hwnd;
+            nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+            nmtb.hdr.code     = TBN_GETBUTTONINFOA;
+            nmtb.iItem = i;
+            nmtb.pszText = Buffer;
+            nmtb.cchText = 256;
+
+            if (!SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                       (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
+            break;
+
+            TRACE("style: %x\n", nmtb.tbButton.fsStyle);
+
+            /* insert button into the apropriate list */
+            index = TOOLBAR_GetButtonIndex (custInfo->tbInfo, nmtb.tbButton.idCommand);
+            if (index == -1)
+            {
+            btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
+            memcpy (&btnInfo->btn, &nmtb.tbButton, sizeof(TBBUTTON));
+            btnInfo->bVirtual = FALSE;
+            btnInfo->bRemovable = TRUE;
+            if (!(nmtb.tbButton.fsStyle & TBSTYLE_SEP))
+                strcpy (btnInfo->text, nmtb.pszText);
+
+            index = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, 0);
+            SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
             }
-            return TRUE;
-
-        case WM_DRAWITEM:
-            if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
-            {
-                LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
-                RECT rcButton;
-                RECT rcText;
-                HPEN hOldPen;
-                HBRUSH hOldBrush;
-                COLORREF oldText = 0;
-                COLORREF oldBk = 0;
-
-                /* get item data */
-                btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, wParam, LB_GETITEMDATA, (WPARAM)lpdis->itemID, 0);
-                if (btnInfo == NULL)
-                {
-                    FIXME("btnInfo invalid!\n");
-                    return TRUE;
-                }
-
-                /* set colors and select objects */
-                oldBk = SetBkColor (lpdis->hDC, GetSysColor((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
-                if (btnInfo->bVirtual)
-                   oldText = SetTextColor (lpdis->hDC, GetSysColor(COLOR_GRAYTEXT));
-                else
-                   oldText = SetTextColor (lpdis->hDC, GetSysColor((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHTTEXT:COLOR_WINDOWTEXT));
-                hOldPen = SelectObject (lpdis->hDC, GetSysColorPen ((lpdis->itemState & ODS_SELECTED)?COLOR_HIGHLIGHT:COLOR_WINDOW));
-                hOldBrush = SelectObject (lpdis->hDC, GetSysColorBrush ((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
-
-                /* fill background rectangle */
-                Rectangle (lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
-                           lpdis->rcItem.right, lpdis->rcItem.bottom);
-
-                /* calculate button and text rectangles */
-                CopyRect (&rcButton, &lpdis->rcItem);
-                InflateRect (&rcButton, -1, -1);
-                CopyRect (&rcText, &rcButton);
-                rcButton.right = rcButton.left + custInfo->tbInfo->nBitmapWidth + 6;
-                rcText.left = rcButton.right + 2;
-
-                /* draw focus rectangle */
-                if (lpdis->itemState & ODS_FOCUS)
-                    DrawFocusRect (lpdis->hDC, &lpdis->rcItem);
-
-                /* draw button */
-                DrawEdge (lpdis->hDC, &rcButton, EDGE_RAISED, BF_RECT|BF_MIDDLE|BF_SOFT);
-
-                /* draw image and text */
-                if ((btnInfo->btn.fsStyle & TBSTYLE_SEP) == 0)
-                    ImageList_Draw (custInfo->tbInfo->himlDef, btnInfo->btn.iBitmap, lpdis->hDC,
-                                    rcButton.left+3, rcButton.top+3, ILD_NORMAL);
-                DrawTextA (lpdis->hDC,  btnInfo->text, -1, &rcText,
-                               DT_LEFT | DT_VCENTER | DT_SINGLELINE);
-
-                /* delete objects and reset colors */
-                SelectObject (lpdis->hDC, hOldBrush);
-                SelectObject (lpdis->hDC, hOldPen);
-                SetBkColor (lpdis->hDC, oldBk);
-                SetTextColor (lpdis->hDC, oldText);
-
-                return TRUE;
-            }
-            return FALSE;
-
-        case WM_MEASUREITEM:
-            if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
-            {
-                MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT*)lParam;
-
-                if (custInfo && custInfo->tbInfo)
-                    lpmis->itemHeight = custInfo->tbInfo->nBitmapHeight + 8;
-                else
-                    lpmis->itemHeight = 15 + 8; /* default height */
-
-                return TRUE;
-            }
-            return FALSE;
-
-        default:
-            return FALSE;
+            else
+            {
+            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
+            memcpy (&btnInfo->btn, &nmtb.tbButton, sizeof(TBBUTTON));
+            if (!(nmtb.tbButton.fsStyle & TBSTYLE_SEP))
+                strcpy (btnInfo->text, nmtb.pszText);
+
+            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
+            }
+        }
+
+        /* select first item in the 'available' list */
+        SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, 0, 0);
+
+        /* append 'virtual' separator button to the 'toolbar buttons' list */
+        btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
+        memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
+        btnInfo->btn.fsStyle = TBSTYLE_SEP;
+        btnInfo->bVirtual = TRUE;
+        btnInfo->bRemovable = FALSE;
+        LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
+        index = (int)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)btnInfo);
+        SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
+
+        /* select last item in the 'toolbar' list */
+        SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index, 0);
+        SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETTOPINDEX, index, 0);
+
+        /* set focus and disable buttons */
+        PostMessageA (hwnd, WM_USER, 0, 0);
+        }
+        return TRUE;
+
+    case WM_USER:
+        EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
+        EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
+        EnableWindow (GetDlgItem (hwnd,IDC_REMOVE_BTN), FALSE);
+        SetFocus (GetDlgItem (hwnd, IDC_TOOLBARBTN_LBOX));
+        return TRUE;
+
+    case WM_CLOSE:
+        EndDialog(hwnd, FALSE);
+        return TRUE;
+
+    case WM_COMMAND:
+        switch (LOWORD(wParam))
+        {
+        case IDC_TOOLBARBTN_LBOX:
+            if (HIWORD(wParam) == LBN_SELCHANGE)
+            {
+            PCUSTOMBUTTON btnInfo;
+            NMTOOLBARA nmtb;
+            int count;
+            int index;
+
+            count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
+            index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
+
+            /* send TBN_QUERYINSERT notification */
+            nmtb.hdr.hwndFrom = hwnd;
+            nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+            nmtb.hdr.code     = TBN_QUERYINSERT;
+            nmtb.iItem = index;
+
+            SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                      (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
+
+            /* get list box item */
+            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
+
+            if (index == (count - 1))
+            {
+                /* last item (virtual separator) */
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
+            }
+            else if (index == (count - 2))
+            {
+                /* second last item (last non-virtual item) */
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
+            }
+            else if (index == 0)
+            {
+                /* first item */
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
+            }
+            else
+            {
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
+            }
+
+            EnableWindow (GetDlgItem (hwnd,IDC_REMOVE_BTN), btnInfo->bRemovable);
+            }
+            break;
+
+        case IDC_MOVEUP_BTN:
+            {
+            PCUSTOMBUTTON btnInfo;
+            int index;
+            int count;
+
+            count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
+            index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
+            TRACE("Move up: index %d\n", index);
+
+            /* send TBN_QUERYINSERT notification */
+            nmtb.hdr.hwndFrom = hwnd;
+            nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+            nmtb.hdr.code     = TBN_QUERYINSERT;
+            nmtb.iItem = index;
+
+            if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                      (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
+            {
+                btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
+
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index-1, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index-1, (LPARAM)btnInfo);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index-1 , 0);
+
+                if (index <= 1)
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
+                else if (index >= (count - 3))
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
+
+                SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
+                SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index-1, (LPARAM)&(btnInfo->btn));
+            }
+            }
+            break;
+
+        case IDC_MOVEDN_BTN: /* move down */
+            {
+            PCUSTOMBUTTON btnInfo;
+            int index;
+            int count;
+
+            count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
+            index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
+            TRACE("Move up: index %d\n", index);
+
+            /* send TBN_QUERYINSERT notification */
+            nmtb.hdr.hwndFrom = hwnd;
+            nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+            nmtb.hdr.code     = TBN_QUERYINSERT;
+            nmtb.iItem = index;
+
+            if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                      (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
+            {
+                btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
+
+                /* move button down */
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index+1, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index+1, (LPARAM)btnInfo);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index+1 , 0);
+
+                if (index == 0)
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
+                else if (index >= (count - 3))
+                EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
+
+                SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
+                SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index+1, (LPARAM)&(btnInfo->btn));
+            }
+            }
+            break;
+
+        case IDC_REMOVE_BTN: /* remove button */
+            {
+            PCUSTOMBUTTON btnInfo;
+            int index;
+
+            index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
+            TRACE("Remove: index %d\n", index);
+
+            /* send TBN_QUERYDELETE notification */
+            nmtb.hdr.hwndFrom = hwnd;
+            nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+            nmtb.hdr.code     = TBN_QUERYDELETE;
+            nmtb.iItem = index;
+
+            if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                      (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
+            {
+                btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index , 0);
+
+                SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
+
+                /* insert into 'available button' list */
+                if (!(btnInfo->btn.fsStyle & TBSTYLE_SEP))
+                {
+                index = (int)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, 0);
+                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
+                }
+                else
+                COMCTL32_Free (btnInfo);
+            }
+            }
+            break;
+
+        case IDOK: /* Add button */
+            {
+            int index;
+            int count;
+
+            count = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCOUNT, 0, 0);
+            index = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCURSEL, 0, 0);
+            TRACE("Add: index %d\n", index);
+
+            /* send TBN_QUERYINSERT notification */
+            nmtb.hdr.hwndFrom = hwnd;
+            nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+            nmtb.hdr.code     = TBN_QUERYINSERT;
+            nmtb.iItem = index;
+
+            if (SendMessageA (custInfo->tbInfo->hwndNotify, WM_NOTIFY,
+                      (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb))
+            {
+                btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETITEMDATA, index, 0);
+
+                if (index != 0)
+                {
+                /* remove from 'available buttons' list */
+                SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_DELETESTRING, index, 0);
+                if (index == count-1)
+                    SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, index-1 , 0);
+                else
+                    SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, index , 0);
+                }
+                else
+                {
+                PCUSTOMBUTTON btnNew;
+
+                /* duplicate 'separator' button */
+                btnNew = (PCUSTOMBUTTON)COMCTL32_Alloc (sizeof(CUSTOMBUTTON));
+                memcpy (btnNew, btnInfo, sizeof(CUSTOMBUTTON));
+                btnInfo = btnNew;
+                }
+
+                /* insert into 'toolbar button' list */
+                index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index, 0);
+                SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
+
+                SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index, (LPARAM)&(btnInfo->btn));
+            }
+            }
+            break;
+
+        case IDCANCEL:
+            EndDialog(hwnd, FALSE);
+            break;
+        }
+        return TRUE;
+
+    case WM_DESTROY:
+        {
+        int count;
+        int i;
+
+        /* delete items from 'toolbar buttons' listbox*/
+        count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
+        for (i = 0; i < count; i++)
+        {
+            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, i, 0);
+            COMCTL32_Free(btnInfo);
+            SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, 0, 0);
+        }
+        SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_RESETCONTENT, 0, 0);
+
+
+        /* delete items from 'available buttons' listbox*/
+        count = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCOUNT, 0, 0);
+        for (i = 0; i < count; i++)
+        {
+            btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETITEMDATA, i, 0);
+            COMCTL32_Free(btnInfo);
+            SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, i, 0);
+        }
+        SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_RESETCONTENT, 0, 0);
+            }
+        return TRUE;
+
+    case WM_DRAWITEM:
+        if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
+        {
+        LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
+        RECT rcButton;
+        RECT rcText;
+        HPEN hOldPen;
+        HBRUSH hOldBrush;
+        COLORREF oldText = 0;
+        COLORREF oldBk = 0;
+
+        /* get item data */
+        btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, wParam, LB_GETITEMDATA, (WPARAM)lpdis->itemID, 0);
+        if (btnInfo == NULL)
+        {
+            FIXME("btnInfo invalid!\n");
+            return TRUE;
+        }
+
+        /* set colors and select objects */
+        oldBk = SetBkColor (lpdis->hDC, GetSysColor((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
+        if (btnInfo->bVirtual)
+           oldText = SetTextColor (lpdis->hDC, GetSysColor(COLOR_GRAYTEXT));
+        else
+           oldText = SetTextColor (lpdis->hDC, GetSysColor((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHTTEXT:COLOR_WINDOWTEXT));
+        hOldPen = SelectObject (lpdis->hDC, GetSysColorPen ((lpdis->itemState & ODS_SELECTED)?COLOR_HIGHLIGHT:COLOR_WINDOW));
+        hOldBrush = SelectObject (lpdis->hDC, GetSysColorBrush ((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
+
+        /* fill background rectangle */
+        Rectangle (lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
+               lpdis->rcItem.right, lpdis->rcItem.bottom);
+
+        /* calculate button and text rectangles */
+        CopyRect (&rcButton, &lpdis->rcItem);
+        InflateRect (&rcButton, -1, -1);
+        CopyRect (&rcText, &rcButton);
+        rcButton.right = rcButton.left + custInfo->tbInfo->nBitmapWidth + 6;
+        rcText.left = rcButton.right + 2;
+
+        /* draw focus rectangle */
+        if (lpdis->itemState & ODS_FOCUS)
+            DrawFocusRect (lpdis->hDC, &lpdis->rcItem);
+
+        /* draw button */
+        DrawEdge (lpdis->hDC, &rcButton, EDGE_RAISED, BF_RECT|BF_MIDDLE|BF_SOFT);
+
+        /* draw image and text */
+        if ((btnInfo->btn.fsStyle & TBSTYLE_SEP) == 0)
+            ImageList_Draw (custInfo->tbInfo->himlDef, btnInfo->btn.iBitmap, lpdis->hDC,
+                    rcButton.left+3, rcButton.top+3, ILD_NORMAL);
+        DrawTextA (lpdis->hDC,  btnInfo->text, -1, &rcText,
+                   DT_LEFT | DT_VCENTER | DT_SINGLELINE);
+
+        /* delete objects and reset colors */
+        SelectObject (lpdis->hDC, hOldBrush);
+        SelectObject (lpdis->hDC, hOldPen);
+        SetBkColor (lpdis->hDC, oldBk);
+        SetTextColor (lpdis->hDC, oldText);
+
+        return TRUE;
+        }
+        return FALSE;
+
+    case WM_MEASUREITEM:
+        if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
+        {
+        MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT*)lParam;
+
+        if (custInfo && custInfo->tbInfo)
+            lpmis->itemHeight = custInfo->tbInfo->nBitmapHeight + 8;
+        else
+            lpmis->itemHeight = 15 + 8; /* default height */
+
+        return TRUE;
+        }
+        return FALSE;
+
+    default:
+        return FALSE;
     }
 }
@@ -1520 +1521 @@
     TRACE("hwnd=%x wParam=%x lParam=%lx\n", hwnd, wParam, lParam);
     if (!lpAddBmp)
-        return -1;
+    return -1;
 
     if (lpAddBmp->hInst == HINST_COMMCTRL)
     {
-        if ((lpAddBmp->nID & ~1) == IDB_STD_SMALL_COLOR)
-            nButtons = 15;
-        else if ((lpAddBmp->nID & ~1) == IDB_VIEW_SMALL_COLOR)
-            nButtons = 13;
-        else if ((lpAddBmp->nID & ~1) == IDB_HIST_SMALL_COLOR)
-            nButtons = 5;
-        else
-            return -1;
-
-        TRACE ("adding %d internal bitmaps!\n", nButtons);
-
-        /* Windows resize all the buttons to the size of a newly added standard image */
-        if (lpAddBmp->nID & 1) 
-        {
-            /* large icons */
-            /* FIXME: on windows the size of the images is 25x24 but the size of the bitmap 
-             * in rsrc is only 24x24. Fix the bitmap (how?) and then fix this 
+    if ((lpAddBmp->nID & ~1) == IDB_STD_SMALL_COLOR)
+        nButtons = 15;
+    else if ((lpAddBmp->nID & ~1) == IDB_VIEW_SMALL_COLOR)
+        nButtons = 13;
+    else if ((lpAddBmp->nID & ~1) == IDB_HIST_SMALL_COLOR)
+        nButtons = 5;
+    else
+        return -1;
+
+    TRACE ("adding %d internal bitmaps!\n", nButtons);
+
+    /* Windows resize all the buttons to the size of a newly added standard image */
+    if (lpAddBmp->nID & 1)
+    {
+        /* large icons */
+        /* FIXME: on windows the size of the images is 25x24 but the size of the bitmap
+             * in rsrc is only 24x24. Fix the bitmap (how?) and then fix this
              */
-            SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
-                          MAKELPARAM((WORD)24, (WORD)24));
-            SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
-                          MAKELPARAM((WORD)31, (WORD)30));
-        }       
-        else 
-        {
-            /* small icons */
-            SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
-                          MAKELPARAM((WORD)16, (WORD)16));
-            SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
-                          MAKELPARAM((WORD)22, (WORD)22));
-        }
-        
-        TOOLBAR_CalcToolbar (hwnd);
+        SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
+              MAKELPARAM((WORD)24, (WORD)24));
+        SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
+              MAKELPARAM((WORD)31, (WORD)30));
     }
     else
     {
-        nButtons = (INT)wParam;
-        if (nButtons <= 0)
-            return -1;
-        
-        TRACE ("adding %d bitmaps!\n", nButtons);
-    }
-    
+        /* small icons */
+        SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
+              MAKELPARAM((WORD)16, (WORD)16));
+        SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
+              MAKELPARAM((WORD)22, (WORD)22));
+    }
+
+    TOOLBAR_CalcToolbar (hwnd);
+    }
+    else
+    {
+    nButtons = (INT)wParam;
+    if (nButtons <= 0)
+        return -1;
+
+    TRACE ("adding %d bitmaps!\n", nButtons);
+    }
+
     if (!(infoPtr->himlDef)) {
-        /* create new default image list */
-        TRACE ("creating default image list!\n");
-
-        infoPtr->himlDef =
-            ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
-                              ILC_COLOR | ILC_MASK, nButtons, 2);
-        infoPtr->himlInt = infoPtr->himlDef;
+    /* create new default image list */
+    TRACE ("creating default image list!\n");
+
+    infoPtr->himlDef =
+        ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
+                  ILC_COLOR | ILC_MASK, nButtons, 2);
+    infoPtr->himlInt = infoPtr->himlDef;
     }
 
@@ -1582 +1583 @@
     if (lpAddBmp->hInst == (HINSTANCE)0)
     {
-        nIndex = 
-            ImageList_AddMasked (infoPtr->himlDef, (HBITMAP)lpAddBmp->nID,
-                                 CLR_DEFAULT);
+    nIndex =
+        ImageList_AddMasked (infoPtr->himlDef, (HBITMAP)lpAddBmp->nID,
+                 CLR_DEFAULT);
     }
     else if (lpAddBmp->hInst == HINST_COMMCTRL)
     {
-        /* Add system bitmaps */
-        switch (lpAddBmp->nID)
-    {
-            case IDB_STD_SMALL_COLOR:
-                hbmLoad = LoadBitmapA (COMCTL32_hModule,
-                                       MAKEINTRESOURCEA(IDB_STD_SMALL));
-                nIndex = ImageList_AddMasked (infoPtr->himlDef,
-                                              hbmLoad, CLR_DEFAULT);
-                DeleteObject (hbmLoad);
-                break;
-
-            case IDB_STD_LARGE_COLOR:
-                hbmLoad = LoadBitmapA (COMCTL32_hModule,
-                                       MAKEINTRESOURCEA(IDB_STD_LARGE));
-                nIndex = ImageList_AddMasked (infoPtr->himlDef,
-                                              hbmLoad, CLR_DEFAULT);
-                DeleteObject (hbmLoad);
-                break;
-
-            case IDB_VIEW_SMALL_COLOR:
-                hbmLoad = LoadBitmapA (COMCTL32_hModule,
-                                       MAKEINTRESOURCEA(IDB_VIEW_SMALL));
-                nIndex = ImageList_AddMasked (infoPtr->himlDef,
-                                              hbmLoad, CLR_DEFAULT);
-                DeleteObject (hbmLoad);
-                break;
-
-            case IDB_VIEW_LARGE_COLOR:
-                hbmLoad = LoadBitmapA (COMCTL32_hModule,
-                                       MAKEINTRESOURCEA(IDB_VIEW_LARGE));
-                nIndex = ImageList_AddMasked (infoPtr->himlDef,
-                                              hbmLoad, CLR_DEFAULT);
-                DeleteObject (hbmLoad);
-                break;
-
-            case IDB_HIST_SMALL_COLOR:
-                hbmLoad = LoadBitmapA (COMCTL32_hModule,
-                                       MAKEINTRESOURCEA(IDB_HIST_SMALL));
-                nIndex = ImageList_AddMasked (infoPtr->himlDef,
-                                              hbmLoad, CLR_DEFAULT);
-                DeleteObject (hbmLoad);
-                break;
-
-            case IDB_HIST_LARGE_COLOR:
-                hbmLoad = LoadBitmapA (COMCTL32_hModule,
-                                       MAKEINTRESOURCEA(IDB_HIST_LARGE));
-                nIndex = ImageList_AddMasked (infoPtr->himlDef,
-                                              hbmLoad, CLR_DEFAULT);
-                DeleteObject (hbmLoad);
-                break;
-
-            default:
-        nIndex = ImageList_GetImageCount (infoPtr->himlDef);
-                ERR ("invalid imagelist!\n");
-                break;
-        }
+    /* Add system bitmaps */
+    switch (lpAddBmp->nID)
+    {
+        case IDB_STD_SMALL_COLOR:
+        hbmLoad = LoadBitmapA (COMCTL32_hModule,
+                       MAKEINTRESOURCEA(IDB_STD_SMALL));
+        nIndex = ImageList_AddMasked (infoPtr->himlDef,
+                          hbmLoad, CLR_DEFAULT);
+        DeleteObject (hbmLoad);
+        break;
+
+        case IDB_STD_LARGE_COLOR:
+        hbmLoad = LoadBitmapA (COMCTL32_hModule,
+                       MAKEINTRESOURCEA(IDB_STD_LARGE));
+        nIndex = ImageList_AddMasked (infoPtr->himlDef,
+                          hbmLoad, CLR_DEFAULT);
+        DeleteObject (hbmLoad);
+        break;
+
+        case IDB_VIEW_SMALL_COLOR:
+        hbmLoad = LoadBitmapA (COMCTL32_hModule,
+                       MAKEINTRESOURCEA(IDB_VIEW_SMALL));
+        nIndex = ImageList_AddMasked (infoPtr->himlDef,
+                          hbmLoad, CLR_DEFAULT);
+        DeleteObject (hbmLoad);
+        break;
+
+        case IDB_VIEW_LARGE_COLOR:
+        hbmLoad = LoadBitmapA (COMCTL32_hModule,
+                       MAKEINTRESOURCEA(IDB_VIEW_LARGE));
+        nIndex = ImageList_AddMasked (infoPtr->himlDef,
+                          hbmLoad, CLR_DEFAULT);
+        DeleteObject (hbmLoad);
+        break;
+
+        case IDB_HIST_SMALL_COLOR:
+        hbmLoad = LoadBitmapA (COMCTL32_hModule,
+                       MAKEINTRESOURCEA(IDB_HIST_SMALL));
+        nIndex = ImageList_AddMasked (infoPtr->himlDef,
+                          hbmLoad, CLR_DEFAULT);
+        DeleteObject (hbmLoad);
+        break;
+
+        case IDB_HIST_LARGE_COLOR:
+        hbmLoad = LoadBitmapA (COMCTL32_hModule,
+                       MAKEINTRESOURCEA(IDB_HIST_LARGE));
+        nIndex = ImageList_AddMasked (infoPtr->himlDef,
+                          hbmLoad, CLR_DEFAULT);
+        DeleteObject (hbmLoad);
+        break;
+
+        default:
+    nIndex = ImageList_GetImageCount (infoPtr->himlDef);
+        ERR ("invalid imagelist!\n");
+        break;
+    }
     }
     else
     {
-        hbmLoad = LoadBitmapA (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
-        nIndex = ImageList_AddMasked (infoPtr->himlDef, hbmLoad, CLR_DEFAULT);
-        DeleteObject (hbmLoad);
+    hbmLoad = LoadBitmapA (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
+    nIndex = ImageList_AddMasked (infoPtr->himlDef, hbmLoad, CLR_DEFAULT);
+    DeleteObject (hbmLoad);
     }
 
@@ -1659 +1660 @@
        {
          WARN("Desired images do not match received images : Previous image number %i Previous images in list %i added %i expecting total %i, Images in list %i\n",
-              infoPtr->nNumBitmaps, nCount, imagecount - nCount,
-              infoPtr->nNumBitmaps+nButtons,imagecount);
-
-         infoPtr->nNumBitmaps = imagecount;
+          infoPtr->nNumBitmaps, nCount, imagecount - nCount,
+          infoPtr->nNumBitmaps+nButtons,imagecount);
+
+     infoPtr->nNumBitmaps = imagecount;
        }
        else
@@ -1688 +1689 @@
 
     if (infoPtr->nNumButtons == 0) {
-        infoPtr->buttons =
-            COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
+    infoPtr->buttons =
+        COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
     }
     else {
-        TBUTTON_INFO *oldButtons = infoPtr->buttons;
-        infoPtr->buttons =
-            COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
-        memcpy (&infoPtr->buttons[0], &oldButtons[0],
-                nOldButtons * sizeof(TBUTTON_INFO));
+    TBUTTON_INFO *oldButtons = infoPtr->buttons;
+    infoPtr->buttons =
+        COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
+    memcpy (&infoPtr->buttons[0], &oldButtons[0],
+        nOldButtons * sizeof(TBUTTON_INFO));
         COMCTL32_Free (oldButtons);
     }
@@ -1704 +1705 @@
     /* insert new button data */
     for (nCount = 0; nCount < nAddButtons; nCount++) {
-        TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
-        btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
-        btnPtr->idCommand = lpTbb[nCount].idCommand;
-        btnPtr->fsState   = lpTbb[nCount].fsState;
-        btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
-        btnPtr->dwData    = lpTbb[nCount].dwData;
-        btnPtr->iString   = lpTbb[nCount].iString;
-        btnPtr->bHot      = FALSE;
-
-        if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
-            TTTOOLINFOA ti;
-
-            ZeroMemory (&ti, sizeof(TTTOOLINFOA));
-            ti.cbSize   = sizeof (TTTOOLINFOA);
-            ti.hwnd     = hwnd;
-            ti.uId      = btnPtr->idCommand;
-            ti.hinst    = 0;
-            ti.lpszText = LPSTR_TEXTCALLBACKA;
-
-            SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
-                            0, (LPARAM)&ti);
-        }
+    TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
+    btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
+    btnPtr->idCommand = lpTbb[nCount].idCommand;
+    btnPtr->fsState   = lpTbb[nCount].fsState;
+    btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
+    btnPtr->dwData    = lpTbb[nCount].dwData;
+    btnPtr->iString   = lpTbb[nCount].iString;
+    btnPtr->bHot      = FALSE;
+
+    if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
+        TTTOOLINFOA ti;
+
+        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
+        ti.cbSize   = sizeof (TTTOOLINFOA);
+        ti.hwnd     = hwnd;
+        ti.uId      = btnPtr->idCommand;
+        ti.hinst    = 0;
+        ti.lpszText = LPSTR_TEXTCALLBACKA;
+
+        SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
+                0, (LPARAM)&ti);
+    }
     }
 
@@ -1750 +1751 @@
 
     if (infoPtr->nNumButtons == 0) {
-        infoPtr->buttons =
-            COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
+    infoPtr->buttons =
+        COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
     }
     else {
-        TBUTTON_INFO *oldButtons = infoPtr->buttons;
-        infoPtr->buttons =
-            COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
-        memcpy (&infoPtr->buttons[0], &oldButtons[0],
-                nOldButtons * sizeof(TBUTTON_INFO));
+    TBUTTON_INFO *oldButtons = infoPtr->buttons;
+    infoPtr->buttons =
+        COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
+    memcpy (&infoPtr->buttons[0], &oldButtons[0],
+        nOldButtons * sizeof(TBUTTON_INFO));
         COMCTL32_Free (oldButtons);
     }
@@ -1766 +1767 @@
     /* insert new button data */
     for (nCount = 0; nCount < nAddButtons; nCount++) {
-        TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
-        btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
-        btnPtr->idCommand = lpTbb[nCount].idCommand;
-        btnPtr->fsState   = lpTbb[nCount].fsState;
-        btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
-        btnPtr->dwData    = lpTbb[nCount].dwData;
-        btnPtr->iString   = lpTbb[nCount].iString;
-        btnPtr->bHot      = FALSE;
-
-        if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
-            TTTOOLINFOW ti;
-
-            ZeroMemory (&ti, sizeof(TTTOOLINFOW));
-            ti.cbSize   = sizeof (TTTOOLINFOW);
-            ti.hwnd     = hwnd;
-            ti.uId      = btnPtr->idCommand;
-            ti.hinst    = 0;
-            ti.lpszText = LPSTR_TEXTCALLBACKW;
-
-            SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
-                            0, (LPARAM)&ti);
-        }
+    TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
+    btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
+    btnPtr->idCommand = lpTbb[nCount].idCommand;
+    btnPtr->fsState   = lpTbb[nCount].fsState;
+    btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
+    btnPtr->dwData    = lpTbb[nCount].dwData;
+    btnPtr->iString   = lpTbb[nCount].iString;
+    btnPtr->bHot      = FALSE;
+
+    if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
+        TTTOOLINFOW ti;
+
+        ZeroMemory (&ti, sizeof(TTTOOLINFOW));
+        ti.cbSize   = sizeof (TTTOOLINFOW);
+        ti.hwnd     = hwnd;
+        ti.uId      = btnPtr->idCommand;
+        ti.hinst    = 0;
+        ti.lpszText = LPSTR_TEXTCALLBACKW;
+
+        SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
+                0, (LPARAM)&ti);
+    }
     }
 
@@ -1805 +1806 @@
 
     if ((wParam) && (HIWORD(lParam) == 0)) {
-        char szString[256];
-        INT len, lenW;
-        TRACE("adding string from resource!\n");
-
-        len = LoadStringA ((HINSTANCE)wParam, (UINT)lParam,
-                             szString, 256);
-
-        TRACE("len=%d \"%s\"\n", len, szString);
-        nIndex = infoPtr->nNumStrings;
-        if (infoPtr->nNumStrings == 0) {
-            infoPtr->strings =
-                COMCTL32_Alloc (sizeof(LPWSTR));
-        }
-        else {
-            LPWSTR *oldStrings = infoPtr->strings;
-            infoPtr->strings =
-                COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
-            memcpy (&infoPtr->strings[0], &oldStrings[0],
-                    sizeof(LPWSTR) * infoPtr->nNumStrings);
-            COMCTL32_Free (oldStrings);
-        }
+    char szString[256];
+    INT len, lenW;
+    TRACE("adding string from resource!\n");
+
+    len = LoadStringA ((HINSTANCE)wParam, (UINT)lParam,
+                 szString, 256);
+
+    TRACE("len=%d \"%s\"\n", len, szString);
+    nIndex = infoPtr->nNumStrings;
+    if (infoPtr->nNumStrings == 0) {
+        infoPtr->strings =
+        COMCTL32_Alloc (sizeof(LPWSTR));
+    }
+    else {
+        LPWSTR *oldStrings = infoPtr->strings;
+        infoPtr->strings =
+        COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
+        memcpy (&infoPtr->strings[0], &oldStrings[0],
+            sizeof(LPWSTR) * infoPtr->nNumStrings);
+        COMCTL32_Free (oldStrings);
+    }
 
         lenW = MultiByteToWideChar( CP_ACP, 0, szString, -1, NULL, 0 );
@@ -1831 +1832 @@
         MultiByteToWideChar( CP_ACP, 0, szString, -1,
                              infoPtr->strings[infoPtr->nNumStrings], lenW );
-        infoPtr->nNumStrings++;
+    infoPtr->nNumStrings++;
     }
     else {
-        LPSTR p = (LPSTR)lParam;
-        INT len, lenW;
-
-        if (p == NULL)
-            return -1;
-        TRACE("adding string(s) from array!\n");
-
-        nIndex = infoPtr->nNumStrings;
-        while (*p) {
-            len = strlen (p);
-            TRACE("len=%d \"%s\"\n", len, p);
-
-            if (infoPtr->nNumStrings == 0) {
-                infoPtr->strings =
-                    COMCTL32_Alloc (sizeof(LPWSTR));
-            }
-            else {
-                LPWSTR *oldStrings = infoPtr->strings;
-                infoPtr->strings =
-                    COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
-                memcpy (&infoPtr->strings[0], &oldStrings[0],
-                        sizeof(LPWSTR) * infoPtr->nNumStrings);
-                COMCTL32_Free (oldStrings);
-            }
+    LPSTR p = (LPSTR)lParam;
+    INT len, lenW;
+
+    if (p == NULL)
+        return -1;
+    TRACE("adding string(s) from array!\n");
+
+    nIndex = infoPtr->nNumStrings;
+    while (*p) {
+        len = strlen (p);
+        TRACE("len=%d \"%s\"\n", len, p);
+
+        if (infoPtr->nNumStrings == 0) {
+        infoPtr->strings =
+            COMCTL32_Alloc (sizeof(LPWSTR));
+        }
+        else {
+        LPWSTR *oldStrings = infoPtr->strings;
+        infoPtr->strings =
+            COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
+        memcpy (&infoPtr->strings[0], &oldStrings[0],
+            sizeof(LPWSTR) * infoPtr->nNumStrings);
+        COMCTL32_Free (oldStrings);
+        }
 
             lenW = MultiByteToWideChar( CP_ACP, 0, p, -1, NULL, 0 );
@@ -1863 +1864 @@
             MultiByteToWideChar( CP_ACP, 0, p, -1,
                                  infoPtr->strings[infoPtr->nNumStrings], lenW );
-            infoPtr->nNumStrings++;
-
-            p += (len+1);
-        }
+        infoPtr->nNumStrings++;
+
+        p += (len+1);
+    }
     }
 
@@ -1881 +1882 @@
 
     if ((wParam) && (HIWORD(lParam) == 0)) {
-        WCHAR szString[MAX_RESOURCE_STRING_LENGTH];
-        INT len;
-        TRACE("adding string from resource!\n");
-
-        len = LoadStringW ((HINSTANCE)wParam, (UINT)lParam,
-                             szString, MAX_RESOURCE_STRING_LENGTH);
-
-        TRACE("len=%d %s\n", len, debugstr_w(szString));
-        TRACE("First char: 0x%x\n", *szString);
-        if (szString[0] == L'|')
-        {
-            PWSTR p = szString + 1;
-                
-            nIndex = infoPtr->nNumStrings;
-            while (*p != L'|') {
-
-            if (infoPtr->nNumStrings == 0) {
-                infoPtr->strings =
-                    COMCTL32_Alloc (sizeof(LPWSTR));
-            }
-            else {
-                LPWSTR *oldStrings = infoPtr->strings;
-                infoPtr->strings =
-                    COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
-                memcpy (&infoPtr->strings[0], &oldStrings[0],
-                        sizeof(LPWSTR) * infoPtr->nNumStrings);
-                COMCTL32_Free (oldStrings);
-            }
-
-            len = COMCTL32_StrChrW (p, L'|') - p;
-            TRACE("len=%d %s\n", len, debugstr_w(p));
-            infoPtr->strings[infoPtr->nNumStrings] =
-                COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
-            lstrcpynW (infoPtr->strings[infoPtr->nNumStrings], p, len);
-            infoPtr->nNumStrings++;
-
-                p += (len+1);
-            }
-        }
-        else
-        {
+    WCHAR szString[MAX_RESOURCE_STRING_LENGTH];
+    INT len;
+    TRACE("adding string from resource!\n");
+
+    len = LoadStringW ((HINSTANCE)wParam, (UINT)lParam,
+                 szString, MAX_RESOURCE_STRING_LENGTH);
+
+    TRACE("len=%d %s\n", len, debugstr_w(szString));
+    TRACE("First char: 0x%x\n", *szString);
+    if (szString[0] == L'|')
+    {
+        PWSTR p = szString + 1;
+
+        nIndex = infoPtr->nNumStrings;
+        while (*p != L'|') {
+
+        if (infoPtr->nNumStrings == 0) {
+        infoPtr->strings =
+            COMCTL32_Alloc (sizeof(LPWSTR));
+        }
+        else {
+        LPWSTR *oldStrings = infoPtr->strings;
+        infoPtr->strings =
+            COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
+        memcpy (&infoPtr->strings[0], &oldStrings[0],
+            sizeof(LPWSTR) * infoPtr->nNumStrings);
+        COMCTL32_Free (oldStrings);
+        }
+
+        len = COMCTL32_StrChrW (p, L'|') - p;
+        TRACE("len=%d %s\n", len, debugstr_w(p));
+        infoPtr->strings[infoPtr->nNumStrings] =
+        COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
+        lstrcpynW (infoPtr->strings[infoPtr->nNumStrings], p, len);
+        infoPtr->nNumStrings++;
+
+        p += (len+1);
+        }
+    }
+    else
+    {
             nIndex = infoPtr->nNumStrings;
             if (infoPtr->nNumStrings == 0) {
@@ -1943 +1944 @@
     }
     else {
-        LPWSTR p = (LPWSTR)lParam;
-        INT len;
-
-        if (p == NULL)
-            return -1;
-        TRACE("adding string(s) from array!\n");
-        nIndex = infoPtr->nNumStrings;
-        while (*p) {
-            len = strlenW (p);
-
-            TRACE("len=%d %s\n", len, debugstr_w(p));
-            if (infoPtr->nNumStrings == 0) {
-                infoPtr->strings =
-                    COMCTL32_Alloc (sizeof(LPWSTR));
-            }
-            else {
-                LPWSTR *oldStrings = infoPtr->strings;
-                infoPtr->strings =
-                    COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
-                memcpy (&infoPtr->strings[0], &oldStrings[0],
-                        sizeof(LPWSTR) * infoPtr->nNumStrings);
-                COMCTL32_Free (oldStrings);
-            }
-
-            infoPtr->strings[infoPtr->nNumStrings] =
-                COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
-            strcpyW (infoPtr->strings[infoPtr->nNumStrings], p);
-            infoPtr->nNumStrings++;
-
-            p += (len+1);
-        }
+    LPWSTR p = (LPWSTR)lParam;
+    INT len;
+
+    if (p == NULL)
+        return -1;
+    TRACE("adding string(s) from array!\n");
+    nIndex = infoPtr->nNumStrings;
+    while (*p) {
+        len = strlenW (p);
+
+        TRACE("len=%d %s\n", len, debugstr_w(p));
+        if (infoPtr->nNumStrings == 0) {
+        infoPtr->strings =
+            COMCTL32_Alloc (sizeof(LPWSTR));
+        }
+        else {
+        LPWSTR *oldStrings = infoPtr->strings;
+        infoPtr->strings =
+            COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
+        memcpy (&infoPtr->strings[0], &oldStrings[0],
+            sizeof(LPWSTR) * infoPtr->nNumStrings);
+        COMCTL32_Free (oldStrings);
+        }
+
+        infoPtr->strings[infoPtr->nNumStrings] =
+        COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
+        strcpyW (infoPtr->strings[infoPtr->nNumStrings], p);
+        infoPtr->nNumStrings++;
+
+        p += (len+1);
+    }
     }
 
@@ -2004 +2005 @@
 
     if (dwStyle & CCS_NORESIZE) {
-        uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
-        cx = 0;
-        cy = 0;
+    uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
+    cx = 0;
+    cy = 0;
     }
     else {
-        infoPtr->nWidth = parent_rect.right - parent_rect.left;
-        TOOLBAR_CalcToolbar (hwnd);
-        InvalidateRect( hwnd, NULL, TRUE );
-        cy = infoPtr->nHeight;
-        cx = infoPtr->nWidth;
-
-        if (dwStyle & CCS_NOMOVEY) {
-                GetWindowRect(hwnd, &window_rect);
-                ScreenToClient(parent, (LPPOINT)&window_rect.left);
-                y = window_rect.top;
-        }
+    infoPtr->nWidth = parent_rect.right - parent_rect.left;
+    TOOLBAR_CalcToolbar (hwnd);
+    InvalidateRect( hwnd, NULL, TRUE );
+    cy = infoPtr->nHeight;
+    cx = infoPtr->nWidth;
+
+    if (dwStyle & CCS_NOMOVEY) {
+        GetWindowRect(hwnd, &window_rect);
+        ScreenToClient(parent, (LPPOINT)&window_rect.left);
+        y = window_rect.top;
+    }
     }
 
     if (dwStyle & CCS_NOPARENTALIGN)
-        uPosFlags |= SWP_NOMOVE;
+    uPosFlags |= SWP_NOMOVE;
 
     if (!(dwStyle & CCS_NODIVIDER))
-        cy += GetSystemMetrics(SM_CYEDGE);
+    cy += GetSystemMetrics(SM_CYEDGE);
 
     if (dwStyle & WS_BORDER)
@@ -2061 +2062 @@
 
     if (infoPtr == NULL) {
-        ERR("(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
-        ERR("infoPtr == NULL!\n");
-        return 0;
+    ERR("(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
+    ERR("infoPtr == NULL!\n");
+    return 0;
     }
 
@@ -2081 +2082 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
@@ -2105 +2106 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
 
     if (!(btnPtr->fsStyle & TBSTYLE_CHECK))
-        return FALSE;
+    return FALSE;
 
     bChecked = (btnPtr->fsState & TBSTATE_CHECKED) ? TRUE : FALSE;
 
     if (LOWORD(lParam) == FALSE)
-        btnPtr->fsState &= ~TBSTATE_CHECKED;
+    btnPtr->fsState &= ~TBSTATE_CHECKED;
     else {
-        if (btnPtr->fsStyle & TBSTYLE_GROUP) {
-            nOldIndex = 
-                TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
-            if (nOldIndex == nIndex)
-                return 0;
-            if (nOldIndex != -1)
-                infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
-        }
-        btnPtr->fsState |= TBSTATE_CHECKED;
+    if (btnPtr->fsStyle & TBSTYLE_GROUP) {
+        nOldIndex =
+        TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
+        if (nOldIndex == nIndex)
+        return 0;
+        if (nOldIndex != -1)
+        infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
+    }
+    btnPtr->fsState |= TBSTATE_CHECKED;
     }
 
     if( bChecked != LOWORD(lParam) )
     {
-        if (nOldIndex != -1)
+    if (nOldIndex != -1)
         {
             InvalidateRect(hwnd, &infoPtr->buttons[nOldIndex].rect,
@@ -2171 +2172 @@
 
     SendMessageA (custInfo.tbInfo->hwndNotify, WM_NOTIFY,
-                  (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
+          (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
 
     if (!(hRes = FindResourceA (COMCTL32_hModule,
                                 MAKEINTRESOURCEA(IDD_TBCUSTOMIZE),
                                 RT_DIALOGA)))
-        return FALSE;
+    return FALSE;
 
     if(!(template = (LPVOID)LoadResource (COMCTL32_hModule, hRes)))
-        return FALSE;
+    return FALSE;
 
     ret = DialogBoxIndirectParamA (GetWindowLongA (hwnd, GWL_HINSTANCE),
@@ -2190 +2191 @@
     nmhdr.code = TBN_ENDADJUST;
     SendMessageA (custInfo.tbInfo->hwndNotify, WM_NOTIFY,
-                  (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
+          (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
 
     return ret;
@@ -2203 +2204 @@
 
     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
-        return FALSE;
-
-    if ((infoPtr->hwndToolTip) && 
-        !(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
-        TTTOOLINFOA ti;
-
-        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
-        ti.cbSize   = sizeof (TTTOOLINFOA);
-        ti.hwnd     = hwnd;
-        ti.uId      = infoPtr->buttons[nIndex].idCommand;
-
-        SendMessageA (infoPtr->hwndToolTip, TTM_DELTOOLA, 0, (LPARAM)&ti);
+    return FALSE;
+
+    if ((infoPtr->hwndToolTip) &&
+    !(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
+    TTTOOLINFOA ti;
+
+    ZeroMemory (&ti, sizeof(TTTOOLINFOA));
+    ti.cbSize   = sizeof (TTTOOLINFOA);
+    ti.hwnd     = hwnd;
+    ti.uId      = infoPtr->buttons[nIndex].idCommand;
+
+    SendMessageA (infoPtr->hwndToolTip, TTM_DELTOOLA, 0, (LPARAM)&ti);
     }
 
     if (infoPtr->nNumButtons == 1) {
-        TRACE(" simple delete!\n");
-        COMCTL32_Free (infoPtr->buttons);
-        infoPtr->buttons = NULL;
-        infoPtr->nNumButtons = 0;
+    TRACE(" simple delete!\n");
+    COMCTL32_Free (infoPtr->buttons);
+    infoPtr->buttons = NULL;
+    infoPtr->nNumButtons = 0;
     }
     else {
-        TBUTTON_INFO *oldButtons = infoPtr->buttons;
+    TBUTTON_INFO *oldButtons = infoPtr->buttons;
         TRACE("complex delete! [nIndex=%d]\n", nIndex);
 
-        infoPtr->nNumButtons--;
-        infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
+    infoPtr->nNumButtons--;
+    infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
         if (nIndex > 0) {
             memcpy (&infoPtr->buttons[0], &oldButtons[0],
@@ -2239 +2240 @@
         }
 
-        COMCTL32_Free (oldButtons);
+    COMCTL32_Free (oldButtons);
     }
 
@@ -2260 +2261 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
@@ -2268 +2269 @@
     /* update the toolbar button state */
     if(LOWORD(lParam) == FALSE) {
-        btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
+    btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
     } else {
-        btnPtr->fsState |= TBSTATE_ENABLED;
+    btnPtr->fsState |= TBSTATE_ENABLED;
     }
 
@@ -2301 +2302 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return -1;
+    return -1;
 
     return infoPtr->buttons[nIndex].iBitmap;
@@ -2323 +2324 @@
 
     if (infoPtr == NULL)
-        return FALSE;
+    return FALSE;
 
     if (lpTbb == NULL)
-        return FALSE;
+    return FALSE;
 
     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
@@ -2352 +2353 @@
 
     if (infoPtr == NULL)
-        return -1;
+    return -1;
     if (lpTbInfo == NULL)
-        return -1;
+    return -1;
     if (lpTbInfo->cbSize < sizeof(TBBUTTONINFOA))
-        return -1;
+    return -1;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return -1;
+    return -1;
 
     btnPtr = &infoPtr->buttons[nIndex];
 
     if (lpTbInfo->dwMask & TBIF_COMMAND)
-        lpTbInfo->idCommand = btnPtr->idCommand;
+    lpTbInfo->idCommand = btnPtr->idCommand;
     if (lpTbInfo->dwMask & TBIF_IMAGE)
-        lpTbInfo->iImage = btnPtr->iBitmap;
+    lpTbInfo->iImage = btnPtr->iBitmap;
     if (lpTbInfo->dwMask & TBIF_LPARAM)
-        lpTbInfo->lParam = btnPtr->dwData;
+    lpTbInfo->lParam = btnPtr->dwData;
     if (lpTbInfo->dwMask & TBIF_SIZE)
-        lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
+    lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
     if (lpTbInfo->dwMask & TBIF_STATE)
-        lpTbInfo->fsState = btnPtr->fsState;
+    lpTbInfo->fsState = btnPtr->fsState;
     if (lpTbInfo->dwMask & TBIF_STYLE)
-        lpTbInfo->fsStyle = btnPtr->fsStyle;
+    lpTbInfo->fsStyle = btnPtr->fsStyle;
      if (lpTbInfo->dwMask & TBIF_TEXT) {
          if ((btnPtr->iString >= 0) && (btnPtr->iString < infoPtr->nNumStrings))
-         {      
+         {
              if (!WideCharToMultiByte( CP_ACP, 0, (LPWSTR)infoPtr->strings[btnPtr->iString], -1,
                                        lpTbInfo->pszText, lpTbInfo->cchText, NULL, NULL ))
@@ -2398 +2399 @@
 
     if (infoPtr == NULL)
-        return -1;
+    return -1;
     if (lpTbInfo == NULL)
-        return -1;
+    return -1;
     if (lpTbInfo->cbSize < sizeof(TBBUTTONINFOW))
-        return -1;
+    return -1;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return -1;
+    return -1;
 
     btnPtr = &infoPtr->buttons[nIndex];
 
     if (lpTbInfo->dwMask & TBIF_COMMAND)
-        lpTbInfo->idCommand = btnPtr->idCommand;
+    lpTbInfo->idCommand = btnPtr->idCommand;
     if (lpTbInfo->dwMask & TBIF_IMAGE)
-        lpTbInfo->iImage = btnPtr->iBitmap;
+    lpTbInfo->iImage = btnPtr->iBitmap;
     if (lpTbInfo->dwMask & TBIF_LPARAM)
-        lpTbInfo->lParam = btnPtr->dwData;
+    lpTbInfo->lParam = btnPtr->dwData;
     if (lpTbInfo->dwMask & TBIF_SIZE)
-        lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
+    lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
     if (lpTbInfo->dwMask & TBIF_STATE)
-        lpTbInfo->fsState = btnPtr->fsState;
+    lpTbInfo->fsState = btnPtr->fsState;
     if (lpTbInfo->dwMask & TBIF_STYLE)
-        lpTbInfo->fsStyle = btnPtr->fsStyle;
+    lpTbInfo->fsStyle = btnPtr->fsStyle;
     if (lpTbInfo->dwMask & TBIF_TEXT) {
-        if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
-            lstrcpynW (lpTbInfo->pszText,
-                       (LPWSTR)infoPtr->strings[btnPtr->iString],
-                       lpTbInfo->cchText);
+    if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
+        lstrcpynW (lpTbInfo->pszText,
+               (LPWSTR)infoPtr->strings[btnPtr->iString],
+               lpTbInfo->cchText);
     }
 
@@ -2439 +2440 @@
 
     return MAKELONG((WORD)infoPtr->nButtonWidth,
-                    (WORD)infoPtr->nButtonHeight);
+            (WORD)infoPtr->nButtonHeight);
 }
 
@@ -2451 +2452 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return -1;
+    return -1;
 
     nStringIndex = infoPtr->buttons[nIndex].iString;
@@ -2458 +2459 @@
 
     if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
-        return -1;
+    return -1;
 
     if (lParam == 0)
-        return -1;
+    return -1;
 
     return WideCharToMultiByte( CP_ACP, 0, (LPWSTR)infoPtr->strings[nStringIndex], -1,
@@ -2476 +2477 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return -1;
+    return -1;
 
     nStringIndex = infoPtr->buttons[nIndex].iString;
@@ -2483 +2484 @@
 
     if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
-        return -1;
+    return -1;
 
     if (lParam == 0)
-        return -1;
+    return -1;
 
     strcpyW ((LPWSTR)lParam, (LPWSTR)infoPtr->strings[nStringIndex]);
@@ -2530 +2531 @@
 
     if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
-        return -1;
+    return -1;
 
     if (infoPtr->nHotItem < 0)
-        return -1;
+    return -1;
 
     return (LRESULT)infoPtr->nHotItem;
@@ -2561 +2562 @@
 
     if (infoPtr == NULL)
-        return FALSE;
+    return FALSE;
     nIndex = (INT)wParam;
     btnPtr = &infoPtr->buttons[nIndex];
     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
-        return FALSE;
+    return FALSE;
     lpRect = (LPRECT)lParam;
     if (lpRect == NULL)
-        return FALSE;
+    return FALSE;
     if (btnPtr->fsState & TBSTATE_HIDDEN)
-        return FALSE;
-    
+    return FALSE;
+
     lpRect->left   = btnPtr->rect.left;
     lpRect->right  = btnPtr->rect.right;
@@ -2588 +2589 @@
 
     if (lpSize == NULL)
-        return FALSE;
+    return FALSE;
 
     lpSize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
@@ -2594 +2595 @@
 
     TRACE("maximum size %d x %d\n",
-           infoPtr->rcBound.right - infoPtr->rcBound.left,
-           infoPtr->rcBound.bottom - infoPtr->rcBound.top);
+       infoPtr->rcBound.right - infoPtr->rcBound.left,
+       infoPtr->rcBound.bottom - infoPtr->rcBound.top);
 
     return TRUE;
@@ -2614 +2615 @@
 
     if (infoPtr == NULL)
-        return FALSE;
+    return FALSE;
     nIndex = (INT)wParam;
     btnPtr = &infoPtr->buttons[nIndex];
     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
-        return FALSE;
+    return FALSE;
     lpRect = (LPRECT)lParam;
     if (lpRect == NULL)
-        return FALSE;
-    
+    return FALSE;
+
     lpRect->left   = btnPtr->rect.left;
     lpRect->right  = btnPtr->rect.right;
@@ -2638 +2639 @@
 
     if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_WRAPABLE)
-        return infoPtr->nRows;
+    return infoPtr->nRows;
     else
-        return 1;
+    return 1;
 }
 
@@ -2652 +2653 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return -1;
+    return -1;
 
     return infoPtr->buttons[nIndex].fsState;
@@ -2666 +2667 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return -1;
+    return -1;
 
     return infoPtr->buttons[nIndex].fsStyle;
@@ -2678 +2679 @@
 
     if (infoPtr == NULL)
-        return 0;
+    return 0;
 
     return infoPtr->nMaxTextRows;
@@ -2690 +2691 @@
 
     if (infoPtr == NULL)
-        return 0;
+    return 0;
     return infoPtr->hwndToolTip;
 }
@@ -2700 +2701 @@
     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 
-    TRACE("%s hwnd=0x%x stub!\n", 
-           infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
+    TRACE("%s hwnd=0x%x stub!\n",
+       infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
 
     return infoPtr->bUnicode;
@@ -2726 +2727 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
     if (LOWORD(lParam) == FALSE)
-        btnPtr->fsState &= ~TBSTATE_HIDDEN;
+    btnPtr->fsState &= ~TBSTATE_HIDDEN;
     else
-        btnPtr->fsState |= TBSTATE_HIDDEN;
+    btnPtr->fsState |= TBSTATE_HIDDEN;
 
     TOOLBAR_CalcToolbar (hwnd);
@@ -2758 +2759 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
     if (LOWORD(lParam) == FALSE)
-        btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
+    btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
     else
-        btnPtr->fsState |= TBSTATE_INDETERMINATE;
+    btnPtr->fsState |= TBSTATE_INDETERMINATE;
 
     InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr, btnPtr));
@@ -2781 +2782 @@
 
     if (lpTbb == NULL)
-        return FALSE;
+    return FALSE;
 
     if (nIndex == -1) {
        /* EPP: this seems to be an undocumented call (from my IE4)
-        * I assume in that case that:
-        * - lpTbb->iString is a string pointer (not a string index in strings[] table
-        * - index of insertion is at the end of existing buttons
-        * I only see this happen with nIndex == -1, but it could have a special
-        * meaning (like -nIndex (or ~nIndex) to get the real position of insertion).
-        */
-       int      len;
-       LPSTR    ptr;
+    * I assume in that case that:
+    * - lpTbb->iString is a string pointer (not a string index in strings[] table
+    * - index of insertion is at the end of existing buttons
+    * I only see this happen with nIndex == -1, but it could have a special
+    * meaning (like -nIndex (or ~nIndex) to get the real position of insertion).
+    */
+       int  len;
+       LPSTR    ptr;
 
        /* FIXME: iString == -1 is undocumented */
@@ -2814 +2815 @@
     TRACE("inserting button index=%d\n", nIndex);
     if (nIndex > infoPtr->nNumButtons) {
-        nIndex = infoPtr->nNumButtons;
-        TRACE("adjust index=%d\n", nIndex);
+    nIndex = infoPtr->nNumButtons;
+    TRACE("adjust index=%d\n", nIndex);
     }
 
@@ -2823 +2824 @@
     /* pre insert copy */
     if (nIndex > 0) {
-        memcpy (&infoPtr->buttons[0], &oldButtons[0],
-                nIndex * sizeof(TBUTTON_INFO));
+    memcpy (&infoPtr->buttons[0], &oldButtons[0],
+        nIndex * sizeof(TBUTTON_INFO));
     }
 
@@ -2836 +2837 @@
 
     if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
-        TTTOOLINFOA ti;
-
-        ZeroMemory (&ti, sizeof(TTTOOLINFOA));
-        ti.cbSize   = sizeof (TTTOOLINFOA);
-        ti.hwnd     = hwnd;
-        ti.uId      = lpTbb->idCommand;
-        ti.hinst    = 0;
-        ti.lpszText = LPSTR_TEXTCALLBACKA;
-
-        SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
-                        0, (LPARAM)&ti);
+    TTTOOLINFOA ti;
+
+    ZeroMemory (&ti, sizeof(TTTOOLINFOA));
+    ti.cbSize   = sizeof (TTTOOLINFOA);
+    ti.hwnd     = hwnd;
+    ti.uId      = lpTbb->idCommand;
+    ti.hinst    = 0;
+    ti.lpszText = LPSTR_TEXTCALLBACKA;
+
+    SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
+            0, (LPARAM)&ti);
     }
 
     /* post insert copy */
     if (nIndex < infoPtr->nNumButtons - 1) {
-        memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
-                (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
+    memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
+        (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
     }
 
@@ -2874 +2875 @@
 
     if (lpTbb == NULL)
-        return FALSE;
+    return FALSE;
     if (nIndex < 0)
-        return FALSE;
+    return FALSE;
 
     TRACE("inserting button index=%d\n", nIndex);
     if (nIndex > infoPtr->nNumButtons) {
-        nIndex = infoPtr->nNumButtons;
-        TRACE("adjust index=%d\n", nIndex);
+    nIndex = infoPtr->nNumButtons;
+    TRACE("adjust index=%d\n", nIndex);
     }
 
@@ -2889 +2890 @@
     /* pre insert copy */
     if (nIndex > 0) {
-        memcpy (&infoPtr->buttons[0], &oldButtons[0],
-                nIndex * sizeof(TBUTTON_INFO));
+    memcpy (&infoPtr->buttons[0], &oldButtons[0],
+        nIndex * sizeof(TBUTTON_INFO));
     }
 
@@ -2902 +2903 @@
 
     if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
-        TTTOOLINFOW ti;
-
-        ZeroMemory (&ti, sizeof(TTTOOLINFOW));
-        ti.cbSize   = sizeof (TTTOOLINFOW);
-        ti.hwnd     = hwnd;
-        ti.uId      = lpTbb->idCommand;
-        ti.hinst    = 0;
-        ti.lpszText = LPSTR_TEXTCALLBACKW;
-
-        SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
-                        0, (LPARAM)&ti);
+    TTTOOLINFOW ti;
+
+    ZeroMemory (&ti, sizeof(TTTOOLINFOW));
+    ti.cbSize   = sizeof (TTTOOLINFOW);
+    ti.hwnd     = hwnd;
+    ti.uId      = lpTbb->idCommand;
+    ti.hinst    = 0;
+    ti.lpszText = LPSTR_TEXTCALLBACKW;
+
+    SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
+            0, (LPARAM)&ti);
     }
 
     /* post insert copy */
     if (nIndex < infoPtr->nNumButtons - 1) {
-        memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
-                (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
+    memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
+        (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
     }
 
@@ -2940 +2941 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     return (infoPtr->buttons[nIndex].fsState & TBSTATE_CHECKED);
@@ -2954 +2955 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     return (infoPtr->buttons[nIndex].fsState & TBSTATE_ENABLED);
@@ -2968 +2969 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return TRUE;
+    return TRUE;
 
     return (infoPtr->buttons[nIndex].fsState & TBSTATE_HIDDEN);
@@ -2982 +2983 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     return (infoPtr->buttons[nIndex].fsState & TBSTATE_MARKED);
@@ -2996 +2997 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     return (infoPtr->buttons[nIndex].fsState & TBSTATE_INDETERMINATE);
@@ -3010 +3011 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     return (infoPtr->buttons[nIndex].fsState & TBSTATE_PRESSED);
@@ -3031 +3032 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
     if (LOWORD(lParam) == FALSE)
-        btnPtr->fsState &= ~TBSTATE_PRESSED;
+    btnPtr->fsState &= ~TBSTATE_PRESSED;
     else
-        btnPtr->fsState |= TBSTATE_PRESSED;
+    btnPtr->fsState |= TBSTATE_PRESSED;
 
     InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr, btnPtr));
@@ -3058 +3059 @@
 
     if ((BOOL)wParam) {
-        /* save toolbar information */
-        FIXME("save to \"%s\" \"%s\"\n",
-               lpSave->pszSubKey, lpSave->pszValueName);
+    /* save toolbar information */
+    FIXME("save to \"%s\" \"%s\"\n",
+           lpSave->pszSubKey, lpSave->pszValueName);
 
 
     }
     else {
-        /* restore toolbar information */
-
-        FIXME("restore from \"%s\" \"%s\"\n",
-               lpSave->pszSubKey, lpSave->pszValueName);
+    /* restore toolbar information */
+
+    FIXME("restore from \"%s\" \"%s\"\n",
+           lpSave->pszSubKey, lpSave->pszValueName);
 
 
@@ -3086 +3087 @@
 
     if (lpSave == NULL)
-        return 0;
+    return 0;
 
     if ((BOOL)wParam) {
-        /* save toolbar information */
-        FIXME("save to \"%s\" \"%s\"\n",
-               lpSave->pszSubKey, lpSave->pszValueName);
+    /* save toolbar information */
+    FIXME("save to \"%s\" \"%s\"\n",
+           lpSave->pszSubKey, lpSave->pszValueName);
 
 
     }
     else {
-        /* restore toolbar information */
-
-        FIXME("restore from \"%s\" \"%s\"\n",
-               lpSave->pszSubKey, lpSave->pszValueName);
+    /* restore toolbar information */
+
+    FIXME("restore from \"%s\" \"%s\"\n",
+           lpSave->pszSubKey, lpSave->pszValueName);
 
 
@@ -3127 +3128 @@
 
     if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
-        return FALSE;
+    return FALSE;
 
     if (infoPtr->nNumButtons > 0)
@@ -3157 +3158 @@
 
     if (lptbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lptbbi->cbSize < sizeof(TBBUTTONINFOA))
-        return FALSE;
-    
+    return FALSE;
+
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
     if (lptbbi->dwMask & TBIF_COMMAND)
-        btnPtr->idCommand = lptbbi->idCommand;
+    btnPtr->idCommand = lptbbi->idCommand;
     if (lptbbi->dwMask & TBIF_IMAGE)
-        btnPtr->iBitmap = lptbbi->iImage;
+    btnPtr->iBitmap = lptbbi->iImage;
     if (lptbbi->dwMask & TBIF_LPARAM)
-        btnPtr->dwData = lptbbi->lParam;
+    btnPtr->dwData = lptbbi->lParam;
 /*    if (lptbbi->dwMask & TBIF_SIZE) */
-/*      btnPtr->cx = lptbbi->cx; */
+/*  btnPtr->cx = lptbbi->cx; */
     if (lptbbi->dwMask & TBIF_STATE)
-        btnPtr->fsState = lptbbi->fsState;
+    btnPtr->fsState = lptbbi->fsState;
     if (lptbbi->dwMask & TBIF_STYLE)
-        btnPtr->fsStyle = lptbbi->fsStyle;
+    btnPtr->fsStyle = lptbbi->fsStyle;
 
     if (lptbbi->dwMask & TBIF_TEXT) {
-        if ((btnPtr->iString >= 0) || 
-            (btnPtr->iString < infoPtr->nNumStrings)) {
-           TRACE("Ooooooch\n");
+    if ((btnPtr->iString >= 0) ||
+        (btnPtr->iString < infoPtr->nNumStrings)) {
+       TRACE("Ooooooch\n");
 #if 0
-            WCHAR **lpString = &infoPtr->strings[btnPtr->iString];
-            INT len = lstrlenA (lptbbi->pszText);
-            *lpString = COMCTL32_ReAlloc (lpString, sizeof(WCHAR)*(len+1));
+        WCHAR **lpString = &infoPtr->strings[btnPtr->iString];
+        INT len = lstrlenA (lptbbi->pszText);
+        *lpString = COMCTL32_ReAlloc (lpString, sizeof(WCHAR)*(len+1));
 #endif
 
-            /* this is the ultimate sollution */
-/*          Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
-        }
+        /* this is the ultimate sollution */
+/*      Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
+    }
     }
 
@@ -3207 +3208 @@
 
     if (lptbbi == NULL)
-        return FALSE;
+    return FALSE;
     if (lptbbi->cbSize < sizeof(TBBUTTONINFOW))
-        return FALSE;
+    return FALSE;
 
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
     if (lptbbi->dwMask & TBIF_COMMAND)
-        btnPtr->idCommand = lptbbi->idCommand;
+    btnPtr->idCommand = lptbbi->idCommand;
     if (lptbbi->dwMask & TBIF_IMAGE)
-        btnPtr->iBitmap = lptbbi->iImage;
+    btnPtr->iBitmap = lptbbi->iImage;
     if (lptbbi->dwMask & TBIF_LPARAM)
-        btnPtr->dwData = lptbbi->lParam;
+    btnPtr->dwData = lptbbi->lParam;
 /*    if (lptbbi->dwMask & TBIF_SIZE) */
-/*      btnPtr->cx = lptbbi->cx; */
+/*  btnPtr->cx = lptbbi->cx; */
     if (lptbbi->dwMask & TBIF_STATE)
-        btnPtr->fsState = lptbbi->fsState;
+    btnPtr->fsState = lptbbi->fsState;
     if (lptbbi->dwMask & TBIF_STYLE)
-        btnPtr->fsStyle = lptbbi->fsStyle;
+    btnPtr->fsStyle = lptbbi->fsStyle;
 
     if (lptbbi->dwMask & TBIF_TEXT) {
-        if ((btnPtr->iString >= 0) ||
-            (btnPtr->iString < infoPtr->nNumStrings)) {
+    if ((btnPtr->iString >= 0) ||
+        (btnPtr->iString < infoPtr->nNumStrings)) {
 #if 0
-            WCHAR **lpString = &infoPtr->strings[btnPtr->iString];
-            INT len = lstrlenW (lptbbi->pszText);
-            *lpString = COMCTL32_ReAlloc (lpString, sizeof(WCHAR)*(len+1));
+        WCHAR **lpString = &infoPtr->strings[btnPtr->iString];
+        INT len = lstrlenW (lptbbi->pszText);
+        *lpString = COMCTL32_ReAlloc (lpString, sizeof(WCHAR)*(len+1));
 #endif
 
-            /* this is the ultimate solution */
-/*          Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
-        }
+        /* this is the ultimate solution */
+/*      Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
+    }
     }
 
@@ -3255 +3256 @@
     {
         ERR("invalid parameter\n");
-        return FALSE;
+    return FALSE;
     }
 
     /* The documentation claims you can only change the button size before
-     * any button has been added. But this is wrong. 
-     * WINZIP32.EXE (ver 8) calls this on one of its buttons after adding 
+     * any button has been added. But this is wrong.
+     * WINZIP32.EXE (ver 8) calls this on one of its buttons after adding
      * it to the toolbar, and it checks that the return value is nonzero - mjm
      * Further testing shows that we must actually perform the change too.
@@ -3276 +3277 @@
 
     if (infoPtr == NULL) {
-        TRACE("Toolbar not initialized yet?????\n");
-        return FALSE;
+    TRACE("Toolbar not initialized yet?????\n");
+    return FALSE;
     }
 
     /* if setting to current values, ignore */
     if ((infoPtr->cxMin == (INT)LOWORD(lParam)) &&
-        (infoPtr->cxMax == (INT)HIWORD(lParam))) {
-        TRACE("matches current width, min=%d, max=%d, no recalc\n",
-              infoPtr->cxMin, infoPtr->cxMax);
-        return TRUE; 
+    (infoPtr->cxMax == (INT)HIWORD(lParam))) {
+    TRACE("matches current width, min=%d, max=%d, no recalc\n",
+          infoPtr->cxMin, infoPtr->cxMax);
+    return TRUE;
     }
 
@@ -3294 +3295 @@
     /* if both values are 0 then we are done */
     if (lParam == 0) {
-        TRACE("setting both min and max to 0, norecalc\n"); 
-        return TRUE;
+    TRACE("setting both min and max to 0, norecalc\n");
+    return TRUE;
     }
 
@@ -3301 +3302 @@
        recalc the bounding rectangle (does DrawText w/ DT_CALCRECT
        which doesn't actually draw - GA). */
-    TRACE("number of buttons %d, cx=%d, cy=%d, recalcing\n", 
-        infoPtr->nNumButtons, infoPtr->cxMin, infoPtr->cxMax);
+    TRACE("number of buttons %d, cx=%d, cy=%d, recalcing\n",
+    infoPtr->nNumButtons, infoPtr->cxMin, infoPtr->cxMax);
 
     TOOLBAR_CalcToolbar (hwnd);
@@ -3319 +3320 @@
 
     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
-        return FALSE;
+    return FALSE;
 
     infoPtr->buttons[nIndex].idCommand = (INT)lParam;
@@ -3325 +3326 @@
     if (infoPtr->hwndToolTip) {
 
-        FIXME("change tool tip!\n");
+    FIXME("change tool tip!\n");
 
     }
@@ -3348 +3349 @@
     /* FIXME: redraw ? */
 
-    return (LRESULT)himlTemp; 
+    return (LRESULT)himlTemp;
 }
 
@@ -3360 +3361 @@
     dwTemp = infoPtr->dwDTFlags;
     infoPtr->dwDTFlags =
-        (infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
+    (infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
 
     return (LRESULT)dwTemp;
@@ -3375 +3376 @@
     infoPtr->dwExStyle = (DWORD)lParam;
 
-    return (LRESULT)dwTemp; 
+    return (LRESULT)dwTemp;
 }
 
@@ -3390 +3391 @@
     /* FIXME: redraw ? */
 
-    return (LRESULT)himlTemp; 
+    return (LRESULT)himlTemp;
 }
 
@@ -3407 +3408 @@
     {
 
-        infoPtr->nHotItem = (INT)wParam;
+        infoPtr->nHotItem = (INT)wParam;
         if ((INT)wParam >=0)
         {
             btnPtr = &infoPtr->buttons[(INT)wParam];
             btnPtr->bHot = TRUE;
-                InvalidateRect (hwnd, &btnPtr->rect,
+            InvalidateRect (hwnd, &btnPtr->rect,
                     TOOLBAR_HasText(infoPtr, btnPtr));
         }
@@ -3419 +3420 @@
             btnPtr = &infoPtr->buttons[nOldHotItem];
             btnPtr->bHot = FALSE;
-                InvalidateRect (hwnd, &btnPtr->rect,
+            InvalidateRect (hwnd, &btnPtr->rect,
                     TOOLBAR_HasText(infoPtr, btnPtr));
         }
@@ -3425 +3426 @@
 
     if (nOldHotItem < 0)
-        return -1;
+    return -1;
 
     return (LRESULT)nOldHotItem;
@@ -3443 +3444 @@
     /* FIXME: redraw ? */
 
-    return (LRESULT)himlTemp; 
+    return (LRESULT)himlTemp;
 }
 
@@ -3490 +3491 @@
 
     if (infoPtr == NULL)
-        return FALSE;
+    return FALSE;
 
     infoPtr->nMaxTextRows = (INT)wParam;
@@ -3510 +3511 @@
 
     if (infoPtr == NULL)
-        return 0;
+    return 0;
     hwndOldNotify = infoPtr->hwndNotify;
     infoPtr->hwndNotify = (HWND)wParam;
@@ -3527 +3528 @@
 
     if (LOWORD(wParam) > 1) {
-        FIXME("multiple rows not supported!\n");
+    FIXME("multiple rows not supported!\n");
     }
 
@@ -3543 +3544 @@
     /* return bounding rectangle */
     if (lprc) {
-        lprc->left   = infoPtr->rcBound.left;
-        lprc->right  = infoPtr->rcBound.right;
-        lprc->top    = infoPtr->rcBound.top;
-        lprc->bottom = infoPtr->rcBound.bottom;
+    lprc->left   = infoPtr->rcBound.left;
+    lprc->right  = infoPtr->rcBound.right;
+    lprc->top    = infoPtr->rcBound.top;
+    lprc->bottom = infoPtr->rcBound.bottom;
     }
 
@@ -3562 +3563 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
@@ -3587 +3588 @@
     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
     if (nIndex == -1)
-        return FALSE;
+    return FALSE;
 
     btnPtr = &infoPtr->buttons[nIndex];
@@ -3599 +3600 @@
 
         if (infoPtr->hwndToolTip) {
-            FIXME("change tool tip!\n");
+        FIXME("change tool tip!\n");
         }
     }
@@ -3613 +3614 @@
 
     if (infoPtr == NULL)
-        return 0;
+    return 0;
     infoPtr->hwndToolTip = (HWND)wParam;
     return 0;
@@ -3625 +3626 @@
     BOOL bTemp;
 
-    TRACE("%s hwnd=0x%04x stub!\n", 
-           ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
+    TRACE("%s hwnd=0x%04x stub!\n",
+       ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
 
     bTemp = infoPtr->bUnicode;
@@ -3683 +3684 @@
 
     if (dwStyle & TBSTYLE_TOOLTIPS) {
-        /* Create tooltip control */
-        infoPtr->hwndToolTip =
-            CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
-                               CW_USEDEFAULT, CW_USEDEFAULT,
-                               CW_USEDEFAULT, CW_USEDEFAULT,
-                               hwnd, 0, 0, 0);
-
-        /* Send NM_TOOLTIPSCREATED notification */
-        if (infoPtr->hwndToolTip) {
-            NMTOOLTIPSCREATED nmttc;
-
-            nmttc.hdr.hwndFrom = hwnd;
-            nmttc.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-            nmttc.hdr.code = NM_TOOLTIPSCREATED;
-            nmttc.hwndToolTips = infoPtr->hwndToolTip;
-
-            SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
-                          (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
-        }
+    /* Create tooltip control */
+    infoPtr->hwndToolTip =
+        CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
+                   CW_USEDEFAULT, CW_USEDEFAULT,
+                   CW_USEDEFAULT, CW_USEDEFAULT,
+                   hwnd, 0, 0, 0);
+
+    /* Send NM_TOOLTIPSCREATED notification */
+    if (infoPtr->hwndToolTip) {
+        NMTOOLTIPSCREATED nmttc;
+
+        nmttc.hdr.hwndFrom = hwnd;
+        nmttc.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
+        nmttc.hdr.code = NM_TOOLTIPSCREATED;
+        nmttc.hwndToolTips = infoPtr->hwndToolTip;
+
+        SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
+              (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
+    }
     }
 
@@ -3717 +3718 @@
     /* delete tooltip control */
     if (infoPtr->hwndToolTip)
-        DestroyWindow (infoPtr->hwndToolTip);
+    DestroyWindow (infoPtr->hwndToolTip);
 
     /* delete button data */
     if (infoPtr->buttons)
-        COMCTL32_Free (infoPtr->buttons);
+    COMCTL32_Free (infoPtr->buttons);
 
     /* delete strings */
     if (infoPtr->strings) {
-        INT i;
-        for (i = 0; i < infoPtr->nNumStrings; i++)
-            if (infoPtr->strings[i])
-                COMCTL32_Free (infoPtr->strings[i]);
-
-        COMCTL32_Free (infoPtr->strings);
+    INT i;
+    for (i = 0; i < infoPtr->nNumStrings; i++)
+        if (infoPtr->strings[i])
+        COMCTL32_Free (infoPtr->strings[i]);
+
+    COMCTL32_Free (infoPtr->strings);
     }
 
     /* destroy internal image list */
     if (infoPtr->himlInt)
-        ImageList_Destroy (infoPtr->himlInt);
+    ImageList_Destroy (infoPtr->himlInt);
 
     /* delete default font */
     if (infoPtr->hFont)
-        DeleteObject (infoPtr->hFont);
+    DeleteObject (infoPtr->hFont);
 
     /* free toolbar info data */
@@ -3755 +3756 @@
 
     if (infoPtr->bTransparent)
-        return SendMessageA (GetParent (hwnd), WM_ERASEBKGND, wParam, lParam);
+    return SendMessageA (GetParent (hwnd), WM_ERASEBKGND, wParam, lParam);
 
     return DefWindowProcA (hwnd, WM_ERASEBKGND, wParam, lParam);
@@ -3783 +3784 @@
 
     if (nHit >= 0) {
-        btnPtr = &infoPtr->buttons[nHit];
-        if (!(btnPtr->fsState & TBSTATE_ENABLED))
-            return 0;
-        SetCapture (hwnd);
-        infoPtr->bCaptured = TRUE;
-        infoPtr->nButtonDown = nHit;
-
-        btnPtr->fsState |= TBSTATE_PRESSED;
+    btnPtr = &infoPtr->buttons[nHit];
+    if (!(btnPtr->fsState & TBSTATE_ENABLED))
+        return 0;
+    SetCapture (hwnd);
+    infoPtr->bCaptured = TRUE;
+    infoPtr->nButtonDown = nHit;
+
+    btnPtr->fsState |= TBSTATE_PRESSED;
 
         InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr,
@@ -3796 +3797 @@
     }
     else if (GetWindowLongA (hwnd, GWL_STYLE) & CCS_ADJUSTABLE)
-        TOOLBAR_Customize (hwnd);
+    TOOLBAR_Customize (hwnd);
 
     return 0;
@@ -3811 +3812 @@
 
     if (infoPtr->hwndToolTip)
-        TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                            WM_LBUTTONDOWN, wParam, lParam);
+    TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
+                WM_LBUTTONDOWN, wParam, lParam);
 
     pt.x = (INT)LOWORD(lParam);
@@ -3819 +3820 @@
 
     if (nHit >= 0) {
-        RECT arrowRect;
-        btnPtr = &infoPtr->buttons[nHit];
-        if (!(btnPtr->fsState & TBSTATE_ENABLED))
-            return 0;
-
-        infoPtr->nOldHit = nHit;
-
-        CopyRect(&arrowRect, &btnPtr->rect);
-        arrowRect.left = max(btnPtr->rect.left, btnPtr->rect.right - DDARROW_WIDTH);
-
-        /* for EX_DRAWDDARROWS style,  click must be in the drop-down arrow rect */
-        if ((btnPtr->fsStyle & TBSTYLE_DROPDOWN) &&
-             ((TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle) && PtInRect(&arrowRect, pt)) ||
-              (!TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle))))
-        {
-            NMTOOLBARA nmtb;
-            /*
-             * this time we must force a Redraw, so the btn is
-             * painted down before CaptureChanged repaints it up
-             */
-            RedrawWindow(hwnd,&btnPtr->rect,0,
-                        RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
-
-            nmtb.hdr.hwndFrom = hwnd;
-            nmtb.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
-            nmtb.hdr.code = TBN_DROPDOWN;
-            nmtb.iItem = btnPtr->idCommand;
-
-            SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
-                          (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
-        }
-        else
-        {
-            SetCapture (hwnd);
-            infoPtr->bCaptured = TRUE;
-            infoPtr->nButtonDown = nHit;
-
-            btnPtr->fsState |= TBSTATE_PRESSED;
-            btnPtr->bHot = FALSE;
-
-            InvalidateRect(hwnd, &btnPtr->rect,
-                           TOOLBAR_HasText(infoPtr, btnPtr));
-        }
+    RECT arrowRect;
+    btnPtr = &infoPtr->buttons[nHit];
+    if (!(btnPtr->fsState & TBSTATE_ENABLED))
+        return 0;
+
+    infoPtr->nOldHit = nHit;
+
+    CopyRect(&arrowRect, &btnPtr->rect);
+    arrowRect.left = max(btnPtr->rect.left, btnPtr->rect.right - DDARROW_WIDTH);
+
+    /* for EX_DRAWDDARROWS style,  click must be in the drop-down arrow rect */
+    if ((btnPtr->fsStyle & TBSTYLE_DROPDOWN) &&
+         ((TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle) && PtInRect(&arrowRect, pt)) ||
+          (!TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle))))
+    {
+        NMTOOLBARA nmtb;
+        /*
+         * this time we must force a Redraw, so the btn is
+         * painted down before CaptureChanged repaints it up
+         */
+        RedrawWindow(hwnd,&btnPtr->rect,0,
+            RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
+
+        nmtb.hdr.hwndFrom = hwnd;
+        nmtb.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
+        nmtb.hdr.code = TBN_DROPDOWN;
+        nmtb.iItem = btnPtr->idCommand;
+
+        SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
+              (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
+    }
+    else
+    {
+        SetCapture (hwnd);
+        infoPtr->bCaptured = TRUE;
+        infoPtr->nButtonDown = nHit;
+
+        btnPtr->fsState |= TBSTATE_PRESSED;
+        btnPtr->bHot = FALSE;
+
+        InvalidateRect(hwnd, &btnPtr->rect,
+               TOOLBAR_HasText(infoPtr, btnPtr));
+    }
     }
 
@@ -3878 +3879 @@
 
     if (infoPtr->hwndToolTip)
-        TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                            WM_LBUTTONUP, wParam, lParam);
+    TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
+                WM_LBUTTONUP, wParam, lParam);
 
     pt.x = (INT)LOWORD(lParam);
@@ -3891 +3892 @@
 
     if ((infoPtr->bCaptured) && (infoPtr->nButtonDown >= 0)) {
-        btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
-        btnPtr->fsState &= ~TBSTATE_PRESSED;
-
-        if (nHit == infoPtr->nButtonDown) {
-            if (btnPtr->fsStyle & TBSTYLE_CHECK) {
-                if (btnPtr->fsStyle & TBSTYLE_GROUP) {
-                    nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
-                        infoPtr->nButtonDown);
-                    if (nOldIndex == infoPtr->nButtonDown)
-                        bSendMessage = FALSE;
-                    if ((nOldIndex != infoPtr->nButtonDown) && 
-                        (nOldIndex != -1))
-                        infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
-                    btnPtr->fsState |= TBSTATE_CHECKED;
-                }
-                else {
-                    if (btnPtr->fsState & TBSTATE_CHECKED)
-                        btnPtr->fsState &= ~TBSTATE_CHECKED;
-                    else
-                        btnPtr->fsState |= TBSTATE_CHECKED;
-                }
-            }
-        }
-        else
-            bSendMessage = FALSE;
-
-        if (nOldIndex != -1)
+    btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
+    btnPtr->fsState &= ~TBSTATE_PRESSED;
+
+    if (nHit == infoPtr->nButtonDown) {
+        if (btnPtr->fsStyle & TBSTYLE_CHECK) {
+        if (btnPtr->fsStyle & TBSTYLE_GROUP) {
+            nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
+            infoPtr->nButtonDown);
+            if (nOldIndex == infoPtr->nButtonDown)
+            bSendMessage = FALSE;
+            if ((nOldIndex != infoPtr->nButtonDown) &&
+            (nOldIndex != -1))
+            infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
+            btnPtr->fsState |= TBSTATE_CHECKED;
+        }
+        else {
+            if (btnPtr->fsState & TBSTATE_CHECKED)
+            btnPtr->fsState &= ~TBSTATE_CHECKED;
+            else
+            btnPtr->fsState |= TBSTATE_CHECKED;
+        }
+        }
+    }
+    else
+        bSendMessage = FALSE;
+
+    if (nOldIndex != -1)
         {
             InvalidateRect(hwnd, &infoPtr->buttons[nOldIndex].rect,
@@ -3923 +3924 @@
         }
 
-        /*
-         * now we can ReleaseCapture, which triggers CAPTURECHANGED msg,
-         * that resets bCaptured and btn TBSTATE_PRESSED flags,
-         * and obliterates nButtonDown and nOldHit (see TOOLBAR_CaptureChanged) 
-         */
-        ReleaseCapture ();
-
-        if (bSendMessage)
-            SendMessageA (GetParent(hwnd), WM_COMMAND,
-                          MAKEWPARAM(btnPtr->idCommand, 0), (LPARAM)hwnd);
+    /*
+     * now we can ReleaseCapture, which triggers CAPTURECHANGED msg,
+     * that resets bCaptured and btn TBSTATE_PRESSED flags,
+     * and obliterates nButtonDown and nOldHit (see TOOLBAR_CaptureChanged)
+     */
+    ReleaseCapture ();
+
+    if (bSendMessage)
+        SendMessageA (GetParent(hwnd), WM_COMMAND,
+              MAKEWPARAM(btnPtr->idCommand, 0), (LPARAM)hwnd);
     }
 
@@ -3949 +3950 @@
     {
         btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
-        btnPtr->fsState &= ~TBSTATE_PRESSED;
+        btnPtr->fsState &= ~TBSTATE_PRESSED;
 
         infoPtr->nButtonDown = -1;
@@ -3975 +3976 @@
     if((infoPtr->nOldHit == infoPtr->nHotItem) && (hotBtnPtr->fsState & TBSTATE_ENABLED))
     {
-        hotBtnPtr->bHot = FALSE;
+    hotBtnPtr->bHot = FALSE;
 
         InvalidateRect (hwnd, &hotBtnPtr->rect, TOOLBAR_HasText(infoPtr,
@@ -4019 +4020 @@
     if(!(trackinfo.dwFlags & TME_LEAVE)) {
         trackinfo.dwFlags = TME_LEAVE; /* notify upon leaving */
- 
+
         /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
         /* and can properly deactivate the hot toolbar button */
@@ -4026 +4027 @@
 
     if (infoPtr->hwndToolTip)
-        TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
-                            WM_MOUSEMOVE, wParam, lParam);
+    TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
+                WM_MOUSEMOVE, wParam, lParam);
 
     pt.x = (INT)LOWORD(lParam);
@@ -4036 +4037 @@
     if (infoPtr->nOldHit != nHit)
     {
-        /* Remove the effect of an old hot button if the button was enabled and was
-           drawn with the hot button effect */
-        if(infoPtr->nOldHit >= 0 && infoPtr->nOldHit == infoPtr->nHotItem && 
-                (infoPtr->buttons[infoPtr->nOldHit].fsState & TBSTATE_ENABLED))
-        {
-            oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
-            oldBtnPtr->bHot = FALSE;
-                    
-            InvalidateRect (hwnd, &oldBtnPtr->rect,
+    /* Remove the effect of an old hot button if the button was enabled and was
+       drawn with the hot button effect */
+    if(infoPtr->nOldHit >= 0 && infoPtr->nOldHit == infoPtr->nHotItem &&
+        (infoPtr->buttons[infoPtr->nOldHit].fsState & TBSTATE_ENABLED))
+    {
+        oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
+        oldBtnPtr->bHot = FALSE;
+
+        InvalidateRect (hwnd, &oldBtnPtr->rect,
                 TOOLBAR_HasText(infoPtr, oldBtnPtr));
-        }
-
-        /* It's not a separator or in nowhere. It's a hot button. */
-        if (nHit >= 0)
-        {
-            btnPtr = &infoPtr->buttons[nHit];
-            btnPtr->bHot = TRUE;
-
-            infoPtr->nHotItem = nHit;
-
-            /* only enabled buttons show hot effect */            
+    }
+
+    /* It's not a separator or in nowhere. It's a hot button. */
+    if (nHit >= 0)
+    {
+        btnPtr = &infoPtr->buttons[nHit];
+        btnPtr->bHot = TRUE;
+
+        infoPtr->nHotItem = nHit;
+
+            /* only enabled buttons show hot effect */
             if(infoPtr->buttons[nHit].fsState & TBSTATE_ENABLED)
             {
@@ -4063 +4064 @@
             }
 
-        }
+    }
 
     if (infoPtr->bCaptured) {
-            btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
-            if (infoPtr->nOldHit == infoPtr->nButtonDown) {
-                btnPtr->fsState &= ~TBSTATE_PRESSED;
+        btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
+        if (infoPtr->nOldHit == infoPtr->nButtonDown) {
+        btnPtr->fsState &= ~TBSTATE_PRESSED;
                 InvalidateRect(hwnd, &btnPtr->rect, TRUE);
-            }
-            else if (nHit == infoPtr->nButtonDown) {
-                btnPtr->fsState |= TBSTATE_PRESSED;
+        }
+        else if (nHit == infoPtr->nButtonDown) {
+        btnPtr->fsState |= TBSTATE_PRESSED;
                 InvalidateRect(hwnd, &btnPtr->rect, TRUE);
-            }
-        }
-        infoPtr->nOldHit = nHit;
+        }
+    }
+    infoPtr->nOldHit = nHit;
     }
     return 0;
@@ -4086 +4087 @@
 {
 /*    if (wndPtr->dwStyle & CCS_NODIVIDER) */
-        return DefWindowProcA (hwnd, WM_NCACTIVATE, wParam, lParam);
+    return DefWindowProcA (hwnd, WM_NCACTIVATE, wParam, lParam);
 /*    else */
-/*      return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
+/*  return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
 }
 
@@ -4096 +4097 @@
 {
     if (!(GetWindowLongA (hwnd, GWL_STYLE) & CCS_NODIVIDER))
-        ((LPRECT)lParam)->top += GetSystemMetrics(SM_CYEDGE);
+    ((LPRECT)lParam)->top += GetSystemMetrics(SM_CYEDGE);
 
     return DefWindowProcA (hwnd, WM_NCCALCSIZE, wParam, lParam);
@@ -4117 +4118 @@
     if (!GetWindowLongA (hwnd, GWL_HINSTANCE)) {
         HINSTANCE hInst = (HINSTANCE)GetWindowLongA (GetParent (hwnd), GWL_HINSTANCE);
-        SetWindowLongA (hwnd, GWL_HINSTANCE, (DWORD)hInst);
+    SetWindowLongA (hwnd, GWL_HINSTANCE, (DWORD)hInst);
     }
 
@@ -4132 +4133 @@
 
     if (dwStyle & WS_MINIMIZE)
-        return 0; /* Nothing to do */
+    return 0; /* Nothing to do */
 
     DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
 
     if (!(hdc = GetDCEx (hwnd, 0, DCX_USESTYLE | DCX_WINDOW)))
-        return 0;
+    return 0;
 
     if (!(dwStyle & CCS_NODIVIDER))
     {
-        GetWindowRect (hwnd, &rcWindow);
-        OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
-        if( dwStyle & WS_BORDER )
-            OffsetRect (&rcWindow, 1, 1);
-        DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP);
+    GetWindowRect (hwnd, &rcWindow);
+    OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
+    if( dwStyle & WS_BORDER )
+        OffsetRect (&rcWindow, 1, 1);
+    DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP);
     }
 
@@ -4163 +4164 @@
 
     if ((infoPtr->hwndToolTip) && (lpnmh->hwndFrom == infoPtr->hwndToolTip)) {
-        SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,   wParam, lParam);
+    SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,   wParam, lParam);
 
 #if 0
-        if (lpnmh->code == TTN_GETDISPINFOA) {
-            LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
-
-            FIXME("retrieving ASCII string\n");
-
-        }
-        else if (lpnmh->code == TTN_GETDISPINFOW) {
-            LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
-
-            FIXME("retrieving UNICODE string\n");
-
-        }
+    if (lpnmh->code == TTN_GETDISPINFOA) {
+        LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
+
+        FIXME("retrieving ASCII string\n");
+
+    }
+    else if (lpnmh->code == TTN_GETDISPINFOW) {
+        LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
+
+        FIXME("retrieving UNICODE string\n");
+
+    }
 #endif
     }
@@ -4193 +4194 @@
 
     /* fill ps.rcPaint with a default rect */
-    memcpy(&(ps.rcPaint), &(infoPtr->rcBound), sizeof(infoPtr->rcBound)); 
+    memcpy(&(ps.rcPaint), &(infoPtr->rcBound), sizeof(infoPtr->rcBound));
 
     hdc = wParam==0 ? BeginPaint(hwnd, &ps) : (HDC)wParam;
 
     TRACE("psrect=(%d,%d)-(%d,%d)\n",
-          ps.rcPaint.left, ps.rcPaint.top,
-          ps.rcPaint.right, ps.rcPaint.bottom);
+      ps.rcPaint.left, ps.rcPaint.top,
+      ps.rcPaint.right, ps.rcPaint.bottom);
 
     TOOLBAR_Refresh (hwnd, hdc, &ps);
@@ -4223 +4224 @@
     /* Resize deadlock check */
     if (infoPtr->bAutoSize) {
-        infoPtr->bAutoSize = FALSE;
-        return 0;
+    infoPtr->bAutoSize = FALSE;
+    return 0;
     }
 
@@ -4239 +4240 @@
 
     if (flags == SIZE_RESTORED) {
-        /* width and height don't apply */
-        parent = GetParent (hwnd);
-        GetClientRect(parent, &parent_rect);
-        x = parent_rect.left;
-        y = parent_rect.top;
-
-        if (dwStyle & CCS_NORESIZE) {
-            uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
-
-            /*
+    /* width and height don't apply */
+    parent = GetParent (hwnd);
+    GetClientRect(parent, &parent_rect);
+    x = parent_rect.left;
+    y = parent_rect.top;
+
+    if (dwStyle & CCS_NORESIZE) {
+        uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
+
+        /*
              * this sets the working width of the toolbar, and
              * Calc Toolbar will not adjust it, only the height
              */
-            infoPtr->nWidth = parent_rect.right - parent_rect.left; 
-            cy = infoPtr->nHeight;
-            cx = infoPtr->nWidth;
-            TOOLBAR_CalcToolbar (hwnd);
-            infoPtr->nWidth = cx;
-            infoPtr->nHeight = cy;
-        }
-        else {
-            infoPtr->nWidth = parent_rect.right - parent_rect.left;
-            TOOLBAR_CalcToolbar (hwnd);
-            cy = infoPtr->nHeight;
-            cx = infoPtr->nWidth;
-
-            if (dwStyle & CCS_NOMOVEY) {
-                GetWindowRect(hwnd, &window_rect);
-                ScreenToClient(parent, (LPPOINT)&window_rect.left);
-                y = window_rect.top;
-            }
-        }
-
-        if (dwStyle & CCS_NOPARENTALIGN) {
-            uPosFlags |= SWP_NOMOVE;
-            cy = infoPtr->nHeight;
-            cx = infoPtr->nWidth;
-        }
-
-        if (!(dwStyle & CCS_NODIVIDER))
-            cy += GetSystemMetrics(SM_CYEDGE);
-
-        if (dwStyle & WS_BORDER)
-        {
-            x = y = 1;
-            cy += GetSystemMetrics(SM_CYEDGE);
-            cx += GetSystemMetrics(SM_CYEDGE);
-        }
-
-        SetWindowPos (hwnd, 0, parent_rect.left - x, parent_rect.top - y,
-                        cx, cy, uPosFlags | SWP_NOZORDER);
+        infoPtr->nWidth = parent_rect.right - parent_rect.left;
+        cy = infoPtr->nHeight;
+        cx = infoPtr->nWidth;
+        TOOLBAR_CalcToolbar (hwnd);
+        infoPtr->nWidth = cx;
+        infoPtr->nHeight = cy;
+    }
+    else {
+        infoPtr->nWidth = parent_rect.right - parent_rect.left;
+        TOOLBAR_CalcToolbar (hwnd);
+        cy = infoPtr->nHeight;
+        cx = infoPtr->nWidth;
+
+        if (dwStyle & CCS_NOMOVEY) {
+        GetWindowRect(hwnd, &window_rect);
+        ScreenToClient(parent, (LPPOINT)&window_rect.left);
+        y = window_rect.top;
+        }
+    }
+
+    if (dwStyle & CCS_NOPARENTALIGN) {
+        uPosFlags |= SWP_NOMOVE;
+        cy = infoPtr->nHeight;
+        cx = infoPtr->nWidth;
+    }
+
+    if (!(dwStyle & CCS_NODIVIDER))
+        cy += GetSystemMetrics(SM_CYEDGE);
+
+    if (dwStyle & WS_BORDER)
+    {
+        x = y = 1;
+        cy += GetSystemMetrics(SM_CYEDGE);
+        cx += GetSystemMetrics(SM_CYEDGE);
+    }
+
+    SetWindowPos (hwnd, 0, parent_rect.left - x, parent_rect.top - y,
+            cx, cy, uPosFlags | SWP_NOZORDER);
     }
     return 0;
@@ -4301 +4302 @@
 
     if (nType == GWL_STYLE) {
-        if (lpStyle->styleNew & TBSTYLE_LIST) {
-            infoPtr->dwDTFlags = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
-        }
-        else {
-            infoPtr->dwDTFlags = DT_CENTER;
-        }
+    if (lpStyle->styleNew & TBSTYLE_LIST) {
+        infoPtr->dwDTFlags = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
+    }
+    else {
+        infoPtr->dwDTFlags = DT_CENTER;
+    }
     }
 
@@ -4322 +4323 @@
 {
     if (!TOOLBAR_GetInfoPtr(hwnd) && (uMsg != WM_NCCREATE))
-        return DefWindowProcA( hwnd, uMsg, wParam, lParam );
+    return DefWindowProcA( hwnd, uMsg, wParam, lParam );
 
     switch (uMsg)
     {
-        case TB_ADDBITMAP:
-            return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
-
-        case TB_ADDBUTTONSA:
-            return TOOLBAR_AddButtonsA (hwnd, wParam, lParam);
-
-        case TB_ADDBUTTONSW:
-            return TOOLBAR_AddButtonsW (hwnd, wParam, lParam);
-
-        case TB_ADDSTRINGA:
-            return TOOLBAR_AddStringA (hwnd, wParam, lParam);
-
-        case TB_ADDSTRINGW:
-            return TOOLBAR_AddStringW (hwnd, wParam, lParam);
-
-        case TB_AUTOSIZE:
-            return TOOLBAR_AutoSize (hwnd);
-
-        case TB_BUTTONCOUNT:
-            return TOOLBAR_ButtonCount (hwnd, wParam, lParam);
-
-        case TB_BUTTONSTRUCTSIZE:
-            return TOOLBAR_ButtonStructSize (hwnd, wParam, lParam);
-
-        case TB_CHANGEBITMAP:
-            return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
-
-        case TB_CHECKBUTTON:
-            return TOOLBAR_CheckButton (hwnd, wParam, lParam);
-
-        case TB_COMMANDTOINDEX:
-            return TOOLBAR_CommandToIndex (hwnd, wParam, lParam);
-
-        case TB_CUSTOMIZE:
-            return TOOLBAR_Customize (hwnd);
-
-        case TB_DELETEBUTTON:
-            return TOOLBAR_DeleteButton (hwnd, wParam, lParam);
-
-        case TB_ENABLEBUTTON:
-            return TOOLBAR_EnableButton (hwnd, wParam, lParam);
-
-        case TB_GETANCHORHIGHLIGHT:
-            return TOOLBAR_GetAnchorHighlight (hwnd);
-
-        case TB_GETBITMAP:
-            return TOOLBAR_GetBitmap (hwnd, wParam, lParam);
-
-        case TB_GETBITMAPFLAGS:
-            return TOOLBAR_GetBitmapFlags (hwnd, wParam, lParam);
-
-        case TB_GETBUTTON:
-            return TOOLBAR_GetButton (hwnd, wParam, lParam);
-
-        case TB_GETBUTTONINFOA:
-            return TOOLBAR_GetButtonInfoA (hwnd, wParam, lParam);
-
-        case TB_GETBUTTONINFOW:
-            return TOOLBAR_GetButtonInfoW (hwnd, wParam, lParam);
-
-        case TB_GETBUTTONSIZE:
-            return TOOLBAR_GetButtonSize (hwnd);
-
-        case TB_GETBUTTONTEXTA:
-            return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
-
-        case TB_GETBUTTONTEXTW:
-            return TOOLBAR_GetButtonTextW (hwnd, wParam, lParam);
-
-/*      case TB_GETCOLORSCHEME:                 */ /* 4.71 */
-
-        case TB_GETDISABLEDIMAGELIST:
-            return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
-
-        case TB_GETEXTENDEDSTYLE:
-            return TOOLBAR_GetExtendedStyle (hwnd);
-
-        case TB_GETHOTIMAGELIST:
-            return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
-
-        case TB_GETHOTITEM:
-            return TOOLBAR_GetHotItem (hwnd);
-
-        case TB_GETIMAGELIST:
-            return TOOLBAR_GetImageList (hwnd, wParam, lParam);
-
-/*      case TB_GETINSERTMARK:                  */ /* 4.71 */
-/*      case TB_GETINSERTMARKCOLOR:             */ /* 4.71 */
-
-        case TB_GETITEMRECT:
-            return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
-
-        case TB_GETMAXSIZE:
-            return TOOLBAR_GetMaxSize (hwnd, wParam, lParam);
-
-/*      case TB_GETOBJECT:                      */ /* 4.71 */
-/*      case TB_GETPADDING:                     */ /* 4.71 */
-
-        case TB_GETRECT:
-            return TOOLBAR_GetRect (hwnd, wParam, lParam);
-
-        case TB_GETROWS:
-            return TOOLBAR_GetRows (hwnd, wParam, lParam);
-
-        case TB_GETSTATE:
-            return TOOLBAR_GetState (hwnd, wParam, lParam);
-
-        case TB_GETSTYLE:
-            return TOOLBAR_GetStyle (hwnd, wParam, lParam);
-
-        case TB_GETTEXTROWS:
-            return TOOLBAR_GetTextRows (hwnd, wParam, lParam);
-
-        case TB_GETTOOLTIPS:
-            return TOOLBAR_GetToolTips (hwnd, wParam, lParam);
-
-        case TB_GETUNICODEFORMAT:
-            return TOOLBAR_GetUnicodeFormat (hwnd, wParam, lParam);
-
-        case CCM_GETVERSION:
-            return TOOLBAR_GetVersion (hwnd);
-
-        case TB_HIDEBUTTON:
-            return TOOLBAR_HideButton (hwnd, wParam, lParam);
-
-        case TB_HITTEST:
-            return TOOLBAR_HitTest (hwnd, wParam, lParam);
-
-        case TB_INDETERMINATE:
-            return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
-
-        case TB_INSERTBUTTONA:
-            return TOOLBAR_InsertButtonA (hwnd, wParam, lParam);
-
-        case TB_INSERTBUTTONW:
-            return TOOLBAR_InsertButtonW (hwnd, wParam, lParam);
-
-/*      case TB_INSERTMARKHITTEST:              */ /* 4.71 */
-
-        case TB_ISBUTTONCHECKED:
-            return TOOLBAR_IsButtonChecked (hwnd, wParam, lParam);
-
-        case TB_ISBUTTONENABLED:
-            return TOOLBAR_IsButtonEnabled (hwnd, wParam, lParam);
-
-        case TB_ISBUTTONHIDDEN:
-            return TOOLBAR_IsButtonHidden (hwnd, wParam, lParam);
-
-        case TB_ISBUTTONHIGHLIGHTED:
-            return TOOLBAR_IsButtonHighlighted (hwnd, wParam, lParam);
-
-        case TB_ISBUTTONINDETERMINATE:
-            return TOOLBAR_IsButtonIndeterminate (hwnd, wParam, lParam);
-
-        case TB_ISBUTTONPRESSED:
-            return TOOLBAR_IsButtonPressed (hwnd, wParam, lParam);
-
-        case TB_LOADIMAGES:                        /* 4.70 */
-            FIXME("missing standard imagelists\n");
-            return 0;
-
-/*      case TB_MAPACCELERATORA:                */ /* 4.71 */
-/*      case TB_MAPACCELERATORW:                */ /* 4.71 */
-/*      case TB_MARKBUTTON:                     */ /* 4.71 */
-/*      case TB_MOVEBUTTON:                     */ /* 4.71 */
-
-        case TB_PRESSBUTTON:
-            return TOOLBAR_PressButton (hwnd, wParam, lParam);
-
-/*      case TB_REPLACEBITMAP: */
-
-        case TB_SAVERESTOREA:
-            return TOOLBAR_SaveRestoreA (hwnd, wParam, lParam);
-
-        case TB_SAVERESTOREW:
-            return TOOLBAR_SaveRestoreW (hwnd, wParam, lParam);
-
-        case TB_SETANCHORHIGHLIGHT:
-            return TOOLBAR_SetAnchorHighlight (hwnd, wParam);
-
-        case TB_SETBITMAPSIZE:
-            return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
-
-        case TB_SETBUTTONINFOA:
-            return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
-
-        case TB_SETBUTTONINFOW:
-            return TOOLBAR_SetButtonInfoW (hwnd, wParam, lParam);
-
-        case TB_SETBUTTONSIZE:
-            return TOOLBAR_SetButtonSize (hwnd, wParam, lParam);
-
-        case TB_SETBUTTONWIDTH:
-            return TOOLBAR_SetButtonWidth (hwnd, wParam, lParam);
-
-        case TB_SETCMDID:
-            return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
-
-/*      case TB_SETCOLORSCHEME:                 */ /* 4.71 */
-
-        case TB_SETDISABLEDIMAGELIST:
-            return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
-
-        case TB_SETDRAWTEXTFLAGS:
-            return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
-
-        case TB_SETEXTENDEDSTYLE:
-            return TOOLBAR_SetExtendedStyle (hwnd, wParam, lParam);
-
-        case TB_SETHOTIMAGELIST:
-            return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
-
-        case TB_SETHOTITEM:
-            return TOOLBAR_SetHotItem (hwnd, wParam);
-
-        case TB_SETIMAGELIST:
-            return TOOLBAR_SetImageList (hwnd, wParam, lParam);
-
-        case TB_SETINDENT:
-            return TOOLBAR_SetIndent (hwnd, wParam, lParam);
-
-/*      case TB_SETINSERTMARK:                  */ /* 4.71 */
-
-        case TB_SETINSERTMARKCOLOR:
-            return TOOLBAR_SetInsertMarkColor (hwnd, wParam, lParam);
-
-        case TB_SETMAXTEXTROWS:
-            return TOOLBAR_SetMaxTextRows (hwnd, wParam, lParam);
-
-/*      case TB_SETPADDING:                     */ /* 4.71 */
-
-        case TB_SETPARENT:
-            return TOOLBAR_SetParent (hwnd, wParam, lParam);
-
-        case TB_SETROWS:
-            return TOOLBAR_SetRows (hwnd, wParam, lParam);
-
-        case TB_SETSTATE:
-            return TOOLBAR_SetState (hwnd, wParam, lParam);
-
-        case TB_SETSTYLE:
-            return TOOLBAR_SetStyle (hwnd, wParam, lParam);
-
-        case TB_SETTOOLTIPS:
-            return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
-
-        case TB_SETUNICODEFORMAT:
-            return TOOLBAR_SetUnicodeFormat (hwnd, wParam, lParam);
-
-        case CCM_SETVERSION:
-            return TOOLBAR_SetVersion (hwnd, (INT)wParam);
-
-
-/*      case WM_CHAR: */
-
-        case WM_CREATE:
-            return TOOLBAR_Create (hwnd, wParam, lParam);
-
-        case WM_DESTROY:
-          return TOOLBAR_Destroy (hwnd, wParam, lParam);
-
-        case WM_ERASEBKGND:
-            return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
-
-        case WM_GETFONT:
-                return TOOLBAR_GetFont (hwnd, wParam, lParam);
-
-/*      case WM_KEYDOWN: */
-/*      case WM_KILLFOCUS: */
-
-        case WM_LBUTTONDBLCLK:
-            return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
-
-        case WM_LBUTTONDOWN:
-            return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
-
-        case WM_LBUTTONUP:
-            return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
-
-        case WM_MOUSEMOVE:
-            return TOOLBAR_MouseMove (hwnd, wParam, lParam);
-
-        case WM_MOUSELEAVE:
-            return TOOLBAR_MouseLeave (hwnd, wParam, lParam);   
-
-        case WM_CAPTURECHANGED:
-            return TOOLBAR_CaptureChanged(hwnd);        
-
-        case WM_NCACTIVATE:
-            return TOOLBAR_NCActivate (hwnd, wParam, lParam);
-
-        case WM_NCCALCSIZE:
-            return TOOLBAR_NCCalcSize (hwnd, wParam, lParam);
-
-        case WM_NCCREATE:
-            return TOOLBAR_NCCreate (hwnd, wParam, lParam);
-
-        case WM_NCPAINT:
-            return TOOLBAR_NCPaint (hwnd, wParam, lParam);
-
-        case WM_NOTIFY:
-            return TOOLBAR_Notify (hwnd, wParam, lParam);
-
-/*      case WM_NOTIFYFORMAT: */
-
-        case WM_PAINT:
-            return TOOLBAR_Paint (hwnd, wParam);
-
-        case WM_SIZE:
-            return TOOLBAR_Size (hwnd, wParam, lParam);
-
-        case WM_STYLECHANGED:
-            return TOOLBAR_StyleChanged (hwnd, (INT)wParam, (LPSTYLESTRUCT)lParam);
-
-/*      case WM_SYSCOLORCHANGE: */
-
-/*      case WM_WININICHANGE: */
-
-        case WM_CHARTOITEM:
-        case WM_COMMAND:
-        case WM_DRAWITEM:
-        case WM_MEASUREITEM:
-        case WM_VKEYTOITEM:
-            return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
-
-        default:
-            if (uMsg >= WM_USER)
-                ERR("unknown msg %04x wp=%08x lp=%08lx\n",
-                     uMsg, wParam, lParam);
-            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+    case TB_ADDBITMAP:
+        return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
+
+    case TB_ADDBUTTONSA:
+        return TOOLBAR_AddButtonsA (hwnd, wParam, lParam);
+
+    case TB_ADDBUTTONSW:
+        return TOOLBAR_AddButtonsW (hwnd, wParam, lParam);
+
+    case TB_ADDSTRINGA:
+        return TOOLBAR_AddStringA (hwnd, wParam, lParam);
+
+    case TB_ADDSTRINGW:
+        return TOOLBAR_AddStringW (hwnd, wParam, lParam);
+
+    case TB_AUTOSIZE:
+        return TOOLBAR_AutoSize (hwnd);
+
+    case TB_BUTTONCOUNT:
+        return TOOLBAR_ButtonCount (hwnd, wParam, lParam);
+
+    case TB_BUTTONSTRUCTSIZE:
+        return TOOLBAR_ButtonStructSize (hwnd, wParam, lParam);
+
+    case TB_CHANGEBITMAP:
+        return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
+
+    case TB_CHECKBUTTON:
+        return TOOLBAR_CheckButton (hwnd, wParam, lParam);
+
+    case TB_COMMANDTOINDEX:
+        return TOOLBAR_CommandToIndex (hwnd, wParam, lParam);
+
+    case TB_CUSTOMIZE:
+        return TOOLBAR_Customize (hwnd);
+
+    case TB_DELETEBUTTON:
+        return TOOLBAR_DeleteButton (hwnd, wParam, lParam);
+
+    case TB_ENABLEBUTTON:
+        return TOOLBAR_EnableButton (hwnd, wParam, lParam);
+
+    case TB_GETANCHORHIGHLIGHT:
+        return TOOLBAR_GetAnchorHighlight (hwnd);
+
+    case TB_GETBITMAP:
+        return TOOLBAR_GetBitmap (hwnd, wParam, lParam);
+
+    case TB_GETBITMAPFLAGS:
+        return TOOLBAR_GetBitmapFlags (hwnd, wParam, lParam);
+
+    case TB_GETBUTTON:
+        return TOOLBAR_GetButton (hwnd, wParam, lParam);
+
+    case TB_GETBUTTONINFOA:
+        return TOOLBAR_GetButtonInfoA (hwnd, wParam, lParam);
+
+    case TB_GETBUTTONINFOW:
+        return TOOLBAR_GetButtonInfoW (hwnd, wParam, lParam);
+
+    case TB_GETBUTTONSIZE:
+        return TOOLBAR_GetButtonSize (hwnd);
+
+    case TB_GETBUTTONTEXTA:
+        return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
+
+    case TB_GETBUTTONTEXTW:
+        return TOOLBAR_GetButtonTextW (hwnd, wParam, lParam);
+
+/*  case TB_GETCOLORSCHEME:         */ /* 4.71 */
+
+    case TB_GETDISABLEDIMAGELIST:
+        return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
+
+    case TB_GETEXTENDEDSTYLE:
+        return TOOLBAR_GetExtendedStyle (hwnd);
+
+    case TB_GETHOTIMAGELIST:
+        return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
+
+    case TB_GETHOTITEM:
+        return TOOLBAR_GetHotItem (hwnd);
+
+    case TB_GETIMAGELIST:
+        return TOOLBAR_GetImageList (hwnd, wParam, lParam);
+
+/*  case TB_GETINSERTMARK:          */ /* 4.71 */
+/*  case TB_GETINSERTMARKCOLOR:     */ /* 4.71 */
+
+    case TB_GETITEMRECT:
+        return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
+
+    case TB_GETMAXSIZE:
+        return TOOLBAR_GetMaxSize (hwnd, wParam, lParam);
+
+/*  case TB_GETOBJECT:          */ /* 4.71 */
+/*  case TB_GETPADDING:         */ /* 4.71 */
+
+    case TB_GETRECT:
+        return TOOLBAR_GetRect (hwnd, wParam, lParam);
+
+    case TB_GETROWS:
+        return TOOLBAR_GetRows (hwnd, wParam, lParam);
+
+    case TB_GETSTATE:
+        return TOOLBAR_GetState (hwnd, wParam, lParam);
+
+    case TB_GETSTYLE:
+        return TOOLBAR_GetStyle (hwnd, wParam, lParam);
+
+    case TB_GETTEXTROWS:
+        return TOOLBAR_GetTextRows (hwnd, wParam, lParam);
+
+    case TB_GETTOOLTIPS:
+        return TOOLBAR_GetToolTips (hwnd, wParam, lParam);
+
+    case TB_GETUNICODEFORMAT:
+        return TOOLBAR_GetUnicodeFormat (hwnd, wParam, lParam);
+
+    case CCM_GETVERSION:
+        return TOOLBAR_GetVersion (hwnd);
+
+    case TB_HIDEBUTTON:
+        return TOOLBAR_HideButton (hwnd, wParam, lParam);
+
+    case TB_HITTEST:
+        return TOOLBAR_HitTest (hwnd, wParam, lParam);
+
+    case TB_INDETERMINATE:
+        return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
+
+    case TB_INSERTBUTTONA:
+        return TOOLBAR_InsertButtonA (hwnd, wParam, lParam);
+
+    case TB_INSERTBUTTONW:
+        return TOOLBAR_InsertButtonW (hwnd, wParam, lParam);
+
+/*  case TB_INSERTMARKHITTEST:      */ /* 4.71 */
+
+    case TB_ISBUTTONCHECKED:
+        return TOOLBAR_IsButtonChecked (hwnd, wParam, lParam);
+
+    case TB_ISBUTTONENABLED:
+        return TOOLBAR_IsButtonEnabled (hwnd, wParam, lParam);
+
+    case TB_ISBUTTONHIDDEN:
+        return TOOLBAR_IsButtonHidden (hwnd, wParam, lParam);
+
+    case TB_ISBUTTONHIGHLIGHTED:
+        return TOOLBAR_IsButtonHighlighted (hwnd, wParam, lParam);
+
+    case TB_ISBUTTONINDETERMINATE:
+        return TOOLBAR_IsButtonIndeterminate (hwnd, wParam, lParam);
+
+    case TB_ISBUTTONPRESSED:
+        return TOOLBAR_IsButtonPressed (hwnd, wParam, lParam);
+
+    case TB_LOADIMAGES:            /* 4.70 */
+        FIXME("missing standard imagelists\n");
+        return 0;
+
+/*  case TB_MAPACCELERATORA:        */ /* 4.71 */
+/*  case TB_MAPACCELERATORW:        */ /* 4.71 */
+/*  case TB_MARKBUTTON:         */ /* 4.71 */
+/*  case TB_MOVEBUTTON:         */ /* 4.71 */
+
+    case TB_PRESSBUTTON:
+        return TOOLBAR_PressButton (hwnd, wParam, lParam);
+
+/*  case TB_REPLACEBITMAP: */
+
+    case TB_SAVERESTOREA:
+        return TOOLBAR_SaveRestoreA (hwnd, wParam, lParam);
+
+    case TB_SAVERESTOREW:
+        return TOOLBAR_SaveRestoreW (hwnd, wParam, lParam);
+
+    case TB_SETANCHORHIGHLIGHT:
+        return TOOLBAR_SetAnchorHighlight (hwnd, wParam);
+
+    case TB_SETBITMAPSIZE:
+        return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
+
+    case TB_SETBUTTONINFOA:
+        return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
+
+    case TB_SETBUTTONINFOW:
+        return TOOLBAR_SetButtonInfoW (hwnd, wParam, lParam);
+
+    case TB_SETBUTTONSIZE:
+        return TOOLBAR_SetButtonSize (hwnd, wParam, lParam);
+
+    case TB_SETBUTTONWIDTH:
+        return TOOLBAR_SetButtonWidth (hwnd, wParam, lParam);
+
+    case TB_SETCMDID:
+        return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
+
+/*  case TB_SETCOLORSCHEME:         */ /* 4.71 */
+
+    case TB_SETDISABLEDIMAGELIST:
+        return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
+
+    case TB_SETDRAWTEXTFLAGS:
+        return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
+
+    case TB_SETEXTENDEDSTYLE:
+        return TOOLBAR_SetExtendedStyle (hwnd, wParam, lParam);
+
+    case TB_SETHOTIMAGELIST:
+        return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
+
+    case TB_SETHOTITEM:
+        return TOOLBAR_SetHotItem (hwnd, wParam);
+
+    case TB_SETIMAGELIST:
+        return TOOLBAR_SetImageList (hwnd, wParam, lParam);
+
+    case TB_SETINDENT:
+        return TOOLBAR_SetIndent (hwnd, wParam, lParam);
+
+/*  case TB_SETINSERTMARK:          */ /* 4.71 */
+
+    case TB_SETINSERTMARKCOLOR:
+        return TOOLBAR_SetInsertMarkColor (hwnd, wParam, lParam);
+
+    case TB_SETMAXTEXTROWS:
+        return TOOLBAR_SetMaxTextRows (hwnd, wParam, lParam);
+
+/*  case TB_SETPADDING:         */ /* 4.71 */
+
+    case TB_SETPARENT:
+        return TOOLBAR_SetParent (hwnd, wParam, lParam);
+
+    case TB_SETROWS:
+        return TOOLBAR_SetRows (hwnd, wParam, lParam);
+
+    case TB_SETSTATE:
+        return TOOLBAR_SetState (hwnd, wParam, lParam);
+
+    case TB_SETSTYLE:
+        return TOOLBAR_SetStyle (hwnd, wParam, lParam);
+
+    case TB_SETTOOLTIPS:
+        return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
+
+    case TB_SETUNICODEFORMAT:
+        return TOOLBAR_SetUnicodeFormat (hwnd, wParam, lParam);
+
+    case CCM_SETVERSION:
+        return TOOLBAR_SetVersion (hwnd, (INT)wParam);
+
+
+/*  case WM_CHAR: */
+
+    case WM_CREATE:
+        return TOOLBAR_Create (hwnd, wParam, lParam);
+
+    case WM_DESTROY:
+      return TOOLBAR_Destroy (hwnd, wParam, lParam);
+
+    case WM_ERASEBKGND:
+        return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
+
+    case WM_GETFONT:
+        return TOOLBAR_GetFont (hwnd, wParam, lParam);
+
+/*  case WM_KEYDOWN: */
+/*  case WM_KILLFOCUS: */
+
+    case WM_LBUTTONDBLCLK:
+        return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
+
+    case WM_LBUTTONDOWN:
+        return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
+
+    case WM_LBUTTONUP:
+        return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
+
+    case WM_MOUSEMOVE:
+        return TOOLBAR_MouseMove (hwnd, wParam, lParam);
+
+    case WM_MOUSELEAVE:
+        return TOOLBAR_MouseLeave (hwnd, wParam, lParam);
+
+    case WM_CAPTURECHANGED:
+        return TOOLBAR_CaptureChanged(hwnd);
+
+    case WM_NCACTIVATE:
+        return TOOLBAR_NCActivate (hwnd, wParam, lParam);
+
+    case WM_NCCALCSIZE:
+        return TOOLBAR_NCCalcSize (hwnd, wParam, lParam);
+
+    case WM_NCCREATE:
+        return TOOLBAR_NCCreate (hwnd, wParam, lParam);
+
+    case WM_NCPAINT:
+        return TOOLBAR_NCPaint (hwnd, wParam, lParam);
+
+    case WM_NOTIFY:
+        return TOOLBAR_Notify (hwnd, wParam, lParam);
+
+/*  case WM_NOTIFYFORMAT: */
+
+    case WM_PAINT:
+        return TOOLBAR_Paint (hwnd, wParam);
+
+    case WM_SIZE:
+        return TOOLBAR_Size (hwnd, wParam, lParam);
+
+    case WM_STYLECHANGED:
+        return TOOLBAR_StyleChanged (hwnd, (INT)wParam, (LPSTYLESTRUCT)lParam);
+
+/*  case WM_SYSCOLORCHANGE: */
+
+/*  case WM_WININICHANGE: */
+
+    case WM_CHARTOITEM:
+    case WM_COMMAND:
+    case WM_DRAWITEM:
+    case WM_MEASUREITEM:
+    case WM_VKEYTOITEM:
+        return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
+
+    default:
+        if (uMsg >= WM_USER)
+        ERR("unknown msg %04x wp=%08x lp=%08lx\n",
+             uMsg, wParam, lParam);
+        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     }
     return 0;
@@ -4674 +4675 @@
     wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
     wndClass.lpszClassName = TOOLBARCLASSNAMEA;
- 
+
     RegisterClassA (&wndClass);
 }