SHELL32: remove tabs and make formatting consistent

Mike McCormack mike at codeweavers.com
Sun Feb 20 21:36:11 CST 2005


ChangeLog:
* remove tabs and make formatting consistent
-------------- next part --------------
Index: dlls/shell32/pidl.c
===================================================================
RCS file: /home/wine/wine/dlls/shell32/pidl.c,v
retrieving revision 1.125
diff -u -p -r1.125 pidl.c
--- dlls/shell32/pidl.c	10 Feb 2005 19:19:35 -0000	1.125
+++ dlls/shell32/pidl.c	21 Feb 2005 03:35:01 -0000
@@ -1,7 +1,7 @@
 /*
- *	pidl Handling
+ *    pidl Handling
  *
- *	Copyright 1998	Juergen Schmied
+ *    Copyright 1998    Juergen Schmied
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -57,7 +57,7 @@ extern LPVOID WINAPI Alloc(INT);
 extern BOOL WINAPI Free(LPVOID);
 
 /*************************************************************************
- * ILGetDisplayNameEx		[SHELL32.186]
+ * ILGetDisplayNameEx        [SHELL32.186]
  *
  * Retrieves the display name of an ItemIDList
  *
@@ -75,106 +75,108 @@ extern BOOL WINAPI Free(LPVOID);
  */
 BOOL WINAPI ILGetDisplayNameExA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPSTR path, DWORD type)
 {
-	BOOL ret = FALSE;
-	WCHAR wPath[MAX_PATH];
+    BOOL ret = FALSE;
+    WCHAR wPath[MAX_PATH];
 
-	TRACE("%p %p %p %ld\n", psf, pidl, path, type);
+    TRACE("%p %p %p %ld\n", psf, pidl, path, type);
 
-	if (!pidl || !path)
-	  return FALSE;
+    if (!pidl || !path)
+        return FALSE;
 
-	ret = ILGetDisplayNameExW(psf, pidl, wPath, type);
-	WideCharToMultiByte(CP_ACP, 0, wPath, -1, path, MAX_PATH, NULL, NULL);
-	TRACE("%p %p %s\n", psf, pidl, debugstr_a(path));
+    ret = ILGetDisplayNameExW(psf, pidl, wPath, type);
+    WideCharToMultiByte(CP_ACP, 0, wPath, -1, path, MAX_PATH, NULL, NULL);
+    TRACE("%p %p %s\n", psf, pidl, debugstr_a(path));
 
-	return ret;
+    return ret;
 }
 
 BOOL WINAPI ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
 {
-	LPSHELLFOLDER psfParent, lsf = psf;
-	HRESULT ret = NO_ERROR;
-	LPCITEMIDLIST pidllast;
-	STRRET strret;
-	DWORD flag;
-
-	TRACE("%p %p %p %ld\n", psf, pidl, path, type);
-
-	if (!pidl || !path)
-	  return FALSE;
-
-	if (!lsf)
-	{
-	  ret = SHGetDesktopFolder(&lsf);
-	  if (FAILED(ret))
-	    return FALSE;
-	}
-
-	if (type >= 0 && type <= 2)
-	{
-	  switch (type)
-	  {
-	    case ILGDN_FORPARSING:
-	      flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
-	      break;
-	    case ILGDN_NORMAL:
-	      flag = SHGDN_NORMAL;
-	      break;
-	    case ILGDN_INFOLDER:
-	      flag = SHGDN_INFOLDER;
-	      break;
-	    default:
-	      FIXME("Unknown type parameter = %lx\n", type);
-	      flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
-	      break;
-	  }
-	  if (!*(const WORD*)pidl || type == ILGDN_FORPARSING)
-	  {
-	    ret = IShellFolder_GetDisplayNameOf(lsf, pidl, flag, &strret);
-	    if (SUCCEEDED(ret))
-	    {
-	      ret = StrRetToStrNW(path, MAX_PATH, &strret, pidl);
-	    }
-	  }
-	  else
-	  {
-	    ret = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psfParent, &pidllast);
-	    if (SUCCEEDED(ret))
-	    {
-	      ret = IShellFolder_GetDisplayNameOf(psfParent, pidllast, flag, &strret);
-	      if (SUCCEEDED(ret))
-	      {
-	        ret = StrRetToStrNW(path, MAX_PATH, &strret, pidllast);
-	      }
-	      IShellFolder_Release(psfParent);
-	    }
-	  }
-	}
-
-	TRACE("%p %p %s\n", psf, pidl, debugstr_w(path));
-
-	if (!psf)
-	  IShellFolder_Release(lsf);
-	return SUCCEEDED(ret);
+    LPSHELLFOLDER psfParent, lsf = psf;
+    HRESULT ret = NO_ERROR;
+    LPCITEMIDLIST pidllast;
+    STRRET strret;
+    DWORD flag;
+
+    TRACE("%p %p %p %ld\n", psf, pidl, path, type);
+
+    if (!pidl || !path)
+        return FALSE;
+
+    if (!lsf)
+    {
+        ret = SHGetDesktopFolder(&lsf);
+        if (FAILED(ret))
+            return FALSE;
+    }
+
+    if (type >= 0 && type <= 2)
+    {
+        switch (type)
+        {
+        case ILGDN_FORPARSING:
+            flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
+            break;
+        case ILGDN_NORMAL:
+            flag = SHGDN_NORMAL;
+            break;
+        case ILGDN_INFOLDER:
+            flag = SHGDN_INFOLDER;
+            break;
+        default:
+            FIXME("Unknown type parameter = %lx\n", type);
+            flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
+            break;
+        }
+        if (!*(const WORD*)pidl || type == ILGDN_FORPARSING)
+        {
+            ret = IShellFolder_GetDisplayNameOf(lsf, pidl, flag, &strret);
+            if (SUCCEEDED(ret))
+            {
+                ret = StrRetToStrNW(path, MAX_PATH, &strret, pidl);
+            }
+        }
+        else
+        {
+            ret = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psfParent, &pidllast);
+            if (SUCCEEDED(ret))
+            {
+                ret = IShellFolder_GetDisplayNameOf(psfParent, pidllast, flag, &strret);
+                if (SUCCEEDED(ret))
+                {
+                    ret = StrRetToStrNW(path, MAX_PATH, &strret, pidllast);
+                }
+                IShellFolder_Release(psfParent);
+            }
+        }
+    }
+
+    TRACE("%p %p %s\n", psf, pidl, debugstr_w(path));
+
+    if (!psf)
+        IShellFolder_Release(lsf);
+    return SUCCEEDED(ret);
 }
 
 BOOL WINAPI ILGetDisplayNameEx(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPVOID path, DWORD type)
 {
-	TRACE_(shell)("%p %p %p %ld\n", psf, pidl, path, type);
-	if (SHELL_OsIsUnicode())
-	  return ILGetDisplayNameExW(psf, pidl, path, type);
-	return ILGetDisplayNameExA(psf, pidl, path, type);
+    TRACE_(shell)("%p %p %p %ld\n", psf, pidl, path, type);
+
+    if (SHELL_OsIsUnicode())
+        return ILGetDisplayNameExW(psf, pidl, path, type);
+    return ILGetDisplayNameExA(psf, pidl, path, type);
 }
 
 /*************************************************************************
- * ILGetDisplayName			[SHELL32.15]
+ * ILGetDisplayName            [SHELL32.15]
  */
 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl, LPVOID path)
 {
-	TRACE_(shell)("%p %p\n", pidl, path);
-	if (SHELL_OsIsUnicode())
-	  return ILGetDisplayNameExW(NULL, pidl, path, ILGDN_FORPARSING);
-	return ILGetDisplayNameExA(NULL, pidl, path, ILGDN_FORPARSING);
+    TRACE_(shell)("%p %p\n", pidl, path);
+
+    if (SHELL_OsIsUnicode())
+        return ILGetDisplayNameExW(NULL, pidl, path, ILGDN_FORPARSING);
+    return ILGetDisplayNameExA(NULL, pidl, path, ILGDN_FORPARSING);
 }
 
 /*************************************************************************
@@ -185,20 +187,21 @@ BOOL WINAPI ILGetDisplayName(LPCITEMIDLI
  */
 LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
 {
-	LPCITEMIDLIST   pidlLast = pidl;
+    LPCITEMIDLIST   pidlLast = pidl;
 
-	TRACE("(pidl=%p)\n",pidl);
+    TRACE("(pidl=%p)\n",pidl);
 
-	if (!pidl)
-	  return NULL;
+    if (!pidl)
+        return NULL;
 
-	while (pidl->mkid.cb)
-	{
-	  pidlLast = pidl;
-	  pidl = ILGetNext(pidl);
-	}
-	return (LPITEMIDLIST)pidlLast;
+    while (pidl->mkid.cb)
+    {
+        pidlLast = pidl;
+        pidl = ILGetNext(pidl);
+    }
+    return (LPITEMIDLIST)pidlLast;
 }
+
 /*************************************************************************
  * ILRemoveLastID [SHELL32.17]
  *
@@ -207,12 +210,12 @@ LPITEMIDLIST WINAPI ILFindLastID(LPCITEM
  */
 BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
 {
-	TRACE_(shell)("pidl=%p\n",pidl);
+    TRACE_(shell)("pidl=%p\n",pidl);
 
-	if (!pidl || !pidl->mkid.cb)
-	  return 0;
-	ILFindLastID(pidl)->mkid.cb = 0;
-	return 1;
+    if (!pidl || !pidl->mkid.cb)
+        return 0;
+    ILFindLastID(pidl)->mkid.cb = 0;
+    return 1;
 }
 
 /*************************************************************************
@@ -222,22 +225,24 @@ BOOL WINAPI ILRemoveLastID(LPITEMIDLIST 
  *    duplicate an idlist
  */
 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
