[ros-diffs] [rharabien] 54991: [SHELL32] - Improve formatting in shelllink.cpp - Load shortcut icon in property page

Author: rharabien
Date: Tue Jan 17 17:57:23 2012
New Revision: 54991

URL: http://svn.reactos.org/svn/reactos?rev=54991&view=rev
Log:
[SHELL32]
- Improve formatting in shelllink.cpp
- Load shortcut icon in property page

Modified:
    trunk/reactos/dll/win32/shell32/shelllink.cpp

Modified: trunk/reactos/dll/win32/shell32/shelllink.cpp
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/shelllin…
==============================================================================
--- trunk/reactos/dll/win32/shell32/shelllink.cpp [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/shell32/shelllink.cpp [iso-8859-1] Tue Jan 17 17:57:23 2012
@@ -95,26 +95,26 @@
 static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir,
LPWSTR* psPath);
 
 /* strdup on the process heap */
-static LPWSTR __inline HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str)
+static LPWSTR __inline HEAP_strdupAtoW(HANDLE heap, DWORD flags, LPCSTR str)
 {
     INT len;
     LPWSTR p;
 
     assert(str);
 
-    len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
-    p = (LPWSTR)HeapAlloc( heap, flags, len*sizeof (WCHAR) );
-    if( !p )
+    len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
+    p = (LPWSTR)HeapAlloc(heap, flags, len * sizeof(WCHAR));
+    if (!p)
         return p;
-    MultiByteToWideChar( CP_ACP, 0, str, -1, p, len );
+    MultiByteToWideChar(CP_ACP, 0, str, -1, p, len);
     return p;
 }
 
-static LPWSTR __inline strdupW( LPCWSTR src )
+static LPWSTR __inline strdupW(LPCWSTR src)
 {
     LPWSTR dest;
     if (!src) return NULL;
-    dest = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, (wcslen(src)+1)*sizeof(WCHAR) );
+    dest = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(src) + 1) * sizeof(WCHAR));
     if (dest)
         wcscpy(dest, src);
     return dest;
@@ -159,7 +159,7 @@
         ILFree(pPidl);
 }
 
-HRESULT WINAPI CShellLink::GetClassID(CLSID *pclsid )
+HRESULT WINAPI CShellLink::GetClassID(CLSID *pclsid)
 {
     TRACE("%p %p\n", this, pclsid);
 
@@ -171,7 +171,7 @@
 
 HRESULT WINAPI CShellLink::IsDirty()
 {
-    TRACE("(%p)\n",this);
+    TRACE("(%p)\n", this);
 
     if (bDirty)
         return S_OK;
@@ -181,63 +181,57 @@
 
 HRESULT WINAPI CShellLink::Load(LPCOLESTR pszFileName, DWORD dwMode)
 {
-    HRESULT r;
-    CComPtr<IStream>        stm;
-
-    TRACE("(%p, %s, %x)\n",this, debugstr_w(pszFileName), dwMode);
+    TRACE("(%p, %s, %x)\n", this, debugstr_w(pszFileName), dwMode);
 
     if (dwMode == 0)
         dwMode = STGM_READ | STGM_SHARE_DENY_WRITE;
-    r = SHCreateStreamOnFileW(pszFileName, dwMode, &stm);
-    if (SUCCEEDED(r))
+
+    CComPtr<IStream> stm;
+    HRESULT hr = SHCreateStreamOnFileW(pszFileName, dwMode, &stm);
+    if (SUCCEEDED(hr))
     {
         HeapFree(GetProcessHeap(), 0, sLinkPath);
         sLinkPath = strdupW(pszFileName);
-        r = Load(stm);
+        hr = Load(stm);
         ShellLink_UpdatePath(sPathRel, pszFileName, sWorkDir, &sPath);
         bDirty = FALSE;
     }
-    TRACE("-- returning hr %08x\n", r);
-    return r;
+    TRACE("-- returning hr %08x\n", hr);
+    return hr;
 }
 
 HRESULT WINAPI CShellLink::Save(LPCOLESTR pszFileName, BOOL fRemember)
 {
-    HRESULT r;
-    CComPtr<IStream>        stm;
-
     TRACE("(%p)->(%s)\n", this, debugstr_w(pszFileName));
 
     if (!pszFileName)
         return E_FAIL;
 
-    r = SHCreateStreamOnFileW( pszFileName, STGM_READWRITE | STGM_CREATE |
STGM_SHARE_EXCLUSIVE, &stm );
-    if( SUCCEEDED( r ) )
-    {
-        r = Save(stm, FALSE);
-
-        if( SUCCEEDED( r ) )
+    CComPtr<IStream> stm;
+    HRESULT hr = SHCreateStreamOnFileW(pszFileName, STGM_READWRITE | STGM_CREATE |
STGM_SHARE_EXCLUSIVE, &stm);
+    if (SUCCEEDED(hr))
+    {
+        hr = Save(stm, FALSE);
+
+        if (SUCCEEDED(hr))
         {
-            if ( sLinkPath )
-            {
+            if (sLinkPath)
                 HeapFree(GetProcessHeap(), 0, sLinkPath);
-            }
-            sLinkPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(pszFileName)+1) *
sizeof(WCHAR));
-            if ( sLinkPath )
-            {
+
+            sLinkPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(pszFileName) + 1)
* sizeof(WCHAR));
+            if (sLinkPath)
                 wcscpy(sLinkPath, pszFileName);
-            }
 
             bDirty = FALSE;
         }
         else
         {
-            DeleteFileW( pszFileName );
-            WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName) );
+            DeleteFileW(pszFileName);
+            WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName));
         }
     }
 
-    return r;
+    return hr;
 }
 
 HRESULT WINAPI CShellLink::SaveCompleted(LPCOLESTR pszFileName)
