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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include "winerror.h"
  25 #include "winreg.h"
  26 #include "wine/debug.h"
  27 #include "winnls.h"
  28 #include "heap.h"
  29
  30 #include "wine/obj_base.h"
  31 #include "shellapi.h"
  32 #include "shlguid.h"
  33 #include "shlobj.h"
  34 #include "shell32_main.h"
  35 #include "undocshell.h"
  36 #include "pidl.h"
  37 #include "shlwapi.h"
  38 #include "commdlg.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  41 WINE_DECLARE_DEBUG_CHANNEL(pidl);
  42
  43 /*************************************************************************
  44  * ParseFieldA                                  [internal]
  45  *
  46  * copies a field from a ',' delimited string
  47  *
  48  * first field is nField = 1
  49  */
  50 DWORD WINAPI ParseFieldA(
  51         LPCSTR src,
  52         DWORD nField,
  53         LPSTR dst,
  54         DWORD len)
  55 {
  56         WARN("(%s,0x%08lx,%p,%ld) semi-stub.\n",debugstr_a(src),nField,dst,len);
  57
  58         if (!src || !src[0] || !dst || !len)
  59           return 0;
  60
  61         /* skip n fields delimited by ',' */
  62         while (nField > 1)
  63         {
  64           if (*src=='\0') return FALSE;
  65           if (*(src++)==',') nField--;
  66         }
  67
  68         /* copy part till the next ',' to dst */
  69         while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
  70
  71         /* finalize the string */
  72         *dst=0x0;
  73
  74         return TRUE;
  75 }
  76
  77 /*************************************************************************
  78  * ParseFieldW                  [internal]
  79  *
  80  * copies a field from a ',' delimited string
  81  *
  82  * first field is nField = 1
  83  */
  84 DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len)
  85 {
  86         FIXME("(%s,0x%08lx,%p,%ld) stub\n",
  87           debugstr_w(src), nField, dst, len);
  88         return FALSE;
  89 }
  90
  91 /*************************************************************************
  92  * ParseField                   [SHELL32.58]
  93  */
  94 DWORD WINAPI ParseFieldAW(LPCVOID src, DWORD nField, LPVOID dst, DWORD len)
  95 {
  96         if (SHELL_OsIsUnicode())
  97           return ParseFieldW(src, nField, dst, len);
  98         return ParseFieldA(src, nField, dst, len);
  99 }
 100
 101 /*************************************************************************
 102  * GetFileNameFromBrowse                        [SHELL32.63]
 103  *
 104  */
 105 BOOL WINAPI GetFileNameFromBrowse(
 106         HWND hwndOwner,
 107         LPSTR lpstrFile,
 108         DWORD nMaxFile,
 109         LPCSTR lpstrInitialDir,
 110         LPCSTR lpstrDefExt,
 111         LPCSTR lpstrFilter,
 112         LPCSTR lpstrTitle)
 113 {
 114     HMODULE hmodule;
 115     FARPROC pGetOpenFileNameA;
 116     OPENFILENAMEA ofn;
 117     BOOL ret;
 118
 119     TRACE("%04x, %s, %ld, %s, %s, %s, %s)\n",
 120           hwndOwner, lpstrFile, nMaxFile, lpstrInitialDir, lpstrDefExt,
 121           lpstrFilter, lpstrTitle);
 122
 123     hmodule = LoadLibraryA("comdlg32.dll");
 124     if(!hmodule) return FALSE;
 125     pGetOpenFileNameA = GetProcAddress(hmodule, "GetOpenFileNameA");
 126     if(!pGetOpenFileNameA)
 127     {
 128         FreeLibrary(hmodule);
 129         return FALSE;
 130     }
 131
 132     memset(&ofn, 0, sizeof(ofn));
 133
 134     ofn.lStructSize = sizeof(ofn);
 135     ofn.hwndOwner = hwndOwner;
 136     ofn.lpstrFilter = lpstrFilter;
 137     ofn.lpstrFile = lpstrFile;
 138     ofn.nMaxFile = nMaxFile;
 139     ofn.lpstrInitialDir = lpstrInitialDir;
 140     ofn.lpstrTitle = lpstrTitle;
 141     ofn.lpstrDefExt = lpstrDefExt;
 142     ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
 143     ret = pGetOpenFileNameA(&ofn);
 144
 145     FreeLibrary(hmodule);
 146     return ret;
 147 }
 148
 149 /*************************************************************************
 150  * SHGetSetSettings                             [SHELL32.68]
 151  */
 152 VOID WINAPI SHGetSetSettings(DWORD x, DWORD y, DWORD z)
 153 {
 154         FIXME("0x%08lx 0x%08lx 0x%08lx\n", x, y, z);
 155 }
 156
 157 /*************************************************************************
 158  * SHGetSettings                                [SHELL32.@]
 159  *
 160  * NOTES
 161  *  the registry path are for win98 (tested)
 162  *  and possibly are the same in nt40
 163  *
 164  */
 165 VOID WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
 166 {
 167         HKEY    hKey;
 168         DWORD   dwData;
 169         DWORD   dwDataSize = sizeof (DWORD);
 170
 171         TRACE("(%p 0x%08lx)\n",lpsfs,dwMask);
 172
 173         if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
 174                                  0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
 175           return;
 176
 177         if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 178           lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
 179
 180         if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 181           lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
 182
 183         if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 184           lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
 185
 186         if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 187           lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
 188
 189         if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 190           lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
 191
 192         if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 193           lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
 194
 195         if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
 196         { if (dwData == 0)
 197           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 198             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 199           }
 200           else if (dwData == 1)
 201           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
 202             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 0;
 203           }
 204           else if (dwData == 2)
 205           { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
 206             if (SSF_SHOWSYSFILES & dwMask)      lpsfs->fShowSysFiles  = 1;
 207           }
 208         }
 209         RegCloseKey (hKey);
 210
 211         TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
 212 }
 213
 214 /*************************************************************************
 215  * SHShellFolderView_Message                    [SHELL32.73]
 216  *
 217  * PARAMETERS
 218  *  hwndCabinet defines the explorer cabinet window that contains the
 219  *              shellview you need to communicate with
 220  *  uMsg        identifying the SFVM enum to perform
 221  *  lParam
 222  *
 223  * NOTES
 224  *  Message SFVM_REARRANGE = 1
 225  *    This message gets sent when a column gets clicked to instruct the
 226  *    shell view to re-sort the item list. lParam identifies the column
 227  *    that was clicked.
 228  */
 229 int WINAPI SHShellFolderView_Message(
 230         HWND hwndCabinet,
 231         DWORD dwMessage,
 232         DWORD dwParam)
 233 {
 234         FIXME("%04x %08lx %08lx stub\n",hwndCabinet, dwMessage, dwParam);
 235         return 0;
 236 }
 237
 238 /*************************************************************************
 239  * RegisterShellHook                            [SHELL32.181]
 240  *
 241  * PARAMS
 242  *      hwnd [I]  window handle
 243  *      y    [I]  flag ????
 244  *
 245  * NOTES
 246  *     exported by ordinal
 247  */
 248 BOOL WINAPI RegisterShellHook(
 249         HWND hWnd,
 250         DWORD dwType)
 251 {
 252         FIXME("(0x%08x,0x%08lx):stub.\n",hWnd, dwType);
 253         return TRUE;
 254 }
 255 /*************************************************************************
 256  * ShellMessageBoxW                             [SHELL32.182]
 257  *
 258  * Format and output errormessage.
 259  *
 260  * idText       resource ID of title or LPSTR
 261  * idTitle      resource ID of title or LPSTR
 262  *
 263  * NOTES
 264  *     exported by ordinal
 265  */
 266 int WINAPIV ShellMessageBoxW(
 267         HINSTANCE hInstance,
 268         HWND hWnd,
 269         LPCWSTR lpText,
 270         LPCWSTR lpCaption,
 271         UINT uType,
 272         ...)
 273 {
 274         WCHAR   szText[100],szTitle[100];
 275         LPCWSTR pszText = szText, pszTitle = szTitle, pszTemp;
 276         va_list args;
 277         int     ret;
 278
 279         va_start(args, uType);
 280         /* wvsprintfA(buf,fmt, args); */
 281
 282         TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
 283         (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
 284
 285         if (!HIWORD(lpCaption))
 286           LoadStringW(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
 287         else
 288           pszTitle = lpCaption;
 289
 290         if (!HIWORD(lpText))
 291           LoadStringW(hInstance, (DWORD)lpText, szText, sizeof(szText)/sizeof(szText[0]));
 292         else
 293           pszText = lpText;
 294
 295         FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
 296                        pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
 297
 298         va_end(args);
 299
 300         ret = MessageBoxW(hWnd,pszTemp,pszTitle,uType);
 301         LocalFree((HLOCAL)pszTemp);
 302         return ret;
 303 }
 304
 305 /*************************************************************************
 306  * ShellMessageBoxA                             [SHELL32.183]
 307  */
 308 int WINAPIV ShellMessageBoxA(
 309         HINSTANCE hInstance,
 310         HWND hWnd,
 311         LPCSTR lpText,
 312         LPCSTR lpCaption,
 313         UINT uType,
 314         ...)
 315 {
 316         char    szText[100],szTitle[100];
 317         LPCSTR  pszText = szText, pszTitle = szTitle, pszTemp;
 318         va_list args;
 319         int     ret;
 320
 321         va_start(args, uType);
 322         /* wvsprintfA(buf,fmt, args); */
 323
 324         TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
 325         (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
 326
 327         if (!HIWORD(lpCaption))
 328           LoadStringA(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle));
 329         else
 330           pszTitle = lpCaption;
 331
 332         if (!HIWORD(lpText))
 333           LoadStringA(hInstance, (DWORD)lpText, szText, sizeof(szText));
 334         else
 335           pszText = lpText;
 336
 337         FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
 338                        pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
 339
 340         va_end(args);
 341
 342         ret = MessageBoxA(hWnd,pszTemp,pszTitle,uType);
 343         LocalFree((HLOCAL)pszTemp);
 344         return ret;
 345 }
 346
 347 /*************************************************************************
 348  * SHFree                                       [SHELL32.195]
 349  *
 350  * NOTES
 351  *     free_ptr() - frees memory using IMalloc
 352  *     exported by ordinal
 353  */
 354 #define MEM_DEBUG 0
 355 void WINAPI SHFree(LPVOID x)
 356 {
 357 #if MEM_DEBUG
 358         WORD len = *(LPWORD)((LPBYTE)x-2);
 359
 360         if ( *(LPWORD)((LPBYTE)x+len) != 0x7384)
 361           ERR("MAGIC2!\n");
 362
 363         if ( (*(LPWORD)((LPBYTE)x-4)) != 0x8271)
 364           ERR("MAGIC1!\n");
 365         else
 366           memset((LPBYTE)x-4, 0xde, len+6);
 367
 368         TRACE("%p len=%u\n",x, len);
 369
 370         x = (LPBYTE) x - 4;
 371 #else
 372         TRACE("%p\n",x);
 373 #endif
 374         HeapFree(GetProcessHeap(), 0, x);
 375 }
 376
 377 /*************************************************************************
 378  * SHAlloc                                      [SHELL32.196]
 379  *
 380  * NOTES
 381  *     void *task_alloc(DWORD len), uses SHMalloc allocator
 382  *     exported by ordinal
 383  */
 384 LPVOID WINAPI SHAlloc(DWORD len)
 385 {
 386         LPBYTE ret;
 387
 388 #if MEM_DEBUG
 389         ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len+6);
 390 #else
 391         ret = (LPVOID) HeapAlloc(GetProcessHeap(),0,len);
 392 #endif
 393
 394 #if MEM_DEBUG
 395         *(LPWORD)(ret) = 0x8271;
 396         *(LPWORD)(ret+2) = (WORD)len;
 397         *(LPWORD)(ret+4+len) = 0x7384;
 398         ret += 4;
 399         memset(ret, 0xdf, len);
 400 #endif
 401         TRACE("%lu bytes at %p\n",len, ret);
 402         return (LPVOID)ret;
 403 }
 404
 405 /*************************************************************************
 406  * SHRegisterDragDrop                           [SHELL32.86]
 407  *
 408  * NOTES
 409  *     exported by ordinal
 410  */
 411 HRESULT WINAPI SHRegisterDragDrop(
 412         HWND hWnd,
 413         LPDROPTARGET pDropTarget)
 414 {
 415         FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
 416         if (GetShellOle()) return pRegisterDragDrop(hWnd, pDropTarget);
 417         return 0;
 418 }
 419
 420 /*************************************************************************
 421  * SHRevokeDragDrop                             [SHELL32.87]
 422  *
 423  * NOTES
 424  *     exported by ordinal
 425  */
 426 HRESULT WINAPI SHRevokeDragDrop(HWND hWnd)
 427 {
 428     FIXME("(0x%08x):stub.\n",hWnd);
 429     return 0;
 430 }
 431
 432 /*************************************************************************
 433  * SHDoDragDrop                                 [SHELL32.88]
 434  *
 435  * NOTES
 436  *     exported by ordinal
 437  */
 438 HRESULT WINAPI SHDoDragDrop(
 439         HWND hWnd,
 440         LPDATAOBJECT lpDataObject,
 441         LPDROPSOURCE lpDropSource,
 442         DWORD dwOKEffect,
 443         LPDWORD pdwEffect)
 444 {
 445     FIXME("(0x%04x %p %p 0x%08lx %p):stub.\n",
 446     hWnd, lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
 447     return 0;
 448 }
 449
 450 /*************************************************************************
 451  * ArrangeWindows                               [SHELL32.184]
 452  *
 453  */
 454 WORD WINAPI ArrangeWindows(
 455         HWND hwndParent,
 456         DWORD dwReserved,
 457         LPCRECT lpRect,
 458         WORD cKids,
 459         CONST HWND * lpKids)
 460 {
 461     FIXME("(0x%08x 0x%08lx %p 0x%04x %p):stub.\n",
 462            hwndParent, dwReserved, lpRect, cKids, lpKids);
 463     return 0;
 464 }
 465
 466 /*************************************************************************
 467  * SignalFileOpen                               [SHELL32.103]
 468  *
 469  * NOTES
 470  *     exported by ordinal
 471  */
 472 DWORD WINAPI
 473 SignalFileOpen (DWORD dwParam1)
 474 {
 475     FIXME("(0x%08lx):stub.\n", dwParam1);
 476
 477     return 0;
 478 }
 479
 480 /*************************************************************************
 481  * SHADD_get_policy - helper function for SHAddToRecentDocs
 482  *
 483  * PARAMETERS
 484  *   policy    [IN]  policy name (null termed string) to find
 485  *   type      [OUT] ptr to DWORD to receive type
 486  *   buffer    [OUT] ptr to area to hold data retrieved
 487  *   len       [IN/OUT] ptr to DWORD holding size of buffer and getting
 488  *                      length filled
 489  *
 490  * RETURNS
 491  *   result of the SHQueryValueEx call
 492  */
 493 static INT SHADD_get_policy(LPSTR policy, LPDWORD type, LPVOID buffer, LPDWORD len)
 494 {
 495     HKEY Policy_basekey;
 496     INT ret;
 497
 498     /* Get the key for the policies location in the registry
 499      */
 500     if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 501                       "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
 502                       0, KEY_READ, &Policy_basekey)) {
 503
 504         if (RegOpenKeyExA(HKEY_CURRENT_USER,
 505                           "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
 506                           0, KEY_READ, &Policy_basekey)) {
 507             TRACE("No Explorer Policies location exists. Policy wanted=%s\n",
 508                   policy);
 509             *len = 0;
 510             return ERROR_FILE_NOT_FOUND;
 511         }
 512     }
 513
 514     /* Retrieve the data if it exists
 515      */
 516     ret = SHQueryValueExA(Policy_basekey, policy, 0, type, buffer, len);
 517     RegCloseKey(Policy_basekey);
 518     return ret;
 519 }
 520
 521
 522 /*************************************************************************
 523  * SHADD_compare_mru - helper function for SHAddToRecentDocs
 524  *
 525  * PARAMETERS
 526  *   data1     [IN] data being looked for
 527  *   data2     [IN] data in MRU
 528  *   cbdata    [IN] length from FindMRUData call (not used)
 529  *
 530  * RETURNS
 531  *   position within MRU list that data was added.
 532  */
 533 static INT CALLBACK SHADD_compare_mru(LPCVOID data1, LPCVOID data2, DWORD cbData)
 534 {
 535     return lstrcmpiA(data1, data2);
 536 }
 537
 538 /*************************************************************************
 539  * SHADD_create_add_mru_data - helper function for SHAddToRecentDocs
 540  *
 541  * PARAMETERS
 542  *   mruhandle    [IN] handle for created MRU list
 543  *   doc_name     [IN] null termed pure doc name
 544  *   new_lnk_name [IN] null termed path and file name for .lnk file
 545  *   buffer       [IN/OUT] 2048 byte area to consturct MRU data
 546  *   len          [OUT] ptr to int to receive space used in buffer
 547  *
 548  * RETURNS
 549  *   position within MRU list that data was added.
 550  */
 551 static INT SHADD_create_add_mru_data(HANDLE mruhandle, LPSTR doc_name, LPSTR new_lnk_name,
 552                                      LPSTR buffer, INT *len)
 553 {
 554     LPSTR ptr;
 555     INT wlen;
 556
 557     /*FIXME: Document:
 558      *  RecentDocs MRU data structure seems to be:
 559      *    +0h   document file name w/ terminating 0h
 560      *    +nh   short int w/ size of remaining
 561      *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown
 562      *    +n+4h 10 bytes zeros  -   unknown
 563      *    +n+eh shortcut file name w/ terminating 0h
 564      *    +n+e+nh 3 zero bytes  -  unknown
 565      */
 566
 567     /* Create the MRU data structure for "RecentDocs"
 568          */
 569     ptr = buffer;
 570     lstrcpyA(ptr, doc_name);
 571     ptr += (lstrlenA(buffer) + 1);
 572     wlen= lstrlenA(new_lnk_name) + 1 + 12;
 573     *((short int*)ptr) = wlen;
 574     ptr += 2;   /* step past the length */
 575     *(ptr++) = 0x30;  /* unknown reason */
 576     *(ptr++) = 0;     /* unknown, but can be 0x00, 0x01, 0x02 */
 577     memset(ptr, 0, 10);
 578     ptr += 10;
 579     lstrcpyA(ptr, new_lnk_name);
 580     ptr += (lstrlenA(new_lnk_name) + 1);
 581     memset(ptr, 0, 3);
 582     ptr += 3;
 583     *len = ptr - buffer;
 584
 585     /* Add the new entry into the MRU list
 586      */
 587     return pAddMRUData(mruhandle, (LPCVOID)buffer, *len);
 588 }
 589
 590 /*************************************************************************
 591  * SHAddToRecentDocs                            [SHELL32.@]
 592  *
 593  * PARAMETERS
 594  *   uFlags  [IN] SHARD_PATH or SHARD_PIDL
 595  *   pv      [IN] string or pidl, NULL clears the list
 596  *
 597  * NOTES
 598  *     exported by name
 599  *
 600  * FIXME: ?? MSDN shows this as a VOID
 601  */
 602 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
 603 {
 604
 605 /* FIXME: !!! move CREATEMRULIST and flags to header file !!! */
 606 /*        !!! it is in both here and comctl32undoc.c      !!! */
 607 typedef struct tagCREATEMRULIST
 608 {
 609     DWORD  cbSize;        /* size of struct */
 610     DWORD  nMaxItems;     /* max no. of items in list */
 611     DWORD  dwFlags;       /* see below */
 612     HKEY   hKey;          /* root reg. key under which list is saved */
 613     LPCSTR lpszSubKey;    /* reg. subkey */
 614     PROC   lpfnCompare;   /* item compare proc */
 615 } CREATEMRULIST, *LPCREATEMRULIST;
 616
 617 /* dwFlags */
 618 #define MRUF_STRING_LIST  0 /* list will contain strings */
 619 #define MRUF_BINARY_LIST  1 /* list will contain binary data */
 620 #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
 621
 622 /* If list is a string list lpfnCompare has the following prototype
 623  * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
 624  * for binary lists the prototype is
 625  * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
 626  * where cbData is the no. of bytes to compare.
 627  * Need to check what return value means identical - 0?
 628  */
 629
 630
 631     UINT olderrormode;
 632     HKEY HCUbasekey;
 633     CHAR doc_name[MAX_PATH];
 634     CHAR link_dir[MAX_PATH];
 635     CHAR new_lnk_filepath[MAX_PATH];
 636     CHAR new_lnk_name[MAX_PATH];
 637     IMalloc *ppM;
 638     LPITEMIDLIST pidl;
 639     HWND hwnd = 0;       /* FIXME:  get real window handle */
 640     INT ret;
 641     DWORD data[64], datalen, type;
 642
 643     /*FIXME: Document:
 644      *  RecentDocs MRU data structure seems to be:
 645      *    +0h   document file name w/ terminating 0h
 646      *    +nh   short int w/ size of remaining
 647      *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown
 648      *    +n+4h 10 bytes zeros  -   unknown
 649      *    +n+eh shortcut file name w/ terminating 0h
 650      *    +n+e+nh 3 zero bytes  -  unknown
 651      */
 652
 653     /* See if we need to do anything.
 654      */
 655     datalen = 64;
 656     ret=SHADD_get_policy( "NoRecentDocsHistory", &type, &data, &datalen);
 657     if ((ret > 0) && (ret != ERROR_FILE_NOT_FOUND)) {
 658         ERR("Error %d getting policy \"NoRecentDocsHistory\"\n", ret);
 659         return 0;
 660     }
 661     if (ret == ERROR_SUCCESS) {
 662         if (!( (type == REG_DWORD) ||
 663                ((type == REG_BINARY) && (datalen == 4)) )) {
 664             ERR("Error policy data for \"NoRecentDocsHistory\" not formated correctly, type=%ld, len=%ld\n",
 665                 type, datalen);
 666             return 0;
 667         }
 668
 669         TRACE("policy value for NoRecentDocsHistory = %08lx\n", data[0]);
 670         /* now test the actual policy value */
 671         if ( data[0] != 0)
 672             return 0;
 673     }
 674
 675     /* Open key to where the necessary info is
 676      */
 677     /* FIXME: This should be done during DLL PROCESS_ATTACH (or THREAD_ATTACH)
 678      *        and the close should be done during the _DETACH. The resulting
 679      *        key is stored in the DLL global data.
 680      */
 681     if (RegCreateKeyExA(HKEY_CURRENT_USER,
 682                         "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
 683                         0, 0, 0, KEY_READ, 0, &HCUbasekey, 0)) {
 684         ERR("Failed to create 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer'\n");
 685         return 0;
 686     }
 687
 688     /* Get path to user's "Recent" directory
 689      */
 690     if(SUCCEEDED(SHGetMalloc(&ppM))) {
 691         if (SUCCEEDED(SHGetSpecialFolderLocation(hwnd, CSIDL_RECENT,
 692                                                  &pidl))) {
 693             SHGetPathFromIDListA(pidl, link_dir);
 694             IMalloc_Free(ppM, pidl);
 695         }
 696         else {
 697             /* serious issues */
 698             link_dir[0] = 0;
 699             ERR("serious issues 1\n");
 700         }
 701         IMalloc_Release(ppM);
 702     }
 703     else {
 704         /* serious issues */
 705         link_dir[0] = 0;
 706         ERR("serious issues 2\n");
 707     }
 708     TRACE("Users Recent dir %s\n", link_dir);
 709
 710     /* If no input, then go clear the lists */
 711     if (!pv) {
 712         /* clear user's Recent dir
 713          */
 714
 715         /* FIXME: delete all files in "link_dir"
 716          *
 717          * while( more files ) {
 718          *    lstrcpyA(old_lnk_name, link_dir);
 719          *    PathAppendA(old_lnk_name, filenam);
 720          *    DeleteFileA(old_lnk_name);
 721          * }
 722          */
 723         FIXME("should delete all files in %s\\ \n", link_dir);
 724
 725         /* clear MRU list
 726          */
 727         /* MS Bug ?? v4.72.3612.1700 of shell32 does the delete against
 728          *  HKEY_LOCAL_MACHINE version of ...CurrentVersion\Explorer
 729          *  and naturally it fails w/ rc=2. It should do it against
 730          *  HKEY_CURRENT_USER which is where it is stored, and where
 731          *  the MRU routines expect it!!!!
 732          */
 733         RegDeleteKeyA(HCUbasekey, "RecentDocs");
 734         RegCloseKey(HCUbasekey);
 735         return 0;
 736     }
 737
 738     /* Have data to add, the jobs to be done:
 739      *   1. Add document to MRU list in registry "HKCU\Software\
 740      *      Microsoft\Windows\CurrentVersion\Explorer\RecentDocs".
 741      *   2. Add shortcut to document in the user's Recent directory
 742      *      (CSIDL_RECENT).
 743      *   3. Add shortcut to Start menu's Documents submenu.
 744      */
 745
 746     /* Get the pure document name from the input
 747      */
 748     if (uFlags & SHARD_PIDL) {
 749         SHGetPathFromIDListA((LPCITEMIDLIST) pv, doc_name);
 750     }
 751     else {
 752         lstrcpyA(doc_name, (LPSTR) pv);
 753     }
 754     TRACE("full document name %s\n", doc_name);
 755     PathStripPathA(doc_name);
 756     TRACE("stripped document name %s\n", doc_name);
 757
 758
 759     /* ***  JOB 1: Update registry for ...\Explorer\RecentDocs list  *** */
 760
 761     {  /* on input needs:
 762         *      doc_name    -  pure file-spec, no path
 763         *      link_dir    -  path to the user's Recent directory
 764         *      HCUbasekey  -  key of ...Windows\CurrentVersion\Explorer" node
 765         * creates:
 766         *      new_lnk_name-  pure file-spec, no path for new .lnk file
 767         *      new_lnk_filepath
 768         *                  -  path and file name of new .lnk file
 769         */
 770         CREATEMRULIST mymru;
 771         HANDLE mruhandle;
 772         INT len, pos, bufused, err;
 773         INT i;
 774         DWORD attr;
 775         CHAR buffer[2048];
 776         CHAR *ptr;
 777         CHAR old_lnk_name[MAX_PATH];
 778         short int slen;
 779
 780         mymru.cbSize = sizeof(CREATEMRULIST);
 781         mymru.nMaxItems = 15;
 782         mymru.dwFlags = MRUF_BINARY_LIST | MRUF_DELAYED_SAVE;
 783         mymru.hKey = HCUbasekey;
 784         mymru.lpszSubKey = "RecentDocs";
 785         mymru.lpfnCompare = &SHADD_compare_mru;
 786         mruhandle = pCreateMRUListA(&mymru);
 787         if (!mruhandle) {
 788             /* MRU failed */
 789             ERR("MRU processing failed, handle zero\n");
 790             RegCloseKey(HCUbasekey);
 791             return 0;
 792         }
 793         len = lstrlenA(doc_name);
 794         pos = pFindMRUData(mruhandle, doc_name, len, 0);
 795
 796         /* Now get the MRU entry that will be replaced
 797          * and delete the .lnk file for it
 798          */
 799         if ((bufused = pEnumMRUListA(mruhandle, (pos == -1) ? 14 : pos,
 800                                      buffer, 2048)) != -1) {
 801             ptr = buffer;
 802             ptr += (lstrlenA(buffer) + 1);
 803             slen = *((short int*)ptr);
 804             ptr += 2;  /* skip the length area */
 805             if (bufused >= slen + (ptr-buffer)) {
 806                 /* buffer size looks good */
 807                 ptr += 12; /* get to string */
 808                 len = bufused - (ptr-buffer);  /* get length of buf remaining */
 809                 if ((lstrlenA(ptr) > 0) && (lstrlenA(ptr) <= len-1)) {
 810                     /* appears to be good string */
 811                     lstrcpyA(old_lnk_name, link_dir);
 812                     PathAppendA(old_lnk_name, ptr);
 813                     if (!DeleteFileA(old_lnk_name)) {
 814                         if ((attr = GetFileAttributesA(old_lnk_name)) == -1) {
 815                             if ((err = GetLastError()) != ERROR_FILE_NOT_FOUND) {
 816                                 ERR("Delete for %s failed, err=%d, attr=%08lx\n",
 817                                     old_lnk_name, err, attr);
 818                             }
 819                             else {
 820                                 TRACE("old .lnk file %s did not exist\n",
 821                                       old_lnk_name);
 822                             }
 823                         }
 824                         else {
 825                             ERR("Delete for %s failed, attr=%08lx\n",
 826                                 old_lnk_name, attr);
 827                         }
 828                     }
 829                     else {
 830                         TRACE("deleted old .lnk file %s\n", old_lnk_name);
 831                     }
 832                 }
 833             }
 834         }
 835
 836         /* Create usable .lnk file name for the "Recent" directory
 837          */
 838         wsprintfA(new_lnk_name, "%s.lnk", doc_name);
 839         lstrcpyA(new_lnk_filepath, link_dir);
 840         PathAppendA(new_lnk_filepath, new_lnk_name);
 841         i = 1;
 842         olderrormode = SetErrorMode(SEM_FAILCRITICALERRORS);
 843         while (GetFileAttributesA(new_lnk_filepath) != -1) {
 844             i++;
 845             wsprintfA(new_lnk_name, "%s (%u).lnk", doc_name, i);
 846             lstrcpyA(new_lnk_filepath, link_dir);
 847             PathAppendA(new_lnk_filepath, new_lnk_name);
 848         }
 849         SetErrorMode(olderrormode);
 850         TRACE("new shortcut will be %s\n", new_lnk_filepath);
 851
 852         /* Now add the new MRU entry and data
 853          */
 854         pos = SHADD_create_add_mru_data(mruhandle, doc_name, new_lnk_name,
 855                                         buffer, &len);
 856         pFreeMRUListA(mruhandle);
 857         TRACE("Updated MRU list, new doc is position %d\n", pos);
 858     }
 859
 860     /* ***  JOB 2: Create shortcut in user's "Recent" directory  *** */
 861
 862     {  /* on input needs:
 863         *      doc_name    -  pure file-spec, no path
 864         *      new_lnk_filepath
 865         *                  -  path and file name of new .lnk file
 866         *      uFlags[in]  -  flags on call to SHAddToRecentDocs
 867         *      pv[in]      -  document path/pidl on call to SHAddToRecentDocs
 868         */
 869         IShellLinkA *psl = NULL;
 870         IPersistFile *pPf = NULL;
 871         HRESULT hres;
 872         CHAR desc[MAX_PATH];
 873         WCHAR widelink[MAX_PATH];
 874
 875         CoInitialize(0);
 876
 877         hres = CoCreateInstance( &CLSID_ShellLink,
 878                                  NULL,
 879                                  CLSCTX_INPROC_SERVER,
 880                                  &IID_IShellLinkA,
 881                                  (LPVOID )&psl);
 882         if(SUCCEEDED(hres)) {
 883
 884             hres = IShellLinkA_QueryInterface(psl, &IID_IPersistFile,
 885                                              (LPVOID *)&pPf);
 886             if(FAILED(hres)) {
 887                 /* bombed */
 888                 ERR("failed QueryInterface for IPersistFile %08lx\n", hres);
 889                 goto fail;
 890             }
 891
 892             /* Set the document path or pidl */
 893             if (uFlags & SHARD_PIDL) {
 894                 hres = IShellLinkA_SetIDList(psl, (LPCITEMIDLIST) pv);
 895             } else {
 896                 hres = IShellLinkA_SetPath(psl, (LPCSTR) pv);
 897             }
 898             if(FAILED(hres)) {
 899                 /* bombed */
 900                 ERR("failed Set{IDList|Path} %08lx\n", hres);
 901                 goto fail;
 902             }
 903
 904             lstrcpyA(desc, "Shortcut to ");
 905             lstrcatA(desc, doc_name);
 906             hres = IShellLinkA_SetDescription(psl, desc);
 907             if(FAILED(hres)) {
 908                 /* bombed */
 909                 ERR("failed SetDescription %08lx\n", hres);
 910                 goto fail;
 911             }
 912
 913             MultiByteToWideChar(CP_ACP, 0, new_lnk_filepath, -1,
 914                                 widelink, MAX_PATH);
 915             /* create the short cut */
 916             hres = IPersistFile_Save(pPf, widelink, TRUE);
 917             if(FAILED(hres)) {
 918                 /* bombed */
 919                 ERR("failed IPersistFile::Save %08lx\n", hres);
 920                 IPersistFile_Release(pPf);
 921                 IShellLinkA_Release(psl);
 922                 goto fail;
 923             }
 924             hres = IPersistFile_SaveCompleted(pPf, widelink);
 925             IPersistFile_Release(pPf);
 926             IShellLinkA_Release(psl);
 927             TRACE("shortcut %s has been created, result=%08lx\n",
 928                   new_lnk_filepath, hres);
 929         }
 930         else {
 931             ERR("CoCreateInstance failed, hres=%08lx\n", hres);
 932         }
 933     }
 934
 935  fail:
 936     CoUninitialize();
 937
 938     /* all done */
 939     RegCloseKey(HCUbasekey);
 940     return 0;
 941 }
 942
 943 /*************************************************************************
 944  * SHCreateShellFolderViewEx                    [SHELL32.174]
 945  *
 946  * NOTES
 947  *  see IShellFolder::CreateViewObject
 948  */
 949 HRESULT WINAPI SHCreateShellFolderViewEx(
 950         LPCSHELLFOLDERVIEWINFO psvcbi, /* [in] shelltemplate struct */
 951         LPSHELLVIEW* ppv)              /* [out] IShellView pointer */
 952 {
 953         IShellView * psf;
 954         HRESULT hRes;
 955
 956         TRACE("sf=%p pidl=%p cb=%p mode=0x%08x parm=0x%08lx\n",
 957           psvcbi->pshf, psvcbi->pidlFolder, psvcbi->lpfnCallback,
 958           psvcbi->uViewMode, psvcbi->dwUser);
 959
 960         psf = IShellView_Constructor(psvcbi->pshf);
 961
 962         if (!psf)
 963           return E_OUTOFMEMORY;
 964
 965         IShellView_AddRef(psf);
 966         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
 967         IShellView_Release(psf);
 968
 969         return hRes;
 970 }
 971 /*************************************************************************
 972  *  SHWinHelp                                   [SHELL32.127]
 973  *
 974  */
 975 HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
 976 {       FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
 977         return 0;
 978 }
 979 /*************************************************************************
 980  *  SHRunControlPanel [SHELL32.161]
 981  *
 982  */
 983 HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
 984 {       FIXME("0x%08lx 0x%08lx stub\n",x,z);
 985         return 0;
 986 }
 987 /*************************************************************************
 988  * ShellExecuteEx                               [SHELL32.291]
 989  *
 990  */
 991 BOOL WINAPI ShellExecuteExAW (LPVOID sei)
 992 {       if (SHELL_OsIsUnicode())
 993           return ShellExecuteExW (sei);
 994         return ShellExecuteExA (sei);
 995 }
 996 /*************************************************************************
 997  * ShellExecuteExA                              [SHELL32.292]
 998  *
 999  * placeholder in the commandline:
1000  *      %1 file
1001  *      %2 printer
1002  *      %3 driver
1003  *      %4 port
1004  *      %I adress of a global item ID (explorer switch /idlist)
1005  *      %L ??? path/url/current file ???
1006  *      %S ???
1007  *      %* all following parameters (see batfile)
1008  */
1009 BOOL WINAPI ShellExecuteExA (LPSHELLEXECUTEINFOA sei)
1010 {       CHAR szApplicationName[MAX_PATH],szCommandline[MAX_PATH],szPidl[20];
1011         LPSTR pos;
1012         int gap, len;
1013         STARTUPINFOA  startup;
1014         PROCESS_INFORMATION info;
1015
1016         WARN("mask=0x%08lx hwnd=0x%04x verb=%s file=%s parm=%s dir=%s show=0x%08x class=%s incomplete\n",
1017              sei->fMask, sei->hwnd, debugstr_a(sei->lpVerb),
1018              debugstr_a(sei->lpFile), debugstr_a(sei->lpParameters),
1019              debugstr_a(sei->lpDirectory), sei->nShow,
1020              (sei->fMask & SEE_MASK_CLASSNAME) ? debugstr_a(sei->lpClass) : "not used");
1021
1022         ZeroMemory(szApplicationName,MAX_PATH);
1023         if (sei->lpFile)
1024           strcpy(szApplicationName, sei->lpFile);
1025
1026         ZeroMemory(szCommandline,MAX_PATH);
1027         if (sei->lpParameters)
1028           strcpy(szCommandline, sei->lpParameters);
1029
1030         if (sei->fMask & (SEE_MASK_CLASSKEY | SEE_MASK_INVOKEIDLIST | SEE_MASK_ICON | SEE_MASK_HOTKEY |
1031                           SEE_MASK_CONNECTNETDRV | SEE_MASK_FLAG_DDEWAIT |
1032                           SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI | SEE_MASK_UNICODE |
1033                           SEE_MASK_NO_CONSOLE | SEE_MASK_ASYNCOK | SEE_MASK_HMONITOR ))
1034         {
1035           FIXME("flags ignored: 0x%08lx\n", sei->fMask);
1036         }
1037
1038         /* launch a document by fileclass like 'Wordpad.Document.1' */
1039         if (sei->fMask & SEE_MASK_CLASSNAME)
1040         {
1041           /* FIXME: szCommandline should not be of a fixed size. Plus MAX_PATH is way too short! */
1042           /* the commandline contains 'c:\Path\wordpad.exe "%1"' */
1043           HCR_GetExecuteCommand(sei->lpClass, (sei->lpVerb) ? sei->lpVerb : "open", szCommandline, sizeof(szCommandline));
1044           /* FIXME: get the extension of lpFile, check if it fits to the lpClass */
1045           TRACE("SEE_MASK_CLASSNAME->'%s'\n", szCommandline);
1046         }
1047
1048         /* process the IDList */
1049         if ( (sei->fMask & SEE_MASK_INVOKEIDLIST) == SEE_MASK_INVOKEIDLIST) /*0x0c*/
1050         {
1051           SHGetPathFromIDListA (sei->lpIDList,szApplicationName);
1052           TRACE("-- idlist=%p (%s)\n", sei->lpIDList, szApplicationName);
1053         }
1054         else
1055         {
1056           if (sei->fMask & SEE_MASK_IDLIST )
1057           {
1058             pos = strstr(szCommandline, "%I");
1059             if (pos)
1060             {
1061               LPVOID pv;
1062               HGLOBAL hmem = SHAllocShared ( sei->lpIDList, ILGetSize(sei->lpIDList), 0);
1063               pv = SHLockShared(hmem,0);
1064               sprintf(szPidl,":%p",pv );
1065               SHUnlockShared(pv);
1066
1067               gap = strlen(szPidl);
1068               len = strlen(pos)-2;
1069               memmove(pos+gap,pos+2,len);
1070               memcpy(pos,szPidl,gap);
1071
1072             }
1073           }
1074         }
1075
1076         TRACE("execute:'%s','%s'\n",szApplicationName, szCommandline);
1077
1078         if (szCommandline[0]) {
1079           strcat(szApplicationName, " ");
1080           strcat(szApplicationName, szCommandline);
1081         }
1082
1083         ZeroMemory(&startup,sizeof(STARTUPINFOA));
1084         startup.cb = sizeof(STARTUPINFOA);
1085
1086         if (! CreateProcessA(NULL, szApplicationName,
1087                          NULL, NULL, FALSE, 0,
1088                          NULL, sei->lpDirectory,
1089                          &startup, &info))
1090         {
1091         BOOL failed = TRUE;
1092
1093         if ((!sei->lpVerb)||(strcasecmp(sei->lpVerb,"open")))
1094         {
1095             LPSTR   ext = PathFindExtensionA(szApplicationName);
1096             CHAR    key[1023];
1097             CHAR    buffer[1023];
1098             CHAR    cmdline[1023];
1099             DWORD   size;
1100
1101             sprintf(key,"Software\\Classes\\%s",ext);
1102             size = 1023;
1103             if (!RegQueryValueA(HKEY_LOCAL_MACHINE,key,buffer,&size))
1104             {
1105                 sprintf(key,"Software\\Classes\\%s\\shell\\%s\\command", buffer,
1106                     (sei->lpVerb)?sei->lpVerb:"open");
1107                 size = 1023;
1108                 if (!RegQueryValueA(HKEY_LOCAL_MACHINE,key,buffer,&size))
1109                 {
1110                     sprintf(cmdline,"%s \"%s\"",buffer,szApplicationName);
1111                     if (CreateProcessA(NULL,cmdline,  NULL, NULL, FALSE, 0,
1112                                    NULL, sei->lpDirectory, &startup, &info))
1113                         failed = FALSE;
1114                 }
1115             }
1116         }
1117
1118         if (failed)
1119         {
1120             sei->hInstApp = GetLastError();
1121             return FALSE;
1122         }
1123         }
1124
1125         sei->hInstApp = 33;
1126
1127         if(sei->fMask & SEE_MASK_NOCLOSEPROCESS)
1128           sei->hProcess = info.hProcess;
1129         else
1130           CloseHandle( info.hProcess );
1131         CloseHandle( info.hThread );
1132         return TRUE;
1133 }
1134 /*************************************************************************
1135  * ShellExecuteExW                              [SHELL32.293]
1136  *
1137  */
1138 BOOL WINAPI ShellExecuteExW (LPSHELLEXECUTEINFOW sei)
1139 {       SHELLEXECUTEINFOA seiA;
1140         DWORD ret;
1141
1142         TRACE("%p\n", sei);
1143
1144         memcpy(&seiA, sei, sizeof(SHELLEXECUTEINFOA));
1145
1146         if (sei->lpVerb)
1147           seiA.lpVerb = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpVerb);
1148
1149         if (sei->lpFile)
1150           seiA.lpFile = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpFile);
1151
1152         if (sei->lpParameters)
1153           seiA.lpParameters = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpParameters);
1154
1155         if (sei->lpDirectory)
1156           seiA.lpDirectory = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpDirectory);
1157
1158         if ((sei->fMask & SEE_MASK_CLASSNAME) && sei->lpClass)
1159           seiA.lpClass = HEAP_strdupWtoA( GetProcessHeap(), 0, sei->lpClass);
1160         else
1161           seiA.lpClass = NULL;
1162
1163         ret = ShellExecuteExA(&seiA);
1164
1165         if (seiA.lpVerb)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpVerb );
1166         if (seiA.lpFile)        HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpFile );
1167         if (seiA.lpParameters)  HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpParameters );
1168         if (seiA.lpDirectory)   HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpDirectory );
1169         if (seiA.lpClass)       HeapFree( GetProcessHeap(), 0, (LPSTR) seiA.lpClass );
1170
1171         return ret;
1172 }
1173
1174 static LPUNKNOWN SHELL32_IExplorerInterface=0;
1175 /*************************************************************************
1176  * SHSetInstanceExplorer                        [SHELL32.176]
1177  *
1178  * NOTES
1179  *  Sets the interface
1180  */
1181 HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
1182 {       TRACE("%p\n", lpUnknown);
1183         SHELL32_IExplorerInterface = lpUnknown;
1184         return (HRESULT) lpUnknown;
1185 }
1186 /*************************************************************************
1187  * SHGetInstanceExplorer                        [SHELL32.@]
1188  *
1189  * NOTES
1190  *  gets the interface pointer of the explorer and a reference
1191  */
1192 HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
1193 {       TRACE("%p\n", lpUnknown);
1194
1195         *lpUnknown = SHELL32_IExplorerInterface;
1196
1197         if (!SHELL32_IExplorerInterface)
1198           return E_FAIL;
1199
1200         IUnknown_AddRef(SHELL32_IExplorerInterface);
1201         return NOERROR;
1202 }
1203 /*************************************************************************
1204  * SHFreeUnusedLibraries                        [SHELL32.123]
1205  *
1206  * NOTES
1207  *  exported by name
1208  */
1209 void WINAPI SHFreeUnusedLibraries (void)
1210 {
1211         FIXME("stub\n");
1212 }
1213 /*************************************************************************
1214  * DAD_SetDragImage                             [SHELL32.136]
1215  *
1216  * NOTES
1217  *  exported by name
1218  */
1219 BOOL WINAPI DAD_SetDragImage(
1220         HIMAGELIST himlTrack,
1221         LPPOINT lppt)
1222 {
1223         FIXME("%p %p stub\n",himlTrack, lppt);
1224   return 0;
1225 }
1226 /*************************************************************************
1227  * DAD_ShowDragImage                            [SHELL32.137]
1228  *
1229  * NOTES
1230  *  exported by name
1231  */
1232 BOOL WINAPI DAD_ShowDragImage(BOOL bShow)
1233 {
1234         FIXME("0x%08x stub\n",bShow);
1235         return 0;
1236 }
1237 /*************************************************************************
1238  * ReadCabinetState                             [SHELL32.651] NT 4.0
1239  *
1240  */
1241 HRESULT WINAPI ReadCabinetState(DWORD u, DWORD v)
1242 {       FIXME("0x%04lx 0x%04lx stub\n",u,v);
1243         return 0;
1244 }
1245 /*************************************************************************
1246  * WriteCabinetState                            [SHELL32.652] NT 4.0
1247  *
1248  */
1249 HRESULT WINAPI WriteCabinetState(DWORD u)
1250 {       FIXME("0x%04lx stub\n",u);
1251         return 0;
1252 }
1253 /*************************************************************************
1254  * FileIconInit                                 [SHELL32.660]
1255  *
1256  */
1257 BOOL WINAPI FileIconInit(BOOL bFullInit)
1258 {       FIXME("(%s)\n", bFullInit ? "true" : "false");
1259         return 0;
1260 }
1261 /*************************************************************************
1262  * IsUserAdmin                                  [SHELL32.680] NT 4.0
1263  *
1264  */
1265 HRESULT WINAPI IsUserAdmin(void)
1266 {       FIXME("stub\n");
1267         return TRUE;
1268 }
1269
1270 /*************************************************************************
1271  * SHAllocShared                                [SHELL32.520]
1272  *
1273  * NOTES
1274  *  parameter1 is return value from HeapAlloc
1275  *  parameter2 is equal to the size allocated with HeapAlloc
1276  *  parameter3 is return value from GetCurrentProcessId
1277  *
1278  *  the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
1279  *  WM_USER+2 could be the undocumented CWM_SETPATH
1280  *  the allocated memory contains a pidl
1281  */
1282 HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
1283 {       HGLOBAL hmem;
1284         LPVOID pmem;
1285
1286         TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
1287         hmem = GlobalAlloc(GMEM_FIXED, size);
1288         if (!hmem)
1289           return 0;
1290
1291         pmem =  GlobalLock (hmem);
1292
1293         if (! pmem)
1294           return 0;
1295
1296         memcpy (pmem, psrc, size);
1297         GlobalUnlock(hmem);
1298         return hmem;
1299 }
1300 /*************************************************************************
1301  * SHLockShared                                 [SHELL32.521]
1302  *
1303  * NOTES
1304  *  parameter1 is return value from SHAllocShared
1305  *  parameter2 is return value from GetCurrentProcessId
1306  *  the receiver of (WM_USER+2) tries to lock the HANDLE (?)
1307  *  the return value seems to be a memory address
1308  */
1309 LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
1310 {       TRACE("handle=0x%04x procID=0x%04lx\n",hmem,procID);
1311         return GlobalLock(hmem);
1312 }
1313 /*************************************************************************
1314  * SHUnlockShared                               [SHELL32.522]
1315  *
1316  * NOTES
1317  *  parameter1 is return value from SHLockShared
1318  */
1319 BOOL WINAPI SHUnlockShared(LPVOID pv)
1320 {
1321         TRACE("%p\n",pv);
1322         return GlobalUnlock((HANDLE)pv);
1323 }
1324 /*************************************************************************
1325  * SHFreeShared                                 [SHELL32.523]
1326  *
1327  * NOTES
1328  *  parameter1 is return value from SHAllocShared
1329  *  parameter2 is return value from GetCurrentProcessId
1330  */
1331 BOOL WINAPI SHFreeShared(
1332         HANDLE hMem,
1333         DWORD pid)
1334 {
1335         TRACE("handle=0x%04x 0x%04lx\n",hMem,pid);
1336         return GlobalFree(hMem);
1337 }
1338
1339 /*************************************************************************
1340  * SetAppStartingCursor                         [SHELL32.99]
1341  */
1342 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
1343 {       FIXME("hwnd=0x%04x 0x%04lx stub\n",u,v );
1344         return 0;
1345 }
1346 /*************************************************************************
1347  * SHLoadOLE                                    [SHELL32.151]
1348  *
1349  */
1350 HRESULT WINAPI SHLoadOLE(DWORD u)
1351 {       FIXME("0x%04lx stub\n",u);
1352         return S_OK;
1353 }
1354 /*************************************************************************
1355  * DriveType                                    [SHELL32.64]
1356  *
1357  */
1358 HRESULT WINAPI DriveType(DWORD u)
1359 {       FIXME("0x%04lx stub\n",u);
1360         return 0;
1361 }
1362 /*************************************************************************
1363  * SHAbortInvokeCommand                         [SHELL32.198]
1364  *
1365  */
1366 HRESULT WINAPI SHAbortInvokeCommand(void)
1367 {       FIXME("stub\n");
1368         return 1;
1369 }
1370 /*************************************************************************
1371  * SHOutOfMemoryMessageBox                      [SHELL32.126]
1372  *
1373  */
1374 int WINAPI SHOutOfMemoryMessageBox(
1375         HWND hwndOwner,
1376         LPCSTR lpCaption,
1377         UINT uType)
1378 {
1379         FIXME("0x%04x %s 0x%08x stub\n",hwndOwner, lpCaption, uType);
1380         return 0;
1381 }
1382 /*************************************************************************
1383  * SHFlushClipboard                             [SHELL32.121]
1384  *
1385  */
1386 HRESULT WINAPI SHFlushClipboard(void)
1387 {       FIXME("stub\n");
1388         return 1;
1389 }
1390
1391 /*************************************************************************
1392  * SHWaitForFileToOpen                          [SHELL32.97]
1393  *
1394  */
1395 BOOL WINAPI SHWaitForFileToOpen(
1396         LPCITEMIDLIST pidl,
1397         DWORD dwFlags,
1398         DWORD dwTimeout)
1399 {
1400         FIXME("%p 0x%08lx 0x%08lx stub\n", pidl, dwFlags, dwTimeout);
1401         return 0;
1402 }
1403
1404 /************************************************************************
1405  *      @                               [SHELL32.654]
1406  *
1407  * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
1408  * second one could be a size (0x0c). The size is the same as the structure saved to
1409  * HCU\Software\Microsoft\Windows\CurrentVersion\Explorer\CabinetState
1410  * I'm (js) guessing: this one is just ReadCabinetState ;-)
1411  */
1412 HRESULT WINAPI shell32_654 (DWORD x, DWORD y)
1413 {       FIXME("0x%08lx 0x%08lx stub\n",x,y);
1414         return 0;
1415 }
1416
1417 /************************************************************************
1418  *      RLBuildListOfPaths                      [SHELL32.146]
1419  *
1420  * NOTES
1421  *   builds a DPA
1422  */
1423 DWORD WINAPI RLBuildListOfPaths (void)
1424 {       FIXME("stub\n");
1425         return 0;
1426 }
1427 /************************************************************************
1428  *      SHValidateUNC                           [SHELL32.173]
1429  *
1430  */
1431 HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
1432 {
1433         FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
1434         return 0;
1435 }
1436
1437 /************************************************************************
1438  *      DoEnvironmentSubstA                     [SHELL32.@]
1439  *
1440  */
1441 HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
1442 {
1443         FIXME("(%s, %s) stub\n", debugstr_a(x), debugstr_a(y));
1444         return 0;
1445 }
1446
1447 /************************************************************************
1448  *      DoEnvironmentSubstW                     [SHELL32.@]
1449  *
1450  */
1451 HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
1452 {
1453         FIXME("(%s, %s): stub\n", debugstr_w(x), debugstr_w(y));
1454         return 0;
1455 }
1456
1457 /************************************************************************
1458  *      DoEnvironmentSubst                      [SHELL32.53]
1459  *
1460  */
1461 HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
1462 {
1463         if (SHELL_OsIsUnicode())
1464           return DoEnvironmentSubstW(x, y);
1465         return DoEnvironmentSubstA(x, y);
1466 }
1467
1468 /*************************************************************************
1469  *      @                             [SHELL32.243]
1470  *
1471  * Win98+ by-ordinal routine.  In Win98 this routine returns zero and
1472  * does nothing else.  Possibly this does something in NT or SHELL32 5.0?
1473  *
1474  */
1475
1476 BOOL WINAPI shell32_243(DWORD a, DWORD b)
1477 {
1478   return FALSE;
1479 }
1480
1481 /*************************************************************************
1482  *      @       [SHELL32.714]
1483  */
1484 DWORD WINAPI SHELL32_714(LPVOID x)
1485 {
1486         FIXME("(%s)stub\n", debugstr_w(x));
1487         return 0;
1488 }
1489
1490 /*************************************************************************
1491  *      SHAddFromPropSheetExtArray      [SHELL32.167]
1492  */
1493 DWORD WINAPI SHAddFromPropSheetExtArray(DWORD a, DWORD b, DWORD c)
1494 {
1495         FIXME("(%08lx,%08lx,%08lx)stub\n", a, b, c);
1496         return 0;
1497 }
1498
1499 /*************************************************************************
1500  *      SHCreatePropSheetExtArray       [SHELL32.168]
1501  */
1502 DWORD WINAPI SHCreatePropSheetExtArray(DWORD a, LPCSTR b, DWORD c)
1503 {
1504         FIXME("(%08lx,%s,%08lx)stub\n", a, debugstr_a(b), c);
1505         return 0;
1506 }
1507
1508 /*************************************************************************
1509  *      SHReplaceFromPropSheetExtArray  [SHELL32.170]
1510  */
1511 DWORD WINAPI SHReplaceFromPropSheetExtArray(DWORD a, DWORD b, DWORD c, DWORD d)
1512 {
1513         FIXME("(%08lx,%08lx,%08lx,%08lx)stub\n", a, b, c, d);
1514         return 0;
1515 }
1516
1517 /*************************************************************************
1518  *      SHDestroyPropSheetExtArray      [SHELL32.169]
1519  */
1520 DWORD WINAPI SHDestroyPropSheetExtArray(DWORD a)
1521 {
1522         FIXME("(%08lx)stub\n", a);
1523         return 0;
1524 }
1525
1526 /*************************************************************************
1527  *      CIDLData_CreateFromIDArray      [SHELL32.83]
1528  *
1529  *  Create IDataObject from PIDLs??
1530  */
1531 HRESULT WINAPI CIDLData_CreateFromIDArray(
1532         LPCITEMIDLIST pidlFolder,
1533         DWORD cpidlFiles,
1534         LPCITEMIDLIST *lppidlFiles,
1535         LPDATAOBJECT *ppdataObject)
1536 {
1537     INT i;
1538     HWND hwnd = 0;   /*FIXME: who should be hwnd of owner? set to desktop */
1539
1540     TRACE("(%p, %ld, %p, %p)\n", pidlFolder, cpidlFiles, lppidlFiles, ppdataObject);
1541     if (TRACE_ON(pidl))
1542     {
1543         pdump (pidlFolder);
1544         for (i=0; i<cpidlFiles; i++) pdump (lppidlFiles[i]);
1545     }
1546     *ppdataObject = IDataObject_Constructor( hwnd, pidlFolder,
1547                                              lppidlFiles, cpidlFiles);
1548     if (*ppdataObject) return S_OK;
1549     return E_OUTOFMEMORY;
1550 }