-{ DWORD    len;
-  LPITEMIDLIST  newpidl;
+{
+    DWORD    len;
+    LPITEMIDLIST  newpidl;
 
-  if (!pidl)
-    return NULL;
+    if (!pidl)
+        return NULL;
 
-  len = ILGetSize(pidl);
-  newpidl = (LPITEMIDLIST)SHAlloc(len);
-  if (newpidl)
-    memcpy(newpidl,pidl,len);
+    len = ILGetSize(pidl);
+    newpidl = (LPITEMIDLIST)SHAlloc(len);
+    if (newpidl)
+        memcpy(newpidl,pidl,len);
 
-  TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
-  pdump(pidl);
+    TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
+    pdump(pidl);
 
-  return newpidl;
+    return newpidl;
 }
+
 /*************************************************************************
  * ILCloneFirst [SHELL32.19]
  *
@@ -245,27 +250,28 @@ LPITEMIDLIST WINAPI ILClone (LPCITEMIDLI
  *  duplicates the first idlist of a complex pidl
  */
 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
-{	DWORD len;
-	LPITEMIDLIST pidlNew = NULL;
+{
+    DWORD len;
+    LPITEMIDLIST pidlNew = NULL;
+
+    TRACE("pidl=%p \n",pidl);
+    pdump(pidl);
 
-	TRACE("pidl=%p \n",pidl);
-	pdump(pidl);
+    if (pidl)
+    {
+        len = pidl->mkid.cb;
+        pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
+        if (pidlNew)
+        {
+            memcpy(pidlNew,pidl,len+2);        /* 2 -> mind a desktop pidl */
 
-	if (pidl)
-	{
-	  len = pidl->mkid.cb;
-	  pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
-	  if (pidlNew)
-	  {
-	    memcpy(pidlNew,pidl,len+2);		/* 2 -> mind a desktop pidl */
-
-	    if (len)
-	      ILGetNext(pidlNew)->mkid.cb = 0x00;
-	  }
-	}
-	TRACE("-- newpidl=%p\n",pidlNew);
+            if (len)
+                ILGetNext(pidlNew)->mkid.cb = 0x00;
+        }
+    }
+    TRACE("-- newpidl=%p\n",pidlNew);
 
-	return pidlNew;
+    return pidlNew;
 }
 
 /*************************************************************************
@@ -275,51 +281,58 @@ LPITEMIDLIST WINAPI ILCloneFirst(LPCITEM
  *   the first two bytes are the len, the pidl is following then
  */
 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
-{	WORD		wLen = 0;
-	DWORD		dwBytesRead;
-	HRESULT		ret = E_FAIL;
-
-
-	TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
-
-	if (*ppPidl)
-	{ SHFree(*ppPidl);
-	  *ppPidl = NULL;
-	}
-
-	IStream_AddRef (pStream);
-
-	if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
-	{
-	  TRACE("PIDL length is %d\n", wLen);
-	  if (wLen != 0) {
-	    *ppPidl = SHAlloc (wLen);
-	    if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead))) {
-		TRACE("Stream read OK\n");
-		ret = S_OK;
-	    } else {
-		WARN("reading pidl failed\n");
-		SHFree(*ppPidl);
-		*ppPidl = NULL;
-	    }
-	  } else {
-	    *ppPidl = NULL;
-	    ret = S_OK;
-	  }
-	}
-
-	/* we are not yet fully compatible */
-	if (*ppPidl && !pcheck(*ppPidl))
-	{
-	  WARN("Check failed\n");
-	  SHFree(*ppPidl);
-	  *ppPidl = NULL;
-	}
-
-	
-	IStream_Release (pStream);
-	TRACE("done\n");
-	return ret;
+{
+    WORD        wLen = 0;
+    DWORD       dwBytesRead;
+    HRESULT     ret = E_FAIL;
+
+
+    TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
+
+    if (*ppPidl)
+    {
+        SHFree(*ppPidl);
+        *ppPidl = NULL;
+    }
+
+    IStream_AddRef (pStream);
+
+    if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
+    {
+        TRACE("PIDL length is %d\n", wLen);
+        if (wLen != 0)
+        {
+            *ppPidl = SHAlloc (wLen);
+            if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
+            {
+                TRACE("Stream read OK\n");
+                ret = S_OK;
+            }
+            else
+            {
+                WARN("reading pidl failed\n");
+                SHFree(*ppPidl);
+                *ppPidl = NULL;
+            }
+        }
+        else
+        {
+            *ppPidl = NULL;
+            ret = S_OK;
+        }
+    }
+
+    /* we are not yet fully compatible */
+    if (*ppPidl && !pcheck(*ppPidl))
+    {
+        WARN("Check failed\n");
+        SHFree(*ppPidl);
+        *ppPidl = NULL;
+    }
+
+    IStream_Release (pStream);
+    TRACE("done\n");
+    return ret;
 }
 
 /*************************************************************************
@@ -330,30 +343,29 @@ HRESULT WINAPI ILLoadFromStream (IStream
  */
 HRESULT WINAPI ILSaveToStream (IStream * pStream, LPCITEMIDLIST pPidl)
 {
-	LPCITEMIDLIST	pidl;
-	WORD		wLen = 0;
-	HRESULT		ret = E_FAIL;
+    LPCITEMIDLIST    pidl;
+    WORD        wLen = 0;
+    HRESULT        ret = E_FAIL;
 
-	TRACE_(shell)("%p %p\n", pStream, pPidl);
+    TRACE_(shell)("%p %p\n", pStream, pPidl);
 
-	IStream_AddRef (pStream);
+    IStream_AddRef (pStream);
 
-	pidl = pPidl;
-        while (pidl->mkid.cb)
-        {
-          wLen += sizeof(WORD) + pidl->mkid.cb;
-          pidl = ILGetNext(pidl);
-        }
+    pidl = pPidl;
+    while (pidl->mkid.cb)
+    {
+        wLen += sizeof(WORD) + pidl->mkid.cb;
+        pidl = ILGetNext(pidl);
+    }
 
-	if (SUCCEEDED(IStream_Write(pStream, (LPVOID)&wLen, 2, NULL)))
-	{
-	  if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
-	  { ret = S_OK;
-	  }
-	}
-	IStream_Release (pStream);
+    if (SUCCEEDED(IStream_Write(pStream, (LPVOID)&wLen, 2, NULL)))
+    {
+        if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
+            ret = S_OK;
+    }
+    IStream_Release (pStream);
 
-	return ret;
+    return ret;
 }
 
 /*************************************************************************
@@ -375,45 +387,45 @@ HRESULT WINAPI ILSaveToStream (IStream *
  */
 HRESULT WINAPI SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
 {
-	LPSHELLFOLDER sf;
-	WCHAR lpszDisplayName[MAX_PATH];
-	DWORD pchEaten;
-	HRESULT ret = E_FAIL;
-
-	TRACE_(shell)("%s %p 0x%08lx\n", path, ppidl, attributes ? *attributes : 0);
-
-	if (!MultiByteToWideChar(CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH))
-	  lpszDisplayName[MAX_PATH-1] = 0;
-
-	if (SUCCEEDED (SHGetDesktopFolder(&sf)))
-	{
-	  ret = IShellFolder_ParseDisplayName(sf, 0, NULL, lpszDisplayName, &pchEaten, ppidl, attributes);
-	  IShellFolder_Release(sf);
-	}
-	return ret;
+    LPSHELLFOLDER sf;
+    WCHAR lpszDisplayName[MAX_PATH];
+    DWORD pchEaten;
+    HRESULT ret = E_FAIL;
+
+    TRACE_(shell)("%s %p 0x%08lx\n", path, ppidl, attributes ? *attributes : 0);
+
+    if (!MultiByteToWideChar(CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH))
+        lpszDisplayName[MAX_PATH-1] = 0;
+
+    if (SUCCEEDED (SHGetDesktopFolder(&sf)))
+    {
+        ret = IShellFolder_ParseDisplayName(sf, 0, NULL, lpszDisplayName, &pchEaten, ppidl, attributes);
+        IShellFolder_Release(sf);
+    }
+    return ret;
 }
 
 HRESULT WINAPI SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
 {
-	LPSHELLFOLDER sf;
-	DWORD pchEaten;
-	HRESULT ret = E_FAIL;
-
-	TRACE_(shell)("%s %p 0x%08lx\n", debugstr_w(path), ppidl, attributes ? *attributes : 0);
-
-	if (SUCCEEDED (SHGetDesktopFolder(&sf)))
-	{
-	  ret = IShellFolder_ParseDisplayName(sf, 0, NULL, (LPWSTR)path, &pchEaten, ppidl, attributes);
-	  IShellFolder_Release(sf);
-	}
-	return ret;
+    LPSHELLFOLDER sf;
+    DWORD pchEaten;
+    HRESULT ret = E_FAIL;
+
+    TRACE_(shell)("%s %p 0x%08lx\n", debugstr_w(path), ppidl, attributes ? *attributes : 0);
+
+    if (SUCCEEDED (SHGetDesktopFolder(&sf)))
+    {
+        ret = IShellFolder_ParseDisplayName(sf, 0, NULL, (LPWSTR)path, &pchEaten, ppidl, attributes);
+        IShellFolder_Release(sf);
+    }
+    return ret;
 }
 
 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
 {
-	if ( SHELL_OsIsUnicode())
-	  return SHILCreateFromPathW (path, ppidl, attributes);
-	return SHILCreateFromPathA (path, ppidl, attributes);
+    if ( SHELL_OsIsUnicode())
+        return SHILCreateFromPathW (path, ppidl, attributes);
+    return SHILCreateFromPathA (path, ppidl, attributes);
 }
 
 /*************************************************************************
@@ -422,9 +434,9 @@ HRESULT WINAPI SHILCreateFromPathAW (LPC
  * Create an ItemIDList to one of the special folders.
 
  * PARAMS
- *  hwndOwner	[in]
- *  nFolder		[in]	CSIDL_xxxxx
- *  fCreate		[in]	Create folder if it does not exist
+ *  hwndOwner    [in]
+ *  nFolder        [in]    CSIDL_xxxxx
+ *  fCreate        [in]    Create folder if it does not exist
  *
  * RETURNS
  *  Success: The newly created pidl
@@ -436,14 +448,15 @@ HRESULT WINAPI SHILCreateFromPathAW (LPC
  *  shells IMalloc interface, aka ILFree.
  */
 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner, DWORD nFolder, BOOL fCreate)