@@ -250,13 +244,13 @@
 {
     *ppszFileName = NULL;
 
-    if ( !sLinkPath)
+    if (!sLinkPath)
     {
         /* IPersistFile::GetCurFile called before IPersistFile::Save */
         return S_FALSE;
     }
 
-    *ppszFileName = (LPOLESTR)CoTaskMemAlloc((wcslen(sLinkPath)+1) * sizeof(WCHAR));
+    *ppszFileName = (LPOLESTR)CoTaskMemAlloc((wcslen(sLinkPath) + 1) * sizeof(WCHAR));
     if (!*ppszFileName)
     {
         /* out of memory */
@@ -273,50 +267,46 @@
  * IPersistStream_IsDirty (IPersistStream)
  */
 
-static HRESULT Stream_LoadString( IStream* stm, BOOL unicode, LPWSTR *pstr )
-{
-    DWORD count;
+static HRESULT Stream_LoadString(IStream* stm, BOOL unicode, LPWSTR *pstr)
+{
+    TRACE("%p\n", stm);
+
     USHORT len;
-    LPSTR temp;
-    LPWSTR str;
-    HRESULT r;
-
-    TRACE("%p\n", stm);
-
-    count = 0;
-    r = stm->Read(&len, sizeof(len), &count);
-    if ( FAILED (r) || ( count != sizeof(len) ) )
+    DWORD count = 0;
+    HRESULT hr = stm->Read(&len, sizeof(len), &count);
+    if (FAILED(hr) || count != sizeof(len))
         return E_FAIL;
 
-    if( unicode )
+    if (unicode)
         len *= sizeof (WCHAR);
 
     TRACE("reading %d\n", len);
-    temp = (LPSTR)HeapAlloc(GetProcessHeap(), 0, len+sizeof(WCHAR));
-    if( !temp )
+    LPSTR temp = (LPSTR)HeapAlloc(GetProcessHeap(), 0, len + sizeof(WCHAR));
+    if (!temp)
         return E_OUTOFMEMORY;
     count = 0;
-    r = stm->Read(temp, len, &count);
-    if( FAILED (r) || ( count != len ) )
-    {
-        HeapFree( GetProcessHeap(), 0, temp );
+    hr = stm->Read(temp, len, &count);
+    if(FAILED(hr) || count != len)
+    {
+        HeapFree(GetProcessHeap(), 0, temp);
         return E_FAIL;
     }
 
-    TRACE("read %s\n", debugstr_an(temp,len));
+    TRACE("read %s\n", debugstr_an(temp, len));
 
     /* convert to unicode if necessary */
-    if( !unicode )
-    {
-        count = MultiByteToWideChar( CP_ACP, 0, temp, len, NULL, 0 );
-        str = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, (count+1)*sizeof (WCHAR) );
-        if( !str )
+    LPWSTR str;
+    if (!unicode)
+    {
+        count = MultiByteToWideChar(CP_ACP, 0, temp, len, NULL, 0);
+        str = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (count + 1) * sizeof (WCHAR));
+        if (!str)
         {
-            HeapFree( GetProcessHeap(), 0, temp );
+            HeapFree(GetProcessHeap(), 0, temp);
             return E_OUTOFMEMORY;
         }
-        MultiByteToWideChar( CP_ACP, 0, temp, len, str, count );
-        HeapFree( GetProcessHeap(), 0, temp );
+        MultiByteToWideChar(CP_ACP, 0, temp, len, str, count);
+        HeapFree(GetProcessHeap(), 0, temp);
     }
     else
     {
@@ -330,117 +320,110 @@
     return S_OK;
 }
 
-static HRESULT Stream_ReadChunk( IStream* stm, LPVOID *data )
-{
-    DWORD size;
-    ULONG count;
-    HRESULT r;
-    struct sized_chunk {
+static HRESULT Stream_ReadChunk(IStream* stm, LPVOID *data)
+{
+    struct sized_chunk
+    {
         DWORD size;
         unsigned char data[1];
     } *chunk;
 
-    TRACE("%p\n",stm);
-
-    r = stm->Read(&size, sizeof(size), &count );
-    if( FAILED( r )  || count != sizeof(size) )
+    TRACE("%p\n", stm);
+
+    DWORD size;
+    ULONG count;
+    HRESULT hr = stm->Read(&size, sizeof(size), &count);
+    if (FAILED(hr) || count != sizeof(size))
         return E_FAIL;
 
-    chunk = (sized_chunk *)HeapAlloc( GetProcessHeap(), 0, size );
-    if( !chunk )
+    chunk = (sized_chunk *)HeapAlloc(GetProcessHeap(), 0, size);
+    if (!chunk)
         return E_OUTOFMEMORY;
 
     chunk->size = size;
-    r = stm->Read(chunk->data, size - sizeof(size), &count );
-    if( FAILED( r ) || count != (size - sizeof(size)) )
-    {
-        HeapFree( GetProcessHeap(), 0, chunk );
+    hr = stm->Read(chunk->data, size - sizeof(size), &count);
+    if (FAILED(hr) || count != (size - sizeof(size)))
+    {
+        HeapFree(GetProcessHeap(), 0, chunk);
         return E_FAIL;
     }
 
-    TRACE("Read %d bytes\n",chunk->size);
+    TRACE("Read %d bytes\n", chunk->size);
 
     *data = chunk;
 
     return S_OK;
 }
 
-static BOOL Stream_LoadVolume( LOCAL_VOLUME_INFO *vol, CShellLink::volume_info *volume )
-{
-    const int label_sz = sizeof volume->label/sizeof volume->label[0];
-    LPSTR label;
-    int len;
-
+static BOOL Stream_LoadVolume(LOCAL_VOLUME_INFO *vol, CShellLink::volume_info *volume)
+{
     volume->serial = vol->dwVolSerial;
     volume->type = vol->dwType;
 
-    if( !vol->dwVolLabelOfs )
+    if (!vol->dwVolLabelOfs)
         return FALSE;
-    if( vol->dwSize <= vol->dwVolLabelOfs )
+    if (vol->dwSize <= vol->dwVolLabelOfs)
         return FALSE;
-    len = vol->dwSize - vol->dwVolLabelOfs;
-
-    label = (LPSTR) vol;
+    INT len = vol->dwSize - vol->dwVolLabelOfs;
+
+    LPSTR label = (LPSTR)vol;
     label += vol->dwVolLabelOfs;
-    MultiByteToWideChar( CP_ACP, 0, label, len, volume->label, label_sz-1);
+    MultiByteToWideChar(CP_ACP, 0, label, len, volume->label,
_countof(volume->label));
 
     return TRUE;
 }
 
-static LPWSTR Stream_LoadPath( LPCSTR p, DWORD maxlen )
-{
-    unsigned int len = 0, wlen;
-    LPWSTR path;
-
-    while( p[len] && (len < maxlen) )
+static LPWSTR Stream_LoadPath(LPCSTR p, DWORD maxlen)
+{
+    UINT len = 0;
+
+    while (p[len] && len < maxlen)
         len++;
 
-    wlen = MultiByteToWideChar(CP_ACP, 0, p, len, NULL, 0);
-    path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wlen+1)*sizeof(WCHAR));
+    UINT wlen = MultiByteToWideChar(CP_ACP, 0, p, len, NULL, 0);
+    LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wlen + 1) * sizeof(WCHAR));
+    if (!path)
+        return NULL;
     MultiByteToWideChar(CP_ACP, 0, p, len, path, wlen);
     path[wlen] = 0;
 
     return path;
 }
 
-static HRESULT Stream_LoadLocation( IStream *stm,
-                                   CShellLink::volume_info *volume, LPWSTR *path )
+static HRESULT Stream_LoadLocation(IStream *stm,
+                                    CShellLink::volume_info *volume, LPWSTR *path)
 {
     char *p = NULL;
-    LOCATION_INFO *loc;
-    HRESULT r;
-    DWORD n;
-
-    r = Stream_ReadChunk( stm, (LPVOID*) &p );
-    if( FAILED(r) )
-        return r;
-
-    loc = (LOCATION_INFO*) p;
+    HRESULT hr = Stream_ReadChunk(stm, (LPVOID*) &p);
+    if (FAILED(hr))
+        return hr;
+
+    LOCATION_INFO *loc = (LOCATION_INFO*) p;
     if (loc->dwTotalSize < sizeof(LOCATION_INFO))
     {
-        HeapFree( GetProcessHeap(), 0, p );
+        HeapFree(GetProcessHeap(), 0, p);
         return E_FAIL;
     }
 
     /* if there's valid local volume information, load it */
-    if( loc->dwVolTableOfs &&
-       ((loc->dwVolTableOfs + sizeof(LOCAL_VOLUME_INFO)) <= loc->dwTotalSize) )
+    if (loc->dwVolTableOfs &&
+        ((loc->dwVolTableOfs + sizeof(LOCAL_VOLUME_INFO)) <= loc->dwTotalSize))
     {
         LOCAL_VOLUME_INFO *volume_info;
 
         volume_info = (LOCAL_VOLUME_INFO*) &p[loc->dwVolTableOfs];
-        Stream_LoadVolume( volume_info, volume );
+        Stream_LoadVolume(volume_info, volume);
     }
 
     /* if there's a local path, load it */
-    n = loc->dwLocalPathOfs;
-    if( n && (n < loc->dwTotalSize) )
-        *path = Stream_LoadPath( &p[n], loc->dwTotalSize - n );
+    DWORD n = loc->dwLocalPathOfs;
+    if (n && n < loc->dwTotalSize)
+        *path = Stream_LoadPath(&p[n], loc->dwTotalSize - n);
 
     TRACE("type %d serial %08x name %s path %s\n", volume->type,
           volume->serial, debugstr_w(volume->label), debugstr_w(*path));
 
-    HeapFree( GetProcessHeap(), 0, p );
+    HeapFree(GetProcessHeap(), 0, p);
     return S_OK;
 }
 
@@ -458,45 +441,42 @@
  * In the original Win32 implementation the buffers are not initialized
  *  to zero, so data trailing the string is random garbage.
  */
-static HRESULT Stream_LoadAdvertiseInfo( IStream* stm, LPWSTR *str )
-{
-    DWORD size;
+static HRESULT Stream_LoadAdvertiseInfo(IStream* stm, LPWSTR *str)
+{
+    TRACE("%p\n", stm);
+
     ULONG count;
-    HRESULT r;
     EXP_DARWIN_LINK buffer;
-
-    TRACE("%p\n",stm);
-
-    r = stm->Read(&buffer.dbh.cbSize, sizeof (DWORD), &count );
-    if( FAILED( r ) )
-        return r;
+    HRESULT hr = stm->Read(&buffer.dbh.cbSize, sizeof (DWORD), &count);
+    if (FAILED(hr))
+        return hr;
 
     /* make sure that we read the size of the structure even on error */
-    size = sizeof buffer - sizeof (DWORD);
-    if( buffer.dbh.cbSize != sizeof buffer )
+    DWORD size = sizeof buffer - sizeof (DWORD);
+    if (buffer.dbh.cbSize != sizeof buffer)
     {
         ERR("Ooops.  This structure is not as expected...\n");
         return E_FAIL;
     }
 
-    r = stm->Read(&buffer.dbh.dwSignature, size, &count );
-    if( FAILED( r ) )
-        return r;
-
-    if( count != size )
+    hr = stm->Read(&buffer.dbh.dwSignature, size, &count);
+    if (FAILED(hr))
+        return hr;
+
+    if (count != size)
         return E_FAIL;
 
     TRACE("magic %08x  string = %s\n", buffer.dbh.dwSignature,
debugstr_w(buffer.szwDarwinID));
 
-    if( (buffer.dbh.dwSignature&0xffff0000) != 0xa0000000 )
+    if ((buffer.dbh.dwSignature & 0xffff0000) != 0xa0000000)
     {
         ERR("Unknown magic number %08x in advertised shortcut\n",
buffer.dbh.dwSignature);
         return E_FAIL;
     }
 
-    *str = (LPWSTR)HeapAlloc( GetProcessHeap(), 0,
-                     (wcslen(buffer.szwDarwinID)+1) * sizeof(WCHAR) );
-    wcscpy( *str, buffer.szwDarwinID );
+    *str = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
+                             (wcslen(buffer.szwDarwinID) + 1) * sizeof(WCHAR));
+    wcscpy(*str, buffer.szwDarwinID);
 
     return S_OK;
 }
@@ -506,21 +486,16 @@
  */
 HRESULT WINAPI CShellLink::Load(IStream *stm)
 {
-    LINK_HEADER hdr;
-    ULONG    dwBytesRead;
-    BOOL     unicode;
-    HRESULT  r;
-    DWORD    zero;
-
     TRACE("%p %p\n", this, stm);
 
     if (!stm)
         return STG_E_INVALIDPOINTER;
 
-    dwBytesRead = 0;
-    r = stm->Read(&hdr, sizeof(hdr), &dwBytesRead);
-    if (FAILED(r))
-        return r;
+    LINK_HEADER hdr;
+    ULONG dwBytesRead = 0;
+    HRESULT hr = stm->Read(&hdr, sizeof(hdr), &dwBytesRead);
+    if (FAILED(hr))
+        return hr;
 
     if (dwBytesRead != sizeof(hdr))
         return E_FAIL;
@@ -532,7 +507,7 @@
     /* free all the old stuff */
     ILFree(pPidl);
     pPidl = NULL;
-    memset( &volume, 0, sizeof volume );
+    memset(&volume, 0, sizeof volume);
     HeapFree(GetProcessHeap(), 0, sPath);
     sPath = NULL;
     HeapFree(GetProcessHeap(), 0, sDescription);
@@ -550,6 +525,7 @@
     HeapFree(GetProcessHeap(), 0, sComponent);
     sComponent = NULL;
 
+    BOOL unicode = FALSE;
     iShowCmd = hdr.fStartup;
     wHotKey = (WORD)hdr.wHotKey;
     iIcoNdx = hdr.nIcon;
@@ -559,102 +535,105 @@
     if (TRACE_ON(shell))
     {
         WCHAR sTemp[MAX_PATH];
-        GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &time1,
-                       NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
-        TRACE("-- time1: %s\n", debugstr_w(sTemp) );
-        GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &time2,
-                       NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
-        TRACE("-- time2: %s\n", debugstr_w(sTemp) );
-        GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &time3,
-                       NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
-        TRACE("-- time3: %s\n", debugstr_w(sTemp) );
+        GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &time1,
+                       NULL, sTemp, sizeof(sTemp) / sizeof(*sTemp));
+        TRACE("-- time1: %s\n", debugstr_w(sTemp));
+        GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &time2,
+                       NULL, sTemp, sizeof(sTemp) / sizeof(*sTemp));
+        TRACE("-- time2: %s\n", debugstr_w(sTemp));
+        GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &time3,
+                       NULL, sTemp, sizeof(sTemp) / sizeof(*sTemp));
+        TRACE("-- time3: %s\n", debugstr_w(sTemp));
     }
 
     /* load all the new stuff */
-    if( hdr.dwFlags & SLDF_HAS_ID_LIST )
-    {
-        r = ILLoadFromStream( stm, &pPidl );
-        if( FAILED( r ) )
-            return r;
+    if (hdr.dwFlags & SLDF_HAS_ID_LIST)
+    {
+        hr = ILLoadFromStream(stm, &pPidl);
+        if (FAILED(hr))
+            return hr;
     }
     pdump(pPidl);
 
     /* load the location information */
-    if( hdr.dwFlags & SLDF_HAS_LINK_INFO )
-        r = Stream_LoadLocation( stm, &volume, &sPath );
-    if( FAILED( r ) )
+    if (hdr.dwFlags & SLDF_HAS_LINK_INFO)
+        hr = Stream_LoadLocation(stm, &volume, &sPath);
+    if (FAILED(hr))
         goto end;
 
-    unicode = hdr.dwFlags & SLDF_UNICODE;
-    if( hdr.dwFlags & SLDF_HAS_NAME )
-    {
-        r = Stream_LoadString( stm, unicode, &sDescription );
-        TRACE("Description  -> %s\n",debugstr_w(sDescription));
-    }
-    if( FAILED( r ) )
+    if (hdr.dwFlags & SLDF_UNICODE)
+        unicode = TRUE;
+
+    if (hdr.dwFlags & SLDF_HAS_NAME)
+    {
+        hr = Stream_LoadString(stm, unicode, &sDescription);
+        TRACE("Description  -> %s\n", debugstr_w(sDescription));
+    }
+    if (FAILED(hr))
         goto end;
 
-    if( hdr.dwFlags & SLDF_HAS_RELPATH )
-    {
-        r = Stream_LoadString( stm, unicode, &sPathRel );
-        TRACE("Relative Path-> %s\n",debugstr_w(sPathRel));
-    }
-    if( FAILED( r ) )
+    if (hdr.dwFlags & SLDF_HAS_RELPATH)
+    {
+        hr = Stream_LoadString(stm, unicode, &sPathRel);
+        TRACE("Relative Path-> %s\n", debugstr_w(sPathRel));
+    }
+    if (FAILED(hr))
         goto end;
 
-    if( hdr.dwFlags & SLDF_HAS_WORKINGDIR )
-    {
-        r = Stream_LoadString( stm, unicode, &sWorkDir );
-        TRACE("Working Dir  -> %s\n",debugstr_w(sWorkDir));
-    }
-    if( FAILED( r ) )
+    if (hdr.dwFlags & SLDF_HAS_WORKINGDIR)
+    {
+        hr = Stream_LoadString(stm, unicode, &sWorkDir);
+        TRACE("Working Dir  -> %s\n", debugstr_w(sWorkDir));
+    }
+    if (FAILED(hr))
         goto end;
 
-    if( hdr.dwFlags & SLDF_HAS_ARGS )
-    {
-        r = Stream_LoadString( stm, unicode, &sArgs );
-        TRACE("Working Dir  -> %s\n",debugstr_w(sArgs));
-    }
-    if( FAILED( r ) )
+    if (hdr.dwFlags & SLDF_HAS_ARGS)
+    {
+        hr = Stream_LoadString(stm, unicode, &sArgs);
+        TRACE("Working Dir  -> %s\n", debugstr_w(sArgs));
+    }
+    if (FAILED(hr))
         goto end;
 
-    if( hdr.dwFlags & SLDF_HAS_ICONLOCATION )
-    {
-        r = Stream_LoadString( stm, unicode, &sIcoPath );
-        TRACE("Icon file    -> %s\n",debugstr_w(sIcoPath));
-    }
-    if( FAILED( r ) )
+    if (hdr.dwFlags & SLDF_HAS_ICONLOCATION)
+    {
+        hr = Stream_LoadString(stm, unicode, &sIcoPath);
+        TRACE("Icon file    -> %s\n", debugstr_w(sIcoPath));
+    }
+    if (FAILED(hr))
         goto end;
 
 #if (NTDDI_VERSION < NTDDI_LONGHORN)
-    if( hdr.dwFlags & SLDF_HAS_LOGO3ID )
-    {
-        r = Stream_LoadAdvertiseInfo( stm, &sProduct );
-        TRACE("Product      -> %s\n",debugstr_w(sProduct));
-    }
-    if( FAILED( r ) )
+    if (hdr.dwFlags & SLDF_HAS_LOGO3ID)
+    {
+        hr = Stream_LoadAdvertiseInfo(stm, &sProduct);
+        TRACE("Product      -> %s\n", debugstr_w(sProduct));
+    }
+    if (FAILED(hr))
         goto end;
 #endif
 
-    if( hdr.dwFlags & SLDF_HAS_DARWINID )
-    {
-        r = Stream_LoadAdvertiseInfo( stm, &sComponent );
-        TRACE("Component    -> %s\n",debugstr_w(sComponent));
-    }
-    if( hdr.dwFlags & SLDF_RUNAS_USER )
-    {
-       bRunAs = TRUE;
+    if (hdr.dwFlags & SLDF_HAS_DARWINID)
+    {
+        hr = Stream_LoadAdvertiseInfo(stm, &sComponent);
+        TRACE("Component    -> %s\n", debugstr_w(sComponent));
+    }
+    if (hdr.dwFlags & SLDF_RUNAS_USER)
+    {
+        bRunAs = TRUE;
     }
     else
     {
-       bRunAs = FALSE;
-    }
-
-    if( FAILED( r ) )
+        bRunAs = FALSE;
+    }
+
+    if (FAILED(hr))
         goto end;
 
-    r = stm->Read(&zero, sizeof zero, &dwBytesRead);
-    if( FAILED( r ) || zero || dwBytesRead != sizeof zero )
+    DWORD dwZero;
+    hr = stm->Read(&dwZero, sizeof(dwZero), &dwBytesRead);
+    if (FAILED(hr) || dwZero || dwBytesRead != sizeof(dwZero))
         ERR("Last word was not zero\n");
 
     TRACE("OK\n");
@@ -662,8 +641,9 @@
     pdump (pPidl);
 
     return S_OK;
+
 end:
-    return r;
+    return hr;
 }
 
 /************************************************************************
@@ -672,21 +652,20 @@
  * Helper function for IPersistStream_Save. Writes a unicode string
  *  with terminating nul byte to a stream, preceded by the its length.
  */
-static HRESULT Stream_WriteString( IStream* stm, LPCWSTR str )
-{
-    USHORT len = wcslen( str ) + 1;
+static HRESULT Stream_WriteString(IStream* stm, LPCWSTR str)
+{
+    USHORT len = wcslen(str) + 1;
     DWORD count;
-    HRESULT r;
-
-    r = stm->Write(&len, sizeof(len), &count );
-    if( FAILED( r ) )
-        return r;
+
+    HRESULT hr = stm->Write(&len, sizeof(len), &count);
+    if (FAILED(hr))
+        return hr;
 
     len *= sizeof(WCHAR);
 
-    r = stm->Write(str, len, &count );
-    if( FAILED( r ) )
-        return r;
+    hr = stm->Write(str, len, &count);
+    if (FAILED(hr))
+        return hr;
 
     return S_OK;
 }
@@ -700,33 +679,29 @@
  *        and the final path.
  *        Figure out how Windows deals with unicode paths here.
  */
-static HRESULT Stream_WriteLocationInfo( IStream* stm, LPCWSTR path,
-                                         CShellLink::volume_info *volume )
-{
-    DWORD total_size, path_size, volume_info_size, label_size, final_path_size;
+static HRESULT Stream_WriteLocationInfo(IStream* stm, LPCWSTR path,
+        CShellLink::volume_info *volume)
+{
     LOCAL_VOLUME_INFO *vol;
     LOCATION_INFO *loc;
-    LPSTR szLabel, szPath, szFinalPath;
-    ULONG count = 0;
-    HRESULT hr;
 
     TRACE("%p %s %p\n", stm, debugstr_w(path), volume);
 
     /* figure out the size of everything */
-    label_size = WideCharToMultiByte( CP_ACP, 0, volume->label, -1,
-                                      NULL, 0, NULL, NULL );
-    path_size = WideCharToMultiByte( CP_ACP, 0, path, -1,
-                                     NULL, 0, NULL, NULL );
-    volume_info_size = sizeof *vol + label_size;
-    final_path_size = 1;
-    total_size = sizeof *loc + volume_info_size + path_size + final_path_size;
+    DWORD label_size = WideCharToMultiByte(CP_ACP, 0, volume->label, -1,
+                                      NULL, 0, NULL, NULL);
+    DWORD path_size = WideCharToMultiByte(CP_ACP, 0, path, -1,
+                                     NULL, 0, NULL, NULL);
+    DWORD volume_info_size = sizeof(*vol) + label_size;
+    DWORD final_path_size = 1;
+    DWORD total_size = sizeof(*loc) + volume_info_size + path_size + final_path_size;
 
     /* create pointers to everything */
     loc = (LOCATION_INFO *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, total_size);
     vol = (LOCAL_VOLUME_INFO*) &loc[1];
-    szLabel = (LPSTR) &vol[1];
-    szPath = &szLabel[label_size];
-    szFinalPath = &szPath[path_size];
+    LPSTR szLabel = (LPSTR) &vol[1];
+    LPSTR szPath = &szLabel[label_size];
+    LPSTR szFinalPath = &szPath[path_size];
 
     /* fill in the location information header */
     loc->dwTotalSize = total_size;
@@ -744,41 +719,38 @@
     vol->dwVolLabelOfs = sizeof (*vol);
 
     /* copy in the strings */
-    WideCharToMultiByte( CP_ACP, 0, volume->label, -1,
-                         szLabel, label_size, NULL, NULL );
-    WideCharToMultiByte( CP_ACP, 0, path, -1,
-                         szPath, path_size, NULL, NULL );
+    WideCharToMultiByte(CP_ACP, 0, volume->label, -1,
+                         szLabel, label_size, NULL, NULL);
+    WideCharToMultiByte(CP_ACP, 0, path, -1,
+                         szPath, path_size, NULL, NULL);
     szFinalPath[0] = 0;
 
-    hr = stm->Write(loc, total_size, &count );
+    ULONG count = 0;
+    HRESULT hr = stm->Write(loc, total_size, &count);
     HeapFree(GetProcessHeap(), 0, loc);
 
     return hr;
 }
 
-static EXP_DARWIN_LINK* shelllink_build_darwinid( LPCWSTR string, DWORD magic )
-{
-    EXP_DARWIN_LINK *buffer;
-
-    buffer = (EXP_DARWIN_LINK *)LocalAlloc( LMEM_ZEROINIT, sizeof *buffer );
-    buffer->dbh.cbSize = sizeof *buffer;
+static EXP_DARWIN_LINK* shelllink_build_darwinid(LPCWSTR string, DWORD magic)
+{
+    EXP_DARWIN_LINK *buffer = (EXP_DARWIN_LINK *)LocalAlloc(LMEM_ZEROINIT, sizeof *
buffer);
+    buffer->dbh.cbSize = sizeof * buffer;
     buffer->dbh.dwSignature = magic;
-    lstrcpynW( buffer->szwDarwinID, string, MAX_PATH );
-    WideCharToMultiByte(CP_ACP, 0, string, -1, buffer->szDarwinID, MAX_PATH, NULL,
NULL );
+    lstrcpynW(buffer->szwDarwinID, string, MAX_PATH);
+    WideCharToMultiByte(CP_ACP, 0, string, -1, buffer->szDarwinID, MAX_PATH, NULL,
NULL);
 
     return buffer;
 }
 
-static HRESULT Stream_WriteAdvertiseInfo( IStream* stm, LPCWSTR string, DWORD magic )
-{
-    EXP_DARWIN_LINK *buffer;
+static HRESULT Stream_WriteAdvertiseInfo(IStream* stm, LPCWSTR string, DWORD magic)
+{
+    TRACE("%p\n", stm);
+
+    EXP_DARWIN_LINK *buffer = shelllink_build_darwinid(string, magic);
+
     ULONG count;
-
-    TRACE("%p\n",stm);
-
-    buffer = shelllink_build_darwinid( string, magic );
-
-    return stm->Write(buffer, buffer->dbh.cbSize, &count );
+    return stm->Write(buffer, buffer->dbh.cbSize, &count);
 }
 
 /************************************************************************
@@ -788,13 +760,9 @@
  */
 HRESULT WINAPI CShellLink::Save(IStream *stm, BOOL fClearDirty)
 {
+    TRACE("%p %p %x\n", this, stm, fClearDirty);
+
     LINK_HEADER header;
-    ULONG   count;
-    DWORD   zero;
-    HRESULT r;
-
-    TRACE("%p %p %x\n", this, stm, fClearDirty);
-
     memset(&header, 0, sizeof(header));
     header.dwSize = sizeof(header);
     header.fStartup = iShowCmd;
@@ -803,79 +771,80 @@
     header.wHotKey = wHotKey;
     header.nIcon = iIcoNdx;
     header.dwFlags = SLDF_UNICODE;   /* strings are in unicode */
-    if( pPidl )
+    if (pPidl)
         header.dwFlags |= SLDF_HAS_ID_LIST;
-    if( sPath )
+    if (sPath)
         header.dwFlags |= SLDF_HAS_LINK_INFO;
-    if( sDescription )
+    if (sDescription)
         header.dwFlags |= SLDF_HAS_NAME;
-    if( sWorkDir )
+    if (sWorkDir)
         header.dwFlags |= SLDF_HAS_WORKINGDIR;
-    if( sArgs )
+    if (sArgs)
         header.dwFlags |= SLDF_HAS_ARGS;
-    if( sIcoPath )
+    if (sIcoPath)
         header.dwFlags |= SLDF_HAS_ICONLOCATION;
 #if (NTDDI_VERSION < NTDDI_LONGHORN)
-    if( sProduct )
+    if (sProduct)
         header.dwFlags |= SLDF_HAS_LOGO3ID;
 #endif
-    if( sComponent )
+    if (sComponent)
         header.dwFlags |= SLDF_HAS_DARWINID;
-    if( bRunAs )
+    if (bRunAs)
         header.dwFlags |= SLDF_RUNAS_USER;
 
-    SystemTimeToFileTime ( &time1, &header.Time1 );
-    SystemTimeToFileTime ( &time2, &header.Time2 );
-    SystemTimeToFileTime ( &time3, &header.Time3 );
+    SystemTimeToFileTime (&time1, &header.Time1);
+    SystemTimeToFileTime (&time2, &header.Time2);
+    SystemTimeToFileTime (&time3, &header.Time3);
 
     /* write the Shortcut header */
-    r = stm->Write(&header, sizeof(header), &count );
-    if( FAILED( r ) )
-    {
-        ERR("Write failed at %d\n",__LINE__);
-        return r;
+    ULONG count;
+    HRESULT hr = stm->Write(&header, sizeof(header), &count);
+    if (FAILED(hr))
+    {
+        ERR("Write failed\n");
+        return hr;
     }
 
     TRACE("Writing pidl\n");
 
     /* write the PIDL to the shortcut */
-    if( pPidl )
-    {
-        r = ILSaveToStream( stm, pPidl );
-        if( FAILED( r ) )
+    if (pPidl)
+    {
+        hr = ILSaveToStream(stm, pPidl);
+        if (FAILED(hr))
         {
-            ERR("Failed to write PIDL at %d\n",__LINE__);
-            return r;
+            ERR("Failed to write PIDL\n");
+            return hr;
         }
     }
 
-    if( sPath )
-        Stream_WriteLocationInfo( stm, sPath, &volume );
-
-    if( sDescription )
-        r = Stream_WriteString( stm, sDescription );
-
-    if( sPathRel )
-        r = Stream_WriteString( stm, sPathRel );
-
-    if( sWorkDir )
-        r = Stream_WriteString( stm, sWorkDir );
-
-    if( sArgs )
-        r = Stream_WriteString( stm, sArgs );
-
-    if( sIcoPath )
-        r = Stream_WriteString( stm, sIcoPath );
-
-    if( sProduct )
-        r = Stream_WriteAdvertiseInfo( stm, sProduct, EXP_SZ_ICON_SIG );
-
-    if( sComponent )
-        r = Stream_WriteAdvertiseInfo( stm, sComponent, EXP_DARWIN_ID_SIG );
+    if (sPath)
+        Stream_WriteLocationInfo(stm, sPath, &volume);
+
+    if (sDescription)
+        hr = Stream_WriteString(stm, sDescription);
+
+    if (sPathRel)
+        hr = Stream_WriteString(stm, sPathRel);
+
+    if (sWorkDir)
+        hr = Stream_WriteString(stm, sWorkDir);
+
+    if (sArgs)
+        hr = Stream_WriteString(stm, sArgs);
+
+    if (sIcoPath)
+        hr = Stream_WriteString(stm, sIcoPath);
+
+    if (sProduct)
+        hr = Stream_WriteAdvertiseInfo(stm, sProduct, EXP_SZ_ICON_SIG);
+
+    if (sComponent)
+        hr = Stream_WriteAdvertiseInfo(stm, sComponent, EXP_DARWIN_ID_SIG);
 
     /* the last field is a single zero dword */
-    zero = 0;
-    r = stm->Write(&zero, sizeof zero, &count );
+    DWORD zero = 0;
+    hr = stm->Write(&zero, sizeof zero, &count);
 
     return S_OK;
 }
@@ -894,6 +863,7 @@
 {
     if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(path))
         return FALSE;
+
     return TRUE;
 }
 
@@ -906,25 +876,30 @@
     if (!path || !psPath)
         return E_INVALIDARG;
 
-    if (!*psPath && sPathRel) {
+    if (!*psPath && sPathRel)
+    {
         WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH];
         LPWSTR final = NULL;
 
         /* first try if [directory of link file] + [relative path] finds an existing file
*/
 
-        GetFullPathNameW( path, MAX_PATH*2, buffer, &final );
-        if( !final )
+        GetFullPathNameW(path, MAX_PATH * 2, buffer, &final);
+        if (!final)
             final = buffer;
         wcscpy(final, sPathRel);
 
         *abs_path = '\0';
 
-        if (SHELL_ExistsFileW(buffer)) {
+        if (SHELL_ExistsFileW(buffer))
+        {
             if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
                 wcscpy(abs_path, buffer);
-        } else {
+        }
+        else
+        {
             /* try if [working directory] + [relative path] finds an existing file */
-            if (sWorkDir) {
+            if (sWorkDir)
+            {
                 wcscpy(buffer, sWorkDir);
                 wcscpy(PathAddBackslashW(buffer), sPathRel);
 
@@ -938,7 +913,7 @@
         if (!*abs_path)
             wcscpy(abs_path, sPathRel);
 
-        *psPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
(wcslen(abs_path)+1)*sizeof(WCHAR));
+        *psPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(abs_path) + 1) *
sizeof(WCHAR));
         if (!*psPath)
             return E_OUTOFMEMORY;
 
@@ -958,8 +933,9 @@
 
     if (cchMaxPath)
         pszFile[0] = 0;
+
     if (sPath)
-        WideCharToMultiByte( CP_ACP, 0, sPath, -1,
+        WideCharToMultiByte(CP_ACP, 0, sPath, -1,
                              pszFile, cchMaxPath, NULL, NULL);
 
     if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", this);
@@ -969,25 +945,27 @@
 
 HRESULT WINAPI CShellLink::GetIDList(LPITEMIDLIST * ppidl)
 {
-    TRACE("(%p)->(ppidl=%p)\n",this, ppidl);
+    TRACE("(%p)->(ppidl=%p)\n", this, ppidl);
 
     if (!pPidl)
     {
         *ppidl = NULL;
         return S_FALSE;
     }
+
     *ppidl = ILClone(pPidl);
     return S_OK;
 }
 
 HRESULT WINAPI CShellLink::SetIDList(LPCITEMIDLIST pidl)
 {
-    TRACE("(%p)->(pidl=%p)\n",this, pidl);
-
-    if( pPidl )
-        ILFree( pPidl );
-    pPidl = ILClone( pidl );
-    if( !pPidl )
+    TRACE("(%p)->(pidl=%p)\n", this, pidl);
+
+    if (pPidl)
+        ILFree(pPidl);
+
+    pPidl = ILClone(pidl);
+    if (!pPidl)
         return E_FAIL;
 
     bDirty = TRUE;
@@ -995,14 +973,15 @@
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::GetDescription(LPSTR pszName,INT cchMaxName)
-{
-    TRACE("(%p)->(%p len=%u)\n",this, pszName, cchMaxName);
-
-    if( cchMaxName )
+HRESULT WINAPI CShellLink::GetDescription(LPSTR pszName, INT cchMaxName)
+{
+    TRACE("(%p)->(%p len=%u)\n", this, pszName, cchMaxName);
+
+    if (cchMaxName)
         pszName[0] = 0;
-    if( sDescription )
-        WideCharToMultiByte( CP_ACP, 0, sDescription, -1,
+
+    if (sDescription)
+        WideCharToMultiByte(CP_ACP, 0, sDescription, -1,
                              pszName, cchMaxName, NULL, NULL);
 
     return S_OK;
@@ -1015,9 +994,10 @@
     HeapFree(GetProcessHeap(), 0, sDescription);
     sDescription = NULL;
 
-    if ( pszName ) {
-        sDescription = HEAP_strdupAtoW( GetProcessHeap(), 0, pszName);
-        if ( !sDescription )
+    if (pszName)
+    {
+        sDescription = HEAP_strdupAtoW(GetProcessHeap(), 0, pszName);
+        if (!sDescription)
             return E_OUTOFMEMORY;
     }
     bDirty = TRUE;
@@ -1025,14 +1005,15 @@
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::GetWorkingDirectory(LPSTR pszDir,INT cchMaxPath)
+HRESULT WINAPI CShellLink::GetWorkingDirectory(LPSTR pszDir, INT cchMaxPath)
 {
     TRACE("(%p)->(%p len=%u)\n", this, pszDir, cchMaxPath);
 
-    if( cchMaxPath )
+    if (cchMaxPath)
         pszDir[0] = 0;
-    if( sWorkDir )
-        WideCharToMultiByte( CP_ACP, 0, sWorkDir, -1,
+
+    if (sWorkDir)
+        WideCharToMultiByte(CP_ACP, 0, sWorkDir, -1,
                              pszDir, cchMaxPath, NULL, NULL);
 
     return S_OK;
@@ -1040,14 +1021,15 @@
 
 HRESULT WINAPI CShellLink::SetWorkingDirectory(LPCSTR pszDir)
 {
-    TRACE("(%p)->(dir=%s)\n",this, pszDir);
+    TRACE("(%p)->(dir=%s)\n", this, pszDir);
 
     HeapFree(GetProcessHeap(), 0, sWorkDir);
     sWorkDir = NULL;
 
-    if ( pszDir ) {
-        sWorkDir = HEAP_strdupAtoW( GetProcessHeap(), 0, pszDir);
-        if ( !sWorkDir )
+    if (pszDir)
+    {
+        sWorkDir = HEAP_strdupAtoW(GetProcessHeap(), 0, pszDir);
+        if (!sWorkDir)
             return E_OUTOFMEMORY;
     }
     bDirty = TRUE;
@@ -1055,14 +1037,14 @@
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::GetArguments(LPSTR pszArgs,INT cchMaxPath)
+HRESULT WINAPI CShellLink::GetArguments(LPSTR pszArgs, INT cchMaxPath)
 {
     TRACE("(%p)->(%p len=%u)\n", this, pszArgs, cchMaxPath);
 
-    if( cchMaxPath )
+    if (cchMaxPath)
         pszArgs[0] = 0;
-    if( sArgs )
-        WideCharToMultiByte( CP_ACP, 0, sArgs, -1,
+    if (sArgs)
+        WideCharToMultiByte(CP_ACP, 0, sArgs, -1,
                              pszArgs, cchMaxPath, NULL, NULL);
 
     return S_OK;
@@ -1070,14 +1052,15 @@
 
 HRESULT WINAPI CShellLink::SetArguments(LPCSTR pszArgs)
 {
-    TRACE("(%p)->(args=%s)\n",this, pszArgs);
+    TRACE("(%p)->(args=%s)\n", this, pszArgs);
 
     HeapFree(GetProcessHeap(), 0, sArgs);
     sArgs = NULL;
 
-    if ( pszArgs ) {
-        sArgs = HEAP_strdupAtoW( GetProcessHeap(), 0, pszArgs);
-        if( !sArgs )
+    if (pszArgs)
+    {
+        sArgs = HEAP_strdupAtoW(GetProcessHeap(), 0, pszArgs);
+        if (!sArgs)
             return E_OUTOFMEMORY;
     }
 
@@ -1088,7 +1071,7 @@
 
 HRESULT WINAPI CShellLink::GetHotkey(WORD *pwHotkey)
 {
-    TRACE("(%p)->(%p)(0x%08x)\n",this, pwHotkey, wHotKey);
+    TRACE("(%p)->(%p)(0x%08x)\n", this, pwHotkey, wHotKey);
 
     *pwHotkey = wHotKey;
 
@@ -1097,7 +1080,7 @@
 
 HRESULT WINAPI CShellLink::SetHotkey(WORD wHotkey)
 {
-    TRACE("(%p)->(hotkey=%x)\n",this, wHotkey);
+    TRACE("(%p)->(hotkey=%x)\n", this, wHotkey);
 
     wHotKey = wHotkey;
     bDirty = TRUE;
@@ -1107,14 +1090,14 @@
 
 HRESULT WINAPI CShellLink::GetShowCmd(INT *piShowCmd)
 {
-    TRACE("(%p)->(%p)\n",this, piShowCmd);
+    TRACE("(%p)->(%p)\n", this, piShowCmd);
     *piShowCmd = iShowCmd;
     return S_OK;
 }
 
 HRESULT WINAPI CShellLink::SetShowCmd(INT iShowCmd)
 {
-    TRACE("(%p) %d\n",this, iShowCmd);
+    TRACE("(%p) %d\n", this, iShowCmd);
 
     this->iShowCmd = iShowCmd;
     bDirty = TRUE;
@@ -1123,20 +1106,20 @@
 }
 
 static HRESULT SHELL_PidlGeticonLocationA(IShellFolder* psf, LPCITEMIDLIST pidl,
-                                          LPSTR pszIconPath, int cchIconPath, int*
piIcon)
+        LPSTR pszIconPath, int cchIconPath, int* piIcon)
 {
     LPCITEMIDLIST pidlLast;
 
     HRESULT hr = SHBindToParent(pidl, IID_IShellFolder, (LPVOID*)&psf,
&pidlLast);
 
-    if (SUCCEEDED(hr)) {
-        CComPtr<IExtractIconA>        pei;
+    if (SUCCEEDED(hr))
+    {
+        CComPtr<IExtractIconA> pei;
 
         hr = psf->GetUIObjectOf(0, 1, &pidlLast, IID_IExtractIconA, NULL,
(LPVOID*)&pei);
 
-        if (SUCCEEDED(hr)) {
+        if (SUCCEEDED(hr))
             hr = pei->GetIconLocation(0, pszIconPath, MAX_PATH, piIcon, NULL);
-        }
 
         psf->Release();
     }
@@ -1144,7 +1127,7 @@
     return hr;
 }
 
-HRESULT WINAPI CShellLink::GetIconLocation(LPSTR pszIconPath,INT cchIconPath,INT
*piIcon)
+HRESULT WINAPI CShellLink::GetIconLocation(LPSTR pszIconPath, INT cchIconPath, INT
*piIcon)
 {
     TRACE("(%p)->(%p len=%u iicon=%p)\n", this, pszIconPath, cchIconPath,
piIcon);
 
@@ -1159,7 +1142,7 @@
 
     if (pPidl || sPath)
     {
-        CComPtr<IShellFolder>        pdsk;
+        CComPtr<IShellFolder> pdsk;
 
         HRESULT hr = SHGetDesktopFolder(&pdsk);
 
@@ -1192,17 +1175,17 @@
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::SetIconLocation(LPCSTR pszIconPath,INT iIcon)
-{
-    TRACE("(%p)->(path=%s iicon=%u)\n",this, pszIconPath, iIcon);
+HRESULT WINAPI CShellLink::SetIconLocation(LPCSTR pszIconPath, INT iIcon)
+{
+    TRACE("(%p)->(path=%s iicon=%u)\n", this, pszIconPath, iIcon);
 
     HeapFree(GetProcessHeap(), 0, sIcoPath);
     sIcoPath = NULL;
 
-    if ( pszIconPath )
+    if (pszIconPath)
     {
         sIcoPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath);
-        if ( !sIcoPath )
+        if (!sIcoPath)
             return E_OUTOFMEMORY;
     }
 
@@ -1214,12 +1197,12 @@
 
 HRESULT WINAPI CShellLink::SetRelativePath(LPCSTR pszPathRel, DWORD dwReserved)
 {
-    TRACE("(%p)->(path=%s %x)\n",this, pszPathRel, dwReserved);
+    TRACE("(%p)->(path=%s %x)\n", this, pszPathRel, dwReserved);
 
     HeapFree(GetProcessHeap(), 0, sPathRel);
     sPathRel = NULL;
 
-    if ( pszPathRel )
+    if (pszPathRel)
     {
         sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel);
         bDirty = TRUE;
@@ -1233,7 +1216,7 @@
     HRESULT hr = S_OK;
     BOOL bSuccess;
 
-    TRACE("(%p)->(hwnd=%p flags=%x)\n",this, hwnd, fFlags);
+    TRACE("(%p)->(hwnd=%p flags=%x)\n", this, hwnd, fFlags);
 
     /*FIXME: use IResolveShellLink interface */
 
@@ -1245,8 +1228,8 @@
 
         if (bSuccess && *buffer)
         {
-            sPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
(wcslen(buffer)+1)*sizeof(WCHAR));
-    
+            sPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(buffer) + 1) *
sizeof(WCHAR));
+
             if (!sPath)
                 return E_OUTOFMEMORY;
 
@@ -1260,8 +1243,8 @@
 
     if (!sIcoPath && sPath)
     {
-        sIcoPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
(wcslen(sPath)+1)*sizeof(WCHAR));
-    
+        sIcoPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(sPath) + 1) *
sizeof(WCHAR));
+
         if (!sIcoPath)
             return E_OUTOFMEMORY;
 
@@ -1276,24 +1259,21 @@
 
 HRESULT WINAPI CShellLink::SetPath(LPCSTR pszFile)
 {
-    HRESULT r;
-    LPWSTR str;
-
-    TRACE("(%p)->(path=%s)\n",this, pszFile);
+    TRACE("(%p)->(path=%s)\n", this, pszFile);
     if (pszFile == NULL)
         return E_INVALIDARG;
 
-    str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
+    LPWSTR str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
     if (!str)
         return E_OUTOFMEMORY;
 
-    r = SetPath(str);
-    HeapFree( GetProcessHeap(), 0, str );
-
-    return r;
-}
-
-HRESULT WINAPI CShellLink::GetPath(LPWSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAW *pfd,
DWORD fFlags)
+    HRESULT hr = SetPath(str);
+    HeapFree(GetProcessHeap(), 0, str);
+
+    return hr;
+}
+
+HRESULT WINAPI CShellLink::GetPath(LPWSTR pszFile, INT cchMaxPath, WIN32_FIND_DATAW *pfd,
DWORD fFlags)
 {
     TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n",
           this, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(sPath));
@@ -1305,110 +1285,111 @@
         pszFile[0] = 0;
 
     if (sPath)
-        lstrcpynW( pszFile, sPath, cchMaxPath );
+        lstrcpynW(pszFile, sPath, cchMaxPath);
 
     if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", this);
 
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::GetDescription(LPWSTR pszName,INT cchMaxName)
-{
-    TRACE("(%p)->(%p len=%u)\n",this, pszName, cchMaxName);
+HRESULT WINAPI CShellLink::GetDescription(LPWSTR pszName, INT cchMaxName)
+{
+    TRACE("(%p)->(%p len=%u)\n", this, pszName, cchMaxName);
 
     pszName[0] = 0;
     if (sDescription)
-        lstrcpynW( pszName, sDescription, cchMaxName );
+        lstrcpynW(pszName, sDescription, cchMaxName);
 
     return S_OK;
 }
 
 HRESULT WINAPI CShellLink::SetDescription(LPCWSTR pszName)
 {
-    TRACE("(%p)->(desc=%s)\n",this, debugstr_w(pszName));
+    TRACE("(%p)->(desc=%s)\n", this, debugstr_w(pszName));
 
     HeapFree(GetProcessHeap(), 0, sDescription);
-    sDescription = (LPWSTR)HeapAlloc( GetProcessHeap(), 0,
-                                    (wcslen( pszName )+1)*sizeof(WCHAR) );
-    if ( !sDescription )
+    sDescription = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
+                                     (wcslen(pszName) + 1) * sizeof(WCHAR));
+    if (!sDescription)
         return E_OUTOFMEMORY;
 
-    wcscpy( sDescription, pszName );
+    wcscpy(sDescription, pszName);
     bDirty = TRUE;
 
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::GetWorkingDirectory(LPWSTR pszDir,INT cchMaxPath)
+HRESULT WINAPI CShellLink::GetWorkingDirectory(LPWSTR pszDir, INT cchMaxPath)
 {
     TRACE("(%p)->(%p len %u)\n", this, pszDir, cchMaxPath);
 
-    if( cchMaxPath )
+    if (cchMaxPath)
         pszDir[0] = 0;
-    if( sWorkDir )
-        lstrcpynW( pszDir, sWorkDir, cchMaxPath );
+    if (sWorkDir)
+        lstrcpynW(pszDir, sWorkDir, cchMaxPath);
 
     return S_OK;
 }
 
 HRESULT WINAPI CShellLink::SetWorkingDirectory(LPCWSTR pszDir)
 {
-    TRACE("(%p)->(dir=%s)\n",this, debugstr_w(pszDir));
+    TRACE("(%p)->(dir=%s)\n", this, debugstr_w(pszDir));
 
     HeapFree(GetProcessHeap(), 0, sWorkDir);
-    sWorkDir = (LPWSTR)HeapAlloc( GetProcessHeap(), 0,
-                                (wcslen( pszDir )+1)*sizeof (WCHAR) );
-    if ( !sWorkDir )
+    sWorkDir = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
+                                 (wcslen(pszDir) + 1) * sizeof (WCHAR));
+    if (!sWorkDir)
         return E_OUTOFMEMORY;
-    wcscpy( sWorkDir, pszDir );
+    wcscpy(sWorkDir, pszDir);
     bDirty = TRUE;
 
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::GetArguments(LPWSTR pszArgs,INT cchMaxPath)
+HRESULT WINAPI CShellLink::GetArguments(LPWSTR pszArgs, INT cchMaxPath)
 {
     TRACE("(%p)->(%p len=%u)\n", this, pszArgs, cchMaxPath);
 
-    if( cchMaxPath )
+    if (cchMaxPath)
         pszArgs[0] = 0;
-    if( sArgs )
-        lstrcpynW( pszArgs, sArgs, cchMaxPath );
+    if (sArgs)
+        lstrcpynW(pszArgs, sArgs, cchMaxPath);
 
     return NOERROR;
 }
 
 HRESULT WINAPI CShellLink::SetArguments(LPCWSTR pszArgs)
 {
-    TRACE("(%p)->(args=%s)\n",this, debugstr_w(pszArgs));
+    TRACE("(%p)->(args=%s)\n", this, debugstr_w(pszArgs));
 
     HeapFree(GetProcessHeap(), 0, sArgs);
-    sArgs = (LPWSTR)HeapAlloc( GetProcessHeap(), 0,
-                             (wcslen( pszArgs )+1)*sizeof (WCHAR) );
-    if ( !sArgs )
+    sArgs = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
+                              (wcslen(pszArgs) + 1) * sizeof (WCHAR));
+    if (!sArgs)
         return E_OUTOFMEMORY;
-    wcscpy( sArgs, pszArgs );
+
+    wcscpy(sArgs, pszArgs);
     bDirty = TRUE;
 
     return S_OK;
 }
 
 static HRESULT SHELL_PidlGeticonLocationW(IShellFolder* psf, LPCITEMIDLIST pidl,
-                                          LPWSTR pszIconPath, int cchIconPath, int*
piIcon)
+        LPWSTR pszIconPath, int cchIconPath, int* piIcon)
 {
     LPCITEMIDLIST pidlLast;
     UINT wFlags;
 
     HRESULT hr = SHBindToParent(pidl, IID_IShellFolder, (LPVOID*)&psf,
&pidlLast);
 
-    if (SUCCEEDED(hr)) {
-        CComPtr<IExtractIconW>        pei;
+    if (SUCCEEDED(hr))
+    {
+        CComPtr<IExtractIconW> pei;
 
         hr = psf->GetUIObjectOf(0, 1, &pidlLast, IID_IExtractIconW, NULL,
(LPVOID*)&pei);
 
-        if (SUCCEEDED(hr)) {
+        if (SUCCEEDED(hr))
             hr = pei->GetIconLocation(0, pszIconPath, MAX_PATH, piIcon, &wFlags);
-        }
 
         psf->Release();
     }
@@ -1416,7 +1397,7 @@
     return hr;
 }
 
-HRESULT WINAPI CShellLink::GetIconLocation(LPWSTR pszIconPath,INT cchIconPath,INT
*piIcon)
+HRESULT WINAPI CShellLink::GetIconLocation(LPWSTR pszIconPath, INT cchIconPath, INT
*piIcon)
 {
     TRACE("(%p)->(%p len=%u iicon=%p)\n", this, pszIconPath, cchIconPath,
piIcon);
 
@@ -1463,16 +1444,16 @@
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::SetIconLocation(LPCWSTR pszIconPath,INT iIcon)
-{
-    TRACE("(%p)->(path=%s iicon=%u)\n",this, debugstr_w(pszIconPath),
iIcon);
+HRESULT WINAPI CShellLink::SetIconLocation(LPCWSTR pszIconPath, INT iIcon)
+{
+    TRACE("(%p)->(path=%s iicon=%u)\n", this, debugstr_w(pszIconPath),
iIcon);
 
     HeapFree(GetProcessHeap(), 0, sIcoPath);
-    sIcoPath = (LPWSTR)HeapAlloc( GetProcessHeap(), 0,
-                                (wcslen( pszIconPath )+1)*sizeof (WCHAR) );
-    if ( !sIcoPath )
+    sIcoPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
+                                  (wcslen(pszIconPath) + 1) * sizeof (WCHAR));
+    if (!sIcoPath)
         return E_OUTOFMEMORY;
-    wcscpy( sIcoPath, pszIconPath );
+    wcscpy(sIcoPath, pszIconPath);
 
     iIcoNdx = iIcon;
     bDirty = TRUE;
@@ -1482,14 +1463,14 @@
 
 HRESULT WINAPI CShellLink::SetRelativePath(LPCWSTR pszPathRel, DWORD dwReserved)
 {
-    TRACE("(%p)->(path=%s %x)\n",this, debugstr_w(pszPathRel), dwReserved);
+    TRACE("(%p)->(path=%s %x)\n", this, debugstr_w(pszPathRel),
dwReserved);
 
     HeapFree(GetProcessHeap(), 0, sPathRel);
-    sPathRel = (LPWSTR)HeapAlloc( GetProcessHeap(), 0,
-                                  (wcslen( pszPathRel )+1) * sizeof (WCHAR) );
-    if ( !sPathRel )
+    sPathRel = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
+                                  (wcslen(pszPathRel) + 1) * sizeof (WCHAR));
+    if (!sPathRel)
         return E_OUTOFMEMORY;
-    wcscpy( sPathRel, pszPathRel );
+    wcscpy(sPathRel, pszPathRel);
     bDirty = TRUE;
 
     return ShellLink_UpdatePath(sPathRel, sPath, sWorkDir, &sPath);
@@ -1497,80 +1478,75 @@
 
 LPWSTR CShellLink::ShellLink_GetAdvertisedArg(LPCWSTR str)
 {
-    LPWSTR ret;
-    LPCWSTR p;
-    DWORD len;
-
-    if( !str )
+    if (!str)
         return NULL;
 
-    p = wcschr( str, ':' );
-    if( !p )
+    LPCWSTR p = wcschr(str, L':');
+    if (!p)
         return NULL;
-    len = p - str;
-    ret = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR)*(len+1));
-    if( !ret )
+    DWORD len = p - str;
+    LPWSTR ret = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (len + 1));
+    if (!ret)
         return ret;
-    memcpy( ret, str, sizeof(WCHAR)*len );
+    memcpy(ret, str, sizeof(WCHAR)*len);
     ret[len] = 0;
     return ret;
 }
 
 HRESULT CShellLink::ShellLink_SetAdvertiseInfo(LPCWSTR str)
 {
-    LPCWSTR szComponent = NULL, szProduct = NULL, p;
-    WCHAR szGuid[39];
-    HRESULT r;
-    GUID guid;
-    int len;
-
-    while( str[0] )
+    LPCWSTR szComponent = NULL, szProduct = NULL;
+
+    while (str[0])
     {
         /* each segment must start with two colons */
-        if( str[0] != ':' || str[1] != ':' )
+        if (str[0] != ':' || str[1] != ':')
             return E_FAIL;
 
         /* the last segment is just two colons */
-        if( !str[2] )
+        if (!str[2])
             break;
         str += 2;
 
         /* there must be a colon straight after a guid */
-        p = wcschr( str, ':' );
-        if( !p )
+        LPCWSTR p = wcschr(str, L':');
+        if (!p)
             return E_FAIL;
-        len = p - str;
-        if( len != 38 )
+        INT len = p - str;
+        if (len != 38)
             return E_FAIL;
 
         /* get the guid, and check it's validly formatted */
-        memcpy( szGuid, str, sizeof(WCHAR)*len );
+        WCHAR szGuid[39];
+        memcpy(szGuid, str, sizeof(WCHAR)*len);
         szGuid[len] = 0;
-        r = CLSIDFromString( szGuid, &guid );
-        if( r != S_OK )
-            return r;
+
+        GUID guid;
+        HRESULT hr = CLSIDFromString(szGuid, &guid);
+        if (hr != S_OK)
+            return hr;
         str = p + 1;
 
         /* match it up to a guid that we care about */
-        if( IsEqualGUID( guid, SHELL32_AdvtShortcutComponent ) && !szComponent )
+        if (IsEqualGUID(guid, SHELL32_AdvtShortcutComponent) && !szComponent)
             szComponent = str;
-        else if( IsEqualGUID(guid, SHELL32_AdvtShortcutProduct ) && !szProduct )
+        else if (IsEqualGUID(guid, SHELL32_AdvtShortcutProduct) && !szProduct)
             szProduct = str;
         else
             return E_FAIL;
 
         /* skip to the next field */
-        str = wcschr( str, ':' );
-        if( !str )
+        str = wcschr(str, L':');
+        if (!str)
             return E_FAIL;
     }
 
     /* we have to have a component for an advertised shortcut */
-    if( !szComponent )
+    if (!szComponent)
         return E_FAIL;
 
-    sComponent = ShellLink_GetAdvertisedArg( szComponent );
-    sProduct = ShellLink_GetAdvertisedArg( szProduct );
+    sComponent = ShellLink_GetAdvertisedArg(szComponent);
+    sProduct = ShellLink_GetAdvertisedArg(szProduct);
 
     TRACE("Component = %s\n", debugstr_w(sComponent));
     TRACE("Product = %s\n", debugstr_w(sProduct));
@@ -1580,30 +1556,27 @@
 
 static BOOL ShellLink_GetVolumeInfo(LPCWSTR path, CShellLink::volume_info *volume)
 {
-    const int label_sz = sizeof volume->label/sizeof volume->label[0];
     WCHAR drive[4] = { path[0], ':', '\\', 0 };
-    BOOL r;
 
     volume->type = GetDriveTypeW(drive);
-    r = GetVolumeInformationW(drive, volume->label, label_sz, &volume->serial,
NULL, NULL, NULL, 0);
-    TRACE("r = %d type %d serial %08x name %s\n", r,
+    BOOL bRet = GetVolumeInformationW(drive, volume->label,
_countof(volume->label), &volume->serial, NULL, NULL, NULL, 0);
+    TRACE("ret = %d type %d serial %08x name %s\n", bRet,
           volume->type, volume->serial, debugstr_w(volume->label));
-    return r;
+    return bRet;
 }
 
 HRESULT WINAPI CShellLink::SetPath(LPCWSTR pszFile)
 {
-    WCHAR buffer[MAX_PATH];
-    LPWSTR fname, unquoted = NULL;
+    LPWSTR unquoted = NULL;
     HRESULT hr = S_OK;
-    UINT len;
-
-    TRACE("(%p)->(path=%s)\n",this, debugstr_w(pszFile));
-
-    if (!pszFile) return E_INVALIDARG;
+
+    TRACE("(%p)->(path=%s)\n", this, debugstr_w(pszFile));
+
+    if (!pszFile)
+        return E_INVALIDARG;
 
     /* quotes at the ends of the string are stripped */
-    len = wcslen(pszFile);
+    UINT len = wcslen(pszFile);
     if (pszFile[0] == '"' && pszFile[len-1] == '"')
     {
         unquoted = strdupW(pszFile);
@@ -1628,52 +1601,56 @@
         ILFree(pPidl);
     pPidl = NULL;
 
-    if (S_OK != ShellLink_SetAdvertiseInfo(pszFile ))
-    {
+    if (S_OK != ShellLink_SetAdvertiseInfo(pszFile))
+    {
+        WCHAR buffer[MAX_PATH];
+        LPWSTR fname;
+
         if (*pszFile == '\0')
             *buffer = '\0';
         else if (!GetFullPathNameW(pszFile, MAX_PATH, buffer, &fname))
             return E_FAIL;
         else if(!PathFileExistsW(buffer) &&
-        !SearchPathW(NULL, pszFile, NULL, MAX_PATH, buffer, NULL))
+                !SearchPathW(NULL, pszFile, NULL, MAX_PATH, buffer, NULL))
             hr = S_FALSE;
 
         pPidl = SHSimpleIDListFromPathW(pszFile);
         ShellLink_GetVolumeInfo(buffer, &volume);
 
-        sPath = (LPWSTR)HeapAlloc( GetProcessHeap(), 0,
-                             (wcslen( buffer )+1) * sizeof (WCHAR) );
+        sPath = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
+                                  (wcslen(buffer) + 1) * sizeof (WCHAR));
         if (!sPath)
             return E_OUTOFMEMORY;
 
         wcscpy(sPath, buffer);
     }
+
     bDirty = TRUE;
     HeapFree(GetProcessHeap(), 0, unquoted);
 
     return hr;
 }
 
-HRESULT WINAPI CShellLink::AddDataBlock(void* pDataBlock )
+HRESULT WINAPI CShellLink::AddDataBlock(void* pDataBlock)
 {
     FIXME("\n");
     return E_NOTIMPL;
 }
 
-HRESULT WINAPI CShellLink::CopyDataBlock(DWORD dwSig, void** ppDataBlock )
+HRESULT WINAPI CShellLink::CopyDataBlock(DWORD dwSig, void** ppDataBlock)
 {
     LPVOID block = NULL;
-    HRESULT r = E_FAIL;
-
-    TRACE("%p %08x %p\n", this, dwSig, ppDataBlock );
+    HRESULT hr = E_FAIL;
+
+    TRACE("%p %08x %p\n", this, dwSig, ppDataBlock);
 
     switch (dwSig)
     {
         case EXP_DARWIN_ID_SIG:
             if (!sComponent)
                 break;
-            block = shelllink_build_darwinid( sComponent, dwSig );
-            r = S_OK;
+            block = shelllink_build_darwinid(sComponent, dwSig);
+            hr = S_OK;
             break;
         case EXP_SZ_LINK_SIG:
         case NT_CONSOLE_PROPS_SIG:
@@ -1686,20 +1663,20 @@
             ERR("unknown datablock %08x\n", dwSig);
     }
     *ppDataBlock = block;
-    return r;
-}
-
-HRESULT WINAPI CShellLink::RemoveDataBlock(DWORD dwSig )
+    return hr;
+}
+
+HRESULT WINAPI CShellLink::RemoveDataBlock(DWORD dwSig)
 {
     FIXME("\n");
     return E_NOTIMPL;
 }
 
-HRESULT WINAPI CShellLink::GetFlags(DWORD* pdwFlags )
+HRESULT WINAPI CShellLink::GetFlags(DWORD *pdwFlags)
 {
     DWORD flags = 0;
 
-    FIXME("%p %p\n", this, pdwFlags );
+    FIXME("%p %p\n", this, pdwFlags);
 
     /* FIXME: add more */
     if (sArgs)
@@ -1720,7 +1697,7 @@
     return S_OK;
 }
 
-HRESULT WINAPI CShellLink::SetFlags(DWORD dwFlags )
+HRESULT WINAPI CShellLink::SetFlags(DWORD dwFlags)
 {
     FIXME("\n");
     return E_NOTIMPL;
@@ -1731,63 +1708,59 @@
  *
  * Loads the shelllink from the dataobject the shell is pointing to.
  */
-HRESULT WINAPI CShellLink::Initialize(LPCITEMIDLIST pidlFolder, IDataObject *pdtobj, HKEY
hkeyProgID )
-{
+HRESULT WINAPI CShellLink::Initialize(LPCITEMIDLIST pidlFolder, IDataObject *pdtobj, HKEY
hkeyProgID)
+{
+    TRACE("%p %p %p %p\n", this, pidlFolder, pdtobj, hkeyProgID);
+
+    if (!pdtobj)
+        return E_FAIL;
+
     FORMATETC format;
-    STGMEDIUM stgm;
-    UINT count;
-    HRESULT r = E_FAIL;
-
-    TRACE("%p %p %p %p\n", this, pidlFolder, pdtobj, hkeyProgID );
-
-    if( !pdtobj )
-        return r;
-
     format.cfFormat = CF_HDROP;
     format.ptd = NULL;
     format.dwAspect = DVASPECT_CONTENT;
     format.lindex = -1;
     format.tymed = TYMED_HGLOBAL;
 
-    if( FAILED(pdtobj->GetData(&format, &stgm ) ) )
-        return r;
-
-    count = DragQueryFileW((HDROP)stgm.hGlobal, -1, NULL, 0 );
-    if( count == 1 )
-    {
-        LPWSTR path;
-
-        count = DragQueryFileW((HDROP)stgm.hGlobal, 0, NULL, 0 );
+    STGMEDIUM stgm;
+    HRESULT hr = pdtobj->GetData(&format, &stgm);
+    if (FAILED(hr))
+        return hr;
+
+    UINT count = DragQueryFileW((HDROP)stgm.hGlobal, -1, NULL, 0);
+    if (count == 1)
+    {
+        count = DragQueryFileW((HDROP)stgm.hGlobal, 0, NULL, 0);
         count++;
-        path = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, count*sizeof(WCHAR) );
-        if( path )
+        LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR));
+        if (path)
         {
-            count = DragQueryFileW((HDROP)stgm.hGlobal, 0, path, count );
-            r = Load(path, 0 );
-            HeapFree(GetProcessHeap(), 0, path );
+            count = DragQueryFileW((HDROP)stgm.hGlobal, 0, path, count);
+            hr = Load(path, 0);
+            HeapFree(GetProcessHeap(), 0, path);
         }
     }
-    ReleaseStgMedium(&stgm );
-
-    return r;
+    ReleaseStgMedium(&stgm);
+
+    return S_OK;
 }
 
 HRESULT WINAPI CShellLink::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst,
UINT idCmdLast, UINT uFlags)
 {
-    WCHAR wszOpen[20];
-    MENUITEMINFOW mii;
     int id = 1;
 
     TRACE("%p %p %u %u %u %u\n", this,
-          hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
+          hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
 
     if (!hMenu)
         return E_INVALIDARG;
 
-    if (!LoadStringW(shell32_hInstance, IDS_OPEN_VERB, wszOpen,
sizeof(wszOpen)/sizeof(WCHAR)))
+    WCHAR wszOpen[20];
+    if (!LoadStringW(shell32_hInstance, IDS_OPEN_VERB, wszOpen, _countof(wszOpen)))
         wszOpen[0] = L'\0';
 
-    memset( &mii, 0, sizeof(mii) );
+    MENUITEMINFOW mii;
+    memset(&mii, 0, sizeof(mii));
     mii.cbSize = sizeof (mii);
     mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
     mii.dwTypeData = wszOpen;
@@ -1803,79 +1776,73 @@
 }
 
 static LPWSTR
-shelllink_get_msi_component_path( LPWSTR component )
-{
-    LPWSTR path;
-    DWORD r, sz = 0;
-
-    r = CommandLineFromMsiDescriptor( component, NULL, &sz );
-    if (r != ERROR_SUCCESS)
-         return NULL;
+shelllink_get_msi_component_path(LPWSTR component)
+{
+    DWORD Result, sz = 0;
+
+    Result = CommandLineFromMsiDescriptor(component, NULL, &sz);
+    if (Result != ERROR_SUCCESS)
+        return NULL;
 
     sz++;
-    path = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
-    r = CommandLineFromMsiDescriptor( component, path, &sz );
-    if (r != ERROR_SUCCESS)
-    {
-        HeapFree( GetProcessHeap(), 0, path );
+    LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR));
+    Result = CommandLineFromMsiDescriptor(component, path, &sz);
+    if (Result != ERROR_SUCCESS)
+    {
+        HeapFree(GetProcessHeap(), 0, path);
         path = NULL;
     }
 
-    TRACE("returning %s\n", debugstr_w( path ) );
+    TRACE("returning %s\n", debugstr_w(path));
 
     return path;
 }
 
 HRESULT WINAPI CShellLink::InvokeCommand(LPCMINVOKECOMMANDINFO lpici)
 {
-    static const WCHAR szOpen[] = { 'o','p','e','n',0 };
-    static const WCHAR szCplOpen[] = {
'c','p','l','o','p','e','n',0 };
-    SHELLEXECUTEINFOW sei;
     HWND hwnd = NULL; /* FIXME: get using interface set from IObjectWithSite */
     LPWSTR args = NULL;
     LPWSTR path = NULL;
-    HRESULT r;
-
-    TRACE("%p %p\n", this, lpici );
-
-    if ( lpici->cbSize < sizeof (CMINVOKECOMMANDINFO) )
+
+    TRACE("%p %p\n", this, lpici);
+
+    if (lpici->cbSize < sizeof (CMINVOKECOMMANDINFO))
         return E_INVALIDARG;
 
-    r = Resolve(hwnd, 0 );
-    if ( FAILED( r ) )
-    {
-        TRACE("failed to resolve component with error 0x%08x", r);
-        return r;
-    }
-    if ( sComponent )
-    {
-        path = shelllink_get_msi_component_path( sComponent );
+    HRESULT hr = Resolve(hwnd, 0);
+    if (FAILED(hr))
+    {
+        TRACE("failed to resolve component with error 0x%08x", hr);
+        return hr;
+    }
+    if (sComponent)
+    {
+        path = shelllink_get_msi_component_path(sComponent);
         if (!path)
             return E_FAIL;
     }
     else
-        path = strdupW( sPath );
-
-    if ( lpici->cbSize == sizeof (CMINVOKECOMMANDINFOEX) &&
-         ( lpici->fMask & CMIC_MASK_UNICODE ) )
+        path = strdupW(sPath);
+
+    if (lpici->cbSize == sizeof (CMINVOKECOMMANDINFOEX) &&
+            (lpici->fMask & CMIC_MASK_UNICODE))
     {
         LPCMINVOKECOMMANDINFOEX iciex = (LPCMINVOKECOMMANDINFOEX) lpici;
         DWORD len = 2;
 
-        if ( sArgs )
-            len += wcslen( sArgs );
-        if ( iciex->lpParametersW )
-            len += wcslen( iciex->lpParametersW );
-
-        args = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
+        if (sArgs)
+            len += wcslen(sArgs);
+        if (iciex->lpParametersW)
+            len += wcslen(iciex->lpParametersW);
+
+        args = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
         args[0] = 0;
-        if ( sArgs )
-            wcscat( args, sArgs );
-        if ( iciex->lpParametersW )
+        if (sArgs)
+            wcscat(args, sArgs);
+        if (iciex->lpParametersW)
         {
-            static const WCHAR space[] = { ' ', 0 };
-            wcscat( args, space );
-            wcscat( args, iciex->lpParametersW );
+            wcscat(args, L" ");
+            wcscat(args, iciex->lpParametersW);
         }
     }
     else if (sArgs != NULL)
@@ -1883,35 +1850,34 @@
         args = strdupW(sArgs);
     }
 
-    memset( &sei, 0, sizeof sei );
+    SHELLEXECUTEINFOW sei;
+    memset(&sei, 0, sizeof sei);
     sei.cbSize = sizeof sei;
-    sei.fMask = SEE_MASK_UNICODE | (lpici->fMask &
(SEE_MASK_NOASYNC|SEE_MASK_ASYNCOK|SEE_MASK_FLAG_NO_UI));
+    sei.fMask = SEE_MASK_UNICODE | (lpici->fMask & (SEE_MASK_NOASYNC |
SEE_MASK_ASYNCOK | SEE_MASK_FLAG_NO_UI));
     sei.lpFile = path;
     sei.nShow = iShowCmd;
     sei.lpDirectory = sWorkDir;
     sei.lpParameters = args;
-    sei.lpVerb = szOpen;
+    sei.lpVerb = L"open";
 
     // HACK for ShellExecuteExW
-    if (!wcsstr(sPath, L".cpl"))
-        sei.lpVerb = szOpen;
+    if (wcsstr(sPath, L".cpl"))
+        sei.lpVerb = L"cplopen";
+
+    if (ShellExecuteExW(&sei))
+        hr = S_OK;
     else
-        sei.lpVerb = szCplOpen;
-
-    if( ShellExecuteExW( &sei ) )
-        r = S_OK;
-    else
-        r = E_FAIL;
-
-    HeapFree( GetProcessHeap(), 0, args );
-    HeapFree( GetProcessHeap(), 0, path );
-
-    return r;
+        hr = E_FAIL;
+
+    HeapFree(GetProcessHeap(), 0, args);
+    HeapFree(GetProcessHeap(), 0, path);
+
+    return hr;
 }
 
 HRESULT WINAPI CShellLink::GetCommandString(UINT_PTR idCmd, UINT uType, UINT* pwReserved,
LPSTR pszName, UINT cchMax)
 {
-    FIXME("%p %lu %u %p %p %u\n", this, idCmd, uType, pwReserved, pszName,
cchMax );
+    FIXME("%p %lu %u %p %p %u\n", this, idCmd, uType, pwReserved, pszName,
cchMax);
 
     return E_NOTIMPL;
 }
@@ -1919,22 +1885,21 @@
 INT_PTR CALLBACK ExtendedShortcutProc(HWND hwndDlg, UINT uMsg,
                                       WPARAM wParam, LPARAM lParam)
 {
-    HWND hDlgCtrl;
-
     switch(uMsg)
     {
         case WM_INITDIALOG:
             if (lParam)
             {
-                hDlgCtrl = GetDlgItem(hwndDlg, 14000);
+                HWND hDlgCtrl = GetDlgItem(hwndDlg, 14000);
                 SendMessage(hDlgCtrl, BM_SETCHECK, BST_CHECKED, 0);
             }
             return TRUE;
         case WM_COMMAND:
-            hDlgCtrl = GetDlgItem(hwndDlg, 14000);
+        {
+            HWND hDlgCtrl = GetDlgItem(hwndDlg, 14000);
             if (LOWORD(wParam) == IDOK)
             {
-                if ( SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED )
+                if (SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED)
                     EndDialog(hwndDlg, 1);
                 else
                     EndDialog(hwndDlg, 0);
@@ -1945,11 +1910,12 @@
             }
             else if (LOWORD(wParam) == 14000)
             {
-                if ( SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED)
+                if (SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED)
                     SendMessage(hDlgCtrl, BM_SETCHECK, BST_UNCHECKED, 0);
                 else
                     SendMessage(hDlgCtrl, BM_SETCHECK, BST_CHECKED, 0);
             }
+        }
     }
     return FALSE;
 }
@@ -1972,13 +1938,27 @@
             if (ppsp == NULL)
                 break;
 
-            TRACE("ShellLink_DlgProc (WM_INITDIALOG hwnd %p lParam %p ppsplParam
%x)\n",hwndDlg, lParam, ppsp->lParam);
+            TRACE("ShellLink_DlgProc (WM_INITDIALOG hwnd %p lParam %p ppsplParam
%x)\n", hwndDlg, lParam, ppsp->lParam);
 
             pThis = (CShellLink *)ppsp->lParam;
             SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pThis);
 
             TRACE("sArgs: %S sComponent: %S sDescription: %S sIcoPath: %S sPath: %S
sPathRel: %S sProduct: %S sWorkDir: %S\n", pThis->sArgs, pThis->sComponent,
pThis->sDescription,
-                pThis->sIcoPath, pThis->sPath, pThis->sPathRel,
pThis->sProduct, pThis->sWorkDir);
+                  pThis->sIcoPath, pThis->sPath, pThis->sPathRel,
pThis->sProduct, pThis->sWorkDir);
+
+            /* Get file information */
+            SHFILEINFO fi;
+            if (!SHGetFileInfoW(pThis->sLinkPath, 0, &fi, sizeof(fi),
SHGFI_TYPENAME|SHGFI_ICON))
+            {
+                ERR("SHGetFileInfoW failed for %ls (%lu)\n",
pThis->sLinkPath, GetLastError());
+                fi.szTypeName[0] = L'\0';
+                fi.hIcon = NULL;
+            }
+
+            if (fi.hIcon) // TODO: destroy icon
+                SendDlgItemMessageW(hwndDlg, 14000, STM_SETICON, (WPARAM)fi.hIcon, 0);
+            else
+                ERR("ExtractIconW failed %ls %u\n", pThis->sIcoPath,
pThis->iIcoNdx);
 
             /* target location */
             if (pThis->sWorkDir)
@@ -2060,7 +2040,7 @@
                     }
                     return TRUE;
                 }
-                    
+
                 case 14022:
                 {
                     INT_PTR result = DialogBoxParamW(shell32_hInstance,
MAKEINTRESOURCEW(SHELL_EXTENDED_SHORTCUT_DLG), hwndDlg, ExtendedShortcutProc,
(LPARAM)pThis->bRunAs);
@@ -2076,12 +2056,8 @@
                     return TRUE;
                 }
             }
-            switch(HIWORD(wParam))
-            {
-                case EN_CHANGE:
+            if(HIWORD(wParam) == EN_CHANGE)
                 PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
-                break;
-            }
             break;
         default:
             break;
@@ -2095,21 +2071,17 @@
 
 HRESULT WINAPI CShellLink::AddPages(LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
 {
-    HPROPSHEETPAGE hPage;
-    BOOL bRet;
-
-    hPage = SH_CreatePropertySheetPage("SHELL_GENERAL_SHORTCUT_DLG",
SH_ShellLinkDlgProc, (LPARAM)this, NULL);
+    HPROPSHEETPAGE hPage =
SH_CreatePropertySheetPage("SHELL_GENERAL_SHORTCUT_DLG", SH_ShellLinkDlgProc,
(LPARAM)this, NULL);
     if (hPage == NULL)
     {
-       ERR("failed to create property sheet page\n");
-       return E_FAIL;
-    }
-
-    bRet = pfnAddPage(hPage, lParam);
-    if (bRet)
-       return S_OK;
-    else
-       return E_FAIL;
+        ERR("failed to create property sheet page\n");
+        return E_FAIL;
+    }
+
+    if (!pfnAddPage(hPage, lParam))
+        return E_FAIL;
+
+    return S_OK;
 }
 
 HRESULT WINAPI CShellLink::ReplacePage(UINT uPageID, LPFNADDPROPSHEETPAGE pfnReplacePage,
LPARAM lParam)
@@ -2129,11 +2101,12 @@
 
 HRESULT WINAPI CShellLink::GetSite(REFIID iid, void ** ppvSite)
 {
-    TRACE("%p %s %p\n", this, debugstr_guid(&iid), ppvSite );
+    TRACE("%p %s %p\n", this, debugstr_guid(&iid), ppvSite);
 
     if (site == NULL)
         return E_FAIL;
-    return site->QueryInterface(iid, ppvSite );
+
+    return site->QueryInterface(iid, ppvSite);
 }
 
 /**************************************************************************
@@ -2141,13 +2114,13 @@
  */
 HRESULT WINAPI IShellLink_ConstructFromFile(IUnknown *pUnkOuter, REFIID riid,
LPCITEMIDLIST pidl, LPVOID *ppv)
 {
-    CComPtr<IUnknown>                psl;
+    CComPtr<IUnknown> psl;
 
     HRESULT hr = CShellLink::_CreatorClass::CreateInstance(NULL, riid,
(void**)&psl);
 
     if (SUCCEEDED(hr))
     {
-        CComPtr<IPersistFile>        ppf;
+        CComPtr<IPersistFile> ppf;
 
         *ppv = NULL;