git.oblomov.eu Git - wine/blob - dlls/shell32/shellord.c

   1 /*
   2  * The parameters of many functions changes between different OS versions
   3  * (NT uses Unicode strings, 95 uses ASCII strings)
   4  *
   5  * Copyright 1997 Marcus Meissner
   6  *           1998 Jürgen Schmied
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22 #include "config.h"
  23
  24 #include <string.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #define COBJMACROS
  29
  30 #include "winerror.h"
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winreg.h"
  34 #include "wine/debug.h"
  35 #include "winnls.h"
  36 #include "winternl.h"
  37
  38 #include "shellapi.h"
  39 #include "objbase.h"
  40 #include "shlguid.h"
  41 #include "wingdi.h"
  42 #include "winuser.h"
  43 #include "shlobj.h"
  44 #include "shell32_main.h"
  45 #include "undocshell.h"
  46 #include "pidl.h"
  47 #include "shlwapi.h"
  48 #include "commdlg.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  51 WINE_DECLARE_DEBUG_CHANNEL(pidl);
  52
  53 /* FIXME: !!! move CREATEMRULIST and flags to header file !!! */
  54 /*        !!! it is in both here and comctl32undoc.c      !!! */
  55 typedef struct tagCREATEMRULIST
  56 {
  57     DWORD  cbSize;        /* size of struct */
  58     DWORD  nMaxItems;     /* max no. of items in list */
  59     DWORD  dwFlags;       /* see below */
  60     HKEY   hKey;          /* root reg. key under which list is saved */
  61     LPCSTR lpszSubKey;    /* reg. subkey */
  62     PROC   lpfnCompare;   /* item compare proc */
  63 } CREATEMRULISTA, *LPCREATEMRULISTA;
  64
  65 /* dwFlags */
  66 #define MRUF_STRING_LIST  0 /* list will contain strings */
  67 #define MRUF_BINARY_LIST  1 /* list will contain binary data */
  68 #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
  69
  70 extern HANDLE WINAPI CreateMRUListA(LPCREATEMRULISTA lpcml);
  71 extern DWORD  WINAPI FreeMRUList(HANDLE hMRUList);
  72 extern INT    WINAPI AddMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData);
  73 extern INT    WINAPI FindMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum);
  74 extern INT    WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize);
  75
  76
  77 /* Get a function pointer from a DLL handle */
  78 #define GET_FUNC(func, module, name, fail) \
  79   do { \
  80     if (!func) { \
  81       if (!SHELL32_h##module && !(SHELL32_h##module = LoadLibraryA(#module ".dll"))) return fail; \
  82       func = (void*)GetProcAddress(SHELL32_h##module, name); \
  83       if (!func) return fail; \
  84     } \
  85   } while (0)
  86
  87 /* Function pointers for GET_FUNC macro */
  88 static HMODULE SHELL32_hshlwapi=NULL;
  89 static HANDLE (WINAPI *pSHAllocShared)(LPCVOID,DWORD,DWORD);
  90 static LPVOID (WINAPI *pSHLockShared)(HANDLE,DWORD);
  91 static BOOL   (WINAPI *pSHUnlockShared)(LPVOID);
  92 static BOOL   (WINAPI *pSHFreeShared)(HANDLE,DWORD);
  93
  94
  95 /*************************************************************************
  96  * ParseFieldA                                  [internal]
  97  *
  98  * copies a field from a ',' delimited string
  99  *
 100  * first field is nField = 1
 101  */
 102 DWORD WINAPI ParseFieldA(
 103         LPCSTR src,
 104         DWORD nField,
 105         LPSTR dst,
 106         DWORD len)
 107 {
 108         WARN("(%s,0x%08x,%p,%d) semi-stub.\n",debugstr_a(src),nField,dst,len);
 109
 110         if (!src || !src[0] || !dst || !len)
 111           return 0;
 112
 113         /* skip n fields delimited by ',' */
 114         while (nField > 1)
 115         {
 116           if (*src=='\0') return FALSE;
 117           if (*(src++)==',') nField--;
 118         }
 119
 120         /* copy part till the next ',' to dst */
 121         while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
 122
 123         /* finalize the string */
 124         *dst=0x0;
 125
 126         return TRUE;
 127 }
 128
 129 /*************************************************************************
 130  * ParseFieldW                  [internal]
 131  *
 132  * copies a field from a ',' delimited string
 133  *
 134  * first field is nField = 1
 135  */
 136 DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len)
 137 {
 138         WARN("(%s,0x%08x,%p,%d) semi-stub.\n", debugstr_w(src), nField, dst, len);
 139
 140         if (!src || !src[0] || !dst || !len)
 141           return 0;
 142
 143         /* skip n fields delimited by ',' */
 144         while (nField > 1)
 145         {
 146           if (*src == 0x0) return FALSE;
 147           if (*src++ == ',') nField--;
 148         }
 149
 150         /* copy part till the next ',' to dst */
 151         while ( *src != 0x0 && *src != ',' && (len--)>0 ) *(dst++) = *(src++);
 152
 153         /* finalize the string */
 154         *dst = 0x0;
 155
 156         return TRUE;
 157 }
 158
 159 /*************************************************************************
 160  * ParseField                   [SHELL32.58]
 161  */
 162 DWORD WINAPI ParseFieldAW(LPCVOID src, DWORD nField, LPVOID dst, DWORD len)
 163 {
 164         if (SHELL_OsIsUnicode())
 165           return ParseFieldW(src, nField, dst, len);
 166         return ParseFieldA(src, nField, dst, len);
 167 }
 168
 169 /*************************************************************************
 170  * GetFileNameFromBrowse                        [SHELL32.63]
 171  *
 172  */
 173 BOOL WINAPI GetFileNameFromBrowse(
 174         HWND hwndOwner,
 175         LPSTR lpstrFile,
 176         DWORD nMaxFile,
 177         LPCSTR lpstrInitialDir,
 178         LPCSTR lpstrDefExt,
 179         LPCSTR lpstrFilter,
 180         LPCSTR lpstrTitle)
 181 {
 182     HMODULE hmodule;
 183     FARPROC pGetOpenFileNameA;
 184     OPENFILENAMEA ofn;
 185     BOOL ret;
 186
 187     TRACE("%p, %s, %d, %s, %s, %s, %s)\n",
 188           hwndOwner, lpstrFile, nMaxFile, lpstrInitialDir, lpstrDefExt,
 189           lpstrFilter, lpstrTitle);
 190
 191     hmodule = LoadLibraryA("comdlg32.dll");
 192     if(!hmodule) return FALSE;
 193     pGetOpenFileNameA = GetProcAddress(hmodule, "GetOpenFileNameA");
 194     if(!pGetOpenFileNameA)
 195     {
 196         FreeLibrary(hmodule);
 197         return FALSE;
 198     }
 199
 200     memset(&ofn, 0, sizeof(ofn));
 201
 202     ofn.lStructSize = sizeof(ofn);
 203     ofn.hwndOwner = hwndOwner;
 204     ofn.lpstrFilter = lpstrFilter;
 205     ofn.lpstrFile = lpstrFile;
 206     ofn.nMaxFile = nMaxFile;
 207     ofn.lpstrInitialDir = lpstrInitialDir;
 208     ofn.lpstrTitle = lpstrTitle;
 209     ofn.lpstrDefExt = lpstrDefExt;
 210     ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
 211     ret = pGetOpenFileNameA(&ofn);
 212
 213     FreeLibrary(hmodule);
 214     return ret;
 215 }
 216
 217 /*************************************************************************
 218  * SHGetSetSettings                             [SHELL32.68]
 219  */
 220 VOID WINAPI SHGetSetSettings(LPSHELLSTATE lpss, DWORD dwMask, BOOL bSet)
 221 {
 222   if(bSet)
 223   {
 224     FIXME("%p 0x%08x TRUE\n", lpss, dwMask);
 225   }
 226   else
 227   {
 228     SHGetSettings((LPSHELLFLAGSTATE)lpss,dwMask);
 229   }
 230 }
 231
 232 /*************************************************************************
 233  * SHGetSettings                                [SHELL32.@]
 234  *
 235  * NOTES
 236  *  the registry path are for win98 (tested)
 237  *  and possibly are the same in nt40
 238  *
 239  */
 240 VOID WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
 241 {
 242         HKEY    hKey;
 243         DWORD   dwData;
 244         DWORD   dwDataSize = sizeof (DWORD);
 245
 246         TRACE("(%p 0x%08x)\n",lpsfs,dwMask);
 247
 248         if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
 249                                  0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
 250           return;
 251
 252         if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 253           lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
 254
 255         if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 256           lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
 257
 258         if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 259           lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
 260
 261         if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 262           lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
 263
 264         if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 265           lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
 266
 267         if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 268           lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
 269
 270         if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 271         { if (dwData == 0)
 272           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 273             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 274           }
 275           else if (dwData == 1)
 276           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
 277             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 278           }
 279           else if (dwData == 2)
 280           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 281             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 1;
 282           }
 283         }
 284         RegCloseKey (hKey);
 285
 286         TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
 287 }
 288
 289 /*************************************************************************
 290  * SHShellFolderView_Message                    [SHELL32.73]
 291  *
 292  * Send a message to an explorer cabinet window.
 293  *
 294  * PARAMS
 295  *  hwndCabinet [I] The window containing the shellview to communicate with
 296  *  dwMessage   [I] The SFVM message to send
 297  *  dwParam     [I] Message parameter
 298  *
 299  * RETURNS
 300  *  fixme.
 301  *
 302  * NOTES
 303  *  Message SFVM_REARRANGE = 1
 304  *
 305  *    This message gets sent when a column gets clicked to instruct the
 306  *    shell view to re-sort the item list. dwParam identifies the column
 307  *    that was clicked.
 308  */
 309 LRESULT WINAPI SHShellFolderView_Message(
 310         HWND hwndCabinet,
 311         UINT uMessage,
 312         LPARAM lParam)
 313 {
 314         FIXME("%p %08x %08lx stub\n",hwndCabinet, uMessage, lParam);
 315         return 0;
 316 }
 317
 318 /*************************************************************************
 319  * RegisterShellHook                            [SHELL32.181]
 320  *
 321  * Register a shell hook.
 322  *
 323  * PARAMS
 324  *      hwnd   [I]  Window handle
 325  *      dwType [I]  Type of hook.
 326  *
 327  * NOTES
 328  *     Exported by ordinal
 329  */
 330 BOOL WINAPI RegisterShellHook(
 331         HWND hWnd,
 332         DWORD dwType)
 333 {
 334         FIXME("(%p,0x%08x):stub.\n",hWnd, dwType);
 335         return TRUE;
 336 }
 337
 338 /*************************************************************************
 339  * ShellMessageBoxW                             [SHELL32.182]
 340  *
 341  * See ShellMessageBoxA.
 342  *
 343  * NOTE:
 344  * shlwapi.ShellMessageBoxWrapW is a duplicate of shell32.ShellMessageBoxW
 345  * because we can't forward to it in the .spec file since it's exported by
 346  * ordinal. If you change the implementation here please update the code in
 347  * shlwapi as well.
 348  */
 349 int WINAPIV ShellMessageBoxW(
 350         HINSTANCE hInstance,
 351         HWND hWnd,
 352         LPCWSTR lpText,
 353         LPCWSTR lpCaption,
 354         UINT uType,
 355         ...)
 356 {
 357         WCHAR   szText[100],szTitle[100];
 358         LPCWSTR pszText = szText, pszTitle = szTitle;
 359         LPWSTR  pszTemp;
 360         __ms_va_list args;
 361         int     ret;
 362
 363         __ms_va_start(args, uType);
 364         /* wvsprintfA(buf,fmt, args); */
 365
 366         TRACE("(%p,%p,%p,%p,%08x)\n",
 367             hInstance,hWnd,lpText,lpCaption,uType);
 368
 369         if (IS_INTRESOURCE(lpCaption))
 370           LoadStringW(hInstance, LOWORD(lpCaption), szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
 371         else
 372           pszTitle = lpCaption;
 373
 374         if (IS_INTRESOURCE(lpText))
 375           LoadStringW(hInstance, LOWORD(lpText), szText, sizeof(szText)/sizeof(szText[0]));
 376         else
 377           pszText = lpText;
 378
 379         FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
 380                        pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
 381
 382         __ms_va_end(args);
 383
 384         ret = MessageBoxW(hWnd,pszTemp,pszTitle,uType);
 385         LocalFree(pszTemp);
 386         return ret;
 387 }
 388
 389 /*************************************************************************
 390  * ShellMessageBoxA                             [SHELL32.183]
 391  *
 392  * Format and output an error message.
 393  *
 394  * PARAMS
 395  *  hInstance [I] Instance handle of message creator
 396  *  hWnd      [I] Window handle of message creator
 397  *  lpText    [I] Resource Id of title or LPSTR
 398  *  lpCaption [I] Resource Id of title or LPSTR
 399  *  uType     [I] Type of error message
 400  *
 401  * RETURNS
 402  *  A return value from MessageBoxA().
 403  *
 404  * NOTES
 405  *     Exported by ordinal
 406  */
 407 int WINAPIV ShellMessageBoxA(
 408         HINSTANCE hInstance,
 409         HWND hWnd,
 410         LPCSTR lpText,
 411         LPCSTR lpCaption,
 412         UINT uType,
 413         ...)
 414 {
 415         char    szText[100],szTitle[100];
 416         LPCSTR  pszText = szText, pszTitle = szTitle;
 417         LPSTR   pszTemp;
 418         __ms_va_list args;
 419         int     ret;
 420
 421         __ms_va_start(args, uType);
 422         /* wvsprintfA(buf,fmt, args); */
 423
 424         TRACE("(%p,%p,%p,%p,%08x)\n",
 425             hInstance,hWnd,lpText,lpCaption,uType);
 426
 427         if (IS_INTRESOURCE(lpCaption))
 428           LoadStringA(hInstance, LOWORD(lpCaption), szTitle, sizeof(szTitle));
 429         else
 430           pszTitle = lpCaption;
 431
 432         if (IS_INTRESOURCE(lpText))
 433           LoadStringA(hInstance, LOWORD(lpText), szText, sizeof(szText));
 434         else
 435           pszText = lpText;
 436
 437         FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
 438                        pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
 439
 440         __ms_va_end(args);
 441
 442         ret = MessageBoxA(hWnd,pszTemp,pszTitle,uType);
 443         LocalFree(pszTemp);
 444         return ret;
 445 }
 446
 447 /*************************************************************************
 448  * SHRegisterDragDrop                           [SHELL32.86]
 449  *
 450  * Probably equivalent to RegisterDragDrop but under Windows 95 it could use the
 451  * shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
 452  * for details. Under Windows 98 this function initializes the true OLE when called
 453  * the first time, on XP always returns E_OUTOFMEMORY and it got removed from Vista.
 454  *
 455  * We follow Windows 98 behaviour.
 456  *
 457  * NOTES
 458  *     exported by ordinal
 459  *
 460  * SEE ALSO
 461  *     RegisterDragDrop, SHLoadOLE
 462  */
 463 HRESULT WINAPI SHRegisterDragDrop(
 464         HWND hWnd,
 465         LPDROPTARGET pDropTarget)
 466 {
 467         static BOOL ole_initialized = FALSE;
 468         HRESULT hr;
 469
 470         TRACE("(%p,%p)\n", hWnd, pDropTarget);
 471
 472         if (!ole_initialized)
 473         {
 474             hr = OleInitialize(NULL);
 475             if (FAILED(hr))
 476                 return hr;
 477             ole_initialized = TRUE;
 478         }
 479         return RegisterDragDrop(hWnd, pDropTarget);
 480 }
 481
 482 /*************************************************************************
 483  * SHRevokeDragDrop                             [SHELL32.87]
 484  *
 485  * Probably equivalent to RevokeDragDrop but under Windows 95 it could use the
 486  * shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
 487  * for details. Function removed from Windows Vista.
 488  *
 489  * We call ole32 RevokeDragDrop which seems to work even if OleInitialize was
 490  * not called.
 491  *
 492  * NOTES
 493  *     exported by ordinal
 494  *
 495  * SEE ALSO
 496  *     RevokeDragDrop, SHLoadOLE
 497  */
 498 HRESULT WINAPI SHRevokeDragDrop(HWND hWnd)
 499 {
 500     TRACE("(%p)\n", hWnd);
 501     return RevokeDragDrop(hWnd);
 502 }
 503
 504 /*************************************************************************
 505  * SHDoDragDrop                                 [SHELL32.88]
 506  *
 507  * Probably equivalent to DoDragDrop but under Windows 9x it could use the
 508  * shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
 509  * for details
 510  *
 511  * NOTES
 512  *     exported by ordinal
 513  *
 514  * SEE ALSO
 515  *     DoDragDrop, SHLoadOLE
 516  */
 517 HRESULT WINAPI SHDoDragDrop(
 518         HWND hWnd,
 519         LPDATAOBJECT lpDataObject,
 520         LPDROPSOURCE lpDropSource,
 521         DWORD dwOKEffect,
 522         LPDWORD pdwEffect)
 523 {
 524     FIXME("(%p %p %p 0x%08x %p):stub.\n",
 525     hWnd, lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
 526         return DoDragDrop(lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
 527 }
 528
 529 /*************************************************************************
 530  * ArrangeWindows                               [SHELL32.184]
 531  *
 532  */
 533 WORD WINAPI ArrangeWindows(
 534         HWND hwndParent,
 535         DWORD dwReserved,
 536         LPCRECT lpRect,
 537         WORD cKids,
 538         CONST HWND * lpKids)
 539 {
 540     FIXME("(%p 0x%08x %p 0x%04x %p):stub.\n",
 541            hwndParent, dwReserved, lpRect, cKids, lpKids);
 542     return 0;
 543 }
 544
 545 /*************************************************************************
 546  * SignalFileOpen                               [SHELL32.103]
 547  *
 548  * NOTES
 549  *     exported by ordinal
 550  */
 551 DWORD WINAPI
 552 SignalFileOpen (DWORD dwParam1)
 553 {
 554     FIXME("(0x%08x):stub.\n", dwParam1);
 555
 556     return 0;
 557 }
 558
 559 /*************************************************************************
 560  * SHADD_get_policy - helper function for SHAddToRecentDocs
 561  *
 562  * PARAMETERS
 563  *   policy    [IN]  policy name (null termed string) to find
 564  *   type      [OUT] ptr to DWORD to receive type
 565  *   buffer    [OUT] ptr to area to hold data retrieved
 566  *   len       [IN/OUT] ptr to DWORD holding size of buffer and getting
 567  *                      length filled
 568  *
 569  * RETURNS
 570  *   result of the SHQueryValueEx call
 571  */
 572 static INT SHADD_get_policy(LPCSTR policy, LPDWORD type, LPVOID buffer, LPDWORD len)
 573 {
 574     HKEY Policy_basekey;
 575     INT ret;
 576
 577     /* Get the key for the policies location in the registry
 578      */
 579     if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 580                       "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
 581                       0, KEY_READ, &Policy_basekey)) {
 582
 583         if (RegOpenKeyExA(HKEY_CURRENT_USER,
 584                           "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
 585                           0, KEY_READ, &Policy_basekey)) {
 586             TRACE("No Explorer Policies location exists. Policy wanted=%s\n",
 587                   policy);
 588             *len = 0;
 589             return ERROR_FILE_NOT_FOUND;
 590         }
 591     }
 592
 593     /* Retrieve the data if it exists
 594      */
 595     ret = SHQueryValueExA(Policy_basekey, policy, 0, type, buffer, len);
 596     RegCloseKey(Policy_basekey);
 597     return ret;
 598 }
 599
 600
 601 /*************************************************************************
 602  * SHADD_compare_mru - helper function for SHAddToRecentDocs
 603  *
 604  * PARAMETERS
 605  *   data1     [IN] data being looked for
 606  *   data2     [IN] data in MRU
 607  *   cbdata    [IN] length from FindMRUData call (not used)
 608  *
 609  * RETURNS
 610  *   position within MRU list that data was added.
 611  */
 612 static INT CALLBACK SHADD_compare_mru(LPCVOID data1, LPCVOID data2, DWORD cbData)
 613 {
 614     return lstrcmpiA(data1, data2);
 615 }
 616
 617 /*************************************************************************
 618  * SHADD_create_add_mru_data - helper function for SHAddToRecentDocs
 619  *
 620  * PARAMETERS
 621  *   mruhandle    [IN] handle for created MRU list
 622  *   doc_name     [IN] null termed pure doc name
 623  *   new_lnk_name [IN] null termed path and file name for .lnk file
 624  *   buffer       [IN/OUT] 2048 byte area to construct MRU data
 625  *   len          [OUT] ptr to int to receive space used in buffer
 626  *
 627  * RETURNS
 628  *   position within MRU list that data was added.
 629  */
 630 static INT SHADD_create_add_mru_data(HANDLE mruhandle, LPCSTR doc_name, LPCSTR new_lnk_name,
 631                                      LPSTR buffer, INT *len)
 632 {
 633     LPSTR ptr;
 634     INT wlen;
 635
 636     /*FIXME: Document:
 637      *  RecentDocs MRU data structure seems to be:
 638      *    +0h   document file name w/ terminating 0h
 639      *    +nh   short int w/ size of remaining
 640      *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown
 641      *    +n+4h 10 bytes zeros  -   unknown
 642      *    +n+eh shortcut file name w/ terminating 0h
 643      *    +n+e+nh 3 zero bytes  -  unknown
 644      */
 645
 646     /* Create the MRU data structure for "RecentDocs"
 647          */
 648     ptr = buffer;
 649     lstrcpyA(ptr, doc_name);
 650     ptr += (lstrlenA(buffer) + 1);
 651     wlen= lstrlenA(new_lnk_name) + 1 + 12;
 652     *((short int*)ptr) = wlen;
 653     ptr += 2;   /* step past the length */
 654     *(ptr++) = 0x30;  /* unknown reason */
 655     *(ptr++) = 0;     /* unknown, but can be 0x00, 0x01, 0x02 */
 656     memset(ptr, 0, 10);
 657     ptr += 10;
 658     lstrcpyA(ptr, new_lnk_name);
 659     ptr += (lstrlenA(new_lnk_name) + 1);
 660     memset(ptr, 0, 3);
 661     ptr += 3;
 662     *len = ptr - buffer;
 663
 664     /* Add the new entry into the MRU list
 665      */
 666     return AddMRUData(mruhandle, buffer, *len);
 667 }
 668
 669 /*************************************************************************
 670  * SHAddToRecentDocs                            [SHELL32.@]
 671  *
 672  * Modify (add/clear) Shell's list of recently used documents.
 673  *
 674  * PARAMETERS
 675  *   uFlags  [IN] SHARD_PATHA, SHARD_PATHW or SHARD_PIDL
 676  *   pv      [IN] string or pidl, NULL clears the list
 677  *
 678  * NOTES
 679  *     exported by name
 680  *
 681  * FIXME
 682  *  convert to unicode
 683  */
 684 void WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
 685 {
 686 /* If list is a string list lpfnCompare has the following prototype
 687  * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
 688  * for binary lists the prototype is
 689  * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
 690  * where cbData is the no. of bytes to compare.
 691  * Need to check what return value means identical - 0?
 692  */
 693
 694
 695     UINT olderrormode;
 696     HKEY HCUbasekey;
 697     CHAR doc_name[MAX_PATH];
 698     CHAR link_dir[MAX_PATH];
 699     CHAR new_lnk_filepath[MAX_PATH];
 700     CHAR new_lnk_name[MAX_PATH];
 701     IMalloc *ppM;
 702     LPITEMIDLIST pidl;
 703     HWND hwnd = 0;       /* FIXME:  get real window handle */
 704     INT ret;
 705     DWORD data[64], datalen, type;
 706
 707     TRACE("%04x %p\n", uFlags, pv);
 708
 709     /*FIXME: Document:
 710      *  RecentDocs MRU data structure seems to be:
 711      *    +0h   document file name w/ terminating 0h
 712      *    +nh   short int w/ size of remaining
 713      *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown
 714      *    +n+4h 10 bytes zeros  -   unknown
 715      *    +n+eh shortcut file name w/ terminating 0h
 716      *    +n+e+nh 3 zero bytes  -  unknown
 717      */
 718
 719     /* See if we need to do anything.
 720      */
 721     datalen = 64;
 722     ret=SHADD_get_policy( "NoRecentDocsHistory", &type, data, &datalen);
 723     if ((ret > 0) && (ret != ERROR_FILE_NOT_FOUND)) {
 724         ERR("Error %d getting policy \"NoRecentDocsHistory\"\n", ret);
 725         return;
 726     }
 727     if (ret == ERROR_SUCCESS) {
 728         if (!( (type == REG_DWORD) ||
 729                ((type == REG_BINARY) && (datalen == 4)) )) {
 730             ERR("Error policy data for \"NoRecentDocsHistory\" not formatted correctly, type=%d, len=%d\n",
 731                 type, datalen);
 732             return;
 733         }
 734
 735         TRACE("policy value for NoRecentDocsHistory = %08x\n", data[0]);
 736         /* now test the actual policy value */
 737         if ( data[0] != 0)
 738             return;
 739     }
 740
 741     /* Open key to where the necessary info is
 742      */
 743     /* FIXME: This should be done during DLL PROCESS_ATTACH (or THREAD_ATTACH)
 744      *        and the close should be done during the _DETACH. The resulting
 745      *        key is stored in the DLL global data.
 746      */
 747     if (RegCreateKeyExA(HKEY_CURRENT_USER,
 748                         "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
 749                         0, 0, 0, KEY_READ, 0, &HCUbasekey, 0)) {
 750         ERR("Failed to create 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer'\n");
 751         return;
 752     }
 753
 754     /* Get path to user's "Recent" directory
 755      */
 756     if(SUCCEEDED(SHGetMalloc(&ppM))) {
 757         if (SUCCEEDED(SHGetSpecialFolderLocation(hwnd, CSIDL_RECENT,
 758                                                  &pidl))) {
 759             SHGetPathFromIDListA(pidl, link_dir);
 760             IMalloc_Free(ppM, pidl);
 761         }
 762         else {
 763             /* serious issues */
 764             link_dir[0] = 0;
 765             ERR("serious issues 1\n");
 766         }
 767         IMalloc_Release(ppM);
 768     }
 769     else {
 770         /* serious issues */
 771         link_dir[0] = 0;
 772         ERR("serious issues 2\n");
 773     }
 774     TRACE("Users Recent dir %s\n", link_dir);
 775
 776     /* If no input, then go clear the lists */
 777     if (!pv) {
 778         /* clear user's Recent dir
 779          */
 780
 781         /* FIXME: delete all files in "link_dir"
 782          *
 783          * while( more files ) {
 784          *    lstrcpyA(old_lnk_name, link_dir);
 785          *    PathAppendA(old_lnk_name, filenam);
 786          *    DeleteFileA(old_lnk_name);
 787          * }
 788          */
 789         FIXME("should delete all files in %s\\\n", link_dir);
 790
 791         /* clear MRU list
 792          */
 793         /* MS Bug ?? v4.72.3612.1700 of shell32 does the delete against
 794          *  HKEY_LOCAL_MACHINE version of ...CurrentVersion\Explorer
 795          *  and naturally it fails w/ rc=2. It should do it against
 796          *  HKEY_CURRENT_USER which is where it is stored, and where
 797          *  the MRU routines expect it!!!!
 798          */
 799         RegDeleteKeyA(HCUbasekey, "RecentDocs");
 800         RegCloseKey(HCUbasekey);
 801         return;
 802     }
 803
 804     /* Have data to add, the jobs to be done:
 805      *   1. Add document to MRU list in registry "HKCU\Software\
 806      *      Microsoft\Windows\CurrentVersion\Explorer\RecentDocs".
 807      *   2. Add shortcut to document in the user's Recent directory
 808      *      (CSIDL_RECENT).
 809      *   3. Add shortcut to Start menu's Documents submenu.
 810      */
 811
 812     /* Get the pure document name from the input
 813      */
 814     switch (uFlags)
 815     {
 816     case SHARD_PIDL:
 817         SHGetPathFromIDListA(pv, doc_name);
 818         break;
 819
 820     case SHARD_PATHA:
 821         lstrcpynA(doc_name, pv, MAX_PATH);
 822         break;
 823
 824     case SHARD_PATHW:
 825         WideCharToMultiByte(CP_ACP, 0, pv, -1, doc_name, MAX_PATH, NULL, NULL);
 826         break;
 827
 828     default:
 829         FIXME("Unsupported flags: %u\n", uFlags);
 830         return;
 831     }
 832
 833     TRACE("full document name %s\n", debugstr_a(doc_name));
 834     PathStripPathA(doc_name);
 835     TRACE("stripped document name %s\n", debugstr_a(doc_name));
 836
 837
 838     /* ***  JOB 1: Update registry for ...\Explorer\RecentDocs list  *** */
 839
 840     {  /* on input needs:
 841         *      doc_name    -  pure file-spec, no path
 842         *      link_dir    -  path to the user's Recent directory
 843         *      HCUbasekey  -  key of ...Windows\CurrentVersion\Explorer" node
 844         * creates:
 845         *      new_lnk_name-  pure file-spec, no path for new .lnk file
 846         *      new_lnk_filepath
 847         *                  -  path and file name of new .lnk file
 848         */
 849         CREATEMRULISTA mymru;
 850         HANDLE mruhandle;
 851         INT len, pos, bufused, err;
 852         INT i;
 853         DWORD attr;
 854         CHAR buffer[2048];
 855         CHAR *ptr;
 856         CHAR old_lnk_name[MAX_PATH];
 857         short int slen;
 858
 859         mymru.cbSize = sizeof(CREATEMRULISTA);
 860         mymru.nMaxItems = 15;
 861         mymru.dwFlags = MRUF_BINARY_LIST | MRUF_DELAYED_SAVE;
 862         mymru.hKey = HCUbasekey;
 863         mymru.lpszSubKey = "RecentDocs";
 864         mymru.lpfnCompare = (PROC)SHADD_compare_mru;
 865         mruhandle = CreateMRUListA(&mymru);
 866         if (!mruhandle) {
 867             /* MRU failed */
 868             ERR("MRU processing failed, handle zero\n");
 869             RegCloseKey(HCUbasekey);
 870             return;
 871         }
 872         len = lstrlenA(doc_name);
 873         pos = FindMRUData(mruhandle, doc_name, len, 0);
 874
 875         /* Now get the MRU entry that will be replaced
 876          * and delete the .lnk file for it
 877          */
 878         if ((bufused = EnumMRUListA(mruhandle, (pos == -1) ? 14 : pos,
 879                                     buffer, 2048)) != -1) {
 880             ptr = buffer;
 881             ptr += (lstrlenA(buffer) + 1);
 882             slen = *((short int*)ptr);
 883             ptr += 2;  /* skip the length area */
 884             if (bufused >= slen + (ptr-buffer)) {
 885                 /* buffer size looks good */
 886                 ptr += 12; /* get to string */
 887                 len = bufused - (ptr-buffer);  /* get length of buf remaining */
 888                 if ((lstrlenA(ptr) > 0) && (lstrlenA(ptr) <= len-1)) {
 889                     /* appears to be good string */
 890                     lstrcpyA(old_lnk_name, link_dir);
 891                     PathAppendA(old_lnk_name, ptr);
 892                     if (!DeleteFileA(old_lnk_name)) {
 893                         if ((attr = GetFileAttributesA(old_lnk_name)) == INVALID_FILE_ATTRIBUTES) {
 894                             if ((err = GetLastError()) != ERROR_FILE_NOT_FOUND) {
 895                                 ERR("Delete for %s failed, err=%d, attr=%08x\n",
 896                                     old_lnk_name, err, attr);
 897                             }
 898                             else {
 899                                 TRACE("old .lnk file %s did not exist\n",
 900                                       old_lnk_name);
 901                             }
 902                         }
 903                         else {
 904                             ERR("Delete for %s failed, attr=%08x\n",
 905                                 old_lnk_name, attr);
 906                         }
 907                     }
 908                     else {
 909                         TRACE("deleted old .lnk file %s\n", old_lnk_name);
 910                     }
 911                 }
 912             }
 913         }
 914
 915         /* Create usable .lnk file name for the "Recent" directory
 916          */
 917         wsprintfA(new_lnk_name, "%s.lnk", doc_name);
 918         lstrcpyA(new_lnk_filepath, link_dir);
 919         PathAppendA(new_lnk_filepath, new_lnk_name);
 920         i = 1;
 921         olderrormode = SetErrorMode(SEM_FAILCRITICALERRORS);
 922         while (GetFileAttributesA(new_lnk_filepath) != INVALID_FILE_ATTRIBUTES) {
 923             i++;
 924             wsprintfA(new_lnk_name, "%s (%u).lnk", doc_name, i);
 925             lstrcpyA(new_lnk_filepath, link_dir);
 926             PathAppendA(new_lnk_filepath, new_lnk_name);
 927         }
 928         SetErrorMode(olderrormode);
 929         TRACE("new shortcut will be %s\n", new_lnk_filepath);
 930
 931         /* Now add the new MRU entry and data
 932          */
 933         pos = SHADD_create_add_mru_data(mruhandle, doc_name, new_lnk_name,
 934                                         buffer, &len);
 935         FreeMRUList(mruhandle);
 936         TRACE("Updated MRU list, new doc is position %d\n", pos);
 937     }
 938
 939     /* ***  JOB 2: Create shortcut in user's "Recent" directory  *** */
 940
 941     {  /* on input needs:
 942         *      doc_name    -  pure file-spec, no path
 943         *      new_lnk_filepath
 944         *                  -  path and file name of new .lnk file
 945         *      uFlags[in]  -  flags on call to SHAddToRecentDocs
 946         *      pv[in]      -  document path/pidl on call to SHAddToRecentDocs
 947         */
 948         IShellLinkA *psl = NULL;
 949         IPersistFile *pPf = NULL;
 950         HRESULT hres;
 951         CHAR desc[MAX_PATH];
 952         WCHAR widelink[MAX_PATH];
 953
 954         CoInitialize(0);
 955
 956         hres = CoCreateInstance( &CLSID_ShellLink,
 957                                  NULL,
 958                                  CLSCTX_INPROC_SERVER,
 959                                  &IID_IShellLinkA,
 960                                  (LPVOID )&psl);
 961         if(SUCCEEDED(hres)) {
 962
 963             hres = IShellLinkA_QueryInterface(psl, &IID_IPersistFile,
 964                                              (LPVOID *)&pPf);
 965             if(FAILED(hres)) {
 966                 /* bombed */
 967                 ERR("failed QueryInterface for IPersistFile %08x\n", hres);
 968                 goto fail;
 969             }
 970
 971             /* Set the document path or pidl */
 972             if (uFlags == SHARD_PIDL) {
 973                 hres = IShellLinkA_SetIDList(psl, pv);
 974             } else {
 975                 hres = IShellLinkA_SetPath(psl, pv);
 976             }
 977             if(FAILED(hres)) {
 978                 /* bombed */
 979                 ERR("failed Set{IDList|Path} %08x\n", hres);
 980                 goto fail;
 981             }
 982
 983             lstrcpyA(desc, "Shortcut to ");
 984             lstrcatA(desc, doc_name);
 985             hres = IShellLinkA_SetDescription(psl, desc);
 986             if(FAILED(hres)) {
 987                 /* bombed */
 988                 ERR("failed SetDescription %08x\n", hres);
 989                 goto fail;
 990             }
 991
 992             MultiByteToWideChar(CP_ACP, 0, new_lnk_filepath, -1,
 993                                 widelink, MAX_PATH);
 994             /* create the short cut */
 995             hres = IPersistFile_Save(pPf, widelink, TRUE);
 996             if(FAILED(hres)) {
 997                 /* bombed */
 998                 ERR("failed IPersistFile::Save %08x\n", hres);
 999                 IPersistFile_Release(pPf);
1000                 IShellLinkA_Release(psl);
1001                 goto fail;
1002             }
1003             hres = IPersistFile_SaveCompleted(pPf, widelink);
1004             IPersistFile_Release(pPf);
1005             IShellLinkA_Release(psl);
1006             TRACE("shortcut %s has been created, result=%08x\n",
1007                   new_lnk_filepath, hres);
1008         }
1009         else {
1010             ERR("CoCreateInstance failed, hres=%08x\n", hres);
1011         }
1012     }
1013
1014  fail:
1015     CoUninitialize();
1016
1017     /* all done */
1018     RegCloseKey(HCUbasekey);
1019     return;
1020 }
1021
1022 /*************************************************************************
1023  * SHCreateShellFolderViewEx                    [SHELL32.174]
1024  *
1025  * Create a new instance of the default Shell folder view object.
1026  *
1027  * RETURNS
1028  *  Success: S_OK
1029  *  Failure: error value
1030  *
1031  * NOTES
1032  *  see IShellFolder::CreateViewObject
1033  */
1034 HRESULT WINAPI SHCreateShellFolderViewEx(
1035         LPCSFV psvcbi,    /* [in] shelltemplate struct */
1036         IShellView **ppv) /* [out] IShellView pointer */
1037 {
1038         IShellView * psf;
1039         HRESULT hRes;
1040
1041         TRACE("sf=%p pidl=%p cb=%p mode=0x%08x parm=%p\n",
1042           psvcbi->pshf, psvcbi->pidl, psvcbi->pfnCallback,
1043           psvcbi->fvm, psvcbi->psvOuter);
1044
1045         psf = IShellView_Constructor(psvcbi->pshf);
1046
1047         if (!psf)
1048           return E_OUTOFMEMORY;
1049
1050         IShellView_AddRef(psf);
1051         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
1052         IShellView_Release(psf);
1053
1054         return hRes;
1055 }
1056 /*************************************************************************
1057  *  SHWinHelp                                   [SHELL32.127]
1058  *
1059  */
1060 HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
1061 {       FIXME("0x%08x 0x%08x 0x%08x 0x%08x stub\n",v,w,x,z);
1062         return 0;
1063 }
1064 /*************************************************************************
1065  *  SHRunControlPanel [SHELL32.161]
1066  *
1067  */
1068 HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
1069 {       FIXME("0x%08x 0x%08x stub\n",x,z);
1070         return 0;
1071 }
1072
1073 static LPUNKNOWN SHELL32_IExplorerInterface=0;
1074 /*************************************************************************
1075  * SHSetInstanceExplorer                        [SHELL32.176]
1076  *
1077  * NOTES
1078  *  Sets the interface
1079  */
1080 VOID WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
1081 {       TRACE("%p\n", lpUnknown);
1082         SHELL32_IExplorerInterface = lpUnknown;
1083 }
1084 /*************************************************************************
1085  * SHGetInstanceExplorer                        [SHELL32.@]
1086  *
1087  * NOTES
1088  *  gets the interface pointer of the explorer and a reference
1089  */
1090 HRESULT WINAPI SHGetInstanceExplorer (IUnknown **lpUnknown)
1091 {       TRACE("%p\n", lpUnknown);
1092
1093         *lpUnknown = SHELL32_IExplorerInterface;
1094
1095         if (!SHELL32_IExplorerInterface)
1096           return E_FAIL;
1097
1098         IUnknown_AddRef(SHELL32_IExplorerInterface);
1099         return NOERROR;
1100 }
1101 /*************************************************************************
1102  * SHFreeUnusedLibraries                        [SHELL32.123]
1103  *
1104  * Probably equivalent to CoFreeUnusedLibraries but under Windows 9x it could use
1105  * the shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
1106  * for details
1107  *
1108  * NOTES
1109  *     exported by ordinal
1110  *
1111  * SEE ALSO
1112  *     CoFreeUnusedLibraries, SHLoadOLE
1113  */
1114 void WINAPI SHFreeUnusedLibraries (void)
1115 {
1116         FIXME("stub\n");
1117         CoFreeUnusedLibraries();
1118 }
1119 /*************************************************************************
1120  * DAD_AutoScroll                               [SHELL32.129]
1121  *
1122  */
1123 BOOL WINAPI DAD_AutoScroll(HWND hwnd, AUTO_SCROLL_DATA *samples, LPPOINT pt)
1124 {
1125     FIXME("hwnd = %p %p %p\n",hwnd,samples,pt);
1126     return 0;
1127 }
1128 /*************************************************************************
1129  * DAD_DragEnter                                [SHELL32.130]
1130  *
1131  */
1132 BOOL WINAPI DAD_DragEnter(HWND hwnd)
1133 {
1134     FIXME("hwnd = %p\n",hwnd);
1135     return FALSE;
1136 }
1137 /*************************************************************************
1138  * DAD_DragEnterEx                              [SHELL32.131]
1139  *
1140  */
1141 BOOL WINAPI DAD_DragEnterEx(HWND hwnd, POINT p)
1142 {
1143     FIXME("hwnd = %p (%d,%d)\n",hwnd,p.x,p.y);
1144     return FALSE;
1145 }
1146 /*************************************************************************
1147  * DAD_DragMove                         [SHELL32.134]
1148  *
1149  */
1150 BOOL WINAPI DAD_DragMove(POINT p)
1151 {
1152     FIXME("(%d,%d)\n",p.x,p.y);
1153     return FALSE;
1154 }
1155 /*************************************************************************
1156  * DAD_DragLeave                                [SHELL32.132]
1157  *
1158  */
1159 BOOL WINAPI DAD_DragLeave(VOID)
1160 {
1161     FIXME("\n");
1162     return FALSE;
1163 }
1164 /*************************************************************************
1165  * DAD_SetDragImage                             [SHELL32.136]
1166  *
1167  * NOTES
1168  *  exported by name
1169  */
1170 BOOL WINAPI DAD_SetDragImage(
1171         HIMAGELIST himlTrack,
1172         LPPOINT lppt)
1173 {
1174         FIXME("%p %p stub\n",himlTrack, lppt);
1175   return 0;
1176 }
1177 /*************************************************************************
1178  * DAD_ShowDragImage                            [SHELL32.137]
1179  *
1180  * NOTES
1181  *  exported by name
1182  */
1183 BOOL WINAPI DAD_ShowDragImage(BOOL bShow)
1184 {
1185         FIXME("0x%08x stub\n",bShow);
1186         return 0;
1187 }
1188
1189 static const WCHAR szwCabLocation[] = {
1190   'S','o','f','t','w','a','r','e','\\',
1191   'M','i','c','r','o','s','o','f','t','\\',
1192   'W','i','n','d','o','w','s','\\',
1193   'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1194   'E','x','p','l','o','r','e','r','\\',
1195   'C','a','b','i','n','e','t','S','t','a','t','e',0
1196 };
1197
1198 static const WCHAR szwSettings[] = { 'S','e','t','t','i','n','g','s',0 };
1199
1200 /*************************************************************************
1201  * ReadCabinetState                             [SHELL32.651] NT 4.0
1202  *
1203  */
1204 BOOL WINAPI ReadCabinetState(CABINETSTATE *cs, int length)
1205 {
1206         HKEY hkey = 0;
1207         DWORD type, r;
1208
1209         TRACE("%p %d\n", cs, length);
1210
1211         if( (cs == NULL) || (length < (int)sizeof(*cs))  )
1212                 return FALSE;
1213
1214         r = RegOpenKeyW( HKEY_CURRENT_USER, szwCabLocation, &hkey );
1215         if( r == ERROR_SUCCESS )
1216         {
1217                 type = REG_BINARY;
1218                 r = RegQueryValueExW( hkey, szwSettings,
1219                         NULL, &type, (LPBYTE)cs, (LPDWORD)&length );
1220                 RegCloseKey( hkey );
1221
1222         }
1223
1224         /* if we can't read from the registry, create default values */
1225         if ( (r != ERROR_SUCCESS) || (cs->cLength < sizeof(*cs)) ||
1226                 (cs->cLength != length) )
1227         {
1228                 ERR("Initializing shell cabinet settings\n");
1229                 memset(cs, 0, sizeof(*cs));
1230                 cs->cLength          = sizeof(*cs);
1231                 cs->nVersion         = 2;
1232                 cs->fFullPathTitle   = FALSE;
1233                 cs->fSaveLocalView   = TRUE;
1234                 cs->fNotShell        = FALSE;
1235                 cs->fSimpleDefault   = TRUE;
1236                 cs->fDontShowDescBar = FALSE;
1237                 cs->fNewWindowMode   = FALSE;
1238                 cs->fShowCompColor   = FALSE;
1239                 cs->fDontPrettyNames = FALSE;
1240                 cs->fAdminsCreateCommonGroups = TRUE;
1241                 cs->fMenuEnumFilter  = 96;
1242         }
1243
1244         return TRUE;
1245 }
1246
1247 /*************************************************************************
1248  * WriteCabinetState                            [SHELL32.652] NT 4.0
1249  *
1250  */
1251 BOOL WINAPI WriteCabinetState(CABINETSTATE *cs)
1252 {
1253         DWORD r;
1254         HKEY hkey = 0;
1255
1256         TRACE("%p\n",cs);
1257
1258         if( cs == NULL )
1259                 return FALSE;
1260
1261         r = RegCreateKeyExW( HKEY_CURRENT_USER, szwCabLocation, 0,
1262                  NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1263         if( r == ERROR_SUCCESS )
1264         {
1265                 r = RegSetValueExW( hkey, szwSettings, 0,
1266                         REG_BINARY, (LPBYTE) cs, cs->cLength);
1267
1268                 RegCloseKey( hkey );
1269         }
1270
1271         return (r==ERROR_SUCCESS);
1272 }
1273
1274 /*************************************************************************
1275  * FileIconInit                                 [SHELL32.660]
1276  *
1277  */
1278 BOOL WINAPI FileIconInit(BOOL bFullInit)
1279 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
1280         return 0;
1281 }
1282
1283 /*************************************************************************
1284  * IsUserAnAdmin    [SHELL32.680] NT 4.0
1285  *
1286  * Checks whether the current user is a member of the Administrators group.
1287  *
1288  * PARAMS
1289  *     None
1290  *
1291  * RETURNS
1292  *     Success: TRUE
1293  *     Failure: FALSE
1294  */
1295 BOOL WINAPI IsUserAnAdmin(VOID)
1296 {
1297     SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
1298     HANDLE hToken;
1299     DWORD dwSize;
1300     PTOKEN_GROUPS lpGroups;
1301     PSID lpSid;
1302     DWORD i;
1303     BOOL bResult = FALSE;
1304
1305     TRACE("\n");
1306     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
1307     {
1308         return FALSE;
1309     }
1310
1311     if (!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
1312     {
1313         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1314         {
1315             CloseHandle(hToken);
1316             return FALSE;
1317         }
1318     }
1319
1320     lpGroups = HeapAlloc(GetProcessHeap(), 0, dwSize);
1321     if (lpGroups == NULL)
1322     {
1323         CloseHandle(hToken);
1324         return FALSE;
1325     }
1326
1327     if (!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
1328     {
1329         HeapFree(GetProcessHeap(), 0, lpGroups);
1330         CloseHandle(hToken);
1331         return FALSE;
1332     }
1333
1334     CloseHandle(hToken);
1335     if (!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
1336                                   DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
1337                                   &lpSid))
1338     {
1339         HeapFree(GetProcessHeap(), 0, lpGroups);
1340         return FALSE;
1341     }
1342
1343     for (i = 0; i < lpGroups->GroupCount; i++)
1344     {
1345         if (EqualSid(lpSid, lpGroups->Groups[i].Sid))
1346         {
1347             bResult = TRUE;
1348             break;
1349         }
1350     }
1351
1352     FreeSid(lpSid);
1353     HeapFree(GetProcessHeap(), 0, lpGroups);
1354     return bResult;
1355 }
1356
1357 /*************************************************************************
1358  * SHAllocShared                                [SHELL32.520]
1359  *
1360  * See shlwapi.SHAllocShared
1361  */
1362 HANDLE WINAPI SHAllocShared(LPVOID lpvData, DWORD dwSize, DWORD dwProcId)
1363 {
1364     GET_FUNC(pSHAllocShared, shlwapi, (char*)7, NULL);
1365     return pSHAllocShared(lpvData, dwSize, dwProcId);
1366 }
1367
1368 /*************************************************************************
1369  * SHLockShared                                 [SHELL32.521]
1370  *
1371  * See shlwapi.SHLockShared
1372  */
1373 LPVOID WINAPI SHLockShared(HANDLE hShared, DWORD dwProcId)
1374 {
1375     GET_FUNC(pSHLockShared, shlwapi, (char*)8, NULL);
1376     return pSHLockShared(hShared, dwProcId);
1377 }
1378
1379 /*************************************************************************
1380  * SHUnlockShared                               [SHELL32.522]
1381  *
1382  * See shlwapi.SHUnlockShared
1383  */
1384 BOOL WINAPI SHUnlockShared(LPVOID lpView)
1385 {
1386     GET_FUNC(pSHUnlockShared, shlwapi, (char*)9, FALSE);
1387     return pSHUnlockShared(lpView);
1388 }
1389
1390 /*************************************************************************
1391  * SHFreeShared                                 [SHELL32.523]
1392  *
1393  * See shlwapi.SHFreeShared
1394  */
1395 BOOL WINAPI SHFreeShared(HANDLE hShared, DWORD dwProcId)
1396 {
1397     GET_FUNC(pSHFreeShared, shlwapi, (char*)10, FALSE);
1398     return pSHFreeShared(hShared, dwProcId);
1399 }
1400
1401 /*************************************************************************
1402  * SetAppStartingCursor                         [SHELL32.99]
1403  */
1404 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
1405 {       FIXME("hwnd=%p 0x%04x stub\n",u,v );
1406         return 0;
1407 }
1408
1409 /*************************************************************************
1410  * SHLoadOLE                                    [SHELL32.151]
1411  *
1412  * To reduce the memory usage of Windows 95, its shell32 contained an
1413  * internal implementation of a part of COM (see e.g. SHGetMalloc, SHCoCreateInstance,
1414  * SHRegisterDragDrop etc.) that allowed to use in-process STA objects without
1415  * the need to load OLE32.DLL. If OLE32.DLL was already loaded, the SH* function
1416  * would just call the Co* functions.
1417  *
1418  * The SHLoadOLE was called when OLE32.DLL was being loaded to transfer all the
1419  * information from the shell32 "mini-COM" to ole32.dll.
1420  *
1421  * See http://blogs.msdn.com/oldnewthing/archive/2004/07/05/173226.aspx for a
1422  * detailed description.
1423  *
1424  * Under wine ole32.dll is always loaded as it is imported by shlwapi.dll which is
1425  * imported by shell32 and no "mini-COM" is used (except for the "LoadWithoutCOM"
1426  * hack in SHCoCreateInstance)
1427  */
1428 HRESULT WINAPI SHLoadOLE(LPARAM lParam)
1429 {       FIXME("0x%08lx stub\n",lParam);
1430         return S_OK;
1431 }
1432 /*************************************************************************
1433  * DriveType                                    [SHELL32.64]
1434  *
1435  */
1436 HRESULT WINAPI DriveType(DWORD u)
1437 {       FIXME("0x%04x stub\n",u);
1438         return 0;
1439 }
1440 /*************************************************************************
1441  * InvalidateDriveType                  [SHELL32.65]
1442  *
1443  */
1444 int WINAPI InvalidateDriveType(int u)
1445 {       FIXME("0x%08x stub\n",u);
1446         return 0;
1447 }
1448 /*************************************************************************
1449  * SHAbortInvokeCommand                         [SHELL32.198]
1450  *
1451  */
1452 HRESULT WINAPI SHAbortInvokeCommand(void)
1453 {       FIXME("stub\n");
1454         return 1;
1455 }
1456 /*************************************************************************
1457  * SHOutOfMemoryMessageBox                      [SHELL32.126]
1458  *
1459  */
1460 int WINAPI SHOutOfMemoryMessageBox(
1461         HWND hwndOwner,
1462         LPCSTR lpCaption,
1463         UINT uType)
1464 {
1465         FIXME("%p %s 0x%08x stub\n",hwndOwner, lpCaption, uType);
1466         return 0;
1467 }
1468 /*************************************************************************
1469  * SHFlushClipboard                             [SHELL32.121]
1470  *
1471  */
1472 HRESULT WINAPI SHFlushClipboard(void)
1473 {       FIXME("stub\n");
1474         return 1;
1475 }
1476
1477 /*************************************************************************
1478  * SHWaitForFileToOpen                          [SHELL32.97]
1479  *
1480  */
1481 BOOL WINAPI SHWaitForFileToOpen(
1482         LPCITEMIDLIST pidl,
1483         DWORD dwFlags,
1484         DWORD dwTimeout)
1485 {
1486         FIXME("%p 0x%08x 0x%08x stub\n", pidl, dwFlags, dwTimeout);
1487         return 0;
1488 }
1489
1490 /************************************************************************
1491  *      @                               [SHELL32.654]
1492  *
1493  * NOTES
1494  *  first parameter seems to be a pointer (same as passed to WriteCabinetState)
1495  *  second one could be a size (0x0c). The size is the same as the structure saved to
1496  *  HCU\Software\Microsoft\Windows\CurrentVersion\Explorer\CabinetState
1497  *  I'm (js) guessing: this one is just ReadCabinetState ;-)
1498  */
1499 HRESULT WINAPI shell32_654 (CABINETSTATE *cs, int length)
1500 {
1501         TRACE("%p %d\n",cs,length);
1502         return ReadCabinetState(cs,length);
1503 }
1504
1505 /************************************************************************
1506  *      RLBuildListOfPaths                      [SHELL32.146]
1507  *
1508  * NOTES
1509  *   builds a DPA
1510  */
1511 DWORD WINAPI RLBuildListOfPaths (void)
1512 {       FIXME("stub\n");
1513         return 0;
1514 }
1515 /************************************************************************
1516  *      SHValidateUNC                           [SHELL32.173]
1517  *
1518  */
1519 HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
1520 {
1521         FIXME("0x%08x 0x%08x 0x%08x stub\n",x,y,z);
1522         return 0;
1523 }
1524
1525 /************************************************************************
1526  *      DoEnvironmentSubstA                     [SHELL32.@]
1527  *
1528  * Replace %KEYWORD% in the str with the value of variable KEYWORD
1529  * from environment. If it is not found the %KEYWORD% is left
1530  * intact. If the buffer is too small, str is not modified.
1531  *
1532  * PARAMS
1533  *  pszString  [I] '\0' terminated string with %keyword%.
1534  *             [O] '\0' terminated string with %keyword% substituted.
1535  *  cchString  [I] size of str.
1536  *
1537  * RETURNS
1538  *     cchString length in the HIWORD;
1539  *     TRUE in LOWORD if subst was successful and FALSE in other case
1540  */
1541 DWORD WINAPI DoEnvironmentSubstA(LPSTR pszString, UINT cchString)
1542 {
1543     LPSTR dst;
1544     BOOL res = FALSE;
1545     FIXME("(%s, %d) stub\n", debugstr_a(pszString), cchString);
1546     if (pszString == NULL) /* Really return 0? */
1547         return 0;
1548     if ((dst = HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(CHAR))))
1549     {
1550         DWORD num = ExpandEnvironmentStringsA(pszString, dst, cchString);
1551         if (num && num < cchString) /* dest buffer is too small */
1552         {
1553             res = TRUE;
1554             memcpy(pszString, dst, num);
1555         }
1556         HeapFree(GetProcessHeap(), 0, dst);
1557     }
1558     return MAKELONG(res,cchString); /* Always cchString? */
1559 }
1560
1561 /************************************************************************
1562  *      DoEnvironmentSubstW                     [SHELL32.@]
1563  *
1564  * See DoEnvironmentSubstA.
1565  */
1566 DWORD WINAPI DoEnvironmentSubstW(LPWSTR pszString, UINT cchString)
1567 {
1568         FIXME("(%s, %d): stub\n", debugstr_w(pszString), cchString);
1569         return MAKELONG(FALSE,cchString);
1570 }
1571
1572 /************************************************************************
1573  *      DoEnvironmentSubst                      [SHELL32.53]
1574  *
1575  * See DoEnvironmentSubstA.
1576  */
1577 DWORD WINAPI DoEnvironmentSubstAW(LPVOID x, UINT y)
1578 {
1579     if (SHELL_OsIsUnicode())
1580         return DoEnvironmentSubstW(x, y);
1581     return DoEnvironmentSubstA(x, y);
1582 }
1583
1584 /*************************************************************************
1585  *      @                             [SHELL32.243]
1586  *
1587  * Win98+ by-ordinal routine.  In Win98 this routine returns zero and
1588  * does nothing else.  Possibly this does something in NT or SHELL32 5.0?
1589  *
1590  */
1591
1592 BOOL WINAPI shell32_243(DWORD a, DWORD b)
1593 {
1594   return FALSE;
1595 }
1596
1597 /*************************************************************************
1598  *      GUIDFromStringW   [SHELL32.704]
1599  */
1600 BOOL WINAPI GUIDFromStringW(LPCWSTR str, LPGUID guid)
1601 {
1602     UNICODE_STRING guid_str;
1603
1604     RtlInitUnicodeString(&guid_str, str);
1605     return !RtlGUIDFromString(&guid_str, guid);
1606 }
1607
1608 /*************************************************************************
1609  *      @       [SHELL32.714]
1610  */
1611 DWORD WINAPI SHELL32_714(LPVOID x)
1612 {
1613         FIXME("(%s)stub\n", debugstr_w(x));
1614         return 0;
1615 }
1616
1617 typedef struct _PSXA
1618 {
1619     UINT uiCount;
1620     UINT uiAllocated;
1621     IShellPropSheetExt *pspsx[1];
1622 } PSXA, *PPSXA;
1623
1624 typedef struct _PSXA_CALL
1625 {
1626     LPFNADDPROPSHEETPAGE lpfnAddReplaceWith;
1627     LPARAM lParam;
1628     BOOL bCalled;
1629     BOOL bMultiple;
1630     UINT uiCount;
1631 } PSXA_CALL, *PPSXA_CALL;
1632
1633 static BOOL CALLBACK PsxaCall(HPROPSHEETPAGE hpage, LPARAM lParam)
1634 {
1635     PPSXA_CALL Call = (PPSXA_CALL)lParam;
1636
1637     if (Call != NULL)
1638     {
1639         if ((Call->bMultiple || !Call->bCalled) &&
1640             Call->lpfnAddReplaceWith(hpage, Call->lParam))
1641         {
1642             Call->bCalled = TRUE;
1643             Call->uiCount++;
1644             return TRUE;
1645         }
1646     }
1647
1648     return FALSE;
1649 }
1650
1651 /*************************************************************************
1652  *      SHAddFromPropSheetExtArray      [SHELL32.167]
1653  */
1654 UINT WINAPI SHAddFromPropSheetExtArray(HPSXA hpsxa, LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam)
1655 {
1656     PSXA_CALL Call;
1657     UINT i;
1658     PPSXA psxa = (PPSXA)hpsxa;
1659
1660     TRACE("(%p,%p,%08lx)\n", hpsxa, lpfnAddPage, lParam);
1661
1662     if (psxa)
1663     {
1664         ZeroMemory(&Call, sizeof(Call));
1665         Call.lpfnAddReplaceWith = lpfnAddPage;
1666         Call.lParam = lParam;
1667         Call.bMultiple = TRUE;
1668
1669         /* Call the AddPage method of all registered IShellPropSheetExt interfaces */
1670         for (i = 0; i != psxa->uiCount; i++)
1671         {
1672             psxa->pspsx[i]->lpVtbl->AddPages(psxa->pspsx[i], PsxaCall, (LPARAM)&Call);
1673         }
1674
1675         return Call.uiCount;
1676     }
1677
1678     return 0;
1679 }
1680
1681 /*************************************************************************
1682  *      SHCreatePropSheetExtArray       [SHELL32.168]
1683  */
1684 HPSXA WINAPI SHCreatePropSheetExtArray(HKEY hKey, LPCWSTR pszSubKey, UINT max_iface)
1685 {
1686     return SHCreatePropSheetExtArrayEx(hKey, pszSubKey, max_iface, NULL);
1687 }
1688
1689 /*************************************************************************
1690  *      SHCreatePropSheetExtArrayEx     [SHELL32.194]
1691  */
1692 HPSXA WINAPI SHCreatePropSheetExtArrayEx(HKEY hKey, LPCWSTR pszSubKey, UINT max_iface, LPDATAOBJECT pDataObj)
1693 {
1694     static const WCHAR szPropSheetSubKey[] = {'s','h','e','l','l','e','x','\\','P','r','o','p','e','r','t','y','S','h','e','e','t','H','a','n','d','l','e','r','s',0};
1695     WCHAR szHandler[64];
1696     DWORD dwHandlerLen;
1697     WCHAR szClsidHandler[39];
1698     DWORD dwClsidSize;
1699     CLSID clsid;
1700     LONG lRet;
1701     DWORD dwIndex;
1702     IShellExtInit *psxi;
1703     IShellPropSheetExt *pspsx;
1704     HKEY hkBase, hkPropSheetHandlers;
1705     PPSXA psxa = NULL;
1706
1707     TRACE("(%p,%s,%u)\n", hKey, debugstr_w(pszSubKey), max_iface);
1708
1709     if (max_iface == 0)
1710         return NULL;
1711
1712     /* Open the registry key */
1713     lRet = RegOpenKeyW(hKey, pszSubKey, &hkBase);
1714     if (lRet != ERROR_SUCCESS)
1715         return NULL;
1716
1717     lRet = RegOpenKeyExW(hkBase, szPropSheetSubKey, 0, KEY_ENUMERATE_SUB_KEYS, &hkPropSheetHandlers);
1718     RegCloseKey(hkBase);
1719     if (lRet == ERROR_SUCCESS)
1720     {
1721         /* Create and initialize the Property Sheet Extensions Array */
1722         psxa = LocalAlloc(LMEM_FIXED, FIELD_OFFSET(PSXA, pspsx[max_iface]));
1723         if (psxa)
1724         {
1725             ZeroMemory(psxa, FIELD_OFFSET(PSXA, pspsx[max_iface]));
1726             psxa->uiAllocated = max_iface;
1727
1728             /* Enumerate all subkeys and attempt to load the shell extensions */
1729             dwIndex = 0;
1730             do
1731             {
1732                 dwHandlerLen = sizeof(szHandler) / sizeof(szHandler[0]);
1733                 lRet = RegEnumKeyExW(hkPropSheetHandlers, dwIndex++, szHandler, &dwHandlerLen, NULL, NULL, NULL, NULL);
1734                 if (lRet != ERROR_SUCCESS)
1735                 {
1736                     if (lRet == ERROR_MORE_DATA)
1737                         continue;
1738
1739                     if (lRet == ERROR_NO_MORE_ITEMS)
1740                         lRet = ERROR_SUCCESS;
1741                     break;
1742                 }
1743
1744                 dwClsidSize = sizeof(szClsidHandler);
1745                 if (SHGetValueW(hkPropSheetHandlers, szHandler, NULL, NULL, szClsidHandler, &dwClsidSize) == ERROR_SUCCESS)
1746                 {
1747                     /* Force a NULL-termination and convert the string */
1748                     szClsidHandler[(sizeof(szClsidHandler) / sizeof(szClsidHandler[0])) - 1] = 0;
1749                     if (SUCCEEDED(SHCLSIDFromStringW(szClsidHandler, &clsid)))
1750                     {
1751                         /* Attempt to get an IShellPropSheetExt and an IShellExtInit instance.
1752                            Only if both interfaces are supported it's a real shell extension.
1753                            Then call IShellExtInit's Initialize method. */
1754                         if (SUCCEEDED(CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER/* | CLSCTX_NO_CODE_DOWNLOAD */, &IID_IShellPropSheetExt, (LPVOID *)&pspsx)))
1755                         {
1756                             if (SUCCEEDED(pspsx->lpVtbl->QueryInterface(pspsx, &IID_IShellExtInit, (PVOID *)&psxi)))
1757                             {
1758                                 if (SUCCEEDED(psxi->lpVtbl->Initialize(psxi, NULL, pDataObj, hKey)))
1759                                 {
1760                                     /* Add the IShellPropSheetExt instance to the array */
1761                                     psxa->pspsx[psxa->uiCount++] = pspsx;
1762                                 }
1763                                 else
1764                                 {
1765                                     psxi->lpVtbl->Release(psxi);
1766                                     pspsx->lpVtbl->Release(pspsx);
1767                                 }
1768                             }
1769                             else
1770                                 pspsx->lpVtbl->Release(pspsx);
1771                         }
1772                     }
1773                 }
1774
1775             } while (psxa->uiCount != psxa->uiAllocated);
1776         }
1777         else
1778             lRet = ERROR_NOT_ENOUGH_MEMORY;
1779
1780         RegCloseKey(hkPropSheetHandlers);
1781     }
1782
1783     if (lRet != ERROR_SUCCESS && psxa)
1784     {
1785         SHDestroyPropSheetExtArray((HPSXA)psxa);
1786         psxa = NULL;
1787     }
1788
1789     return (HPSXA)psxa;
1790 }
1791
1792 /*************************************************************************
1793  *      SHReplaceFromPropSheetExtArray  [SHELL32.170]
1794  */
1795 UINT WINAPI SHReplaceFromPropSheetExtArray(HPSXA hpsxa, UINT uPageID, LPFNADDPROPSHEETPAGE lpfnReplaceWith, LPARAM lParam)
1796 {
1797     PSXA_CALL Call;
1798     UINT i;
1799     PPSXA psxa = (PPSXA)hpsxa;
1800
1801     TRACE("(%p,%u,%p,%08lx)\n", hpsxa, uPageID, lpfnReplaceWith, lParam);
1802
1803     if (psxa)
1804     {
1805         ZeroMemory(&Call, sizeof(Call));
1806         Call.lpfnAddReplaceWith = lpfnReplaceWith;
1807         Call.lParam = lParam;
1808
1809         /* Call the ReplacePage method of all registered IShellPropSheetExt interfaces.
1810            Each shell extension is only allowed to call the callback once during the callback. */
1811         for (i = 0; i != psxa->uiCount; i++)
1812         {
1813             Call.bCalled = FALSE;
1814             psxa->pspsx[i]->lpVtbl->ReplacePage(psxa->pspsx[i], uPageID, PsxaCall, (LPARAM)&Call);
1815         }
1816
1817         return Call.uiCount;
1818     }
1819
1820     return 0;
1821 }
1822
1823 /*************************************************************************
1824  *      SHDestroyPropSheetExtArray      [SHELL32.169]
1825  */
1826 void WINAPI SHDestroyPropSheetExtArray(HPSXA hpsxa)
1827 {
1828     UINT i;
1829     PPSXA psxa = (PPSXA)hpsxa;
1830
1831     TRACE("(%p)\n", hpsxa);
1832
1833     if (psxa)
1834     {
1835         for (i = 0; i != psxa->uiCount; i++)
1836         {
1837             psxa->pspsx[i]->lpVtbl->Release(psxa->pspsx[i]);
1838         }
1839
1840         LocalFree(psxa);
1841     }
1842 }
1843
1844 /*************************************************************************
1845  *      CIDLData_CreateFromIDArray      [SHELL32.83]
1846  *
1847  *  Create IDataObject from PIDLs??
1848  */
1849 HRESULT WINAPI CIDLData_CreateFromIDArray(
1850         LPCITEMIDLIST pidlFolder,
1851         DWORD cpidlFiles,
1852         LPCITEMIDLIST *lppidlFiles,
1853         LPDATAOBJECT *ppdataObject)
1854 {
1855     UINT i;
1856     HWND hwnd = 0;   /*FIXME: who should be hwnd of owner? set to desktop */
1857
1858     TRACE("(%p, %d, %p, %p)\n", pidlFolder, cpidlFiles, lppidlFiles, ppdataObject);
1859     if (TRACE_ON(pidl))
1860     {
1861         pdump (pidlFolder);
1862         for (i=0; i<cpidlFiles; i++) pdump (lppidlFiles[i]);
1863     }
1864     *ppdataObject = IDataObject_Constructor( hwnd, pidlFolder,
1865                                              lppidlFiles, cpidlFiles);
1866     if (*ppdataObject) return S_OK;
1867     return E_OUTOFMEMORY;
1868 }
1869
1870 /*************************************************************************
1871  * SHCreateStdEnumFmtEtc                        [SHELL32.74]
1872  *
1873  * NOTES
1874  *
1875  */
1876 HRESULT WINAPI SHCreateStdEnumFmtEtc(
1877         DWORD cFormats,
1878         const FORMATETC *lpFormats,
1879         LPENUMFORMATETC *ppenumFormatetc)
1880 {
1881         IEnumFORMATETC *pef;
1882         HRESULT hRes;
1883         TRACE("cf=%d fe=%p pef=%p\n", cFormats, lpFormats, ppenumFormatetc);
1884
1885         pef = IEnumFORMATETC_Constructor(cFormats, lpFormats);
1886         if (!pef)
1887           return E_OUTOFMEMORY;
1888
1889         IEnumFORMATETC_AddRef(pef);
1890         hRes = IEnumFORMATETC_QueryInterface(pef, &IID_IEnumFORMATETC, (LPVOID*)ppenumFormatetc);
1891         IEnumFORMATETC_Release(pef);
1892
1893         return hRes;
1894 }
1895
1896 /*************************************************************************
1897  *              SHFindFiles (SHELL32.90)
1898  */
1899 BOOL WINAPI SHFindFiles( LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlSaveFile )
1900 {
1901     FIXME("%p %p\n", pidlFolder, pidlSaveFile );
1902     return FALSE;
1903 }
1904
1905 /*************************************************************************
1906  *              SHUpdateImageW (SHELL32.192)
1907  *
1908  * Notifies the shell that an icon in the system image list has been changed.
1909  *
1910  * PARAMS
1911  *  pszHashItem [I] Path to file that contains the icon.
1912  *  iIndex      [I] Zero-based index of the icon in the file.
1913  *  uFlags      [I] Flags determining the icon attributes. See notes.
1914  *  iImageIndex [I] Index of the icon in the system image list.
1915  *
1916  * RETURNS
1917  *  Nothing
1918  *
1919  * NOTES
1920  *  uFlags can be one or more of the following flags:
1921  *  GIL_NOTFILENAME - pszHashItem is not a file name.
1922  *  GIL_SIMULATEDOC - Create a document icon using the specified icon.
1923  */
1924 void WINAPI SHUpdateImageW(LPCWSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex)
1925 {
1926     FIXME("%s, %d, 0x%x, %d - stub\n", debugstr_w(pszHashItem), iIndex, uFlags, iImageIndex);
1927 }
1928
1929 /*************************************************************************
1930  *              SHUpdateImageA (SHELL32.191)
1931  *
1932  * See SHUpdateImageW.
1933  */
1934 VOID WINAPI SHUpdateImageA(LPCSTR pszHashItem, INT iIndex, UINT uFlags, INT iImageIndex)
1935 {
1936     FIXME("%s, %d, 0x%x, %d - stub\n", debugstr_a(pszHashItem), iIndex, uFlags, iImageIndex);
1937 }
1938
1939 INT WINAPI SHHandleUpdateImage(LPCITEMIDLIST pidlExtra)
1940 {
1941     FIXME("%p - stub\n", pidlExtra);
1942
1943     return -1;
1944 }
1945
1946 BOOL WINAPI SHObjectProperties(HWND hwnd, DWORD dwType, LPCWSTR szObject, LPCWSTR szPage)
1947 {
1948     FIXME("%p, 0x%08x, %s, %s - stub\n", hwnd, dwType, debugstr_w(szObject), debugstr_w(szPage));
1949
1950     return TRUE;
1951 }
1952
1953 BOOL WINAPI SHGetNewLinkInfoA(LPCSTR pszLinkTo, LPCSTR pszDir, LPSTR pszName, BOOL *pfMustCopy,
1954                               UINT uFlags)
1955 {
1956     WCHAR wszLinkTo[MAX_PATH];
1957     WCHAR wszDir[MAX_PATH];
1958     WCHAR wszName[MAX_PATH];
1959     BOOL res;
1960
1961     MultiByteToWideChar(CP_ACP, 0, pszLinkTo, -1, wszLinkTo, MAX_PATH);
1962     MultiByteToWideChar(CP_ACP, 0, pszDir, -1, wszDir, MAX_PATH);
1963
1964     res = SHGetNewLinkInfoW(wszLinkTo, wszDir, wszName, pfMustCopy, uFlags);
1965
1966     if (res)
1967         WideCharToMultiByte(CP_ACP, 0, wszName, -1, pszName, MAX_PATH, NULL, NULL);
1968
1969     return res;
1970 }
1971
1972 BOOL WINAPI SHGetNewLinkInfoW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName, BOOL *pfMustCopy,
1973                               UINT uFlags)
1974 {
1975     const WCHAR *basename;
1976     WCHAR *dst_basename;
1977     int i=2;
1978     static const WCHAR lnkformat[] = {'%','s','.','l','n','k',0};
1979     static const WCHAR lnkformatnum[] = {'%','s',' ','(','%','d',')','.','l','n','k',0};
1980
1981     TRACE("(%s, %s, %p, %p, 0x%08x)\n", debugstr_w(pszLinkTo), debugstr_w(pszDir),
1982           pszName, pfMustCopy, uFlags);
1983
1984     *pfMustCopy = FALSE;
1985
1986     if (uFlags & SHGNLI_PIDL)
1987     {
1988         FIXME("SHGNLI_PIDL flag unsupported\n");
1989         return FALSE;
1990     }
1991
1992     if (uFlags)
1993         FIXME("ignoring flags: 0x%08x\n", uFlags);
1994
1995     /* FIXME: should test if the file is a shortcut or DOS program */
1996     if (GetFileAttributesW(pszLinkTo) == INVALID_FILE_ATTRIBUTES)
1997         return FALSE;
1998
1999     basename = strrchrW(pszLinkTo, '\\');
2000     if (basename)
2001         basename = basename+1;
2002     else
2003         basename = pszLinkTo;
2004
2005     lstrcpynW(pszName, pszDir, MAX_PATH);
2006     if (!PathAddBackslashW(pszName))
2007         return FALSE;
2008
2009     dst_basename = pszName + strlenW(pszName);
2010
2011     snprintfW(dst_basename, pszName + MAX_PATH - dst_basename, lnkformat, basename);
2012
2013     while (GetFileAttributesW(pszName) != INVALID_FILE_ATTRIBUTES)
2014     {
2015         snprintfW(dst_basename, pszName + MAX_PATH - dst_basename, lnkformatnum, basename, i);
2016         i++;
2017     }
2018
2019     return TRUE;
2020 }
2021
2022 HRESULT WINAPI SHStartNetConnectionDialog(HWND hwnd, LPCSTR pszRemoteName, DWORD dwType)
2023 {
2024     FIXME("%p, %s, 0x%08x - stub\n", hwnd, debugstr_a(pszRemoteName), dwType);
2025
2026     return S_OK;
2027 }
2028
2029 HRESULT WINAPI SHEmptyRecycleBinA(HWND hwnd, LPCSTR pszRootPath, DWORD dwFlags)
2030 {
2031     FIXME("%p, %s, 0x%08x - stub\n", hwnd, debugstr_a(pszRootPath), dwFlags);
2032
2033     return S_OK;
2034 }
2035
2036 HRESULT WINAPI SHEmptyRecycleBinW(HWND hwnd, LPCWSTR pszRootPath, DWORD dwFlags)
2037 {
2038     FIXME("%p, %s, 0x%08x - stub\n", hwnd, debugstr_w(pszRootPath), dwFlags);
2039
2040     return S_OK;
2041 }
2042
2043 DWORD WINAPI SHFormatDrive(HWND hwnd, UINT drive, UINT fmtID, UINT options)
2044 {
2045     FIXME("%p, 0x%08x, 0x%08x, 0x%08x - stub\n", hwnd, drive, fmtID, options);
2046
2047     return SHFMT_NOFORMAT;
2048 }
2049
2050 HRESULT WINAPI SHQueryRecycleBinA(LPCSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)
2051 {
2052     FIXME("%s, %p - stub\n", debugstr_a(pszRootPath), pSHQueryRBInfo);
2053
2054     pSHQueryRBInfo->i64Size = 0;
2055     pSHQueryRBInfo->i64NumItems = 0;
2056
2057     return S_OK;
2058 }
2059
2060 HRESULT WINAPI SHQueryRecycleBinW(LPCWSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)
2061 {
2062     FIXME("%s, %p - stub\n", debugstr_w(pszRootPath), pSHQueryRBInfo);
2063
2064     pSHQueryRBInfo->i64Size = 0;
2065     pSHQueryRBInfo->i64NumItems = 0;
2066
2067     return S_OK;
2068 }
2069
2070 /*************************************************************************
2071  *              SHSetLocalizedName (SHELL32.@)
2072  */
2073 HRESULT WINAPI SHSetLocalizedName(LPWSTR pszPath, LPCWSTR pszResModule, int idsRes)
2074 {
2075     FIXME("%p, %s, %d - stub\n", pszPath, debugstr_w(pszResModule), idsRes);
2076
2077     return S_OK;
2078 }
2079
2080 /*************************************************************************
2081  *              LinkWindow_RegisterClass (SHELL32.258)
2082  */
2083 BOOL WINAPI LinkWindow_RegisterClass(void)
2084 {
2085     FIXME("()\n");
2086     return TRUE;
2087 }
2088
2089 /*************************************************************************
2090  *              LinkWindow_UnregisterClass (SHELL32.259)
2091  */
2092 BOOL WINAPI LinkWindow_UnregisterClass(void)
2093 {
2094     FIXME("()\n");
2095     return TRUE;
2096 }
2097
2098 /*************************************************************************
2099  *              SHFlushSFCache (SHELL32.526)
2100  *
2101  * Notifies the shell that a user-specified special folder location has changed.
2102  *
2103  * NOTES
2104  *   In Wine, the shell folder registry values are not cached, so this function
2105  *   has no effect.
2106  */
2107 void WINAPI SHFlushSFCache(void)
2108 {
2109 }
2110
2111 HRESULT WINAPI SHGetImageList(int iImageList, REFIID riid, void **ppv)
2112 {
2113     FIXME("STUB: %i %s\n",iImageList,debugstr_guid(riid));
2114     return E_NOINTERFACE;
2115 }
2116
2117 /*************************************************************************
2118  * SHCreateShellFolderView                      [SHELL32.256]
2119  *
2120  * Create a new instance of the default Shell folder view object.
2121  *
2122  * RETURNS
2123  *  Success: S_OK
2124  *  Failure: error value
2125  *
2126  * NOTES
2127  *  see IShellFolder::CreateViewObject
2128  */
2129 HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv,
2130                         IShellView **ppsv)
2131 {
2132         IShellView * psf;
2133         HRESULT hRes;
2134
2135         TRACE("sf=%p outer=%p callback=%p\n",
2136           pcsfv->pshf, pcsfv->psvOuter, pcsfv->psfvcb);
2137
2138         psf = IShellView_Constructor(pcsfv->pshf);
2139
2140         if (!psf)
2141           return E_OUTOFMEMORY;
2142
2143         IShellView_AddRef(psf);
2144         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppsv);
2145         IShellView_Release(psf);
2146
2147         return hRes;
2148 }