-{	LPITEMIDLIST ppidl;
-	TRACE_(shell)("(hwnd=%p,csidl=0x%lx,%s).\n", hwndOwner, nFolder, fCreate ? "T" : "F");
+{
+    LPITEMIDLIST ppidl;
+    TRACE_(shell)("(hwnd=%p,csidl=0x%lx,%s).\n", hwndOwner, nFolder, fCreate ? "T" : "F");
 
-	if (fCreate)
-	  nFolder |= CSIDL_FLAG_CREATE;
+    if (fCreate)
+        nFolder |= CSIDL_FLAG_CREATE;
 
-	SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
-	return ppidl;
+    SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
+    return ppidl;
 }
 
 /*************************************************************************
@@ -461,21 +474,22 @@ LPITEMIDLIST WINAPI SHCloneSpecialIDList
  *  exported by ordinal.
  */
 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
-{	DWORD    len;
-	LPITEMIDLIST  newpidl;
+{
+    DWORD    len;
+    LPITEMIDLIST  newpidl;
 
-	if (!pidl)
-	  return NULL;
+    if (!pidl)
+        return NULL;
 
-	len = ILGetSize(pidl);
-	newpidl = (LPITEMIDLIST)Alloc(len);
-	if (newpidl)
-	  memcpy(newpidl,pidl,len);
+    len = ILGetSize(pidl);
+    newpidl = (LPITEMIDLIST)Alloc(len);
+    if (newpidl)
+        memcpy(newpidl,pidl,len);
 
-	TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
-	pdump(pidl);
+    TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
+    pdump(pidl);
 
-	return newpidl;
+    return newpidl;
 }
 
 /*************************************************************************
@@ -484,42 +498,45 @@ LPITEMIDLIST WINAPI ILGlobalClone(LPCITE
  */
 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 {
-	char	szData1[MAX_PATH];
-	char	szData2[MAX_PATH];
+    char    szData1[MAX_PATH];
+    char    szData2[MAX_PATH];
 
-	LPCITEMIDLIST pidltemp1 = pidl1;
-	LPCITEMIDLIST pidltemp2 = pidl2;
+    LPCITEMIDLIST pidltemp1 = pidl1;
+    LPCITEMIDLIST pidltemp2 = pidl2;
 
-	TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
+    TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
 
-	/* explorer reads from registry directly (StreamMRU),
-	   so we can only check here */
-	if ((!pcheck (pidl1)) || (!pcheck (pidl2))) return FALSE;
+    /*
+     * Explorer reads from registry directly (StreamMRU),
+     * so we can only check here
+     */
+    if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
+        return FALSE;
 
-	pdump (pidl1);
-	pdump (pidl2);
+    pdump (pidl1);
+    pdump (pidl2);
 
-	if ( (!pidl1) || (!pidl2) ) return FALSE;
+    if ( (!pidl1) || (!pidl2) )
+        return FALSE;
 
-	while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
-	{
-	    _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
-	    _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
+    while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
+    {
+        _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
+        _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
 
-	    if (strcasecmp ( szData1, szData2 )!=0 )
-	      return FALSE;
+        if (strcasecmp ( szData1, szData2 )!=0 )
+            return FALSE;
 
-	    pidltemp1 = ILGetNext(pidltemp1);
-	    pidltemp2 = ILGetNext(pidltemp2);
-	}
+        pidltemp1 = ILGetNext(pidltemp1);
+        pidltemp2 = ILGetNext(pidltemp2);
+    }
 
-	if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
-	{
-	  return TRUE;
-	}
+    if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
+        return TRUE;
 
-	return FALSE;
+    return FALSE;
 }
+
 /*************************************************************************
  * ILIsParent                [SHELL32.23]
  *
@@ -542,35 +559,37 @@ BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl
  */
 BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
 {
-	char	szData1[MAX_PATH];
-	char	szData2[MAX_PATH];
+    char    szData1[MAX_PATH];
+    char    szData2[MAX_PATH];
+    LPCITEMIDLIST pParent = pidlParent;
+    LPCITEMIDLIST pChild = pidlChild;
 
-	LPCITEMIDLIST pParent = pidlParent;
-	LPCITEMIDLIST pChild = pidlChild;
+    TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
 
-	TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
+    if (!pParent || !pChild)
+        return FALSE;
 
-	if (!pParent || !pChild) return FALSE;
-
-	while (pParent->mkid.cb && pChild->mkid.cb)
-	{
-	  _ILSimpleGetText(pParent, szData1, MAX_PATH);
-	  _ILSimpleGetText(pChild, szData2, MAX_PATH);
-
-	  if (strcasecmp ( szData1, szData2 )!=0 )
-	    return FALSE;
+    while (pParent->mkid.cb && pChild->mkid.cb)
+    {
+        _ILSimpleGetText(pParent, szData1, MAX_PATH);
+        _ILSimpleGetText(pChild, szData2, MAX_PATH);
 
-	  pParent = ILGetNext(pParent);
-	  pChild = ILGetNext(pChild);
-	}
+        if (strcasecmp ( szData1, szData2 )!=0 )
+            return FALSE;
 
-	if ( pParent->mkid.cb || ! pChild->mkid.cb) /* child shorter or has equal length to parent */
-	  return FALSE;
+        pParent = ILGetNext(pParent);
+        pChild = ILGetNext(pChild);
+    }
 
-	if ( ILGetNext(pChild)->mkid.cb && bImmediate) /* not immediate descent */
-	  return FALSE;
+    /* child shorter or has equal length to parent */
+    if ( pParent->mkid.cb || ! pChild->mkid.cb)
+        return FALSE;
+
+    /* not immediate descent */
+    if ( ILGetNext(pChild)->mkid.cb && bImmediate)
+        return FALSE;
 
-	return TRUE;
+    return TRUE;
 }
 
 /*************************************************************************
@@ -594,49 +613,47 @@ BOOL WINAPI ILIsParent(LPCITEMIDLIST pid
  */
 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 {
-	char	szData1[MAX_PATH];
-	char	szData2[MAX_PATH];
+    char    szData1[MAX_PATH];
+    char    szData2[MAX_PATH];
+
+    LPCITEMIDLIST pidltemp1 = pidl1;
+    LPCITEMIDLIST pidltemp2 = pidl2;
+    LPCITEMIDLIST ret=NULL;
+
+    TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
+
+    /* explorer reads from registry directly (StreamMRU),
+       so we can only check here */
+    if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
+        return FALSE;
+
+    pdump (pidl1);
+    pdump (pidl2);
 
-	LPCITEMIDLIST pidltemp1 = pidl1;
-	LPCITEMIDLIST pidltemp2 = pidl2;
-	LPCITEMIDLIST ret=NULL;
-
-	TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
-
-	/* explorer reads from registry directly (StreamMRU),
-	   so we can only check here */
-	if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
-	  return FALSE;
-
-	pdump (pidl1);
-	pdump (pidl2);
-
-	if ( _ILIsDesktop(pidl1) )
-	{
-	  ret = pidl2;
-	}
-	else
-	{
-	  while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
-	  {
-	    _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
-	    _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
-
-	    if (strcasecmp(szData1,szData2))
-	      break;
-
-	    pidltemp1 = ILGetNext(pidltemp1);
-	    pidltemp2 = ILGetNext(pidltemp2);
-	    ret = pidltemp2;
-	  }
-
-	  if (pidltemp1->mkid.cb)
-	  {
-	    ret = NULL; /* elements of pidl1 left*/
-	  }
-	}
-	TRACE_(shell)("--- %p\n", ret);
-	return (LPITEMIDLIST)ret; /* pidl 1 is shorter */
+    if ( _ILIsDesktop(pidl1) )
+    {
+        ret = pidl2;
+    }
+    else
+    {
+        while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
+        {
+            _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
+            _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
+
+            if (strcasecmp(szData1,szData2))
+                break;
+
+            pidltemp1 = ILGetNext(pidltemp1);
+            pidltemp2 = ILGetNext(pidltemp2);
+            ret = pidltemp2;
+        }
+
+        if (pidltemp1->mkid.cb)
+            ret = NULL; /* elements of pidl1 left*/
+    }
+    TRACE_(shell)("--- %p\n", ret);
+    return (LPITEMIDLIST)ret; /* pidl 1 is shorter */
 }
 
 /*************************************************************************
@@ -660,40 +677,40 @@ LPITEMIDLIST WINAPI ILFindChild(LPCITEMI
  */
 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 {
-	DWORD    len1,len2;
-	LPITEMIDLIST  pidlNew;
+    DWORD    len1,len2;
+    LPITEMIDLIST  pidlNew;
 
-	TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
+    TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
 
-	if(!pidl1 && !pidl2) return NULL;
+    if(!pidl1 && !pidl2) return NULL;
 
-	pdump (pidl1);
-	pdump (pidl2);
-
-	if(!pidl1)
-	{
-	  pidlNew = ILClone(pidl2);
-	  return pidlNew;
-	}
-
-	if(!pidl2)
-	{
-	  pidlNew = ILClone(pidl1);
-	  return pidlNew;
-	}
-
-	len1  = ILGetSize(pidl1)-2;
-	len2  = ILGetSize(pidl2);
-	pidlNew  = SHAlloc(len1+len2);
-
-	if (pidlNew)
-	{
-	  memcpy(pidlNew,pidl1,len1);
-	  memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
-	}
+    pdump (pidl1);
+    pdump (pidl2);
 
-	/*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
-	return pidlNew;
+    if(!pidl1)
+    {
+        pidlNew = ILClone(pidl2);
+        return pidlNew;
+    }
+
+    if(!pidl2)
+    {
+        pidlNew = ILClone(pidl1);
+        return pidlNew;
+    }
+
+    len1  = ILGetSize(pidl1)-2;
+    len2  = ILGetSize(pidl2);
+    pidlNew  = SHAlloc(len1+len2);
+
+    if (pidlNew)
+    {
+        memcpy(pidlNew,pidl1,len1);
+        memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
+    }
+
+    /*  TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
+    return pidlNew;
 }
 
 /*************************************************************************
@@ -703,57 +720,61 @@ LPITEMIDLIST WINAPI ILCombine(LPCITEMIDL
  */
 HRESULT WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPCITEMIDLIST pidlSimple, LPITEMIDLIST *pidlReal)
 {
-	IDataObject* pDataObj;
-	HRESULT hr = IShellFolder_GetUIObjectOf(lpsf, 0, 1, &pidlSimple, &IID_IDataObject, 0, (LPVOID*)&pDataObj);
+    IDataObject* pDataObj;
+    HRESULT hr;
 
-	if (SUCCEEDED(hr)) {
-            STGMEDIUM medium;
-            FORMATETC fmt;
+    hr = IShellFolder_GetUIObjectOf(lpsf, 0, 1, &pidlSimple,
+                             &IID_IDataObject, 0, (LPVOID*)&pDataObj);
+    if (SUCCEEDED(hr))
+    {
+        STGMEDIUM medium;
+        FORMATETC fmt;
 
-            fmt.cfFormat = RegisterClipboardFormatA(CFSTR_SHELLIDLIST);
-            fmt.ptd = NULL;
-            fmt.dwAspect = DVASPECT_CONTENT;
-            fmt.lindex = -1;
-            fmt.tymed = TYMED_HGLOBAL;
+        fmt.cfFormat = RegisterClipboardFormatA(CFSTR_SHELLIDLIST);
+        fmt.ptd = NULL;
+        fmt.dwAspect = DVASPECT_CONTENT;
+        fmt.lindex = -1;
+        fmt.tymed = TYMED_HGLOBAL;
 
-	    hr = IDataObject_GetData(pDataObj, &fmt, &medium);
+        hr = IDataObject_GetData(pDataObj, &fmt, &medium);
 
-	    IDataObject_Release(pDataObj);
+        IDataObject_Release(pDataObj);
 
-	    if (SUCCEEDED(hr)) {
-		/*assert(pida->cidl==1);*/
-		LPIDA pida = (LPIDA)GlobalLock(medium.u.hGlobal);
+        if (SUCCEEDED(hr))
+        {
+            /*assert(pida->cidl==1);*/
+            LPIDA pida = (LPIDA)GlobalLock(medium.u.hGlobal);
 
-		LPCITEMIDLIST pidl_folder = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
-		LPCITEMIDLIST pidl_child = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]);
+            LPCITEMIDLIST pidl_folder = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
+            LPCITEMIDLIST pidl_child = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]);
 
-		*pidlReal = ILCombine(pidl_folder, pidl_child);
+            *pidlReal = ILCombine(pidl_folder, pidl_child);
 
-		if (!*pidlReal)
-			hr = E_OUTOFMEMORY;
+            if (!*pidlReal)
+                hr = E_OUTOFMEMORY;
 
-		GlobalUnlock(medium.u.hGlobal);
-		GlobalFree(medium.u.hGlobal);
-	    }
-	}
+            GlobalUnlock(medium.u.hGlobal);
+            GlobalFree(medium.u.hGlobal);
+        }
+    }
 
