Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
fldsets.c
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 28k
Category:

Windows Kernel

Development Platform:

Visual C++

fldsets.c：Code Content
  1. #include "shellprv.h"
  2. #pragma  hdrstop
  4. #define GUIDSIZE  (GUIDSTR_MAX+1)
  6. //
  7. // This function uses SHGetIniStringUTF7 to access the string, so it is valid
  8. // to use SZ_CANBEUNICODE on the key name.
  9. //
  10. HRESULT SHGetSetFolderSetting(LPCTSTR pszIniFile, DWORD dwReadWrite, LPCTSTR pszSection,
  11.                                        LPCTSTR pszKey, LPTSTR pszValue, DWORD cchValueSize)
  12. {
  13.     HRESULT hres = S_OK;
  14.     //They just want to read.
  15.     if (dwReadWrite == FCS_READ)
  16.     {
  17.         if (pszValue)
  18.         {
  19.             if (!SHGetIniStringUTF7(pszSection,pszKey, pszValue, cchValueSize, pszIniFile))
  20.                 hres = E_FAIL;
  21.         }
  23.     }        
  24.     //They want to write the value regardless whether the value is already there or not.
  25.     if (dwReadWrite == FCS_FORCEWRITE)
  26.     {
  27.         SHSetIniStringUTF7(pszSection, pszKey, pszValue, pszIniFile);
  28.     }
  30.     //Write only if the value is not already present.
  31.     if (dwReadWrite == FCS_WRITE)
  32.     {
  33.         TCHAR szBuf[MAX_PATH];
  34.         BOOL fWrite = TRUE;
  36.         szBuf[0] = TEXT('');
  37.         //See if the value already exists ?
  38.         SHGetIniStringUTF7(pszSection,pszKey, szBuf, ARRAYSIZE(szBuf), pszIniFile);
  40.         if (!szBuf[0])
  41.         {            
  42.             //Write only if the value is not already in the file
  43.             SHSetIniStringUTF7(pszSection, pszKey, pszValue, pszIniFile);
  44.         }
  45.     }
  47.     return hres;
  48. }
  50. // SHGetSetFolderSetting for path values
  51. HRESULT SHGetSetFolderSettingPath(LPCTSTR pszIniFile, DWORD dwReadWrite, LPCTSTR pszSection,
  52.                                   LPCTSTR pszKey, LPTSTR pszValue, DWORD cchValueSize)
  53. {
  54.     HRESULT hres;
  55.     TCHAR szTemp[MAX_PATH];
  56.     if ((dwReadWrite == FCS_FORCEWRITE) || (dwReadWrite == FCS_WRITE))  // We write
  57.     {
  58.         int cch = cchValueSize;
  59.         if (pszValue)
  60.         {
  61.             SubstituteWebDir(pszValue, cch);
  62.             if (PathUnExpandEnvStrings(pszValue, szTemp, ARRAYSIZE(szTemp)))
  63.             {
  64.                 pszValue = szTemp;
  65.                 cch = ARRAYSIZE(szTemp);
  66.             }
  67.         }
  68.         hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, pszSection, pszKey, pszValue, 0);
  69.     }
  70.     else
  71.     {
  72.         hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, pszSection, pszKey, szTemp, ARRAYSIZE(szTemp));
  73.         if (SUCCEEDED(hres))    // We've read a path
  74.         {
  75.             SHExpandEnvironmentStrings(szTemp, pszValue, cchValueSize);   // This is a path, so expand the env vars in it
  76.             ExpandOtherVariables(pszValue, cchValueSize);
  77.         }
  78.     }
  79.     return hres;
  80. }
  82. // Read/write desktop.ini settings
  83. HRESULT SHGetSetLogo(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  84. {
  85.     HRESULT hres = S_FALSE;
  86.     if (pfcs->dwMask & FCSM_LOGO)
  87.     {
  88.         hres =  SHGetSetFolderSettingPath(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), SZ_CANBEUNICODE TEXT("Logo"),
  89.                                      pfcs->pszLogo, pfcs->cchLogo);
  90.     }
  91.     return hres;
  92. }
  94. // Read/write desktop.ini settings
  95. HRESULT SHGetSetInfoTip(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  96. {
  97.     HRESULT hres = S_FALSE;
  98.     if (pfcs->dwMask & FCSM_INFOTIP)
  99.     {
  100.         hres =  SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), SZ_CANBEUNICODE TEXT("InfoTip"),
  101.                                 pfcs->pszInfoTip, pfcs->cchInfoTip);
  102.     }
  104.     return hres;
  105. }
  107. // Read/write desktop.ini settings
  108. HRESULT SHGetSetIconFile(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  109. {
  110.     HRESULT hres = S_FALSE;
  111.     if (pfcs->dwMask & FCSM_ICONFILE)
  112.     {
  113.         hres =  SHGetSetFolderSettingPath(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), SZ_CANBEUNICODE TEXT("IconFile"),
  114.                                       pfcs->pszIconFile, pfcs->cchIconFile);
  115.     }
  116.     return hres;
  117. }
  119.   
  120. // Read/write desktop.ini settings
  121. HRESULT SHGetSetVID(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  122. {
  123.     HRESULT hres = S_FALSE;
  124.     TCHAR szVID[GUIDSIZE];
  126.     if (pfcs->dwMask & FCSM_VIEWID)
  127.     {
  128.         if (dwReadWrite == FCS_READ)
  129.         {
  130.             if (pfcs->pvid)
  131.             {
  132.                 hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT("ExtShellFolderViews"), TEXT("Default"),
  133.                                              szVID, ARRAYSIZE(szVID));
  134.                 if (hres == S_OK)
  135.                     SHCLSIDFromString(szVID, pfcs->pvid);
  136.             }
  137.         }
  138.         else if (pfcs->pvid)
  139.         {
  140.             SHStringFromGUID(pfcs->pvid, szVID, ARRAYSIZE(szVID));
  141.             SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT("ExtShellFolderViews"), TEXT("Default"),
  142.                                               szVID, ARRAYSIZE(szVID));        
  143.             hres =  SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT("ExtShellFolderViews"), szVID,
  144.                                               szVID, ARRAYSIZE(szVID));        
  145.         }
  146.         else
  147.         {
  148.             // if we get here we assume that they want to nuke the whole section
  149.             if(0 != WritePrivateProfileString(TEXT("ExtShellFolderViews"), NULL, NULL, pszIniFile))
  150.             {
  151.                 hres = S_OK;
  152.             }
  153.         }
  154.     }
  155.     return hres;
  156. }
  159. // Read/write desktop.ini settings
  160. HRESULT SHGetSetCLSID(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  161. {
  162.     HRESULT hres = S_FALSE;
  163.     TCHAR szCLSID[GUIDSIZE];
  165.     if (pfcs->dwMask & FCSM_CLSID)
  166.     {
  167.         if (dwReadWrite == FCS_READ)
  168.         {
  169.             if (pfcs->pclsid)
  170.             {
  171.                 SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("CLSID2"),
  172.                                                   szCLSID, ARRAYSIZE(szCLSID));        
  173.                 hres = SHCLSIDFromString(szCLSID, pfcs->pclsid);
  174.             }
  175.         }
  176.         else if (pfcs->pclsid)
  177.         {
  178.             SHStringFromGUID(pfcs->pclsid, szCLSID, ARRAYSIZE(szCLSID));
  179.             hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("CLSID2"),
  180.                                                   szCLSID, ARRAYSIZE(szCLSID));        
  181.         }
  182.         else
  183.         {
  184.             hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("CLSID2"),
  185.                                                   NULL, 0);        
  186.         }
  188.     }
  189.     return hres;
  190. }
  193. // Read/write desktop.ini settings
  194. HRESULT SHGetSetFlags(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  195. {
  196.     HRESULT hres = S_FALSE;
  197.     TCHAR szFlags[20];
  199.     if (pfcs->dwMask & FCSM_FLAGS)
  200.     {
  201.         if (dwReadWrite == FCS_READ)
  202.         {
  203.            hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("Flags"),
  204.                                            szFlags, ARRAYSIZE(szFlags));        
  205.            pfcs->dwFlags = StrToInt(szFlags);
  206.         }
  207.         else
  208.         {
  209.             wsprintf(szFlags, TEXT("%d"), (int)pfcs->dwFlags);
  210.             hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("Flags"),
  211.                                                 szFlags, ARRAYSIZE(szFlags));        
  212.         }
  213.     }
  214.     return hres;
  215. }
  218. // Read/write desktop.ini settings
  219. HRESULT SHGetSetIconIndex(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  220. {
  221.     TCHAR szIconIndex[20];
  222.     HRESULT hres = S_FALSE;
  224.     if (pfcs->dwMask & FCSM_ICONFILE)
  225.     {
  226.         if (dwReadWrite == FCS_READ)
  227.         {
  228.            hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("IconIndex"),
  229.                                            szIconIndex, ARRAYSIZE(szIconIndex));        
  230.            pfcs->iIconIndex = StrToInt(szIconIndex);
  231.         }
  232.         else if (pfcs->pszIconFile)
  233.         {
  234.             wsprintf(szIconIndex, TEXT("%d"), (int)pfcs->iIconIndex);
  235.             hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("IconIndex"),
  236.                                                 szIconIndex, ARRAYSIZE(szIconIndex));        
  237.         }
  238.         else
  239.         {
  240.             hres = SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT(".ShellClassInfo"), TEXT("IconIndex"),
  241.                                                 NULL, 0);        
  242.         }
  243.     }
  244.     return hres;
  245. }
  248. const LPCTSTR c_szWebViewTemplateVersions[] =
  249. {
  250.     SZ_CANBEUNICODE TEXT("WebViewTemplate.NT5"),
  251.     SZ_CANBEUNICODE TEXT("PersistMoniker")
  252. };
  254. // Read/write desktop.ini settings
  255. HRESULT SHGetSetWebViewTemplate(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszIniFile, DWORD dwReadWrite)
  256. {
  257.     int i;
  258.     TCHAR szVID[GUIDSIZE], szTemp[MAX_PATH];
  259.     HRESULT hres = S_FALSE;
  260.     if (pfcs->dwMask & FCSM_WEBVIEWTEMPLATE)
  261.     {
  262.         if (!SHStringFromGUID(&VID_WebView, szVID, ARRAYSIZE(szVID)))
  263.         {
  264.             hres = E_FAIL;
  265.         }
  267.         if ((!pfcs->pszWebViewTemplate || !pfcs->pszWebViewTemplate[0]) && (dwReadWrite == FCS_FORCEWRITE)) // We have to remove webview
  268.         {
  269.             WritePrivateProfileString(szVID, NULL, NULL, pszIniFile);
  270.             WritePrivateProfileString(TEXT("ExtShellFolderViews"), szVID, NULL, pszIniFile);
  271.             if (SHGetSetFolderSetting(pszIniFile, FCS_READ, TEXT("ExtShellFolderViews"), TEXT("Default"), szTemp, ARRAYSIZE(szTemp)) == S_OK
  272.                     && StrCmpI(szTemp, szVID) == 0)
  273.             {
  274.                 WritePrivateProfileString(TEXT("ExtShellFolderViews"), TEXT("Default"), NULL, pszIniFile);
  275.             }
  276.         }
  277.         else
  278.         {
  279.             TCHAR szKey[MAX_PATH];
  280.             if (!pfcs->pszWebViewTemplateVersion || !pfcs->pszWebViewTemplateVersion[0]
  281.                     || (lstrcmpi(pfcs->pszWebViewTemplateVersion, TEXT("IE4")) == 0))
  282.             {   // They don't know which version template they want. Let's try from the latest version down.
  283.                 if (dwReadWrite & FCS_READ)
  284.                 {
  285.                     for (i = 0; i < ARRAYSIZE(c_szWebViewTemplateVersions); i++)
  286.                     {
  287.                         lstrcpyn(szKey, c_szWebViewTemplateVersions[i], ARRAYSIZE(szKey));
  288.                         if (SHGetSetFolderSetting(pszIniFile, FCS_READ, szVID, szKey, szTemp, ARRAYSIZE(szTemp)) == S_OK)
  289.                         {
  290.                             break;
  291.                         }
  292.                     }
  293.                 }
  294.                 else
  295.                 {
  296.                     lstrcpyn(szKey, c_szWebViewTemplateVersions[ARRAYSIZE(c_szWebViewTemplateVersions) - 1], ARRAYSIZE(szKey));
  297.                 }
  298.             }
  299.             else
  300.             {
  301.                 lstrcpyn(szKey, SZ_CANBEUNICODE TEXT("WebViewTemplate."), ARRAYSIZE(szKey));
  302.                 StrCatBuff(szKey, pfcs->pszWebViewTemplateVersion, ARRAYSIZE(szKey));
  303.             }
  304.             
  305.             if (dwReadWrite == FCS_FORCEWRITE)
  306.             {
  307.                 // Remove all old templates
  308.                 for (i = 0; i < ARRAYSIZE(c_szWebViewTemplateVersions); i++)
  309.                 {
  310.                     SHGetSetFolderSetting(pszIniFile, FCS_FORCEWRITE, szVID, c_szWebViewTemplateVersions[i], NULL, 0);
  311.                 }
  312.             }
  313.             
  314.             hres = SHGetSetFolderSettingPath(pszIniFile, dwReadWrite, szVID, szKey,
  315.                                     pfcs->pszWebViewTemplate, pfcs->cchWebViewTemplate);
  316.             if (SUCCEEDED(hres))
  317.             {
  318.                 if ((dwReadWrite == FCS_FORCEWRITE) || (dwReadWrite == FCS_WRITE))
  319.                 {
  320.                     // If we have set the template, make sure that the VID_Webview = VID_WebView line under "ExtShellFolderViews" is present
  321.                     if (pfcs->pszWebViewTemplate)
  322.                     {
  323.                         SHGetSetFolderSetting(pszIniFile, dwReadWrite, TEXT("ExtShellFolderViews"), szVID, 
  324.                                         szVID, ARRAYSIZE(szVID));
  325.                     }
  326.                 }
  327.             }
  328.         }
  329.     }
  330.     return hres;
  331. }
  334. // Read/write desktop.ini settings
  335. HRESULT SHGetSetFCS(LPSHFOLDERCUSTOMSETTINGS pfcs, LPCTSTR pszPath, DWORD dwReadWrite)
  336. {
  337.     HRESULT hret = S_OK, hres;
  338.     TCHAR szIniFile[MAX_PATH];
  339.     DWORD dwValueReturned = 0;
  341.     // Get the pathname for desktop.ini
  342.     PathCombine(szIniFile, pszPath, TEXT("Desktop.ini"));
  344.     hres = SHGetSetVID(pfcs, szIniFile, dwReadWrite);
  345.     if (S_OK == hres)
  346.     {
  347.         dwValueReturned |= FCSM_VIEWID;
  348.     }
  350.     hres = SHGetSetWebViewTemplate(pfcs, szIniFile, dwReadWrite);
  351.     if (S_OK == hres)
  352.     {
  353.         dwValueReturned |= FCSM_WEBVIEWTEMPLATE;
  354.     }
  356.     hres = SHGetSetInfoTip(pfcs, szIniFile, dwReadWrite);
  357.     if (S_OK == hres)
  358.     {
  359.         dwValueReturned |= FCSM_INFOTIP;
  360.     }
  362.     hres = SHGetSetCLSID(pfcs, szIniFile, dwReadWrite);
  363.     if (S_OK == hres)
  364.     {
  365.         dwValueReturned |= FCSM_CLSID;
  366.     }
  368.     
  369.     hres = SHGetSetFlags(pfcs, szIniFile, dwReadWrite);
  370.     if (S_OK == hres)
  371.     {
  372.         dwValueReturned |= FCSM_FLAGS;
  373.     }
  375.     hres = SHGetSetIconFile(pfcs, szIniFile, dwReadWrite);
  376.     if (S_OK == hres)
  377.     {
  378.         dwValueReturned |= FCSM_ICONFILE;
  379.     }
  381.     hres = SHGetSetIconIndex(pfcs, szIniFile, dwReadWrite);
  382.     if (S_OK == hres)
  383.     {
  384.         dwValueReturned |= FCSM_ICONFILE;
  385.     }
  386.     
  387.     hres = SHGetSetLogo(pfcs, szIniFile, dwReadWrite);
  388.     if (S_OK == hres)
  389.     {
  390.         dwValueReturned |= FCSM_LOGO;
  391.     }
  392.     
  393.     if (SUCCEEDED(hret) && (dwReadWrite & FCS_FORCEWRITE))
  394.     {
  395.         // Set ConfirmFileOp to 0
  396.         BOOL fWrite = TRUE;
  397.         if (dwReadWrite & FCS_READ)
  398.         {
  399.             TCHAR szConfirmFileOp[20];
  400.             GetPrivateProfileString(TEXT(".ShellClassInfo"), TEXT("ConfirmFileOp"), TEXT("-1"),
  401.                     szConfirmFileOp, ARRAYSIZE(szConfirmFileOp), szIniFile);
  402.             if (StrToInt(szConfirmFileOp) >= 0)
  403.             {
  404.                 fWrite = FALSE;
  405.             }
  406.         }
  407.         if (fWrite)
  408.         {
  409.             WritePrivateProfileString(TEXT(".ShellClassInfo"), TEXT("ConfirmFileOp"), TEXT("0"), szIniFile);
  410.         }
  411.         // Make desktop.ini hidden
  412.         SetFileAttributes(szIniFile, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
  413.         // Make this a system folder, so that we look for desktop.ini when we navigate to this folder.
  414.         PathMakeSystemFolder(pszPath);
  415.     }
  417.     if (dwReadWrite & FCS_READ)
  418.     {
  419.         // If we were asked to get something and we are not returning anything, return error.
  420.         if (pfcs->dwMask && !dwValueReturned)
  421.         {
  422.             hret = E_FAIL;
  423.         }
  424.         pfcs->dwMask = dwValueReturned;
  425.     }
  426.     return hret;
  427. }
  429. HRESULT SHAllocAndThunkUnicodeToTChar(LPWSTR pwsz, LPTSTR* ppsz)
  430. {
  431.     HRESULT hres = S_OK;
  433.     if (!ppsz || !pwsz)
  434.     {
  435.         hres = E_INVALIDARG;
  436.     }
  437.     else
  438.     {
  439.         int cch = lstrlenW(pwsz) + 1;
  440.         *ppsz = (LPTSTR)LocalAlloc(LMEM_FIXED, cch * SIZEOF(TCHAR));
  441.         if (!*ppsz)
  442.         {
  443.             hres = E_OUTOFMEMORY;
  444.         }
  445.         else
  446.         {
  447.             SHUnicodeToTChar(pwsz, *ppsz, cch);
  448.         }
  449.     }
  450.     return hres;
  451. }
  453. HRESULT SHAllocAndThunkAnsiToTChar(LPSTR psz, LPTSTR* ppsz)
  454. {
  455.     HRESULT hres = S_OK;
  457.     if (!ppsz || !psz)
  458.     {
  459.         hres = E_INVALIDARG;
  460.     }
  461.     else
  462.     {
  463.         int cch = lstrlenA(psz) + 1;
  464.         *ppsz = (LPTSTR)LocalAlloc(LMEM_FIXED, cch * SIZEOF(TCHAR));
  465.         if (!*ppsz)
  466.         {
  467.             hres = E_OUTOFMEMORY;
  468.         }
  469.         else
  470.         {
  471.             SHAnsiToTChar(psz, *ppsz, cch);
  472.         }
  473.     }
  474.     return hres;
  475. }
  477. // Read/write desktop.ini settings - Unicode (thunking function)
  478. HRESULT SHGetSetFolderCustomSettingsW(LPSHFOLDERCUSTOMSETTINGSW pfcsW, LPCWSTR pwszPath, DWORD dwReadWrite)
  479. {
  480.     HRESULT hres = S_OK;
  482.     if (pfcsW->dwSize >= SIZEOF(SHFOLDERCUSTOMSETTINGSW)  && pwszPath)
  483.     {
  484.         TCHAR szPath[MAX_PATH], *pszWebViewTemplate = NULL, *pszWebViewTemplateVersion = NULL;
  485.         TCHAR *pszInfoTip = NULL, *pszIconFile = NULL, *pszLogo = NULL;
  487.         SHUnicodeToTChar(pwszPath, szPath, ARRAYSIZE(szPath));
  488.         if (dwReadWrite == FCS_WRITE || dwReadWrite == FCS_FORCEWRITE)
  489.         {
  490.             if (pfcsW->dwMask & FCSM_WEBVIEWTEMPLATE && pfcsW->pszWebViewTemplate)
  491.             {
  492.                 hres = SHAllocAndThunkUnicodeToTChar(pfcsW->pszWebViewTemplate, &pszWebViewTemplate);
  493.                 if (SUCCEEDED(hres) && pfcsW->pszWebViewTemplateVersion)
  494.                 {
  495.                     hres = SHAllocAndThunkUnicodeToTChar(pfcsW->pszWebViewTemplateVersion, &pszWebViewTemplateVersion);
  496.                 }
  497.             }
  498.             if (pfcsW->dwMask & FCSM_INFOTIP && pfcsW->pszInfoTip && SUCCEEDED(hres))
  499.             {
  500.                 hres = SHAllocAndThunkUnicodeToTChar(pfcsW->pszInfoTip, &pszInfoTip);
  501.             }
  502.             if (pfcsW->dwMask & FCSM_ICONFILE && pfcsW->pszIconFile && SUCCEEDED(hres))
  503.             {
  504.                 hres = SHAllocAndThunkUnicodeToTChar(pfcsW->pszIconFile, &pszIconFile);
  505.             }
  506.             if (pfcsW->dwMask & FCSM_LOGO && pfcsW->pszLogo && SUCCEEDED(hres))
  507.             {
  508.                 hres = SHAllocAndThunkUnicodeToTChar(pfcsW->pszLogo, &pszLogo);
  509.             }
  510.         }
  511.         else if (dwReadWrite == FCS_READ)
  512.         {
  513.             if (pfcsW->dwMask & FCSM_WEBVIEWTEMPLATE && pfcsW->pszWebViewTemplate && pfcsW->cchWebViewTemplate > 0)
  514.             {
  515.                 pszWebViewTemplate = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsW->cchWebViewTemplate * SIZEOF(TCHAR));
  516.                 if (!pszWebViewTemplate)
  517.                 {
  518.                     hres = E_OUTOFMEMORY;
  519.                 }
  520.                 else
  521.                 {
  522.                     pszWebViewTemplate[0] = TEXT('');
  523.                     if (pfcsW->pszWebViewTemplateVersion)
  524.                     {
  525.                         hres = SHAllocAndThunkUnicodeToTChar(pfcsW->pszWebViewTemplateVersion, &pszWebViewTemplateVersion);
  526.                     }
  527.                 }
  528.             }
  530.             if (pfcsW->dwMask & FCSM_INFOTIP && pfcsW->pszInfoTip && pfcsW->cchInfoTip > 0 && SUCCEEDED(hres))
  531.             {
  532.                 pszInfoTip = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsW->cchInfoTip * SIZEOF(TCHAR));
  533.                 if (!pszInfoTip)
  534.                 {
  535.                     hres = E_OUTOFMEMORY;
  536.                 }
  537.                 else
  538.                 {
  539.                     pszInfoTip[0] = TEXT('');
  540.                 }
  541.             }
  543.             if (pfcsW->dwMask & FCSM_ICONFILE && pfcsW->pszIconFile && pfcsW->cchIconFile > 0 && SUCCEEDED(hres))
  544.             {
  545.                 pszIconFile = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsW->cchIconFile * SIZEOF(TCHAR));
  546.                 if (!pszIconFile)
  547.                 {
  548.                     hres = E_OUTOFMEMORY;
  549.                 }
  550.                 else
  551.                 {
  552.                     pszIconFile[0] = TEXT('');
  553.                 }
  554.             }
  556.             if (pfcsW->dwMask & FCSM_LOGO && pfcsW->pszLogo && pfcsW->cchLogo > 0 && SUCCEEDED(hres))
  557.             {
  558.                 pszLogo = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsW->cchLogo * SIZEOF(TCHAR));
  559.                 if (!pszLogo)
  560.                 {
  561.                     hres = E_OUTOFMEMORY;
  562.                 }
  563.                 else
  564.                 {
  565.                     pszLogo[0] = TEXT('');
  566.                 }
  567.             }
  569.         }
  570.         else
  571.         {
  572.             hres = E_INVALIDARG;
  573.         }
  574.         
  575.         if (SUCCEEDED(hres))
  576.         {
  577.             SHFOLDERCUSTOMSETTINGS fcs;
  578.             fcs.dwSize = sizeof(LPSHFOLDERCUSTOMSETTINGS);
  579.             fcs.dwMask = pfcsW->dwMask;
  580.             fcs.pvid = pfcsW->pvid;
  581.             fcs.pszWebViewTemplate = pszWebViewTemplate;
  582.             fcs.cchWebViewTemplate = pfcsW->cchWebViewTemplate;
  583.             fcs.pszWebViewTemplateVersion = pszWebViewTemplateVersion;
  584.             fcs.pszInfoTip = pszInfoTip;
  585.             fcs.cchInfoTip = pfcsW->cchInfoTip;
  586.             fcs.pclsid = pfcsW->pclsid;
  587.             fcs.dwFlags = pfcsW->dwFlags;
  588.             fcs.pszIconFile = pszIconFile;
  589.             fcs.cchIconFile = pfcsW->cchIconFile;
  590.             fcs.iIconIndex  = pfcsW->iIconIndex;
  591.             fcs.pszLogo = pszLogo;
  592.             fcs.cchLogo = pfcsW->cchLogo;
  594.             hres = SHGetSetFCS(&fcs, szPath, dwReadWrite);
  595.             if (SUCCEEDED(hres))
  596.             {
  597.                 if (dwReadWrite == FCS_READ)
  598.                 {
  599.                     if (fcs.dwMask & FCSM_WEBVIEWTEMPLATE && fcs.pszWebViewTemplate)
  600.                     {
  601.                         SHTCharToUnicode(fcs.pszWebViewTemplate, pfcsW->pszWebViewTemplate, pfcsW->cchWebViewTemplate);
  602.                     }
  603.                     if (fcs.dwMask & FCSM_INFOTIP && fcs.pszInfoTip)
  604.                     {
  605.                         SHTCharToUnicode(fcs.pszInfoTip, pfcsW->pszInfoTip, pfcsW->cchInfoTip);
  606.                     }
  607.                     if (fcs.dwMask & FCSM_ICONFILE && fcs.pszIconFile)
  608.                     {
  609.                         SHTCharToUnicode(fcs.pszIconFile, pfcsW->pszIconFile, pfcsW->cchIconFile);
  610.                     }
  611.                     if (fcs.dwMask & FCSM_LOGO && fcs.pszLogo)
  612.                     {
  613.                         SHTCharToUnicode(fcs.pszLogo, pfcsW->pszLogo, pfcsW->cchLogo);
  614.                     }
  615.                     pfcsW->dwFlags = fcs.dwFlags;
  616.                     pfcsW->iIconIndex = fcs.iIconIndex;
  617.                     pfcsW->dwMask = fcs.dwMask;
  618.                 }
  619.             }
  620.         }
  622.         // Free allocated memory
  623.         if (pszWebViewTemplate)
  624.         {
  625.             LocalFree(pszWebViewTemplate);
  626.         }
  627.         if (pszWebViewTemplateVersion)
  628.         {
  629.             LocalFree(pszWebViewTemplateVersion);
  630.         }
  631.         if (pszInfoTip)
  632.         {
  633.             LocalFree(pszInfoTip);
  634.         }
  635.         if (pszIconFile)
  636.         {
  637.             LocalFree(pszIconFile);
  638.         }
  639.         if (pszLogo)
  640.         {
  641.             LocalFree(pszLogo);
  642.         }
  643.     }
  644.     else
  645.     {
  646.         hres = E_INVALIDARG;
  647.     }
  648.     return hres;
  649. }
  652. // Read/write desktop.ini settings - ANSI (thunking function)
  653. HRESULT SHGetSetFolderCustomSettingsA(LPSHFOLDERCUSTOMSETTINGSA pfcsA, LPCSTR pszPath, DWORD dwReadWrite)
  654. {
  655.     HRESULT hres = S_OK;
  656.     if (pfcsA->dwSize >= SIZEOF(SHFOLDERCUSTOMSETTINGSA) && pszPath)
  657.     {
  658.         TCHAR szPath[MAX_PATH], *pszWebViewTemplate = NULL, *pszWebViewTemplateVersion = NULL;
  659.         TCHAR *pszInfoTip = NULL, *pszIconFile =NULL, *pszLogo = NULL;
  661.         SHAnsiToTChar(pszPath, szPath, ARRAYSIZE(szPath));
  662.         if (dwReadWrite == FCS_WRITE || dwReadWrite == FCS_FORCEWRITE)
  663.         {
  664.             if (pfcsA->dwMask & FCSM_WEBVIEWTEMPLATE && pfcsA->pszWebViewTemplate)
  665.             {
  666.                 hres = SHAllocAndThunkAnsiToTChar(pfcsA->pszWebViewTemplate, &pszWebViewTemplate);
  667.                 if (SUCCEEDED(hres) && pfcsA->pszWebViewTemplateVersion)
  668.                 {
  669.                     hres = SHAllocAndThunkAnsiToTChar(pfcsA->pszWebViewTemplateVersion, &pszWebViewTemplateVersion);
  670.                 }
  671.             }
  673.             if (pfcsA->dwMask & FCSM_INFOTIP && pfcsA->pszInfoTip && SUCCEEDED(hres))
  674.             {
  675.                 hres = SHAllocAndThunkAnsiToTChar(pfcsA->pszInfoTip, &pszInfoTip);
  676.             }
  678.             if (pfcsA->dwMask & FCSM_ICONFILE && pfcsA->pszIconFile && SUCCEEDED(hres))
  679.             {
  680.                 hres = SHAllocAndThunkAnsiToTChar(pfcsA->pszIconFile, &pszIconFile);
  681.             }
  683.             if (pfcsA->dwMask & FCSM_LOGO && pfcsA->pszLogo && SUCCEEDED(hres))
  684.             {
  685.                 hres = SHAllocAndThunkAnsiToTChar(pfcsA->pszLogo, &pszLogo);
  686.             }
  687.         }
  688.         else if (dwReadWrite == FCS_READ)
  689.         {
  690.             if (pfcsA->dwMask & FCSM_WEBVIEWTEMPLATE && pfcsA->pszWebViewTemplate && pfcsA->cchWebViewTemplate > 0)
  691.             {
  692.                 pszWebViewTemplate = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsA->cchWebViewTemplate * SIZEOF(TCHAR));
  693.                 if (!pszWebViewTemplate)
  694.                 {
  695.                     hres = E_OUTOFMEMORY;
  696.                 }
  697.                 else
  698.                 {
  699.                     pszWebViewTemplate[0] = TEXT('');
  700.                     if (pfcsA->pszWebViewTemplateVersion)
  701.                     {
  702.                         hres = SHAllocAndThunkAnsiToTChar(pfcsA->pszWebViewTemplateVersion, &pszWebViewTemplateVersion);
  703.                     }
  704.                 }
  705.             }
  706.             if (pfcsA->dwMask & FCSM_INFOTIP && pfcsA->pszInfoTip && pfcsA->cchInfoTip > 0 && SUCCEEDED(hres))
  707.             {
  708.                 pszInfoTip = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsA->cchInfoTip * SIZEOF(TCHAR));
  709.                 if (!pszInfoTip)
  710.                 {
  711.                     hres = E_OUTOFMEMORY;
  712.                 }
  713.                 else
  714.                 {
  715.                     pszInfoTip[0] = TEXT('');
  716.                 }
  717.             }
  718.             if (pfcsA->dwMask & FCSM_ICONFILE && pfcsA->pszIconFile && pfcsA->cchIconFile > 0 && SUCCEEDED(hres))
  719.             {
  720.                 pszIconFile = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsA->cchIconFile * SIZEOF(TCHAR));
  721.                 if (!pszIconFile)
  722.                 {
  723.                     hres = E_OUTOFMEMORY;
  724.                 }
  725.                 else
  726.                 {
  727.                     pszIconFile[0] = TEXT('');
  728.                 }
  729.             }
  730.             if (pfcsA->dwMask & FCSM_LOGO && pfcsA->pszLogo && pfcsA->cchLogo > 0 && SUCCEEDED(hres))
  731.             {
  732.                 pszLogo = (LPTSTR)LocalAlloc(LMEM_FIXED, pfcsA->cchLogo * SIZEOF(TCHAR));
  733.                 if (!pszLogo)
  734.                 {
  735.                     hres = E_OUTOFMEMORY;
  736.                 }
  737.                 else
  738.                 {
  739.                     pszLogo[0] = TEXT('');
  740.                 }
  741.             }
  742.         }
  743.         else
  744.         {
  745.             hres = E_INVALIDARG;
  746.         }
  747.         
  748.         if (SUCCEEDED(hres))
  749.         {
  750.             SHFOLDERCUSTOMSETTINGS fcs;
  751.             fcs.dwSize = sizeof(LPSHFOLDERCUSTOMSETTINGS);
  752.             fcs.dwMask = pfcsA->dwMask;
  753.             fcs.pvid = pfcsA->pvid;
  754.             fcs.pszWebViewTemplate = pszWebViewTemplate;
  755.             fcs.cchWebViewTemplate = pfcsA->cchWebViewTemplate;
  756.             fcs.pszWebViewTemplateVersion = pszWebViewTemplateVersion;
  757.             fcs.pszInfoTip = pszInfoTip;
  758.             fcs.cchInfoTip = pfcsA->cchInfoTip;
  759.             fcs.pclsid = pfcsA->pclsid;
  760.             fcs.dwFlags = pfcsA->dwFlags;
  761.             fcs.pszIconFile = pszIconFile;
  762.             fcs.cchIconFile = pfcsA->cchIconFile;
  763.             fcs.iIconIndex = pfcsA->iIconIndex;
  764.             fcs.pszLogo = pszLogo;
  765.             fcs.cchLogo = pfcsA->cchLogo;
  767.             hres = SHGetSetFCS(&fcs, szPath, dwReadWrite);
  768.             if (SUCCEEDED(hres))
  769.             {
  770.                 if (dwReadWrite == FCS_READ)
  771.                 {
  772.                     if (fcs.dwMask & FCSM_WEBVIEWTEMPLATE && fcs.pszWebViewTemplate)
  773.                     {
  774.                         SHTCharToAnsi(fcs.pszWebViewTemplate, pfcsA->pszWebViewTemplate, pfcsA->cchWebViewTemplate);
  775.                     }
  776.                     if (fcs.dwMask & FCSM_INFOTIP && fcs.pszInfoTip)
  777.                     {
  778.                         SHTCharToAnsi(fcs.pszInfoTip, pfcsA->pszInfoTip, pfcsA->cchInfoTip);
  779.                     }
  780.                     if (fcs.dwMask & FCSM_ICONFILE && fcs.pszIconFile)
  781.                     {
  782.                         SHTCharToAnsi(fcs.pszIconFile, pfcsA->pszIconFile, pfcsA->cchIconFile);
  783.                     }
  784.                     if (fcs.dwMask & FCSM_LOGO && fcs.pszLogo)
  785.                     {
  786.                         SHTCharToAnsi(fcs.pszLogo, pfcsA->pszLogo, pfcsA->cchLogo);
  787.                     }
  788.                     pfcsA->dwFlags = fcs.dwFlags;
  789.                     pfcsA->iIconIndex = fcs.iIconIndex;
  790.                     pfcsA->dwMask = fcs.dwMask;
  791.                 }
  792.             }
  793.         }
  795.         // Free allocated memory
  796.         if (pszWebViewTemplate)
  797.         {
  798.             LocalFree(pszWebViewTemplate);
  799.         }
  800.         if (pszWebViewTemplateVersion)
  801.         {
  802.             LocalFree(pszWebViewTemplateVersion);
  803.         }
  804.         if (pszInfoTip)
  805.         {
  806.             LocalFree(pszInfoTip);
  807.         }
  809.         if (pszIconFile)
  810.         {
  811.             LocalFree(pszIconFile);
  812.         }
  814.         if (pszLogo)
  815.         {
  816.             LocalFree(pszLogo);
  817.         }
  818.     }
  819.     else
  820.     {
  821.         hres = E_INVALIDARG;
  822.     }
  823.     return hres;
  824. }