-	return hr;
+    return hr;
 }
 
 /*************************************************************************
  *  SHLogILFromFSIL [SHELL32.95]
  *
  * NOTES
- *  pild = CSIDL_DESKTOP	ret = 0
- *  pild = CSIDL_DRIVES		ret = 0
+ *  pild = CSIDL_DESKTOP    ret = 0
+ *  pild = CSIDL_DRIVES        ret = 0
  */
 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
 {
-	FIXME("(pidl=%p)\n",pidl);
+    FIXME("(pidl=%p)\n",pidl);
 
-	pdump(pidl);
+    pdump(pidl);
 
-	return 0;
+    return 0;
 }
 
 /*************************************************************************
@@ -772,18 +793,20 @@ LPITEMIDLIST WINAPI SHLogILFromFSIL(LPIT
  */
 UINT WINAPI ILGetSize(LPCITEMIDLIST pidl)
 {
-	LPCSHITEMID si = &(pidl->mkid);
-	UINT len=0;
+    LPCSHITEMID si = &(pidl->mkid);
+    UINT len=0;
 
-	if (pidl)
-	{ while (si->cb)
-	  { len += si->cb;
-	    si  = (LPCSHITEMID)(((const BYTE*)si)+si->cb);
-	  }
-	  len += 2;
-	}
-	TRACE("pidl=%p size=%u\n",pidl, len);
-	return len;
+    if (pidl)
+    {
+        while (si->cb)
+        {
+            len += si->cb;
+            si  = (LPCSHITEMID)(((const BYTE*)si)+si->cb);
+        }
+        len += 2;
+    }
+    TRACE("pidl=%p size=%u\n",pidl, len);
+    return len;
 }
 
 /*************************************************************************
@@ -804,21 +827,21 @@ UINT WINAPI ILGetSize(LPCITEMIDLIST pidl
  */
 LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
 {
-	WORD len;
+    WORD len;
 
-	TRACE("%p\n", pidl);
+    TRACE("%p\n", pidl);
 
-	if(pidl)
-	{
-	  len =  pidl->mkid.cb;
-	  if (len)
-	  {
-	    pidl = (LPCITEMIDLIST) (((const BYTE*)pidl)+len);
-	    TRACE("-- %p\n", pidl);
-	    return (LPITEMIDLIST)pidl;
-	  }
-	}
-	return NULL;
+    if(pidl)
+    {
+        len =  pidl->mkid.cb;
+        if (len)
+        {
+            pidl = (LPCITEMIDLIST) (((const BYTE*)pidl)+len);
+            TRACE("-- %p\n", pidl);
+            return (LPITEMIDLIST)pidl;
+        }
+    }
+    return NULL;
 }
 
 /*************************************************************************
@@ -838,32 +861,28 @@ LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDL
  */
 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl, LPCITEMIDLIST item, BOOL bEnd)
 {
-	LPITEMIDLIST idlRet;
+    LPITEMIDLIST idlRet;
 
-	WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
+    WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
 
-	pdump (pidl);
-	pdump (item);
+    pdump (pidl);
+    pdump (item);
 
-	if (_ILIsDesktop(pidl))
-	{
-	   idlRet = ILClone(item);
-	   if (pidl)
-	     SHFree (pidl);
-	   return idlRet;
-	}
-
-	if (bEnd)
-	{
-	  idlRet = ILCombine(pidl, item);
-	}
-	else
-	{
-	  idlRet = ILCombine(item, pidl);
-	}
+    if (_ILIsDesktop(pidl))
+    {
+        idlRet = ILClone(item);
+        if (pidl)
+            SHFree (pidl);
+        return idlRet;
+    }
 
-	SHFree(pidl);
-	return idlRet;
+    if (bEnd)
+        idlRet = ILCombine(pidl, item);
+    else
+        idlRet = ILCombine(item, pidl);
+
+    SHFree(pidl);
+    return idlRet;
 }
 
 /*************************************************************************
@@ -879,8 +898,9 @@ LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIS
  */
 void WINAPI ILFree(LPITEMIDLIST pidl)
 {
-	TRACE("(pidl=%p)\n",pidl);
-	if(pidl) SHFree(pidl);
+    TRACE("(pidl=%p)\n",pidl);
+    if(pidl)
+        SHFree(pidl);
 }
 
 /*************************************************************************
@@ -896,10 +916,10 @@ void WINAPI ILFree(LPITEMIDLIST pidl)
  */
 void WINAPI ILGlobalFree( LPITEMIDLIST pidl)
 {
-	TRACE("%p\n", pidl);
+    TRACE("%p\n", pidl);
 
-	if(!pidl) return;
-	Free(pidl);
+    if(pidl)
+        Free(pidl);
 }
 
 /*************************************************************************
@@ -916,16 +936,15 @@ void WINAPI ILGlobalFree( LPITEMIDLIST p
  * NOTES
  *  exported by ordinal.
  */
-
 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
 {
-	LPITEMIDLIST pidlnew = NULL;
+    LPITEMIDLIST pidlnew = NULL;
 
-	TRACE_(shell)("%s\n", debugstr_a(path));
+    TRACE_(shell)("%s\n", debugstr_a(path));
 
-	if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
-	  return pidlnew;
-	return NULL;
+    if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
+        return pidlnew;
+    return NULL;
 }
 
 /*************************************************************************
@@ -933,13 +952,13 @@ LPITEMIDLIST WINAPI ILCreateFromPathA (L
  */
 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
 {
-	LPITEMIDLIST pidlnew = NULL;
+    LPITEMIDLIST pidlnew = NULL;
 
-	TRACE_(shell)("%s\n", debugstr_w(path));
+    TRACE_(shell)("%s\n", debugstr_w(path));
 
-	if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
-	  return pidlnew;
-	return NULL;
+    if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
+        return pidlnew;
+    return NULL;
 }
 
 /*************************************************************************
@@ -947,9 +966,9 @@ LPITEMIDLIST WINAPI ILCreateFromPathW (L
  */
 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
 {
-	if ( SHELL_OsIsUnicode())
-	  return ILCreateFromPathW (path);
-	return ILCreateFromPathA (path);
+    if ( SHELL_OsIsUnicode())
+        return ILCreateFromPathW (path);
+    return ILCreateFromPathA (path);
 }
 
 /*************************************************************************
@@ -982,42 +1001,40 @@ LPITEMIDLIST WINAPI ILCreateFromPathAW (
 static HRESULT WINAPI _ILParsePathW(LPCWSTR path, LPWIN32_FIND_DATAW lpFindFile,
                              BOOL bBindCtx, LPITEMIDLIST *ppidl, LPDWORD prgfInOut)
 {
-	LPSHELLFOLDER pSF = NULL;
-	LPBC pBC = NULL;
-	HRESULT ret;
-
-	TRACE("%s %p %d (%p)->%p (%p)->0x%lx\n", debugstr_w(path), lpFindFile, bBindCtx,
-	                                         ppidl, ppidl ? *ppidl : NULL,
-	                                         prgfInOut, prgfInOut ? *prgfInOut : 0);
-
-	ret = SHGetDesktopFolder(&pSF);
-	if (FAILED(ret))
-	{
-	  return ret;
-	}
-
-	if (lpFindFile || bBindCtx)
-	  ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
-
-	if (SUCCEEDED(ret))
-	{
-	  ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
-	}
-
-	if (pBC)
-	{
-	  IBindCtx_Release(pBC);
-	  pBC = NULL;
-	}
+    LPSHELLFOLDER pSF = NULL;
+    LPBC pBC = NULL;
+    HRESULT ret;
+
+    TRACE("%s %p %d (%p)->%p (%p)->0x%lx\n", debugstr_w(path), lpFindFile, bBindCtx,
+                                             ppidl, ppidl ? *ppidl : NULL,
+                                             prgfInOut, prgfInOut ? *prgfInOut : 0);
+
+    ret = SHGetDesktopFolder(&pSF);
+    if (FAILED(ret))
+        return ret;
 
-	IShellFolder_Release(pSF);
+    if (lpFindFile || bBindCtx)
+        ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
 
-	if (!SUCCEEDED(ret) && ppidl)
-	  *ppidl = NULL;
+    if (SUCCEEDED(ret))
+    {
+        ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
+    }
 
-	TRACE("%s %p 0x%lx\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
+    if (pBC)
+    {
+        IBindCtx_Release(pBC);
+        pBC = NULL;
+    }
+
+    IShellFolder_Release(pSF);
+
+    if (!SUCCEEDED(ret) && ppidl)
+        *ppidl = NULL;
 
-	return ret;
+    TRACE("%s %p 0x%lx\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
+
+    return ret;
 }
 
 /*************************************************************************
@@ -1064,20 +1081,20 @@ LPITEMIDLIST WINAPI SHSimpleIDListFromPa
 
 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW(LPCWSTR lpszPath)
 {
-	LPITEMIDLIST pidl = NULL;
+    LPITEMIDLIST pidl = NULL;
 
-	TRACE("%s\n", debugstr_w(lpszPath));
+    TRACE("%s\n", debugstr_w(lpszPath));
 
-	_ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
-	TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
-	return pidl;
+    _ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
+    TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
+    return pidl;
 }
 
 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW(LPCVOID lpszPath)
 {
-	if ( SHELL_OsIsUnicode())
-	  return SHSimpleIDListFromPathW (lpszPath);
-	return SHSimpleIDListFromPathA (lpszPath);
+    if ( SHELL_OsIsUnicode())
+      return SHSimpleIDListFromPathW (lpszPath);
+    return SHSimpleIDListFromPathA (lpszPath);
 }
 
 /*************************************************************************
@@ -1087,110 +1104,117 @@ LPITEMIDLIST WINAPI SHSimpleIDListFromPa
  *  the pidl can be a simple one. since we can't get the path out of the pidl
  *  we have to take all data from the pidl
  */
-HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
+HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
+                                    int nFormat, LPVOID dest, int len)
 {
-	TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
+    LPSTR filename, shortname;
+    WIN32_FIND_DATAA * pfd;
 
-	pdump(pidl);
-	if (!psf || !dest )  return E_INVALIDARG;
+    TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
 
-	switch (nFormat)
-	{
-	  case SHGDFIL_FINDDATA:
-	    {
-	       LPSTR filename, shortname;
-	       WIN32_FIND_DATAA * pfd = dest;
-
-	       if (_ILIsDrive(pidl))
-	           return E_INVALIDARG;
-
-	       if (len < (int)sizeof(WIN32_FIND_DATAA)) return E_INVALIDARG;
-
-	       ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
-	       _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
-	       pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
-	       pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
-
-	       filename = _ILGetTextPointer(pidl);
-	       shortname = _ILGetSTextPointer(pidl);
-
-	       if (filename)
-	           lstrcpynA(pfd->cFileName, filename, MAX_PATH);
-	       else
-	           pfd->cFileName[0] = '\0';
-
-	       if (shortname)
-	           lstrcpynA(pfd->cAlternateFileName, shortname, MAX_PATH);
-	       else
-	           pfd->cAlternateFileName[0] = '\0';
-	    }
-	    return NOERROR;
-
-	  case SHGDFIL_NETRESOURCE:
-	  case SHGDFIL_DESCRIPTIONID:
-	    FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
-	    break;
-
-	  default:
-	    ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
-	}
+    pdump(pidl);
+    if (!psf || !dest)
+        return E_INVALIDARG;
+
+    switch (nFormat)
+    {
+    case SHGDFIL_FINDDATA:
+        pfd = dest;
 
-	return E_INVALIDARG;
+        if (_ILIsDrive(pidl))
+            return E_INVALIDARG;
+
+        if (len < sizeof(WIN32_FIND_DATAA))
+            return E_INVALIDARG;
+
+        ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
+        _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
+        pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
+        pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
+
+        filename = _ILGetTextPointer(pidl);
+        shortname = _ILGetSTextPointer(pidl);
+
+        if (filename)
+            lstrcpynA(pfd->cFileName, filename, MAX_PATH);
+        else
+            pfd->cFileName[0] = '\0';
+
+        if (shortname)
+            lstrcpynA(pfd->cAlternateFileName, shortname, MAX_PATH);
+        else
+            pfd->cAlternateFileName[0] = '\0';
+        return NOERROR;
+
+    case SHGDFIL_NETRESOURCE:
+    case SHGDFIL_DESCRIPTIONID:
+        FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
+        break;
+
+    default:
+        ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
+    }
+
+    return E_INVALIDARG;
 }
 
 /*************************************************************************
  * SHGetDataFromIDListW [SHELL32.248]
  *
  */
-HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
+HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
+                                    int nFormat, LPVOID dest, int len)
 {
-	TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
+    LPSTR filename, shortname;
+    WIN32_FIND_DATAW * pfd = dest;
 
-	pdump(pidl);
+    TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
 
-	if (! psf || !dest )  return E_INVALIDARG;
+    pdump(pidl);
+
+    if (!psf || !dest)
+        return E_INVALIDARG;
+
+    switch (nFormat)
+    {
+    case SHGDFIL_FINDDATA:
+        pfd = dest;
 
-	switch (nFormat)
-	{
-	  case SHGDFIL_FINDDATA:
-	    {
-	       LPSTR filename, shortname;
-	       WIN32_FIND_DATAW * pfd = dest;
-
-	       if (_ILIsDrive(pidl))
-	           return E_INVALIDARG;
-
-	       if (len < (int)sizeof(WIN32_FIND_DATAW)) return E_INVALIDARG;
-
-	       ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
-	       _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
-	       pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
-	       pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
-
-	       filename = _ILGetTextPointer(pidl);
-	       shortname = _ILGetSTextPointer(pidl);
-
-	       if (!filename)
-	           pfd->cFileName[0] = '\0';
-	       else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
-	           pfd->cFileName[MAX_PATH-1] = 0;
-
-	       if (!shortname)
-	           pfd->cAlternateFileName[0] = '\0';
-	       else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
-	           pfd->cAlternateFileName[13] = 0;
-	    }
-	    return NOERROR;
-	  case SHGDFIL_NETRESOURCE:
-	  case SHGDFIL_DESCRIPTIONID:
-	    FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
-	    break;
-
-	  default:
-	    ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
-	}
+        if (_ILIsDrive(pidl))
+            return E_INVALIDARG;
 
-	return E_INVALIDARG;
+        if (len < sizeof(WIN32_FIND_DATAW))
+            return E_INVALIDARG;
+
+        ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
+        _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
+        pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
+        pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
+
+        filename = _ILGetTextPointer(pidl);
+        shortname = _ILGetSTextPointer(pidl);
+
+        if (!filename)
+            pfd->cFileName[0] = '\0';
+        else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
+            pfd->cFileName[MAX_PATH-1] = 0;
+
+        if (!shortname)
+            pfd->cAlternateFileName[0] = '\0';
+        else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
+            pfd->cAlternateFileName[13] = 0;
+        return NOERROR;
+
+    case SHGDFIL_NETRESOURCE:
+    case SHGDFIL_DESCRIPTIONID:
+        FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
+        break;
+
+    default:
+        ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
+    }
+
+    return E_INVALIDARG;
 }
 
 /*************************************************************************
@@ -1198,63 +1222,84 @@ HRESULT WINAPI SHGetDataFromIDListW(LPSH
  */
 HRESULT SHELL_GetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath, UINT uOutSize)
 {
-	HRESULT hr = S_OK;
+    HRESULT hr = S_OK;
 
-        pszPath[0]=0;
+    pszPath[0]=0;
+
+    /* One case is a PIDL rooted at desktop level */
+    if (_ILIsValue(pidl) || _ILIsFolder(pidl))
+    {
+        hr = SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOP, FALSE);
+
+        if (SUCCEEDED(hr))
+            PathAddBackslashA(pszPath);
+    }
+    /* The only other valid case is a item ID list beginning at "My Computer" */
+    else if (_ILIsMyComputer(pidl))
+        pidl = ILGetNext(pidl);
+
+    if (SUCCEEDED(hr))
+    {
+        LPSTR txt;
 
-	/* One case is a PIDL rooted at desktop level */
-	if (_ILIsValue(pidl) || _ILIsFolder(pidl)) {
-	    hr = SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOP, FALSE);
-
-	    if (SUCCEEDED(hr))
-		PathAddBackslashA(pszPath);
-	}
-	/* The only other valid case is a item ID list beginning at "My Computer" */
- 	else if (_ILIsMyComputer(pidl))
-	    pidl = ILGetNext(pidl);
-
-        if (SUCCEEDED(hr)) {
-	    LPSTR txt;
-
-	    while(pidl && pidl->mkid.cb) {
-		if (_ILIsSpecialFolder(pidl))
-		    {hr = E_INVALIDARG; break;}
-
-		txt = _ILGetTextPointer(pidl);
-		if (!txt)
-		    {hr = E_INVALIDARG; break;}
-
-                if (lstrlenA(txt) > pidl->mkid.cb)
-                    ERR("pidl %p is borked\n",pidl);
-
-                /* make sure there's enough space for the next segment */
-                if ( (lstrlenA(txt) + lstrlenA(pszPath)) > uOutSize)
-		    {hr = E_INVALIDARG; break;}
-		lstrcatA( pszPath, txt );
-
-		pidl = ILGetNext(pidl);
-		if (!pidl)
-		    {hr = E_INVALIDARG; break;}
-
-		if (!pidl->mkid.cb) {
-		    /* We are at the end and successfully converted the complete PIDL. */
-		    break;
-		}
-
-                if( (lstrlenA(pszPath) + 1) > uOutSize)
-		    {hr = E_INVALIDARG; break;}
-		if (!PathAddBackslashA(pszPath))
-		    {hr = E_INVALIDARG; break;}
-	    }
-	} else
-	    hr = E_INVALIDARG;
+        while(pidl && pidl->mkid.cb)
+        {
+            if (_ILIsSpecialFolder(pidl))
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+
+            txt = _ILGetTextPointer(pidl);
+            if (!txt)
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+
+            if (lstrlenA(txt) > pidl->mkid.cb)
+                ERR("pidl %p is borked\n",pidl);
+
+            /* make sure there's enough space for the next segment */
+            if ( (lstrlenA(txt) + lstrlenA(pszPath)) > uOutSize)
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+            lstrcatA( pszPath, txt );
+
+            pidl = ILGetNext(pidl);
+            if (!pidl)
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+
+            /* Are we at the end and successfully converted the complete PIDL? */
+            if (!pidl->mkid.cb)
+                break;
+
+            if( (lstrlenA(pszPath) + 1) > uOutSize)
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+            if (!PathAddBackslashA(pszPath))
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+        }
+    }
+    else
+        hr = E_INVALIDARG;
 
-	TRACE_(shell)("-- %s, 0x%08lx\n", pszPath, hr);
-	return hr;
+    TRACE_(shell)("-- %s, 0x%08lx\n", pszPath, hr);
+    return hr;
 }
 
 /*************************************************************************
- * SHGetPathFromIDListA		[SHELL32.@][NT 4.0: SHELL32.220]
+ * SHGetPathFromIDListA        [SHELL32.@][NT 4.0: SHELL32.220]
  *
  * PARAMETERS
  *  pidl,   [IN] pidl
@@ -1264,23 +1309,23 @@ HRESULT SHELL_GetPathFromIDListA(LPCITEM
  *  path from a passed PIDL.
  *
  * NOTES
- *	NULL returns FALSE
- *	desktop pidl gives path to desktop directory back
- *	special pidls returning FALSE
+ *    NULL returns FALSE
+ *    desktop pidl gives path to desktop directory back
+ *    special pidls returning FALSE
  */
 BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
 {
-	HRESULT hr;
+    HRESULT hr;
 
-	TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
-	pdump(pidl);
+    TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
+    pdump(pidl);
 
-	if (!pidl)
-	    return FALSE;
+    if (!pidl)
+        return FALSE;
 
-	hr = SHELL_GetPathFromIDListA(pidl, pszPath, MAX_PATH);
+    hr = SHELL_GetPathFromIDListA(pidl, pszPath, MAX_PATH);
 
-	return SUCCEEDED(hr);
+    return SUCCEEDED(hr);
 }
 
 /*************************************************************************
@@ -1288,144 +1333,166 @@ BOOL WINAPI SHGetPathFromIDListA(LPCITEM
  */
 HRESULT SHELL_GetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath, UINT uOutSize)
 {
-	HRESULT hr = S_OK;
-	UINT len;
+    HRESULT hr = S_OK;
+    UINT len;
 
         pszPath[0]=0;
 
-	/* One case is a PIDL rooted at desktop level */
-	if (_ILIsValue(pidl) || _ILIsFolder(pidl)) {
-	    hr = SHGetSpecialFolderPathW(0, pszPath, CSIDL_DESKTOP, FALSE);
-
-	    if (SUCCEEDED(hr))
-		PathAddBackslashW(pszPath);
-	}
-	/* The only other valid case is a item ID list beginning at "My Computer" */
- 	else if (_ILIsMyComputer(pidl))
-	    pidl = ILGetNext(pidl);
-
-        if (SUCCEEDED(hr)) {
-	    LPSTR txt;
-
-	    while(pidl && pidl->mkid.cb) {
-		if (_ILIsSpecialFolder(pidl))
-		    {hr = E_INVALIDARG; break;}
-
-		txt = _ILGetTextPointer(pidl);
-		if (!txt)
-		    {hr = E_INVALIDARG; break;}
-
-                if (lstrlenA(txt) > pidl->mkid.cb)
-                    ERR("pidl %p is borked\n",pidl);
-		len = MultiByteToWideChar(CP_ACP, 0, txt, -1, NULL, 0);
-                if ( (lstrlenW(pszPath) + len) > uOutSize )
-		    {hr = E_INVALIDARG; break;}
+    /* One case is a PIDL rooted at desktop level */
+    if (_ILIsValue(pidl) || _ILIsFolder(pidl))
+    {
+        hr = SHGetSpecialFolderPathW(0, pszPath, CSIDL_DESKTOP, FALSE);
 
-		MultiByteToWideChar(CP_ACP, 0, txt, -1, 
+        if (SUCCEEDED(hr))
+            PathAddBackslashW(pszPath);
+    }
+    /* The only other valid case is a item ID list beginning at "My Computer" */
+    else if (_ILIsMyComputer(pidl))
+        pidl = ILGetNext(pidl);
+
+    if (SUCCEEDED(hr))
+    {
+        LPSTR txt;
+
+        while(pidl && pidl->mkid.cb)
+        {
+            if (_ILIsSpecialFolder(pidl))
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+
+            txt = _ILGetTextPointer(pidl);
+            if (!txt)
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+
+            if (lstrlenA(txt) > pidl->mkid.cb)
+                ERR("pidl %p is borked\n",pidl);
+            len = MultiByteToWideChar(CP_ACP, 0, txt, -1, NULL, 0);
+            if ( (lstrlenW(pszPath) + len) > uOutSize )
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+
+            MultiByteToWideChar(CP_ACP, 0, txt, -1, 
                                     &pszPath[lstrlenW(pszPath)], len);
 
-		pidl = ILGetNext(pidl);
-		if (!pidl)
-		    {hr = E_INVALIDARG; break;}
-
-		if (!pidl->mkid.cb) {
-		    /* We are at the end and successfully converted the complete PIDL. */
-		    break;
-		}
-
-                if ( (lstrlenW(pszPath) + 1) > uOutSize )
-		    {hr = E_INVALIDARG; break;}
-		if (!PathAddBackslashW(pszPath))
-		    {hr = E_INVALIDARG; break;}
-	    }
-	} else
-	    hr = E_INVALIDARG;
+            pidl = ILGetNext(pidl);
+            if (!pidl)
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+
+            /* Are we at the end and successfully converted the complete PIDL? */
+            if (!pidl->mkid.cb)
+                break;
+
+            if ( (lstrlenW(pszPath) + 1) > uOutSize )
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+            if (!PathAddBackslashW(pszPath))
+            {
+                hr = E_INVALIDARG;
+                break;
+            }
+        }
+    }
+    else
+        hr = E_INVALIDARG;
 
     TRACE_(shell)("-- %s, 0x%08lx\n", debugstr_w(pszPath), hr);
     return hr;
 }
 
 /*************************************************************************
- * SHGetPathFromIDListW 			[SHELL32.@]
+ * SHGetPathFromIDListW             [SHELL32.@]
  */
 BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
 {
-	HRESULT hr;
+    HRESULT hr;
 
-	TRACE_(shell)("(pidl=%p,%p)\n", pidl, debugstr_w(pszPath));
-	pdump(pidl);
+    TRACE_(shell)("(pidl=%p,%p)\n", pidl, debugstr_w(pszPath));
+    pdump(pidl);
 
-	if (!pidl)
-	    return FALSE;
+    if (!pidl)
+        return FALSE;
 
-	hr = SHELL_GetPathFromIDListW(pidl, pszPath, MAX_PATH);
+    hr = SHELL_GetPathFromIDListW(pidl, pszPath, MAX_PATH);
 
-	TRACE_(shell)("-- %s, 0x%08lx\n",debugstr_w(pszPath), hr);
-	return SUCCEEDED(hr);
+    TRACE_(shell)("-- %s, 0x%08lx\n",debugstr_w(pszPath), hr);
+    return SUCCEEDED(hr);
 }
 
 /*************************************************************************
- *	SHBindToParent		[shell version 5.0]
+ *    SHBindToParent        [shell version 5.0]
  */
 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
 {
-	IShellFolder	* psf;
-	LPITEMIDLIST	pidlChild, pidlParent;
-	HRESULT		hr=E_FAIL;
-
-	TRACE_(shell)("pidl=%p\n", pidl);
-	pdump(pidl);
-
-	*ppv = NULL;
-	if (ppidlLast) *ppidlLast = NULL;
-
-	if (_ILIsPidlSimple(pidl))
-	{
-	  IShellFolder* desktop;
-
-	  /* we are on desktop level */
-	  hr = SHGetDesktopFolder(&desktop);
+    IShellFolder    * psf;
+    LPITEMIDLIST    pidlChild, pidlParent;
+    HRESULT         hr=E_FAIL;
+
+    TRACE_(shell)("pidl=%p\n", pidl);
+    pdump(pidl);
+
+    *ppv = NULL;
+    if (ppidlLast)
+        *ppidlLast = NULL;
 
-	  if (SUCCEEDED(hr))
-	  {
-	    hr = IShellFolder_QueryInterface(desktop, riid, ppv);
-
-	    if (SUCCEEDED(hr) && ppidlLast)
-	      *ppidlLast = ILClone(pidl);
-
-	    IShellFolder_Release(desktop);
-	  }
-	}
-	else
-	{
-	  pidlChild =  ILClone(ILFindLastID(pidl));
-	  pidlParent = ILClone(pidl);
-	  ILRemoveLastID(pidlParent);
-
-	  hr = SHGetDesktopFolder(&psf);
+    if (_ILIsPidlSimple(pidl))
+    {
+        IShellFolder* desktop;
 
-	  if (SUCCEEDED(hr))
-	    hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
+        /* we are on desktop level */
+        hr = SHGetDesktopFolder(&desktop);
 
-	  if (SUCCEEDED(hr) && ppidlLast)
-	    *ppidlLast = pidlChild;
-	  else
-	    ILFree (pidlChild);
+        if (SUCCEEDED(hr))
+        {
+            hr = IShellFolder_QueryInterface(desktop, riid, ppv);
 
-	  SHFree (pidlParent);
-	  if (psf) IShellFolder_Release(psf);
-	}
+            if (SUCCEEDED(hr) && ppidlLast)
+                *ppidlLast = ILClone(pidl);
 
+            IShellFolder_Release(desktop);
+        }
+    }
+    else
+    {
+        pidlChild =  ILClone(ILFindLastID(pidl));
+        pidlParent = ILClone(pidl);
+        ILRemoveLastID(pidlParent);
+
+        hr = SHGetDesktopFolder(&psf);
+
+        if (SUCCEEDED(hr))
+            hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
+
+        if (SUCCEEDED(hr) && ppidlLast)
+            *ppidlLast = pidlChild;
+        else
+            ILFree (pidlChild);
+
+        SHFree (pidlParent);
+        if (psf)
+            IShellFolder_Release(psf);
+    }
 
-	TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
-	return hr;
+    TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
+    return hr;
 }
 
 /**************************************************************************
  *
- *		internal functions
+ *        internal functions
  *
- *	### 1. section creating pidls ###
+ *    ### 1. section creating pidls ###
  *
  *************************************************************************
  */
@@ -1433,7 +1500,8 @@ LPITEMIDLIST _ILAlloc(PIDLTYPE type, siz
 {
     LPITEMIDLIST pidlOut = NULL;
 
-    if((pidlOut = SHAlloc(size + 5)))
+    pidlOut = SHAlloc(size + 5);
+    if(pidlOut)
     {
         LPPIDLDATA pData;
         LPITEMIDLIST pidlNext;
@@ -1441,10 +1509,12 @@ LPITEMIDLIST _ILAlloc(PIDLTYPE type, siz
         ZeroMemory(pidlOut, size + 5);
         pidlOut->mkid.cb = size + 3;
 
-        if ((pData = _ILGetDataPointer(pidlOut)))
+        pData = _ILGetDataPointer(pidlOut);
+        if (pData)
             pData->type = type;
 
-        if ((pidlNext = ILGetNext(pidlOut)))
+        pidlNext = ILGetNext(pidlOut);
+        if (pidlNext)
             pidlNext->mkid.cb = 0x00;
         TRACE("-- (pidl=%p, size=%u)\n", pidlOut, size);
     }
@@ -1464,13 +1534,15 @@ LPITEMIDLIST _ILCreateDesktop()
 }
 
 LPITEMIDLIST _ILCreateMyComputer()
-{	TRACE("()\n");
-	return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
+{
+    TRACE("()\n");
+    return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
 }
 
 LPITEMIDLIST _ILCreateIExplore()
-{	TRACE("()\n");
-	return _ILCreateGuid(PT_GUID, &CLSID_Internet);
+{
+    TRACE("()\n");
+    return _ILCreateGuid(PT_GUID, &CLSID_Internet);
 }
 
 LPITEMIDLIST _ILCreateControlPanel()
@@ -1512,12 +1584,14 @@ LPITEMIDLIST _ILCreatePrinters()
 }
 
 LPITEMIDLIST _ILCreateNetwork()
-{	TRACE("()\n");
+{
+	TRACE("()\n");
 	return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
 }
 
 LPITEMIDLIST _ILCreateBitBucket()
-{	TRACE("()\n");
+{
+	TRACE("()\n");
 	return _ILCreateGuid(PT_GUID, &CLSID_RecycleBin);
 }
 
@@ -1534,7 +1608,7 @@ LPITEMIDLIST _ILCreateGuid(PIDLTYPE type
 
             memcpy(&(pData->u.guid.guid), guid, sizeof(GUID));
             TRACE("-- create GUID-pidl %s\n",
-             debugstr_guid(&(pData->u.guid.guid)));
+                  debugstr_guid(&(pData->u.guid.guid)));
         }
     }
     else
@@ -1547,21 +1621,21 @@ LPITEMIDLIST _ILCreateGuid(PIDLTYPE type
 
 LPITEMIDLIST _ILCreateGuidFromStrA(LPCSTR szGUID)
 {
-	IID iid;
+    IID iid;
 
-	if (!SUCCEEDED(SHCLSIDFromStringA(szGUID, &iid)))
-	{
-	  ERR("%s is not a GUID\n", szGUID);
-	  return NULL;
-	}
-	return _ILCreateGuid(PT_GUID, &iid);
+    if (!SUCCEEDED(SHCLSIDFromStringA(szGUID, &iid)))
+    {
+        ERR("%s is not a GUID\n", szGUID);
+        return NULL;
+    }
+    return _ILCreateGuid(PT_GUID, &iid);
 }
 
 LPITEMIDLIST _ILCreateFromFindDataA(WIN32_FIND_DATAA * stffile )
 {
-    char	buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
-    char *	pbuff = buff;
-    size_t	len, len1;
+    char    buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
+    char *  pbuff = buff;
+    size_t  len, len1;
     LPITEMIDLIST pidl;
     PIDLTYPE type;
 
@@ -1578,25 +1652,30 @@ LPITEMIDLIST _ILCreateFromFindDataA(WIN3
     len1 = strlen (stffile->cAlternateFileName)+1;
     memcpy (pbuff, stffile->cAlternateFileName, len1);
 
-    type = (stffile->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : 
-     PT_VALUE;
-    /* FileStruct already has one byte for the first name, so use len - 1 in
+    type = (stffile->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : PT_VALUE;
+
+    /*
+     * FileStruct already has one byte for the first name, so use len - 1 in
      * size calculation
      */
-    if ((pidl = _ILAlloc(type, sizeof(FileStruct) + (len - 1) + len1)))
+    pidl = _ILAlloc(type, sizeof(FileStruct) + (len - 1) + len1);
+    if (pidl)
     {
         LPPIDLDATA pData;
         LPSTR pszDest;
 
         /* set attributes */
-        if ((pData = _ILGetDataPointer(pidl)))
+        pData = _ILGetDataPointer(pidl);
+        if (pData)
         {
             pData->type = type;
-            FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.file.uFileDate,&pData->u.file.uFileTime);
+            FileTimeToDosDateTime( &(stffile->ftLastWriteTime),
+                          &pData->u.file.uFileDate, &pData->u.file.uFileTime);
             pData->u.file.dwFileSize = stffile->nFileSizeLow;
             pData->u.file.uFileAttribs = (WORD)stffile->dwFileAttributes;
         }
-        if ((pszDest = _ILGetTextPointer(pidl)))
+        pszDest = _ILGetTextPointer(pidl);
+        if (pszDest)
         {
             memcpy(pszDest, buff, len + len1);
             TRACE("-- create Value: %s\n",debugstr_a(pszDest));
@@ -1607,22 +1686,21 @@ LPITEMIDLIST _ILCreateFromFindDataA(WIN3
 
 HRESULT _ILCreateFromPathA(LPCSTR szPath, LPITEMIDLIST* ppidl)
 {
-	HANDLE hFile;
-	WIN32_FIND_DATAA stffile;
+    HANDLE hFile;
+    WIN32_FIND_DATAA stffile;
 
     if (!ppidl)
         return E_INVALIDARG;
 
-	hFile = FindFirstFileA(szPath, &stffile);
-
-	if (hFile == INVALID_HANDLE_VALUE)
-		return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
+    hFile = FindFirstFileA(szPath, &stffile);
+    if (hFile == INVALID_HANDLE_VALUE)
+        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
-	FindClose(hFile);
+    FindClose(hFile);
 
-	*ppidl = _ILCreateFromFindDataA(&stffile);
+    *ppidl = _ILCreateFromFindDataA(&stffile);
 
-	return *ppidl ? S_OK : E_OUTOFMEMORY;
+    return *ppidl ? S_OK : E_OUTOFMEMORY;
 }
 
 LPITEMIDLIST _ILCreateDrive(LPCWSTR lpszNew)
@@ -1642,7 +1720,8 @@ LPITEMIDLIST _ILCreateDrive(LPCWSTR lpsz
 
         if ((pszDest = _ILGetTextPointer(pidlOut)))
         {
-	    WideCharToMultiByte(CP_ACP, 0, sTemp, sizeof(sTemp)/sizeof(WCHAR), pszDest, sizeof(sTemp)/sizeof(WCHAR), NULL, NULL);
+            WideCharToMultiByte(CP_ACP, 0, sTemp, sizeof(sTemp)/sizeof(WCHAR),
+                            pszDest, sizeof(sTemp)/sizeof(WCHAR), NULL, NULL);
             TRACE("-- create Drive: %s\n", debugstr_a(pszDest));
         }
     }
@@ -1658,20 +1737,21 @@ LPITEMIDLIST _ILCreateDrive(LPCWSTR lpsz
  *  strlen (lpszText)
  */
 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
-{	TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
+{
+    TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
 
-	if(_ILIsMyComputer(pidl))
-	  pidl = ILGetNext(pidl);
+    if(_ILIsMyComputer(pidl))
+        pidl = ILGetNext(pidl);
 
-	if (pidl && _ILIsDrive(pidl))
-	  return _ILSimpleGetText(pidl, pOut, uSize);
+    if (pidl && _ILIsDrive(pidl))
+        return _ILSimpleGetText(pidl, pOut, uSize);
 
-	return 0;
+    return 0;
 }
 
 /**************************************************************************
  *
- *	### 2. section testing pidls ###
+ *    ### 2. section testing pidls ###
  *
  **************************************************************************
  *  _ILIsDesktop()
@@ -1683,79 +1763,96 @@ DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPS
  *  _ILIsPidlSimple()
  */
 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
-{	TRACE("(%p)\n",pidl);
-	return pidl && pidl->mkid.cb  ? 0 : 1;
+{
+    TRACE("(%p)\n",pidl);
+
+    return pidl && pidl->mkid.cb  ? 0 : 1;
 }
 
 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
 {
-	REFIID iid = _ILGetGUIDPointer(pidl);
+    REFIID iid = _ILGetGUIDPointer(pidl);
 
-	TRACE("(%p)\n",pidl);
+    TRACE("(%p)\n",pidl);
 
-	if (iid)
-	  return IsEqualIID(iid, &CLSID_MyComputer);
-	return FALSE;
+    if (iid)
+        return IsEqualIID(iid, &CLSID_MyComputer);
+    return FALSE;
 }
 
 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
 {
-	LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
-	TRACE("(%p)\n",pidl);
-	return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type)) ||
-			  (pidl && pidl->mkid.cb == 0x00)
-			));
+    LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
+
+    TRACE("(%p)\n",pidl);
+
+    return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type)) ||
+              (pidl && pidl->mkid.cb == 0x00)
+            ));
 }
 
 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
-{	LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
-	TRACE("(%p)\n",pidl);
-	return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
-				    PT_DRIVE1 == lpPData->type ||
-				    PT_DRIVE2 == lpPData->type ||
-				    PT_DRIVE3 == lpPData->type));
+{
+    LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
+
+    TRACE("(%p)\n",pidl);
+
+    return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
+                    PT_DRIVE1 == lpPData->type ||
+                    PT_DRIVE2 == lpPData->type ||
+                    PT_DRIVE3 == lpPData->type));
 }
 
 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
-{	LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
-	TRACE("(%p)\n",pidl);
-	return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
+{
+    LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
+
+    TRACE("(%p)\n",pidl);
+
+    return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
 }
 
 BOOL _ILIsValue(LPCITEMIDLIST pidl)
-{	LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
-	TRACE("(%p)\n",pidl);
-	return (pidl && lpPData && PT_VALUE == lpPData->type);
+{
+    LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
+
+    TRACE("(%p)\n",pidl);
+
+    return (pidl && lpPData && PT_VALUE == lpPData->type);
 }
 
 BOOL _ILIsCPanelStruct(LPCITEMIDLIST pidl)
-{	LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
-	TRACE("(%p)\n",pidl);
-	return (pidl && lpPData && (lpPData->type == 0));
+{
+    LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
+
+    TRACE("(%p)\n",pidl);
+
+    return (pidl && lpPData && (lpPData->type == 0));
 }
 
 /**************************************************************************
- *	_ILIsPidlSimple
+ *    _ILIsPidlSimple
  */
 BOOL _ILIsPidlSimple ( LPCITEMIDLIST pidl)
 {
-	BOOL ret = TRUE;
+    BOOL ret = TRUE;
 
-	if(! _ILIsDesktop(pidl))	/* pidl=NULL or mkid.cb=0 */
-	{
-	  WORD len = pidl->mkid.cb;
-	  LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((const BYTE*)pidl) + len );
-	  if (pidlnext->mkid.cb)
-	    ret = FALSE;
-	}
+    if(! _ILIsDesktop(pidl))    /* pidl=NULL or mkid.cb=0 */
+    {
+        WORD len = pidl->mkid.cb;
+        LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((const BYTE*)pidl) + len );
+
+        if (pidlnext->mkid.cb)
+            ret = FALSE;
+    }
 
-	TRACE("%s\n", ret ? "Yes" : "No");
-	return ret;
+    TRACE("%s\n", ret ? "Yes" : "No");
+    return ret;
 }
 
 /**************************************************************************
  *
- *	### 3. section getting values from pidls ###
+ *    ### 3. section getting values from pidls ###
  */
 
  /**************************************************************************
@@ -1767,55 +1864,56 @@ BOOL _ILIsPidlSimple ( LPCITEMIDLIST pid
  */
 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
 {
-	DWORD		dwReturn=0;
-	LPSTR		szSrc;
-	GUID const * 	riid;
-	char szTemp[MAX_PATH];
-
-	TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
-
-	if (!pidl) return 0;
-
-	if (szOut)
-	  *szOut = 0;
-
-	if (_ILIsDesktop(pidl))
-	{
-	 /* desktop */
-	  if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
-	  {
-	    if (szOut)
-	      lstrcpynA(szOut, szTemp, uOutSize);
-
-	    dwReturn = strlen (szTemp);
-	  }
-	}
-	else if (( szSrc = _ILGetTextPointer(pidl) ))
-	{
-	  /* filesystem */
-	  if (szOut)
-	    lstrcpynA(szOut, szSrc, uOutSize);
-
-	  dwReturn = strlen(szSrc);
-	}
-	else if (( riid = _ILGetGUIDPointer(pidl) ))
-	{
-	  /* special folder */
-	  if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
-	  {
-	    if (szOut)
-	      lstrcpynA(szOut, szTemp, uOutSize);
-
-	    dwReturn = strlen (szTemp);
-	  }
-	}
-	else
-	{
-	  ERR("-- no text\n");
-	}
+    DWORD        dwReturn=0;
+    LPSTR        szSrc;
+    GUID const * riid;
+    char szTemp[MAX_PATH];
+
+    TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
+
+    if (!pidl)
+        return 0;
+
+    if (szOut)
+        *szOut = 0;
+
+    if (_ILIsDesktop(pidl))
+    {
+        /* desktop */
+        if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
+        {
+            if (szOut)
+                lstrcpynA(szOut, szTemp, uOutSize);
+
+            dwReturn = strlen (szTemp);
+        }
+    }
+    else if (( szSrc = _ILGetTextPointer(pidl) ))
+    {
+        /* filesystem */
+        if (szOut)
+            lstrcpynA(szOut, szSrc, uOutSize);
+
+        dwReturn = strlen(szSrc);
+    }
+    else if (( riid = _ILGetGUIDPointer(pidl) ))
+    {
+        /* special folder */
+        if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
+        {
+            if (szOut)
+                lstrcpynA(szOut, szTemp, uOutSize);
+
+            dwReturn = strlen (szTemp);
+        }
+    }
+    else
+    {
+        ERR("-- no text\n");
+    }
 
-	TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_a(szOut),dwReturn);
-	return dwReturn;
+    TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_a(szOut),dwReturn);
+    return dwReturn;
 }
 
  /**************************************************************************
@@ -1827,32 +1925,32 @@ DWORD _ILSimpleGetText (LPCITEMIDLIST pi
  */
 DWORD _ILSimpleGetTextW (LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
 {
-	DWORD	dwReturn;
-	char	szTemp[MAX_PATH];
+    DWORD    dwReturn;
+    char    szTemp[MAX_PATH];
 
-	TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
+    TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
 
-	dwReturn = _ILSimpleGetText(pidl, szTemp, uOutSize);
+    dwReturn = _ILSimpleGetText(pidl, szTemp, uOutSize);
 
-	if (!MultiByteToWideChar(CP_ACP, 0, szTemp, -1, szOut, MAX_PATH))
-		*szOut = 0;
+    if (!MultiByteToWideChar(CP_ACP, 0, szTemp, -1, szOut, MAX_PATH))
+        *szOut = 0;
 
-	TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_w(szOut),dwReturn);
-	return dwReturn;
+    TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_w(szOut),dwReturn);
+    return dwReturn;
 }
 
 /**************************************************************************
  *
- *	### 4. getting pointers to parts of pidls ###
+ *    ### 4. getting pointers to parts of pidls ###
  *
  **************************************************************************
  *  _ILGetDataPointer()
  */
 LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
 {
-	if(pidl && pidl->mkid.cb != 0x00)
-	  return (LPPIDLDATA) &(pidl->mkid.abID);
-	return NULL;
+    if(pidl && pidl->mkid.cb != 0x00)
+        return (LPPIDLDATA) &(pidl->mkid.abID);
+    return NULL;
 }
 
 /**************************************************************************
@@ -1860,41 +1958,42 @@ LPPIDLDATA _ILGetDataPointer(LPCITEMIDLI
  * gets a pointer to the long filename string stored in the pidl
  */
 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
-{/*	TRACE(pidl,"(pidl%p)\n", pidl);*/
+{
+    /* TRACE(pidl,"(pidl%p)\n", pidl);*/
 
-	LPPIDLDATA pdata = _ILGetDataPointer(pidl);
+    LPPIDLDATA pdata = _ILGetDataPointer(pidl);
+
+    if (!pdata)
+        return NULL;
 
-	if (pdata)
-	{
-	  switch (pdata->type)
-	  {
-	    case PT_GUID:
-	    case PT_SHELLEXT:
-	    case PT_YAGUID:
-	      return NULL;
-
-	    case PT_DRIVE:
-	    case PT_DRIVE1:
-	    case PT_DRIVE2:
-	    case PT_DRIVE3:
-	      return (LPSTR)&(pdata->u.drive.szDriveName);
-
-	    case PT_FOLDER:
-	    case PT_FOLDER1:
-	    case PT_VALUE:
-	    case PT_IESPECIAL1:
-	    case PT_IESPECIAL2:
-	      return (LPSTR)&(pdata->u.file.szNames);
-
-	    case PT_WORKGRP:
-	    case PT_COMP:
-	    case PT_NETWORK:
-	    case PT_NETPROVIDER:
-	    case PT_SHARE:
-	      return (LPSTR)&(pdata->u.network.szNames);
-	  }
-	}
-	return NULL;
+    switch (pdata->type)
+    {
+    case PT_GUID:
+    case PT_SHELLEXT:
+    case PT_YAGUID:
+        return NULL;
+
+    case PT_DRIVE:
+    case PT_DRIVE1:
+    case PT_DRIVE2:
+    case PT_DRIVE3:
+        return (LPSTR)&(pdata->u.drive.szDriveName);
+
+    case PT_FOLDER:
+    case PT_FOLDER1:
+    case PT_VALUE:
+    case PT_IESPECIAL1:
+    case PT_IESPECIAL2:
+        return (LPSTR)&(pdata->u.file.szNames);
+
+    case PT_WORKGRP:
+    case PT_COMP:
+    case PT_NETWORK:
+    case PT_NETPROVIDER:
+    case PT_SHARE:
+        return (LPSTR)&(pdata->u.network.szNames);
+    }
+    return NULL;
 }
 
 /**************************************************************************
@@ -1902,25 +2001,26 @@ LPSTR _ILGetTextPointer(LPCITEMIDLIST pi
  * gets a pointer to the short filename string stored in the pidl
  */
 LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
-{/*	TRACE(pidl,"(pidl%p)\n", pidl);*/
+{
+    /* TRACE(pidl,"(pidl%p)\n", pidl); */
 
-	LPPIDLDATA pdata =_ILGetDataPointer(pidl);
+    LPPIDLDATA pdata =_ILGetDataPointer(pidl);
 
-	if (pdata)
-	{
-	  switch (pdata->type)
-	  {
-	    case PT_FOLDER:
-	    case PT_VALUE:
-	    case PT_IESPECIAL1:
-	    case PT_IESPECIAL2:
-	      return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
-
-	    case PT_WORKGRP:
-	      return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
-	  }
-	}
-	return NULL;
+    if (!pdata)
+        return NULL;
+
+    switch (pdata->type)
+    {
+    case PT_FOLDER:
+    case PT_VALUE:
+    case PT_IESPECIAL1:
+    case PT_IESPECIAL2:
+        return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
+
+    case PT_WORKGRP:
+        return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
+    }
+    return NULL;
 }
 
 /**************************************************************************
@@ -1930,25 +2030,25 @@ LPSTR _ILGetSTextPointer(LPCITEMIDLIST p
  */
 IID* _ILGetGUIDPointer(LPCITEMIDLIST pidl)
 {
-	LPPIDLDATA pdata =_ILGetDataPointer(pidl);
+    LPPIDLDATA pdata =_ILGetDataPointer(pidl);
 
-	TRACE("%p\n", pidl);
+    TRACE("%p\n", pidl);
 
-	if (pdata)
-	{
-	  TRACE("pdata->type 0x%04x\n", pdata->type);
-	  switch (pdata->type)
-	  {
-	    case PT_SHELLEXT:
-	    case PT_GUID:
-	      return &(pdata->u.guid.guid);
-
-	    default:
-		TRACE("Unknown pidl type 0x%04x\n", pdata->type);
-		break;
-	  }
-	}
-	return NULL;
+    if (!pdata)
+        return NULL;
+
+    TRACE("pdata->type 0x%04x\n", pdata->type);
+    switch (pdata->type)
+    {
+    case PT_SHELLEXT:
+    case PT_GUID:
+        return &(pdata->u.guid.guid);
+
+    default:
+        TRACE("Unknown pidl type 0x%04x\n", pdata->type);
+        break;
+    }
+    return NULL;
 }
 
 /*************************************************************************
@@ -1970,36 +2070,39 @@ BOOL _ILGetFileDateTime(LPCITEMIDLIST pi
 {
     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
 
-    if(! pdata) return FALSE;
+    if (!pdata)
+        return FALSE;
 
     switch (pdata->type)
     {
-        case PT_FOLDER:
-        case PT_VALUE:
-            DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
-            break;
-        default:
-            return FALSE;
+    case PT_FOLDER:
+    case PT_VALUE:
+        DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
+        break;
+    default:
+        return FALSE;
     }
     return TRUE;
 }
 
 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
 {
-	FILETIME ft,lft;
-	SYSTEMTIME time;
-	BOOL ret;
-
-	if (_ILGetFileDateTime( pidl, &ft )) {
-	    FileTimeToLocalFileTime(&ft, &lft);
-	    FileTimeToSystemTime (&lft, &time);
-	    ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
-	} else {
-	    pOut[0] = '\0';
-	    ret = FALSE;
-	}
-	return ret;
+    FILETIME ft,lft;
+    SYSTEMTIME time;
+    BOOL ret;
 
+    if (_ILGetFileDateTime( pidl, &ft ))
+    {
+        FileTimeToLocalFileTime(&ft, &lft);
+        FileTimeToSystemTime (&lft, &time);
+        ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL,  pOut, uOutSize);
+    }
+    else
+    {
+        pOut[0] = '\0';
+        ret = FALSE;
+    }
+    return ret;
 }
 
 /*************************************************************************
@@ -2008,59 +2111,66 @@ BOOL _ILGetFileDate (LPCITEMIDLIST pidl,
  * Given the ItemIdList, get the FileSize
  *
  * PARAMS
- *      pidl    [I] The ItemIDList
- *	pOut	[I] The buffer to save the result
- *      uOutsize [I] The size of the buffer
+ *    pidl     [I] The ItemIDList
+ *    pOut     [I] The buffer to save the result
+ *    uOutsize [I] The size of the buffer
  *
  * RETURNS
- *     The FileSize
+ *    The FileSize
  *
  * NOTES
- *	pOut can be null when no string is needed
+ *    pOut can be null when no string is needed
  *
  */
 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
 {
-	LPPIDLDATA pdata = _ILGetDataPointer(pidl);
-	DWORD dwSize;
+    LPPIDLDATA pdata = _ILGetDataPointer(pidl);
+    DWORD dwSize;
 
-	if(! pdata) return 0;
+    if (!pdata)
+        return 0;
 
-	switch (pdata->type)
-	{
-	  case PT_VALUE:
-	    dwSize = pdata->u.file.dwFileSize;
-	    if (pOut) StrFormatByteSizeA(dwSize, pOut, uOutSize);
-	    return dwSize;
-	}
-	if (pOut) *pOut = 0x00;
-	return 0;
+    switch (pdata->type)
+    {
+    case PT_VALUE:
+        dwSize = pdata->u.file.dwFileSize;
+        if (pOut)
+            StrFormatByteSizeA(dwSize, pOut, uOutSize);
+        return dwSize;
+    }
+    if (pOut)
+        *pOut = 0x00;
+    return 0;
 }
 
 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
 {
-	char szTemp[MAX_PATH];
-	const char * pPoint;
-	LPCITEMIDLIST  pidlTemp=pidl;
+    char szTemp[MAX_PATH];
+    const char * pPoint;
+    LPCITEMIDLIST  pidlTemp=pidl;
 
-	TRACE("pidl=%p\n",pidl);
+    TRACE("pidl=%p\n",pidl);
 
-	if (!pidl) return FALSE;
+    if (!pidl)
+        return FALSE;
 
-	pidlTemp = ILFindLastID(pidl);
+    pidlTemp = ILFindLastID(pidl);
 
-	if (!_ILIsValue(pidlTemp)) return FALSE;
-	if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
+    if (!_ILIsValue(pidlTemp))
+        return FALSE;
+    if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH))
+        return FALSE;
 
-	pPoint = PathFindExtensionA(szTemp);
+    pPoint = PathFindExtensionA(szTemp);
 
-	if (! *pPoint) return FALSE;
+    if (!*pPoint)
+        return FALSE;
 
-	pPoint++;
-	lstrcpynA(pOut, pPoint, uOutSize);
-	TRACE("%s\n",pOut);
+    pPoint++;
+    lstrcpynA(pOut, pPoint, uOutSize);
+    TRACE("%s\n",pOut);
 
-	return TRUE;
+    return TRUE;
 }
 
 /*************************************************************************
@@ -2074,34 +2184,31 @@ BOOL _ILGetExtension (LPCITEMIDLIST pidl
  *      uOutsize    [I] The size of the buffer
  *
  * RETURNS
- *	nothing
+ *    nothing
  *
  * NOTES
- *	This function copies as much as possible into the buffer.
+ *    This function copies as much as possible into the buffer.
  */
 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
 {
-	if(_ILIsValue(pidl))
-	{
-	  char sTemp[64];
-          if(uOutSize > 0)
-          {
+    if(_ILIsValue(pidl))
+    {
+        char sTemp[64];
+
+        if(uOutSize > 0)
             pOut[0] = 0;
-          }
-	  if (_ILGetExtension (pidl, sTemp, 64))
-	  {
-	    if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
-	        && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE )))
-	    {
-	      lstrcpynA (pOut, sTemp, uOutSize - 6);
-	      strcat (pOut, "-file");
-	    }
-	  }
-	}
-	else
-	{
-	  lstrcpynA(pOut, "Folder", uOutSize);
-	}
+        if (_ILGetExtension (pidl, sTemp, 64))
+        {
+            if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
+                && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE )))
+            {
+                lstrcpynA (pOut, sTemp, uOutSize - 6);
+                strcat (pOut, "-file");
+            }
+        }
+    }
+    else
+        lstrcpynA(pOut, "Folder", uOutSize);
 }
 
 /*************************************************************************
@@ -2123,98 +2230,95 @@ void _ILGetFileType(LPCITEMIDLIST pidl, 
  */
 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
 {
-	LPPIDLDATA pData = _ILGetDataPointer(pidl);
-	WORD wAttrib = 0;
-	int i;
-
-	if(! pData) return 0;
-
-	switch(pData->type)
-	{
-	  case PT_FOLDER:
-	  case PT_VALUE:
-	    wAttrib = pData->u.file.uFileAttribs;
-	    break;
-	}
-
-	if(uOutSize >= 6)
-	{
-	  i=0;
-	  if(wAttrib & FILE_ATTRIBUTE_READONLY)
-	  {
-	    pOut[i++] = 'R';
-	  }
-	  if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
-	  {
-	    pOut[i++] = 'H';
-	  }
-	  if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
-	  {
-	    pOut[i++] = 'S';
-	  }
-	  if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
-	  {
-	    pOut[i++] = 'A';
-	  }
-	  if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
-	  {
-	    pOut[i++] = 'C';
-	  }
-	  pOut[i] = 0x00;
-	}
-	return wAttrib;
+    LPPIDLDATA pData = _ILGetDataPointer(pidl);
+    WORD wAttrib = 0;
+    int i;
+
+    if (!pData)
+        return 0;
+
+    switch(pData->type)
+    {
+    case PT_FOLDER:
+    case PT_VALUE:
+        wAttrib = pData->u.file.uFileAttribs;
+        break;
+    }
+
+    if(uOutSize >= 6)
+    {
+        i=0;
+        if(wAttrib & FILE_ATTRIBUTE_READONLY)
+            pOut[i++] = 'R';
+        if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
+            pOut[i++] = 'H';
+        if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
+            pOut[i++] = 'S';
+        if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
+            pOut[i++] = 'A';
+        if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
+            pOut[i++] = 'C';
+        pOut[i] = 0x00;
+    }
+    return wAttrib;
 }
 
 /*************************************************************************
-* ILFreeaPidl
-*
-* free a aPidl struct
-*/
+ * ILFreeaPidl
+ *
+ * free a aPidl struct
+ */
 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
 {
-	UINT   i;
+    UINT   i;
 
-	if (apidl)
-	{
-	  for (i = 0; i < cidl; i++) SHFree(apidl[i]);
-	  SHFree(apidl);
-	}
+    if (apidl)
+    {
+        for (i = 0; i < cidl; i++)
+            SHFree(apidl[i]);
+        SHFree(apidl);
+    }
 }
 
 /*************************************************************************
-* ILCopyaPidl
-*
-* copies an aPidl struct
-*/
+ * ILCopyaPidl
+ *
+ * copies an aPidl struct
+ */
 LPITEMIDLIST* _ILCopyaPidl(LPCITEMIDLIST * apidlsrc, UINT cidl)
 {
-	UINT i;
-	LPITEMIDLIST * apidldest = (LPITEMIDLIST*)SHAlloc(cidl * sizeof(LPITEMIDLIST));
-	if(!apidlsrc) return NULL;
+    UINT i;
+    LPITEMIDLIST *apidldest;
 
-	for (i = 0; i < cidl; i++)
-	  apidldest[i] = ILClone(apidlsrc[i]);
+    apidldest = SHAlloc(cidl * sizeof(LPITEMIDLIST));
+    if (!apidlsrc)
+        return NULL;
 
-	return apidldest;
+    for (i = 0; i < cidl; i++)
+        apidldest[i] = ILClone(apidlsrc[i]);
+
+    return apidldest;
 }
 
 /*************************************************************************
-* _ILCopyCidaToaPidl
-*
-* creates aPidl from CIDA
-*/
+ * _ILCopyCidaToaPidl
+ *
+ * creates aPidl from CIDA
+ */
 LPITEMIDLIST* _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, LPIDA cida)
 {
-	UINT i;
-	LPITEMIDLIST * dst = (LPITEMIDLIST*)SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
+    UINT i;
+    LPITEMIDLIST *dst;
 
-	if(!dst) return NULL;
+    dst = SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
+    if (!dst)
+        return NULL;
 
-	if (pidl)
-	  *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
+    if (pidl)
+        *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
 
-	for (i = 0; i < cida->cidl; i++)
-	  dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
+    for (i = 0; i < cida->cidl; i++)
+        dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
 
-	return dst;
+    return dst;
 }


More information about the wine-patches mailing list