git.oblomov.eu Git - wine/blob - dlls/shlwapi/ordinal.c

   1 /*
   2  * SHLWAPI ordinal functions
   3  *
   4  * Copyright 1997 Marcus Meissner
   5  *           1998 Jürgen Schmied
   6  *           2001-2003 Jon Griffiths
   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
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #define COBJMACROS
  31 #define NONAMELESSUNION
  32 #define NONAMELESSSTRUCT
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winnls.h"
  37 #include "winreg.h"
  38 #include "wingdi.h"
  39 #include "winuser.h"
  40 #include "winver.h"
  41 #include "winnetwk.h"
  42 #include "mmsystem.h"
  43 #include "objbase.h"
  44 #include "exdisp.h"
  45 #include "shlobj.h"
  46 #include "shlwapi.h"
  47 #include "shellapi.h"
  48 #include "commdlg.h"
  49 #include "mshtmhst.h"
  50 #include "wine/unicode.h"
  51 #include "wine/debug.h"
  52
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  55
  56 /* DLL handles for late bound calls */
  57 extern HINSTANCE shlwapi_hInstance;
  58 extern DWORD SHLWAPI_ThreadRef_index;
  59
  60 HRESULT WINAPI IUnknown_QueryService(IUnknown*,REFGUID,REFIID,LPVOID*);
  61 HRESULT WINAPI SHInvokeCommand(HWND,IShellFolder*,LPCITEMIDLIST,BOOL);
  62 BOOL    WINAPI SHAboutInfoW(LPWSTR,DWORD);
  63
  64 /*
  65  NOTES: Most functions exported by ordinal seem to be superfluous.
  66  The reason for these functions to be there is to provide a wrapper
  67  for unicode functions to provide these functions on systems without
  68  unicode functions eg. win95/win98. Since we have such functions we just
  69  call these. If running Wine with native DLLs, some late bound calls may
  70  fail. However, it is better to implement the functions in the forward DLL
  71  and recommend the builtin rather than reimplementing the calls here!
  72 */
  73
  74 /*************************************************************************
  75  * SHLWAPI_DupSharedHandle
  76  *
  77  * Internal implemetation of SHLWAPI_11.
  78  */
  79 static
  80 HANDLE WINAPI SHLWAPI_DupSharedHandle(HANDLE hShared, DWORD dwDstProcId,
  81                                        DWORD dwSrcProcId, DWORD dwAccess,
  82                                        DWORD dwOptions)
  83 {
  84   HANDLE hDst, hSrc;
  85   DWORD dwMyProcId = GetCurrentProcessId();
  86   HANDLE hRet = NULL;
  87
  88   TRACE("(%p,%d,%d,%08x,%08x)\n", hShared, dwDstProcId, dwSrcProcId,
  89         dwAccess, dwOptions);
  90
  91   /* Get dest process handle */
  92   if (dwDstProcId == dwMyProcId)
  93     hDst = GetCurrentProcess();
  94   else
  95     hDst = OpenProcess(PROCESS_DUP_HANDLE, 0, dwDstProcId);
  96
  97   if (hDst)
  98   {
  99     /* Get src process handle */
 100     if (dwSrcProcId == dwMyProcId)
 101       hSrc = GetCurrentProcess();
 102     else
 103       hSrc = OpenProcess(PROCESS_DUP_HANDLE, 0, dwSrcProcId);
 104
 105     if (hSrc)
 106     {
 107       /* Make handle available to dest process */
 108       if (!DuplicateHandle(hDst, hShared, hSrc, &hRet,
 109                            dwAccess, 0, dwOptions | DUPLICATE_SAME_ACCESS))
 110         hRet = NULL;
 111
 112       if (dwSrcProcId != dwMyProcId)
 113         CloseHandle(hSrc);
 114     }
 115
 116     if (dwDstProcId != dwMyProcId)
 117       CloseHandle(hDst);
 118   }
 119
 120   TRACE("Returning handle %p\n", hRet);
 121   return hRet;
 122 }
 123
 124 /*************************************************************************
 125  * @  [SHLWAPI.7]
 126  *
 127  * Create a block of sharable memory and initialise it with data.
 128  *
 129  * PARAMS
 130  * lpvData  [I] Pointer to data to write
 131  * dwSize   [I] Size of data
 132  * dwProcId [I] ID of process owning data
 133  *
 134  * RETURNS
 135  * Success: A shared memory handle
 136  * Failure: NULL
 137  *
 138  * NOTES
 139  * Ordinals 7-11 provide a set of calls to create shared memory between a
 140  * group of processes. The shared memory is treated opaquely in that its size
 141  * is not exposed to clients who map it. This is accomplished by storing
 142  * the size of the map as the first DWORD of mapped data, and then offsetting
 143  * the view pointer returned by this size.
 144  *
 145  */
 146 HANDLE WINAPI SHAllocShared(LPCVOID lpvData, DWORD dwSize, DWORD dwProcId)
 147 {
 148   HANDLE hMap;
 149   LPVOID pMapped;
 150   HANDLE hRet = NULL;
 151
 152   TRACE("(%p,%d,%d)\n", lpvData, dwSize, dwProcId);
 153
 154   /* Create file mapping of the correct length */
 155   hMap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, FILE_MAP_READ, 0,
 156                             dwSize + sizeof(dwSize), NULL);
 157   if (!hMap)
 158     return hRet;
 159
 160   /* Get a view in our process address space */
 161   pMapped = MapViewOfFile(hMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 162
 163   if (pMapped)
 164   {
 165     /* Write size of data, followed by the data, to the view */
 166     *((DWORD*)pMapped) = dwSize;
 167     if (lpvData)
 168       memcpy((char *) pMapped + sizeof(dwSize), lpvData, dwSize);
 169
 170     /* Release view. All further views mapped will be opaque */
 171     UnmapViewOfFile(pMapped);
 172     hRet = SHLWAPI_DupSharedHandle(hMap, dwProcId,
 173                                    GetCurrentProcessId(), FILE_MAP_ALL_ACCESS,
 174                                    DUPLICATE_SAME_ACCESS);
 175   }
 176
 177   CloseHandle(hMap);
 178   return hRet;
 179 }
 180
 181 /*************************************************************************
 182  * @ [SHLWAPI.8]
 183  *
 184  * Get a pointer to a block of shared memory from a shared memory handle.
 185  *
 186  * PARAMS
 187  * hShared  [I] Shared memory handle
 188  * dwProcId [I] ID of process owning hShared
 189  *
 190  * RETURNS
 191  * Success: A pointer to the shared memory
 192  * Failure: NULL
 193  *
 194  */
 195 PVOID WINAPI SHLockShared(HANDLE hShared, DWORD dwProcId)
 196 {
 197   HANDLE hDup;
 198   LPVOID pMapped;
 199
 200   TRACE("(%p %d)\n", hShared, dwProcId);
 201
 202   /* Get handle to shared memory for current process */
 203   hDup = SHLWAPI_DupSharedHandle(hShared, dwProcId, GetCurrentProcessId(),
 204                                  FILE_MAP_ALL_ACCESS, 0);
 205   /* Get View */
 206   pMapped = MapViewOfFile(hDup, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 207   CloseHandle(hDup);
 208
 209   if (pMapped)
 210     return (char *) pMapped + sizeof(DWORD); /* Hide size */
 211   return NULL;
 212 }
 213
 214 /*************************************************************************
 215  * @ [SHLWAPI.9]
 216  *
 217  * Release a pointer to a block of shared memory.
 218  *
 219  * PARAMS
 220  * lpView [I] Shared memory pointer
 221  *
 222  * RETURNS
 223  * Success: TRUE
 224  * Failure: FALSE
 225  *
 226  */
 227 BOOL WINAPI SHUnlockShared(LPVOID lpView)
 228 {
 229   TRACE("(%p)\n", lpView);
 230   return UnmapViewOfFile((char *) lpView - sizeof(DWORD)); /* Include size */
 231 }
 232
 233 /*************************************************************************
 234  * @ [SHLWAPI.10]
 235  *
 236  * Destroy a block of sharable memory.
 237  *
 238  * PARAMS
 239  * hShared  [I] Shared memory handle
 240  * dwProcId [I] ID of process owning hShared
 241  *
 242  * RETURNS
 243  * Success: TRUE
 244  * Failure: FALSE
 245  *
 246  */
 247 BOOL WINAPI SHFreeShared(HANDLE hShared, DWORD dwProcId)
 248 {
 249   HANDLE hClose;
 250
 251   TRACE("(%p %d)\n", hShared, dwProcId);
 252
 253   /* Get a copy of the handle for our process, closing the source handle */
 254   hClose = SHLWAPI_DupSharedHandle(hShared, dwProcId, GetCurrentProcessId(),
 255                                    FILE_MAP_ALL_ACCESS,DUPLICATE_CLOSE_SOURCE);
 256   /* Close local copy */
 257   return CloseHandle(hClose);
 258 }
 259
 260 /*************************************************************************
 261  * @   [SHLWAPI.11]
 262  *
 263  * Copy a sharable memory handle from one process to another.
 264  *
 265  * PARAMS
 266  * hShared     [I] Shared memory handle to duplicate
 267  * dwDstProcId [I] ID of the process wanting the duplicated handle
 268  * dwSrcProcId [I] ID of the process owning hShared
 269  * dwAccess    [I] Desired DuplicateHandle() access
 270  * dwOptions   [I] Desired DuplicateHandle() options
 271  *
 272  * RETURNS
 273  * Success: A handle suitable for use by the dwDstProcId process.
 274  * Failure: A NULL handle.
 275  *
 276  */
 277 HANDLE WINAPI SHMapHandle(HANDLE hShared, DWORD dwDstProcId, DWORD dwSrcProcId,
 278                           DWORD dwAccess, DWORD dwOptions)
 279 {
 280   HANDLE hRet;
 281
 282   hRet = SHLWAPI_DupSharedHandle(hShared, dwDstProcId, dwSrcProcId,
 283                                  dwAccess, dwOptions);
 284   return hRet;
 285 }
 286
 287 /*************************************************************************
 288  *      @       [SHLWAPI.13]
 289  *
 290  * Create and register a clipboard enumerator for a web browser.
 291  *
 292  * PARAMS
 293  *  lpBC      [I] Binding context
 294  *  lpUnknown [I] An object exposing the IWebBrowserApp interface
 295  *
 296  * RETURNS
 297  *  Success: S_OK.
 298  *  Failure: An HRESULT error code.
 299  *
 300  * NOTES
 301  *  The enumerator is stored as a property of the web browser. If it does not
 302  *  yet exist, it is created and set before being registered.
 303  */
 304 HRESULT WINAPI RegisterDefaultAcceptHeaders(LPBC lpBC, IUnknown *lpUnknown)
 305 {
 306   static const WCHAR szProperty[] = { '{','D','0','F','C','A','4','2','0',
 307       '-','D','3','F','5','-','1','1','C','F', '-','B','2','1','1','-','0',
 308       '0','A','A','0','0','4','A','E','8','3','7','}','\0' };
 309   BSTR property;
 310   IEnumFORMATETC* pIEnumFormatEtc = NULL;
 311   VARIANTARG var;
 312   HRESULT hRet;
 313   IWebBrowserApp* pBrowser = NULL;
 314
 315   TRACE("(%p, %p)\n", lpBC, lpUnknown);
 316
 317   /* Get An IWebBrowserApp interface from  lpUnknown */
 318   hRet = IUnknown_QueryService(lpUnknown, &IID_IWebBrowserApp, &IID_IWebBrowserApp, (PVOID)&pBrowser);
 319   if (FAILED(hRet) || !pBrowser)
 320     return E_NOINTERFACE;
 321
 322   V_VT(&var) = VT_EMPTY;
 323
 324   /* The property we get is the browsers clipboard enumerator */
 325   property = SysAllocString(szProperty);
 326   hRet = IWebBrowserApp_GetProperty(pBrowser, property, &var);
 327   SysFreeString(property);
 328   if (FAILED(hRet))
 329     return hRet;
 330
 331   if (V_VT(&var) == VT_EMPTY)
 332   {
 333     /* Iterate through accepted documents and RegisterClipBoardFormatA() them */
 334     char szKeyBuff[128], szValueBuff[128];
 335     DWORD dwKeySize, dwValueSize, dwRet = 0, dwCount = 0, dwNumValues, dwType;
 336     FORMATETC* formatList, *format;
 337     HKEY hDocs;
 338
 339     TRACE("Registering formats and creating IEnumFORMATETC instance\n");
 340
 341     if (!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\Current"
 342                      "Version\\Internet Settings\\Accepted Documents", &hDocs))
 343       return E_FAIL;
 344
 345     /* Get count of values in key */
 346     while (!dwRet)
 347     {
 348       dwKeySize = sizeof(szKeyBuff);
 349       dwRet = RegEnumValueA(hDocs,dwCount,szKeyBuff,&dwKeySize,0,&dwType,0,0);
 350       dwCount++;
 351     }
 352
 353     dwNumValues = dwCount;
 354
 355     /* Note: dwCount = number of items + 1; The extra item is the end node */
 356     format = formatList = HeapAlloc(GetProcessHeap(), 0, dwCount * sizeof(FORMATETC));
 357     if (!formatList)
 358       return E_OUTOFMEMORY;
 359
 360     if (dwNumValues > 1)
 361     {
 362       dwRet = 0;
 363       dwCount = 0;
 364
 365       dwNumValues--;
 366
 367       /* Register clipboard formats for the values and populate format list */
 368       while(!dwRet && dwCount < dwNumValues)
 369       {
 370         dwKeySize = sizeof(szKeyBuff);
 371         dwValueSize = sizeof(szValueBuff);
 372         dwRet = RegEnumValueA(hDocs, dwCount, szKeyBuff, &dwKeySize, 0, &dwType,
 373                               (PBYTE)szValueBuff, &dwValueSize);
 374         if (!dwRet)
 375           return E_FAIL;
 376
 377         format->cfFormat = RegisterClipboardFormatA(szValueBuff);
 378         format->ptd = NULL;
 379         format->dwAspect = 1;
 380         format->lindex = 4;
 381         format->tymed = -1;
 382
 383         format++;
 384         dwCount++;
 385       }
 386     }
 387
 388     /* Terminate the (maybe empty) list, last entry has a cfFormat of 0 */
 389     format->cfFormat = 0;
 390     format->ptd = NULL;
 391     format->dwAspect = 1;
 392     format->lindex = 4;
 393     format->tymed = -1;
 394
 395     /* Create a clipboard enumerator */
 396     hRet = CreateFormatEnumerator(dwNumValues, formatList, &pIEnumFormatEtc);
 397
 398     if (FAILED(hRet) || !pIEnumFormatEtc)
 399       return hRet;
 400
 401     /* Set our enumerator as the browsers property */
 402     V_VT(&var) = VT_UNKNOWN;
 403     V_UNKNOWN(&var) = (IUnknown*)pIEnumFormatEtc;
 404
 405     hRet = IWebBrowserApp_PutProperty(pBrowser, (BSTR)szProperty, var);
 406     if (FAILED(hRet))
 407     {
 408        IEnumFORMATETC_Release(pIEnumFormatEtc);
 409        goto RegisterDefaultAcceptHeaders_Exit;
 410     }
 411   }
 412
 413   if (V_VT(&var) == VT_UNKNOWN)
 414   {
 415     /* Our variant is holding the clipboard enumerator */
 416     IUnknown* pIUnknown = V_UNKNOWN(&var);
 417     IEnumFORMATETC* pClone = NULL;
 418
 419     TRACE("Retrieved IEnumFORMATETC property\n");
 420
 421     /* Get an IEnumFormatEtc interface from the variants value */
 422     pIEnumFormatEtc = NULL;
 423     hRet = IUnknown_QueryInterface(pIUnknown, &IID_IEnumFORMATETC,
 424                                    (PVOID)&pIEnumFormatEtc);
 425     if (!hRet && pIEnumFormatEtc)
 426     {
 427       /* Clone and register the enumerator */
 428       hRet = IEnumFORMATETC_Clone(pIEnumFormatEtc, &pClone);
 429       if (!hRet && pClone)
 430       {
 431         RegisterFormatEnumerator(lpBC, pClone, 0);
 432
 433         IEnumFORMATETC_Release(pClone);
 434       }
 435
 436       /* Release the IEnumFormatEtc interface */
 437       IEnumFORMATETC_Release(pIUnknown);
 438     }
 439     IUnknown_Release(V_UNKNOWN(&var));
 440   }
 441
 442 RegisterDefaultAcceptHeaders_Exit:
 443   IWebBrowserApp_Release(pBrowser);
 444   return hRet;
 445 }
 446
 447 /*************************************************************************
 448  *      @       [SHLWAPI.15]
 449  *
 450  * Get Explorers "AcceptLanguage" setting.
 451  *
 452  * PARAMS
 453  *  langbuf [O] Destination for language string
 454  *  buflen  [I] Length of langbuf
 455  *          [0] Success: used length of langbuf
 456  *
 457  * RETURNS
 458  *  Success: S_OK.   langbuf is set to the language string found.
 459  *  Failure: E_FAIL, If any arguments are invalid, error occurred, or Explorer
 460  *           does not contain the setting.
 461  *           E_INVALIDARG, If the buffer is not big enough
 462  */
 463 HRESULT WINAPI GetAcceptLanguagesW( LPWSTR langbuf, LPDWORD buflen)
 464 {
 465     static const WCHAR szkeyW[] = {
 466         'S','o','f','t','w','a','r','e','\\',
 467         'M','i','c','r','o','s','o','f','t','\\',
 468         'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
 469         'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
 470     static const WCHAR valueW[] = {
 471         'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
 472     static const WCHAR enusW[] = {'e','n','-','u','s',0};
 473     DWORD mystrlen, mytype;
 474     HKEY mykey;
 475     HRESULT retval;
 476     LCID mylcid;
 477     WCHAR *mystr;
 478
 479     if(!langbuf || !buflen || !*buflen)
 480         return E_FAIL;
 481
 482     mystrlen = (*buflen > 20) ? *buflen : 20 ;
 483     mystr = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * mystrlen);
 484     RegOpenKeyW(HKEY_CURRENT_USER, szkeyW, &mykey);
 485     if(RegQueryValueExW(mykey, valueW, 0, &mytype, (PBYTE)mystr, &mystrlen)) {
 486         /* Did not find value */
 487         mylcid = GetUserDefaultLCID();
 488         /* somehow the mylcid translates into "en-us"
 489          *  this is similar to "LOCALE_SABBREVLANGNAME"
 490          *  which could be gotten via GetLocaleInfo.
 491          *  The only problem is LOCALE_SABBREVLANGUAGE" is
 492          *  a 3 char string (first 2 are country code and third is
 493          *  letter for "sublanguage", which does not come close to
 494          *  "en-us"
 495          */
 496         lstrcpyW(mystr, enusW);
 497         mystrlen = lstrlenW(mystr);
 498     } else {
 499         /* handle returned string */
 500         FIXME("missing code\n");
 501     }
 502     memcpy( langbuf, mystr, min(*buflen,strlenW(mystr)+1)*sizeof(WCHAR) );
 503
 504     if(*buflen > strlenW(mystr)) {
 505         *buflen = strlenW(mystr);
 506         retval = S_OK;
 507     } else {
 508         *buflen = 0;
 509         retval = E_INVALIDARG;
 510         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 511     }
 512     RegCloseKey(mykey);
 513     HeapFree(GetProcessHeap(), 0, mystr);
 514     return retval;
 515 }
 516
 517 /*************************************************************************
 518  *      @       [SHLWAPI.14]
 519  *
 520  * Ascii version of GetAcceptLanguagesW.
 521  */
 522 HRESULT WINAPI GetAcceptLanguagesA( LPSTR langbuf, LPDWORD buflen)
 523 {
 524     WCHAR *langbufW;
 525     DWORD buflenW, convlen;
 526     HRESULT retval;
 527
 528     if(!langbuf || !buflen || !*buflen) return E_FAIL;
 529
 530     buflenW = *buflen;
 531     langbufW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * buflenW);
 532     retval = GetAcceptLanguagesW(langbufW, &buflenW);
 533
 534     if (retval == S_OK)
 535     {
 536         convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, -1, langbuf, *buflen, NULL, NULL);
 537     }
 538     else  /* copy partial string anyway */
 539     {
 540         convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, *buflen, langbuf, *buflen, NULL, NULL);
 541         if (convlen < *buflen) langbuf[convlen] = 0;
 542     }
 543     *buflen = buflenW ? convlen : 0;
 544
 545     HeapFree(GetProcessHeap(), 0, langbufW);
 546     return retval;
 547 }
 548
 549 /*************************************************************************
 550  *      @       [SHLWAPI.23]
 551  *
 552  * Convert a GUID to a string.
 553  *
 554  * PARAMS
 555  *  guid     [I] GUID to convert
 556  *  lpszDest [O] Destination for string
 557  *  cchMax   [I] Length of output buffer
 558  *
 559  * RETURNS
 560  *  The length of the string created.
 561  */
 562 INT WINAPI SHStringFromGUIDA(REFGUID guid, LPSTR lpszDest, INT cchMax)
 563 {
 564   char xguid[40];
 565   INT iLen;
 566
 567   TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
 568
 569   sprintf(xguid, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 570           guid->Data1, guid->Data2, guid->Data3,
 571           guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 572           guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 573
 574   iLen = strlen(xguid) + 1;
 575
 576   if (iLen > cchMax)
 577     return 0;
 578   memcpy(lpszDest, xguid, iLen);
 579   return iLen;
 580 }
 581
 582 /*************************************************************************
 583  *      @       [SHLWAPI.24]
 584  *
 585  * Convert a GUID to a string.
 586  *
 587  * PARAMS
 588  *  guid [I] GUID to convert
 589  *  str  [O] Destination for string
 590  *  cmax [I] Length of output buffer
 591  *
 592  * RETURNS
 593  *  The length of the string created.
 594  */
 595 INT WINAPI SHStringFromGUIDW(REFGUID guid, LPWSTR lpszDest, INT cchMax)
 596 {
 597   WCHAR xguid[40];
 598   INT iLen;
 599   static const WCHAR wszFormat[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
 600       '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
 601       'X','%','0','2','X','%','0','2','X','}',0};
 602
 603   TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
 604
 605   sprintfW(xguid, wszFormat, guid->Data1, guid->Data2, guid->Data3,
 606           guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 607           guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 608
 609   iLen = strlenW(xguid) + 1;
 610
 611   if (iLen > cchMax)
 612     return 0;
 613   memcpy(lpszDest, xguid, iLen*sizeof(WCHAR));
 614   return iLen;
 615 }
 616
 617 /*************************************************************************
 618  *      @       [SHLWAPI.29]
 619  *
 620  * Determine if a Unicode character is a space.
 621  *
 622  * PARAMS
 623  *  wc [I] Character to check.
 624  *
 625  * RETURNS
 626  *  TRUE, if wc is a space,
 627  *  FALSE otherwise.
 628  */
 629 BOOL WINAPI IsCharSpaceW(WCHAR wc)
 630 {
 631     WORD CharType;
 632
 633     return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_SPACE);
 634 }
 635
 636 /*************************************************************************
 637  *      @       [SHLWAPI.30]
 638  *
 639  * Determine if a Unicode character is a blank.
 640  *
 641  * PARAMS
 642  *  wc [I] Character to check.
 643  *
 644  * RETURNS
 645  *  TRUE, if wc is a blank,
 646  *  FALSE otherwise.
 647  *
 648  */
 649 BOOL WINAPI IsCharBlankW(WCHAR wc)
 650 {
 651     WORD CharType;
 652
 653     return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_BLANK);
 654 }
 655
 656 /*************************************************************************
 657  *      @       [SHLWAPI.31]
 658  *
 659  * Determine if a Unicode character is punctuation.
 660  *
 661  * PARAMS
 662  *  wc [I] Character to check.
 663  *
 664  * RETURNS
 665  *  TRUE, if wc is punctuation,
 666  *  FALSE otherwise.
 667  */
 668 BOOL WINAPI IsCharPunctW(WCHAR wc)
 669 {
 670     WORD CharType;
 671
 672     return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_PUNCT);
 673 }
 674
 675 /*************************************************************************
 676  *      @       [SHLWAPI.32]
 677  *
 678  * Determine if a Unicode character is a control character.
 679  *
 680  * PARAMS
 681  *  wc [I] Character to check.
 682  *
 683  * RETURNS
 684  *  TRUE, if wc is a control character,
 685  *  FALSE otherwise.
 686  */
 687 BOOL WINAPI IsCharCntrlW(WCHAR wc)
 688 {
 689     WORD CharType;
 690
 691     return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_CNTRL);
 692 }
 693
 694 /*************************************************************************
 695  *      @       [SHLWAPI.33]
 696  *
 697  * Determine if a Unicode character is a digit.
 698  *
 699  * PARAMS
 700  *  wc [I] Character to check.
 701  *
 702  * RETURNS
 703  *  TRUE, if wc is a digit,
 704  *  FALSE otherwise.
 705  */
 706 BOOL WINAPI IsCharDigitW(WCHAR wc)
 707 {
 708     WORD CharType;
 709
 710     return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_DIGIT);
 711 }
 712
 713 /*************************************************************************
 714  *      @       [SHLWAPI.34]
 715  *
 716  * Determine if a Unicode character is a hex digit.
 717  *
 718  * PARAMS
 719  *  wc [I] Character to check.
 720  *
 721  * RETURNS
 722  *  TRUE, if wc is a hex digit,
 723  *  FALSE otherwise.
 724  */
 725 BOOL WINAPI IsCharXDigitW(WCHAR wc)
 726 {
 727     WORD CharType;
 728
 729     return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_XDIGIT);
 730 }
 731
 732 /*************************************************************************
 733  *      @       [SHLWAPI.35]
 734  *
 735  */
 736 BOOL WINAPI GetStringType3ExW(LPWSTR src, INT count, LPWORD type)
 737 {
 738     return GetStringTypeW(CT_CTYPE3, src, count, type);
 739 }
 740
 741 /*************************************************************************
 742  *      @       [SHLWAPI.151]
 743  *
 744  * Compare two Ascii strings up to a given length.
 745  *
 746  * PARAMS
 747  *  lpszSrc [I] Source string
 748  *  lpszCmp [I] String to compare to lpszSrc
 749  *  len     [I] Maximum length
 750  *
 751  * RETURNS
 752  *  A number greater than, less than or equal to 0 depending on whether
 753  *  lpszSrc is greater than, less than or equal to lpszCmp.
 754  */
 755 DWORD WINAPI StrCmpNCA(LPCSTR lpszSrc, LPCSTR lpszCmp, INT len)
 756 {
 757     return StrCmpNA(lpszSrc, lpszCmp, len);
 758 }
 759
 760 /*************************************************************************
 761  *      @       [SHLWAPI.152]
 762  *
 763  * Unicode version of StrCmpNCA.
 764  */
 765 DWORD WINAPI StrCmpNCW(LPCWSTR lpszSrc, LPCWSTR lpszCmp, INT len)
 766 {
 767     return StrCmpNW(lpszSrc, lpszCmp, len);
 768 }
 769
 770 /*************************************************************************
 771  *      @       [SHLWAPI.153]
 772  *
 773  * Compare two Ascii strings up to a given length, ignoring case.
 774  *
 775  * PARAMS
 776  *  lpszSrc [I] Source string
 777  *  lpszCmp [I] String to compare to lpszSrc
 778  *  len     [I] Maximum length
 779  *
 780  * RETURNS
 781  *  A number greater than, less than or equal to 0 depending on whether
 782  *  lpszSrc is greater than, less than or equal to lpszCmp.
 783  */
 784 DWORD WINAPI StrCmpNICA(LPCSTR lpszSrc, LPCSTR lpszCmp, DWORD len)
 785 {
 786     return StrCmpNIA(lpszSrc, lpszCmp, len);
 787 }
 788
 789 /*************************************************************************
 790  *      @       [SHLWAPI.154]
 791  *
 792  * Unicode version of StrCmpNICA.
 793  */
 794 DWORD WINAPI StrCmpNICW(LPCWSTR lpszSrc, LPCWSTR lpszCmp, DWORD len)
 795 {
 796     return StrCmpNIW(lpszSrc, lpszCmp, len);
 797 }
 798
 799 /*************************************************************************
 800  *      @       [SHLWAPI.155]
 801  *
 802  * Compare two Ascii strings.
 803  *
 804  * PARAMS
 805  *  lpszSrc [I] Source string
 806  *  lpszCmp [I] String to compare to lpszSrc
 807  *
 808  * RETURNS
 809  *  A number greater than, less than or equal to 0 depending on whether
 810  *  lpszSrc is greater than, less than or equal to lpszCmp.
 811  */
 812 DWORD WINAPI StrCmpCA(LPCSTR lpszSrc, LPCSTR lpszCmp)
 813 {
 814     return lstrcmpA(lpszSrc, lpszCmp);
 815 }
 816
 817 /*************************************************************************
 818  *      @       [SHLWAPI.156]
 819  *
 820  * Unicode version of StrCmpCA.
 821  */
 822 DWORD WINAPI StrCmpCW(LPCWSTR lpszSrc, LPCWSTR lpszCmp)
 823 {
 824     return lstrcmpW(lpszSrc, lpszCmp);
 825 }
 826
 827 /*************************************************************************
 828  *      @       [SHLWAPI.157]
 829  *
 830  * Compare two Ascii strings, ignoring case.
 831  *
 832  * PARAMS
 833  *  lpszSrc [I] Source string
 834  *  lpszCmp [I] String to compare to lpszSrc
 835  *
 836  * RETURNS
 837  *  A number greater than, less than or equal to 0 depending on whether
 838  *  lpszSrc is greater than, less than or equal to lpszCmp.
 839  */
 840 DWORD WINAPI StrCmpICA(LPCSTR lpszSrc, LPCSTR lpszCmp)
 841 {
 842     return lstrcmpiA(lpszSrc, lpszCmp);
 843 }
 844
 845 /*************************************************************************
 846  *      @       [SHLWAPI.158]
 847  *
 848  * Unicode version of StrCmpICA.
 849  */
 850 DWORD WINAPI StrCmpICW(LPCWSTR lpszSrc, LPCWSTR lpszCmp)
 851 {
 852     return lstrcmpiW(lpszSrc, lpszCmp);
 853 }
 854
 855 /*************************************************************************
 856  *      @       [SHLWAPI.160]
 857  *
 858  * Get an identification string for the OS and explorer.
 859  *
 860  * PARAMS
 861  *  lpszDest  [O] Destination for Id string
 862  *  dwDestLen [I] Length of lpszDest
 863  *
 864  * RETURNS
 865  *  TRUE,  If the string was created successfully
 866  *  FALSE, Otherwise
 867  */
 868 BOOL WINAPI SHAboutInfoA(LPSTR lpszDest, DWORD dwDestLen)
 869 {
 870   WCHAR buff[2084];
 871
 872   TRACE("(%p,%d)\n", lpszDest, dwDestLen);
 873
 874   if (lpszDest && SHAboutInfoW(buff, dwDestLen))
 875   {
 876     WideCharToMultiByte(CP_ACP, 0, buff, -1, lpszDest, dwDestLen, NULL, NULL);
 877     return TRUE;
 878   }
 879   return FALSE;
 880 }
 881
 882 /*************************************************************************
 883  *      @       [SHLWAPI.161]
 884  *
 885  * Unicode version of SHAboutInfoA.
 886  */
 887 BOOL WINAPI SHAboutInfoW(LPWSTR lpszDest, DWORD dwDestLen)
 888 {
 889   static const WCHAR szIEKey[] = { 'S','O','F','T','W','A','R','E','\\',
 890     'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
 891     ' ','E','x','p','l','o','r','e','r','\0' };
 892   static const WCHAR szWinNtKey[] = { 'S','O','F','T','W','A','R','E','\\',
 893     'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
 894     'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
 895   static const WCHAR szWinKey[] = { 'S','O','F','T','W','A','R','E','\\',
 896     'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
 897     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
 898   static const WCHAR szRegKey[] = { 'S','O','F','T','W','A','R','E','\\',
 899     'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
 900     ' ','E','x','p','l','o','r','e','r','\\',
 901     'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
 902   static const WCHAR szVersion[] = { 'V','e','r','s','i','o','n','\0' };
 903   static const WCHAR szCustomized[] = { 'C','u','s','t','o','m','i','z','e','d',
 904     'V','e','r','s','i','o','n','\0' };
 905   static const WCHAR szOwner[] = { 'R','e','g','i','s','t','e','r','e','d',
 906     'O','w','n','e','r','\0' };
 907   static const WCHAR szOrg[] = { 'R','e','g','i','s','t','e','r','e','d',
 908     'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
 909   static const WCHAR szProduct[] = { 'P','r','o','d','u','c','t','I','d','\0' };
 910   static const WCHAR szUpdate[] = { 'I','E','A','K',
 911     'U','p','d','a','t','e','U','r','l','\0' };
 912   static const WCHAR szHelp[] = { 'I','E','A','K',
 913     'H','e','l','p','S','t','r','i','n','g','\0' };
 914   WCHAR buff[2084];
 915   HKEY hReg;
 916   DWORD dwType, dwLen;
 917
 918   TRACE("(%p,%d)\n", lpszDest, dwDestLen);
 919
 920   if (!lpszDest)
 921     return FALSE;
 922
 923   *lpszDest = '\0';
 924
 925   /* Try the NT key first, followed by 95/98 key */
 926   if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinNtKey, 0, KEY_READ, &hReg) &&
 927       RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinKey, 0, KEY_READ, &hReg))
 928     return FALSE;
 929
 930   /* OS Version */
 931   buff[0] = '\0';
 932   dwLen = 30;
 933   if (!SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey, szVersion, &dwType, buff, &dwLen))
 934   {
 935     DWORD dwStrLen = strlenW(buff);
 936     dwLen = 30 - dwStrLen;
 937     SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey,
 938                 szCustomized, &dwType, buff+dwStrLen, &dwLen);
 939   }
 940   StrCatBuffW(lpszDest, buff, dwDestLen);
 941
 942   /* ~Registered Owner */
 943   buff[0] = '~';
 944   dwLen = 256;
 945   if (SHGetValueW(hReg, szOwner, 0, &dwType, buff+1, &dwLen))
 946     buff[1] = '\0';
 947   StrCatBuffW(lpszDest, buff, dwDestLen);
 948
 949   /* ~Registered Organization */
 950   dwLen = 256;
 951   if (SHGetValueW(hReg, szOrg, 0, &dwType, buff+1, &dwLen))
 952     buff[1] = '\0';
 953   StrCatBuffW(lpszDest, buff, dwDestLen);
 954
 955   /* FIXME: Not sure where this number comes from  */
 956   buff[0] = '~';
 957   buff[1] = '0';
 958   buff[2] = '\0';
 959   StrCatBuffW(lpszDest, buff, dwDestLen);
 960
 961   /* ~Product Id */
 962   dwLen = 256;
 963   if (SHGetValueW(HKEY_LOCAL_MACHINE, szRegKey, szProduct, &dwType, buff+1, &dwLen))
 964     buff[1] = '\0';
 965   StrCatBuffW(lpszDest, buff, dwDestLen);
 966
 967   /* ~IE Update Url */
 968   dwLen = 2048;
 969   if(SHGetValueW(HKEY_LOCAL_MACHINE, szWinKey, szUpdate, &dwType, buff+1, &dwLen))
 970     buff[1] = '\0';
 971   StrCatBuffW(lpszDest, buff, dwDestLen);
 972
 973   /* ~IE Help String */
 974   dwLen = 256;
 975   if(SHGetValueW(hReg, szHelp, 0, &dwType, buff+1, &dwLen))
 976     buff[1] = '\0';
 977   StrCatBuffW(lpszDest, buff, dwDestLen);
 978
 979   RegCloseKey(hReg);
 980   return TRUE;
 981 }
 982
 983 /*************************************************************************
 984  *      @       [SHLWAPI.163]
 985  *
 986  * Call IOleCommandTarget_QueryStatus() on an object.
 987  *
 988  * PARAMS
 989  *  lpUnknown     [I] Object supporting the IOleCommandTarget interface
 990  *  pguidCmdGroup [I] GUID for the command group
 991  *  cCmds         [I]
 992  *  prgCmds       [O] Commands
 993  *  pCmdText      [O] Command text
 994  *
 995  * RETURNS
 996  *  Success: S_OK.
 997  *  Failure: E_FAIL, if lpUnknown is NULL.
 998  *           E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
 999  *           Otherwise, an error code from IOleCommandTarget_QueryStatus().
1000  */
1001 HRESULT WINAPI IUnknown_QueryStatus(IUnknown* lpUnknown, REFGUID pguidCmdGroup,
1002                            ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT* pCmdText)
1003 {
1004   HRESULT hRet = E_FAIL;
1005
1006   TRACE("(%p,%p,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, cCmds, prgCmds, pCmdText);
1007
1008   if (lpUnknown)
1009   {
1010     IOleCommandTarget* lpOle;
1011
1012     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
1013                                    (void**)&lpOle);
1014
1015     if (SUCCEEDED(hRet) && lpOle)
1016     {
1017       hRet = IOleCommandTarget_QueryStatus(lpOle, pguidCmdGroup, cCmds,
1018                                            prgCmds, pCmdText);
1019       IOleCommandTarget_Release(lpOle);
1020     }
1021   }
1022   return hRet;
1023 }
1024
1025 /*************************************************************************
1026  *      @               [SHLWAPI.164]
1027  *
1028  * Call IOleCommandTarget_Exec() on an object.
1029  *
1030  * PARAMS
1031  *  lpUnknown     [I] Object supporting the IOleCommandTarget interface
1032  *  pguidCmdGroup [I] GUID for the command group
1033  *
1034  * RETURNS
1035  *  Success: S_OK.
1036  *  Failure: E_FAIL, if lpUnknown is NULL.
1037  *           E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1038  *           Otherwise, an error code from IOleCommandTarget_Exec().
1039  */
1040 HRESULT WINAPI IUnknown_Exec(IUnknown* lpUnknown, REFGUID pguidCmdGroup,
1041                            DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
1042                            VARIANT* pvaOut)
1043 {
1044   HRESULT hRet = E_FAIL;
1045
1046   TRACE("(%p,%p,%d,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, nCmdID,
1047         nCmdexecopt, pvaIn, pvaOut);
1048
1049   if (lpUnknown)
1050   {
1051     IOleCommandTarget* lpOle;
1052
1053     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
1054                                    (void**)&lpOle);
1055     if (SUCCEEDED(hRet) && lpOle)
1056     {
1057       hRet = IOleCommandTarget_Exec(lpOle, pguidCmdGroup, nCmdID,
1058                                     nCmdexecopt, pvaIn, pvaOut);
1059       IOleCommandTarget_Release(lpOle);
1060     }
1061   }
1062   return hRet;
1063 }
1064
1065 /*************************************************************************
1066  *      @       [SHLWAPI.165]
1067  *
1068  * Retrieve, modify, and re-set a value from a window.
1069  *
1070  * PARAMS
1071  *  hWnd   [I] Window to get value from
1072  *  offset [I] Offset of value
1073  *  wMask  [I] Mask for uiFlags
1074  *  wFlags [I] Bits to set in window value
1075  *
1076  * RETURNS
1077  *  The new value as it was set, or 0 if any parameter is invalid.
1078  *
1079  * NOTES
1080  *  Any bits set in uiMask are cleared from the value, then any bits set in
1081  *  uiFlags are set in the value.
1082  */
1083 LONG WINAPI SHSetWindowBits(HWND hwnd, INT offset, UINT wMask, UINT wFlags)
1084 {
1085   LONG ret = GetWindowLongA(hwnd, offset);
1086   LONG newFlags = (wFlags & wMask) | (ret & ~wFlags);
1087
1088   if (newFlags != ret)
1089     ret = SetWindowLongA(hwnd, offset, newFlags);
1090   return ret;
1091 }
1092
1093 /*************************************************************************
1094  *      @       [SHLWAPI.167]
1095  *
1096  * Change a window's parent.
1097  *
1098  * PARAMS
1099  *  hWnd       [I] Window to change parent of
1100  *  hWndParent [I] New parent window
1101  *
1102  * RETURNS
1103  *  The old parent of hWnd.
1104  *
1105  * NOTES
1106  *  If hWndParent is NULL (desktop), the window style is changed to WS_POPUP.
1107  *  If hWndParent is NOT NULL then we set the WS_CHILD style.
1108  */
1109 HWND WINAPI SHSetParentHwnd(HWND hWnd, HWND hWndParent)
1110 {
1111   TRACE("%p, %p\n", hWnd, hWndParent);
1112
1113   if(GetParent(hWnd) == hWndParent)
1114     return 0;
1115
1116   if(hWndParent)
1117     SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD, WS_CHILD);
1118   else
1119     SHSetWindowBits(hWnd, GWL_STYLE, WS_POPUP, WS_POPUP);
1120
1121   return SetParent(hWnd, hWndParent);
1122 }
1123
1124 /*************************************************************************
1125  *      @       [SHLWAPI.168]
1126  *
1127  * Locate and advise a connection point in an IConnectionPointContainer object.
1128  *
1129  * PARAMS
1130  *  lpUnkSink   [I] Sink for the connection point advise call
1131  *  riid        [I] REFIID of connection point to advise
1132  *  bAdviseOnly [I] TRUE = Advise only, FALSE = Unadvise first
1133  *  lpUnknown   [I] Object supporting the IConnectionPointContainer interface
1134  *  lpCookie    [O] Pointer to connection point cookie
1135  *  lppCP       [O] Destination for the IConnectionPoint found
1136  *
1137  * RETURNS
1138  *  Success: S_OK. If lppCP is non-NULL, it is filled with the IConnectionPoint
1139  *           that was advised. The caller is responsible for releasing it.
1140  *  Failure: E_FAIL, if any arguments are invalid.
1141  *           E_NOINTERFACE, if lpUnknown isn't an IConnectionPointContainer,
1142  *           Or an HRESULT error code if any call fails.
1143  */
1144 HRESULT WINAPI ConnectToConnectionPoint(IUnknown* lpUnkSink, REFIID riid, BOOL bAdviseOnly,
1145                            IUnknown* lpUnknown, LPDWORD lpCookie,
1146                            IConnectionPoint **lppCP)
1147 {
1148   HRESULT hRet;
1149   IConnectionPointContainer* lpContainer;
1150   IConnectionPoint *lpCP;
1151
1152   if(!lpUnknown || (bAdviseOnly && !lpUnkSink))
1153     return E_FAIL;
1154
1155   if(lppCP)
1156     *lppCP = NULL;
1157
1158   hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer,
1159                                  (void**)&lpContainer);
1160   if (SUCCEEDED(hRet))
1161   {
1162     hRet = IConnectionPointContainer_FindConnectionPoint(lpContainer, riid, &lpCP);
1163
1164     if (SUCCEEDED(hRet))
1165     {
1166       if(!bAdviseOnly)
1167         hRet = IConnectionPoint_Unadvise(lpCP, *lpCookie);
1168       hRet = IConnectionPoint_Advise(lpCP, lpUnkSink, lpCookie);
1169
1170       if (FAILED(hRet))
1171         *lpCookie = 0;
1172
1173       if (lppCP && SUCCEEDED(hRet))
1174         *lppCP = lpCP; /* Caller keeps the interface */
1175       else
1176         IConnectionPoint_Release(lpCP); /* Release it */
1177     }
1178
1179     IUnknown_Release(lpContainer);
1180   }
1181   return hRet;
1182 }
1183
1184 /*************************************************************************
1185  *      @       [SHLWAPI.169]
1186  *
1187  * Release an interface.
1188  *
1189  * PARAMS
1190  *  lpUnknown [I] Object to release
1191  *
1192  * RETURNS
1193  *  Nothing.
1194  */
1195 DWORD WINAPI IUnknown_AtomicRelease(IUnknown ** lpUnknown)
1196 {
1197     IUnknown *temp;
1198
1199     TRACE("(%p)\n",lpUnknown);
1200
1201     if(!lpUnknown || !*((LPDWORD)lpUnknown)) return 0;
1202     temp = *lpUnknown;
1203     *lpUnknown = NULL;
1204
1205     TRACE("doing Release\n");
1206
1207     return IUnknown_Release(temp);
1208 }
1209
1210 /*************************************************************************
1211  *      @       [SHLWAPI.170]
1212  *
1213  * Skip '//' if present in a string.
1214  *
1215  * PARAMS
1216  *  lpszSrc [I] String to check for '//'
1217  *
1218  * RETURNS
1219  *  Success: The next character after the '//' or the string if not present
1220  *  Failure: NULL, if lpszStr is NULL.
1221  */
1222 LPCSTR WINAPI PathSkipLeadingSlashesA(LPCSTR lpszSrc)
1223 {
1224   if (lpszSrc && lpszSrc[0] == '/' && lpszSrc[1] == '/')
1225     lpszSrc += 2;
1226   return lpszSrc;
1227 }
1228
1229 /*************************************************************************
1230  *      @               [SHLWAPI.171]
1231  *
1232  * Check if two interfaces come from the same object.
1233  *
1234  * PARAMS
1235  *   lpInt1 [I] Interface to check against lpInt2.
1236  *   lpInt2 [I] Interface to check against lpInt1.
1237  *
1238  * RETURNS
1239  *   TRUE, If the interfaces come from the same object.
1240  *   FALSE Otherwise.
1241  */
1242 BOOL WINAPI SHIsSameObject(IUnknown* lpInt1, IUnknown* lpInt2)
1243 {
1244   LPVOID lpUnknown1, lpUnknown2;
1245
1246   TRACE("%p %p\n", lpInt1, lpInt2);
1247
1248   if (!lpInt1 || !lpInt2)
1249     return FALSE;
1250
1251   if (lpInt1 == lpInt2)
1252     return TRUE;
1253
1254   if (!SUCCEEDED(IUnknown_QueryInterface(lpInt1, &IID_IUnknown,
1255                                        (LPVOID *)&lpUnknown1)))
1256     return FALSE;
1257
1258   if (!SUCCEEDED(IUnknown_QueryInterface(lpInt2, &IID_IUnknown,
1259                                        (LPVOID *)&lpUnknown2)))
1260     return FALSE;
1261
1262   if (lpUnknown1 == lpUnknown2)
1263     return TRUE;
1264
1265   return FALSE;
1266 }
1267
1268 /*************************************************************************
1269  *      @       [SHLWAPI.172]
1270  *
1271  * Get the window handle of an object.
1272  *
1273  * PARAMS
1274  *  lpUnknown [I] Object to get the window handle of
1275  *  lphWnd    [O] Destination for window handle
1276  *
1277  * RETURNS
1278  *  Success: S_OK. lphWnd contains the objects window handle.
1279  *  Failure: An HRESULT error code.
1280  *
1281  * NOTES
1282  *  lpUnknown is expected to support one of the following interfaces:
1283  *  IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1284  */
1285 HRESULT WINAPI IUnknown_GetWindow(IUnknown *lpUnknown, HWND *lphWnd)
1286 {
1287   IUnknown *lpOle;
1288   HRESULT hRet = E_FAIL;
1289
1290   TRACE("(%p,%p)\n", lpUnknown, lphWnd);
1291
1292   if (!lpUnknown)
1293     return hRet;
1294
1295   hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleWindow, (void**)&lpOle);
1296
1297   if (FAILED(hRet))
1298   {
1299     hRet = IUnknown_QueryInterface(lpUnknown,&IID_IShellView, (void**)&lpOle);
1300
1301     if (FAILED(hRet))
1302     {
1303       hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInternetSecurityMgrSite,
1304                                       (void**)&lpOle);
1305     }
1306   }
1307
1308   if (SUCCEEDED(hRet))
1309   {
1310     /* Lazyness here - Since GetWindow() is the first method for the above 3
1311      * interfaces, we use the same call for them all.
1312      */
1313     hRet = IOleWindow_GetWindow((IOleWindow*)lpOle, lphWnd);
1314     IUnknown_Release(lpOle);
1315     if (lphWnd)
1316       TRACE("Returning HWND=%p\n", *lphWnd);
1317   }
1318
1319   return hRet;
1320 }
1321
1322 /*************************************************************************
1323  *      @       [SHLWAPI.173]
1324  *
1325  * Call a method on as as yet unidentified object.
1326  *
1327  * PARAMS
1328  *  pUnk [I] Object supporting the unidentified interface,
1329  *  arg  [I] Argument for the call on the object.
1330  *
1331  * RETURNS
1332  *  S_OK.
1333  */
1334 HRESULT WINAPI IUnknown_SetOwner(IUnknown *pUnk, ULONG arg)
1335 {
1336   static const GUID guid_173 = {
1337     0x5836fb00, 0x8187, 0x11cf, { 0xa1,0x2b,0x00,0xaa,0x00,0x4a,0xe8,0x37 }
1338   };
1339   IMalloc *pUnk2;
1340
1341   TRACE("(%p,%d)\n", pUnk, arg);
1342
1343   /* Note: arg may not be a ULONG and pUnk2 is for sure not an IMalloc -
1344    *       We use this interface as its vtable entry is compatible with the
1345    *       object in question.
1346    * FIXME: Find out what this object is and where it should be defined.
1347    */
1348   if (pUnk &&
1349       SUCCEEDED(IUnknown_QueryInterface(pUnk, &guid_173, (void**)&pUnk2)))
1350   {
1351     IMalloc_Alloc(pUnk2, arg); /* Faked call!! */
1352     IMalloc_Release(pUnk2);
1353   }
1354   return S_OK;
1355 }
1356
1357 /*************************************************************************
1358  *      @       [SHLWAPI.174]
1359  *
1360  * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
1361  * an object.
1362  *
1363  */
1364 HRESULT WINAPI IUnknown_SetSite(
1365         IUnknown *obj,        /* [in]   OLE object     */
1366         IUnknown *site)       /* [in]   Site interface */
1367 {
1368     HRESULT hr;
1369     IObjectWithSite *iobjwithsite;
1370     IInternetSecurityManager *isecmgr;
1371
1372     if (!obj) return E_FAIL;
1373
1374     hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (LPVOID *)&iobjwithsite);
1375     TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr, iobjwithsite);
1376     if (SUCCEEDED(hr))
1377     {
1378         hr = IObjectWithSite_SetSite(iobjwithsite, site);
1379         TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr);
1380         IUnknown_Release(iobjwithsite);
1381     }
1382     else
1383     {
1384         hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (LPVOID *)&isecmgr);
1385         TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr, isecmgr);
1386         if (FAILED(hr)) return hr;
1387
1388         hr = IInternetSecurityManager_SetSecuritySite(isecmgr, (IInternetSecurityMgrSite *)site);
1389         TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr);
1390         IUnknown_Release(isecmgr);
1391     }
1392     return hr;
1393 }
1394
1395 /*************************************************************************
1396  *      @       [SHLWAPI.175]
1397  *
1398  * Call IPersist_GetClassID() on an object.
1399  *
1400  * PARAMS
1401  *  lpUnknown [I] Object supporting the IPersist interface
1402  *  lpClassId [O] Destination for Class Id
1403  *
1404  * RETURNS
1405  *  Success: S_OK. lpClassId contains the Class Id requested.
1406  *  Failure: E_FAIL, If lpUnknown is NULL,
1407  *           E_NOINTERFACE If lpUnknown does not support IPersist,
1408  *           Or an HRESULT error code.
1409  */
1410 HRESULT WINAPI IUnknown_GetClassID(IUnknown *lpUnknown, CLSID* lpClassId)
1411 {
1412   IPersist* lpPersist;
1413   HRESULT hRet = E_FAIL;
1414
1415   TRACE("(%p,%p)\n", lpUnknown, debugstr_guid(lpClassId));
1416
1417   if (lpUnknown)
1418   {
1419     hRet = IUnknown_QueryInterface(lpUnknown,&IID_IPersist,(void**)&lpPersist);
1420     if (SUCCEEDED(hRet))
1421     {
1422       IPersist_GetClassID(lpPersist, lpClassId);
1423       IPersist_Release(lpPersist);
1424     }
1425   }
1426   return hRet;
1427 }
1428
1429 /*************************************************************************
1430  *      @       [SHLWAPI.176]
1431  *
1432  * Retrieve a Service Interface from an object.
1433  *
1434  * PARAMS
1435  *  lpUnknown [I] Object to get an IServiceProvider interface from
1436  *  sid       [I] Service ID for IServiceProvider_QueryService() call
1437  *  riid      [I] Function requested for QueryService call
1438  *  lppOut    [O] Destination for the service interface pointer
1439  *
1440  * RETURNS
1441  *  Success: S_OK. lppOut contains an object providing the requested service
1442  *  Failure: An HRESULT error code
1443  *
1444  * NOTES
1445  *  lpUnknown is expected to support the IServiceProvider interface.
1446  */
1447 HRESULT WINAPI IUnknown_QueryService(IUnknown* lpUnknown, REFGUID sid, REFIID riid,
1448                            LPVOID *lppOut)
1449 {
1450   IServiceProvider* pService = NULL;
1451   HRESULT hRet;
1452
1453   if (!lppOut)
1454     return E_FAIL;
1455
1456   *lppOut = NULL;
1457
1458   if (!lpUnknown)
1459     return E_FAIL;
1460
1461   /* Get an IServiceProvider interface from the object */
1462   hRet = IUnknown_QueryInterface(lpUnknown, &IID_IServiceProvider,
1463                                  (LPVOID*)&pService);
1464
1465   if (!hRet && pService)
1466   {
1467     TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService);
1468
1469     /* Get a Service interface from the object */
1470     hRet = IServiceProvider_QueryService(pService, sid, riid, lppOut);
1471
1472     TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService, *lppOut);
1473
1474     /* Release the IServiceProvider interface */
1475     IUnknown_Release(pService);
1476   }
1477   return hRet;
1478 }
1479
1480 /*************************************************************************
1481  *      @       [SHLWAPI.177]
1482  *
1483  * Loads a popup menu.
1484  *
1485  * PARAMS
1486  *  hInst  [I] Instance handle
1487  *  szName [I] Menu name
1488  *
1489  * RETURNS
1490  *  Success: TRUE.
1491  *  Failure: FALSE.
1492  */
1493 BOOL WINAPI SHLoadMenuPopup(HINSTANCE hInst, LPCWSTR szName)
1494 {
1495   HMENU hMenu, hSubMenu;
1496
1497   if ((hMenu = LoadMenuW(hInst, szName)))
1498   {
1499     if ((hSubMenu = GetSubMenu(hMenu, 0)))
1500       RemoveMenu(hMenu, 0, MF_BYPOSITION);
1501
1502     DestroyMenu(hMenu);
1503     return TRUE;
1504   }
1505   return FALSE;
1506 }
1507
1508 typedef struct _enumWndData
1509 {
1510   UINT   uiMsgId;
1511   WPARAM wParam;
1512   LPARAM lParam;
1513   LRESULT (WINAPI *pfnPost)(HWND,UINT,WPARAM,LPARAM);
1514 } enumWndData;
1515
1516 /* Callback for SHLWAPI_178 */
1517 static BOOL CALLBACK SHLWAPI_EnumChildProc(HWND hWnd, LPARAM lParam)
1518 {
1519   enumWndData *data = (enumWndData *)lParam;
1520
1521   TRACE("(%p,%p)\n", hWnd, data);
1522   data->pfnPost(hWnd, data->uiMsgId, data->wParam, data->lParam);
1523   return TRUE;
1524 }
1525
1526 /*************************************************************************
1527  * @  [SHLWAPI.178]
1528  *
1529  * Send or post a message to every child of a window.
1530  *
1531  * PARAMS
1532  *  hWnd    [I] Window whose children will get the messages
1533  *  uiMsgId [I] Message Id
1534  *  wParam  [I] WPARAM of message
1535  *  lParam  [I] LPARAM of message
1536  *  bSend   [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1537  *
1538  * RETURNS
1539  *  Nothing.
1540  *
1541  * NOTES
1542  *  The appropriate ASCII or Unicode function is called for the window.
1543  */
1544 void WINAPI SHPropagateMessage(HWND hWnd, UINT uiMsgId, WPARAM wParam, LPARAM lParam, BOOL bSend)
1545 {
1546   enumWndData data;
1547
1548   TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd, uiMsgId, wParam, lParam, bSend);
1549
1550   if(hWnd)
1551   {
1552     data.uiMsgId = uiMsgId;
1553     data.wParam  = wParam;
1554     data.lParam  = lParam;
1555
1556     if (bSend)
1557       data.pfnPost = IsWindowUnicode(hWnd) ? (void*)SendMessageW : (void*)SendMessageA;
1558     else
1559       data.pfnPost = IsWindowUnicode(hWnd) ? (void*)PostMessageW : (void*)PostMessageA;
1560
1561     EnumChildWindows(hWnd, SHLWAPI_EnumChildProc, (LPARAM)&data);
1562   }
1563 }
1564
1565 /*************************************************************************
1566  *      @       [SHLWAPI.180]
1567  *
1568  * Remove all sub-menus from a menu.
1569  *
1570  * PARAMS
1571  *  hMenu [I] Menu to remove sub-menus from
1572  *
1573  * RETURNS
1574  *  Success: 0.  All sub-menus under hMenu are removed
1575  *  Failure: -1, if any parameter is invalid
1576  */
1577 DWORD WINAPI SHRemoveAllSubMenus(HMENU hMenu)
1578 {
1579   int iItemCount = GetMenuItemCount(hMenu) - 1;
1580   while (iItemCount >= 0)
1581   {
1582     HMENU hSubMenu = GetSubMenu(hMenu, iItemCount);
1583     if (hSubMenu)
1584       RemoveMenu(hMenu, iItemCount, MF_BYPOSITION);
1585     iItemCount--;
1586   }
1587   return iItemCount;
1588 }
1589
1590 /*************************************************************************
1591  *      @       [SHLWAPI.181]
1592  *
1593  * Enable or disable a menu item.
1594  *
1595  * PARAMS
1596  *  hMenu   [I] Menu holding menu item
1597  *  uID     [I] ID of menu item to enable/disable
1598  *  bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1599  *
1600  * RETURNS
1601  *  The return code from EnableMenuItem.
1602  */
1603 UINT WINAPI SHEnableMenuItem(HMENU hMenu, UINT wItemID, BOOL bEnable)
1604 {
1605   return EnableMenuItem(hMenu, wItemID, bEnable ? MF_ENABLED : MF_GRAYED);
1606 }
1607
1608 /*************************************************************************
1609  * @    [SHLWAPI.182]
1610  *
1611  * Check or uncheck a menu item.
1612  *
1613  * PARAMS
1614  *  hMenu  [I] Menu holding menu item
1615  *  uID    [I] ID of menu item to check/uncheck
1616  *  bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1617  *
1618  * RETURNS
1619  *  The return code from CheckMenuItem.
1620  */
1621 DWORD WINAPI SHCheckMenuItem(HMENU hMenu, UINT uID, BOOL bCheck)
1622 {
1623   return CheckMenuItem(hMenu, uID, bCheck ? MF_CHECKED : MF_UNCHECKED);
1624 }
1625
1626 /*************************************************************************
1627  *      @       [SHLWAPI.183]
1628  *
1629  * Register a window class if it isn't already.
1630  *
1631  * PARAMS
1632  *  lpWndClass [I] Window class to register
1633  *
1634  * RETURNS
1635  *  The result of the RegisterClassA call.
1636  */
1637 DWORD WINAPI SHRegisterClassA(WNDCLASSA *wndclass)
1638 {
1639   WNDCLASSA wca;
1640   if (GetClassInfoA(wndclass->hInstance, wndclass->lpszClassName, &wca))
1641     return TRUE;
1642   return (DWORD)RegisterClassA(wndclass);
1643 }
1644
1645 /*************************************************************************
1646  *      @       [SHLWAPI.186]
1647  */
1648 BOOL WINAPI SHSimulateDrop(IDropTarget *pDrop, IDataObject *pDataObj,
1649                            DWORD grfKeyState, PPOINTL lpPt, DWORD* pdwEffect)
1650 {
1651   DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
1652   POINTL pt = { 0, 0 };
1653
1654   if (!lpPt)
1655     lpPt = &pt;
1656
1657   if (!pdwEffect)
1658     pdwEffect = &dwEffect;
1659
1660   IDropTarget_DragEnter(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1661
1662   if (*pdwEffect)
1663     return IDropTarget_Drop(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1664
1665   IDropTarget_DragLeave(pDrop);
1666   return TRUE;
1667 }
1668
1669 /*************************************************************************
1670  *      @       [SHLWAPI.187]
1671  *
1672  * Call IPersistPropertyBag_Load() on an object.
1673  *
1674  * PARAMS
1675  *  lpUnknown [I] Object supporting the IPersistPropertyBag interface
1676  *  lpPropBag [O] Destination for loaded IPropertyBag
1677  *
1678  * RETURNS
1679  *  Success: S_OK.
1680  *  Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1681  */
1682 DWORD WINAPI SHLoadFromPropertyBag(IUnknown *lpUnknown, IPropertyBag* lpPropBag)
1683 {
1684   IPersistPropertyBag* lpPPBag;
1685   HRESULT hRet = E_FAIL;
1686
1687   TRACE("(%p,%p)\n", lpUnknown, lpPropBag);
1688
1689   if (lpUnknown)
1690   {
1691     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IPersistPropertyBag,
1692                                    (void**)&lpPPBag);
1693     if (SUCCEEDED(hRet) && lpPPBag)
1694     {
1695       hRet = IPersistPropertyBag_Load(lpPPBag, lpPropBag, NULL);
1696       IPersistPropertyBag_Release(lpPPBag);
1697     }
1698   }
1699   return hRet;
1700 }
1701
1702 /*************************************************************************
1703  * @  [SHLWAPI.188]
1704  *
1705  * Call IOleControlSite_TranslateAccelerator()  on an object.
1706  *
1707  * PARAMS
1708  *  lpUnknown   [I] Object supporting the IOleControlSite interface.
1709  *  lpMsg       [I] Key message to be processed.
1710  *  dwModifiers [I] Flags containing the state of the modifier keys.
1711  *
1712  * RETURNS
1713  *  Success: S_OK.
1714  *  Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
1715  */
1716 HRESULT WINAPI IUnknown_TranslateAcceleratorOCS(IUnknown *lpUnknown, LPMSG lpMsg, DWORD dwModifiers)
1717 {
1718   IOleControlSite* lpCSite = NULL;
1719   HRESULT hRet = E_INVALIDARG;
1720
1721   TRACE("(%p,%p,0x%08x)\n", lpUnknown, lpMsg, dwModifiers);
1722   if (lpUnknown)
1723   {
1724     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1725                                    (void**)&lpCSite);
1726     if (SUCCEEDED(hRet) && lpCSite)
1727     {
1728       hRet = IOleControlSite_TranslateAccelerator(lpCSite, lpMsg, dwModifiers);
1729       IOleControlSite_Release(lpCSite);
1730     }
1731   }
1732   return hRet;
1733 }
1734
1735
1736 /*************************************************************************
1737  * @  [SHLWAPI.189]
1738  *
1739  * Call IOleControlSite_OnFocus() on an object.
1740  *
1741  * PARAMS
1742  *  lpUnknown [I] Object supporting the IOleControlSite interface.
1743  *  fGotFocus [I] Whether focus was gained (TRUE) or lost (FALSE).
1744  *
1745  * RETURNS
1746  *  Success: S_OK.
1747  *  Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1748  */
1749 HRESULT WINAPI IUnknown_OnFocusOCS(IUnknown *lpUnknown, BOOL fGotFocus)
1750 {
1751   IOleControlSite* lpCSite = NULL;
1752   HRESULT hRet = E_FAIL;
1753
1754   TRACE("(%p,%s)\n", lpUnknown, fGotFocus ? "TRUE" : "FALSE");
1755   if (lpUnknown)
1756   {
1757     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1758                                    (void**)&lpCSite);
1759     if (SUCCEEDED(hRet) && lpCSite)
1760     {
1761       hRet = IOleControlSite_OnFocus(lpCSite, fGotFocus);
1762       IOleControlSite_Release(lpCSite);
1763     }
1764   }
1765   return hRet;
1766 }
1767
1768 /*************************************************************************
1769  * @    [SHLWAPI.190]
1770  */
1771 HRESULT WINAPI IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown, PVOID lpArg1,
1772                                         PVOID lpArg2, PVOID lpArg3, PVOID lpArg4)
1773 {
1774   /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
1775   static const DWORD service_id[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1776   /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
1777   static const DWORD function_id[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1778   HRESULT hRet = E_INVALIDARG;
1779   LPUNKNOWN lpUnkInner = NULL; /* FIXME: Real type is unknown */
1780
1781   TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown, lpArg1, lpArg2, lpArg3, lpArg4);
1782
1783   if (lpUnknown && lpArg4)
1784   {
1785      hRet = IUnknown_QueryService(lpUnknown, (REFGUID)service_id,
1786                                   (REFGUID)function_id, (void**)&lpUnkInner);
1787
1788      if (SUCCEEDED(hRet) && lpUnkInner)
1789      {
1790        /* FIXME: The type of service object requested is unknown, however
1791         * testing shows that its first method is called with 4 parameters.
1792         * Fake this by using IParseDisplayName_ParseDisplayName since the
1793         * signature and position in the vtable matches our unknown object type.
1794         */
1795        hRet = IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME)lpUnkInner,
1796                                                  lpArg1, lpArg2, lpArg3, lpArg4);
1797        IUnknown_Release(lpUnkInner);
1798      }
1799   }
1800   return hRet;
1801 }
1802
1803 /*************************************************************************
1804  * @    [SHLWAPI.192]
1805  *
1806  * Get a sub-menu from a menu item.
1807  *
1808  * PARAMS
1809  *  hMenu [I] Menu to get sub-menu from
1810  *  uID   [I] ID of menu item containing sub-menu
1811  *
1812  * RETURNS
1813  *  The sub-menu of the item, or a NULL handle if any parameters are invalid.
1814  */
1815 HMENU WINAPI SHGetMenuFromID(HMENU hMenu, UINT uID)
1816 {
1817   MENUITEMINFOW mi;
1818
1819   TRACE("(%p,%u)\n", hMenu, uID);
1820
1821   mi.cbSize = sizeof(mi);
1822   mi.fMask = MIIM_SUBMENU;
1823
1824   if (!GetMenuItemInfoW(hMenu, uID, FALSE, &mi))
1825     return NULL;
1826
1827   return mi.hSubMenu;
1828 }
1829
1830 /*************************************************************************
1831  *      @       [SHLWAPI.193]
1832  *
1833  * Get the color depth of the primary display.
1834  *
1835  * PARAMS
1836  *  None.
1837  *
1838  * RETURNS
1839  *  The color depth of the primary display.
1840  */
1841 DWORD WINAPI SHGetCurColorRes(void)
1842 {
1843     HDC hdc;
1844     DWORD ret;
1845
1846     TRACE("()\n");
1847
1848     hdc = GetDC(0);
1849     ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
1850     ReleaseDC(0, hdc);
1851     return ret;
1852 }
1853
1854 /*************************************************************************
1855  *      @       [SHLWAPI.194]
1856  *
1857  * Wait for a message to arrive, with a timeout.
1858  *
1859  * PARAMS
1860  *  hand      [I] Handle to query
1861  *  dwTimeout [I] Timeout in ticks or INFINITE to never timeout
1862  *
1863  * RETURNS
1864  *  STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
1865  *  Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
1866  *  message is available.
1867  */
1868 DWORD WINAPI SHWaitForSendMessageThread(HANDLE hand, DWORD dwTimeout)
1869 {
1870   DWORD dwEndTicks = GetTickCount() + dwTimeout;
1871   DWORD dwRet;
1872
1873   while ((dwRet = MsgWaitForMultipleObjectsEx(1, &hand, dwTimeout, QS_SENDMESSAGE, 0)) == 1)
1874   {
1875     MSG msg;
1876
1877     PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
1878
1879     if (dwTimeout != INFINITE)
1880     {
1881         if ((int)(dwTimeout = dwEndTicks - GetTickCount()) <= 0)
1882             return WAIT_TIMEOUT;
1883     }
1884   }
1885
1886   return dwRet;
1887 }
1888
1889 /*************************************************************************
1890  *      @       [SHLWAPI.195]
1891  *
1892  * Determine if a shell folder can be expanded.
1893  *
1894  * PARAMS
1895  *  lpFolder [I] Parent folder containing the object to test.
1896  *  pidl     [I] Id of the object to test.
1897  *
1898  * RETURNS
1899  *  Success: S_OK, if the object is expandable, S_FALSE otherwise.
1900  *  Failure: E_INVALIDARG, if any argument is invalid.
1901  *
1902  * NOTES
1903  *  If the object to be tested does not expose the IQueryInfo() interface it
1904  *  will not be identified as an expandable folder.
1905  */
1906 HRESULT WINAPI SHIsExpandableFolder(LPSHELLFOLDER lpFolder, LPCITEMIDLIST pidl)
1907 {
1908   HRESULT hRet = E_INVALIDARG;
1909   IQueryInfo *lpInfo;
1910
1911   if (lpFolder && pidl)
1912   {
1913     hRet = IShellFolder_GetUIObjectOf(lpFolder, NULL, 1, &pidl, &IID_IQueryInfo,
1914                                       NULL, (void**)&lpInfo);
1915     if (FAILED(hRet))
1916       hRet = S_FALSE; /* Doesn't expose IQueryInfo */
1917     else
1918     {
1919       DWORD dwFlags = 0;
1920
1921       /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
1922        * currently used". Really? You wouldn't be holding out on me would you?
1923        */
1924       hRet = IQueryInfo_GetInfoFlags(lpInfo, &dwFlags);
1925
1926       if (SUCCEEDED(hRet))
1927       {
1928         /* 0x2 is an undocumented flag apparently indicating expandability */
1929         hRet = dwFlags & 0x2 ? S_OK : S_FALSE;
1930       }
1931
1932       IQueryInfo_Release(lpInfo);
1933     }
1934   }
1935   return hRet;
1936 }
1937
1938 /*************************************************************************
1939  *      @       [SHLWAPI.197]
1940  *
1941  * Blank out a region of text by drawing the background only.
1942  *
1943  * PARAMS
1944  *  hDC   [I] Device context to draw in
1945  *  pRect [I] Area to draw in
1946  *  cRef  [I] Color to draw in
1947  *
1948  * RETURNS
1949  *  Nothing.
1950  */
1951 DWORD WINAPI SHFillRectClr(HDC hDC, LPCRECT pRect, COLORREF cRef)
1952 {
1953     COLORREF cOldColor = SetBkColor(hDC, cRef);
1954     ExtTextOutA(hDC, 0, 0, ETO_OPAQUE, pRect, 0, 0, 0);
1955     SetBkColor(hDC, cOldColor);
1956     return 0;
1957 }
1958
1959 /*************************************************************************
1960  *      @       [SHLWAPI.198]
1961  *
1962  * Return the value associated with a key in a map.
1963  *
1964  * PARAMS
1965  *  lpKeys   [I] A list of keys of length iLen
1966  *  lpValues [I] A list of values associated with lpKeys, of length iLen
1967  *  iLen     [I] Length of both lpKeys and lpValues
1968  *  iKey     [I] The key value to look up in lpKeys
1969  *
1970  * RETURNS
1971  *  The value in lpValues associated with iKey, or -1 if iKey is not
1972  *  found in lpKeys.
1973  *
1974  * NOTES
1975  *  - If two elements in the map share the same key, this function returns
1976  *    the value closest to the start of the map
1977  *  - The native version of this function crashes if lpKeys or lpValues is NULL.
1978  */
1979 int WINAPI SHSearchMapInt(const int *lpKeys, const int *lpValues, int iLen, int iKey)
1980 {
1981   if (lpKeys && lpValues)
1982   {
1983     int i = 0;
1984
1985     while (i < iLen)
1986     {
1987       if (lpKeys[i] == iKey)
1988         return lpValues[i]; /* Found */
1989       i++;
1990     }
1991   }
1992   return -1; /* Not found */
1993 }
1994
1995
1996 /*************************************************************************
1997  *      @       [SHLWAPI.199]
1998  *
1999  * Copy an interface pointer
2000  *
2001  * PARAMS
2002  *   lppDest   [O] Destination for copy
2003  *   lpUnknown [I] Source for copy
2004  *
2005  * RETURNS
2006  *  Nothing.
2007  */
2008 VOID WINAPI IUnknown_Set(IUnknown **lppDest, IUnknown *lpUnknown)
2009 {
2010   TRACE("(%p,%p)\n", lppDest, lpUnknown);
2011
2012   if (lppDest)
2013     IUnknown_AtomicRelease(lppDest); /* Release existing interface */
2014
2015   if (lpUnknown)
2016   {
2017     /* Copy */
2018     IUnknown_AddRef(lpUnknown);
2019     *lppDest = lpUnknown;
2020   }
2021 }
2022
2023 /*************************************************************************
2024  *      @       [SHLWAPI.200]
2025  *
2026  */
2027 HRESULT WINAPI MayQSForward(IUnknown* lpUnknown, PVOID lpReserved,
2028                             REFGUID riidCmdGrp, ULONG cCmds,
2029                             OLECMD *prgCmds, OLECMDTEXT* pCmdText)
2030 {
2031   FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
2032         lpUnknown, lpReserved, riidCmdGrp, cCmds, prgCmds, pCmdText);
2033
2034   /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
2035   return DRAGDROP_E_NOTREGISTERED;
2036 }
2037
2038 /*************************************************************************
2039  *      @       [SHLWAPI.201]
2040  *
2041  */
2042 HRESULT WINAPI MayExecForward(IUnknown* lpUnknown, INT iUnk, REFGUID pguidCmdGroup,
2043                            DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
2044                            VARIANT* pvaOut)
2045 {
2046   FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown, iUnk, pguidCmdGroup,
2047         nCmdID, nCmdexecopt, pvaIn, pvaOut);
2048   return DRAGDROP_E_NOTREGISTERED;
2049 }
2050
2051 /*************************************************************************
2052  *      @       [SHLWAPI.202]
2053  *
2054  */
2055 HRESULT WINAPI IsQSForward(REFGUID pguidCmdGroup,ULONG cCmds, OLECMD *prgCmds)
2056 {
2057   FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup, cCmds, prgCmds);
2058   return DRAGDROP_E_NOTREGISTERED;
2059 }
2060
2061 /*************************************************************************
2062  * @    [SHLWAPI.204]
2063  *
2064  * Determine if a window is not a child of another window.
2065  *
2066  * PARAMS
2067  * hParent [I] Suspected parent window
2068  * hChild  [I] Suspected child window
2069  *
2070  * RETURNS
2071  * TRUE:  If hChild is a child window of hParent
2072  * FALSE: If hChild is not a child window of hParent, or they are equal
2073  */
2074 BOOL WINAPI SHIsChildOrSelf(HWND hParent, HWND hChild)
2075 {
2076   TRACE("(%p,%p)\n", hParent, hChild);
2077
2078   if (!hParent || !hChild)
2079     return TRUE;
2080   else if(hParent == hChild)
2081     return FALSE;
2082   return !IsChild(hParent, hChild);
2083 }
2084
2085 /*************************************************************************
2086  *    FDSA functions.  Manage a dynamic array of fixed size memory blocks.
2087  */
2088
2089 typedef struct
2090 {
2091     DWORD num_items;       /* Number of elements inserted */
2092     void *mem;             /* Ptr to array */
2093     DWORD blocks_alloced;  /* Number of elements allocated */
2094     BYTE inc;              /* Number of elements to grow by when we need to expand */
2095     BYTE block_size;       /* Size in bytes of an element */
2096     BYTE flags;            /* Flags */
2097 } FDSA_info;
2098
2099 #define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
2100
2101 /*************************************************************************
2102  *      @       [SHLWAPI.208]
2103  *
2104  * Initialize an FDSA array.
2105  */
2106 BOOL WINAPI FDSA_Initialize(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
2107                             DWORD init_blocks)
2108 {
2109     TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size, inc, info, mem, init_blocks);
2110
2111     if(inc == 0)
2112         inc = 1;
2113
2114     if(mem)
2115         memset(mem, 0, block_size * init_blocks);
2116
2117     info->num_items = 0;
2118     info->inc = inc;
2119     info->mem = mem;
2120     info->blocks_alloced = init_blocks;
2121     info->block_size = block_size;
2122     info->flags = 0;
2123
2124     return TRUE;
2125 }
2126
2127 /*************************************************************************
2128  *      @       [SHLWAPI.209]
2129  *
2130  * Destroy an FDSA array
2131  */
2132 BOOL WINAPI FDSA_Destroy(FDSA_info *info)
2133 {
2134     TRACE("(%p)\n", info);
2135
2136     if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
2137     {
2138         HeapFree(GetProcessHeap(), 0, info->mem);
2139         return FALSE;
2140     }
2141
2142     return TRUE;
2143 }
2144
2145 /*************************************************************************
2146  *      @       [SHLWAPI.210]
2147  *
2148  * Insert element into an FDSA array
2149  */
2150 DWORD WINAPI FDSA_InsertItem(FDSA_info *info, DWORD where, const void *block)
2151 {
2152     TRACE("(%p 0x%08x %p)\n", info, where, block);
2153     if(where > info->num_items)
2154         where = info->num_items;
2155
2156     if(info->num_items >= info->blocks_alloced)
2157     {
2158         DWORD size = (info->blocks_alloced + info->inc) * info->block_size;
2159         if(info->flags & 0x1)
2160             info->mem = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->mem, size);
2161         else
2162         {
2163             void *old_mem = info->mem;
2164             info->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2165             memcpy(info->mem, old_mem, info->blocks_alloced * info->block_size);
2166         }
2167         info->blocks_alloced += info->inc;
2168         info->flags |= 0x1;
2169     }
2170
2171     if(where < info->num_items)
2172     {
2173         memmove((char*)info->mem + (where + 1) * info->block_size,
2174                 (char*)info->mem + where * info->block_size,
2175                 (info->num_items - where) * info->block_size);
2176     }
2177     memcpy((char*)info->mem + where * info->block_size, block, info->block_size);
2178
2179     info->num_items++;
2180     return where;
2181 }
2182
2183 /*************************************************************************
2184  *      @       [SHLWAPI.211]
2185  *
2186  * Delete an element from an FDSA array.
2187  */
2188 BOOL WINAPI FDSA_DeleteItem(FDSA_info *info, DWORD where)
2189 {
2190     TRACE("(%p 0x%08x)\n", info, where);
2191
2192     if(where >= info->num_items)
2193         return FALSE;
2194
2195     if(where < info->num_items - 1)
2196     {
2197         memmove((char*)info->mem + where * info->block_size,
2198                 (char*)info->mem + (where + 1) * info->block_size,
2199                 (info->num_items - where - 1) * info->block_size);
2200     }
2201     memset((char*)info->mem + (info->num_items - 1) * info->block_size,
2202            0, info->block_size);
2203     info->num_items--;
2204     return TRUE;
2205 }
2206
2207
2208 typedef struct {
2209     REFIID   refid;
2210     DWORD    indx;
2211 } IFACE_INDEX_TBL;
2212
2213 /*************************************************************************
2214  *      @       [SHLWAPI.219]
2215  *
2216  * Call IUnknown_QueryInterface() on a table of objects.
2217  *
2218  * RETURNS
2219  *  Success: S_OK.
2220  *  Failure: E_POINTER or E_NOINTERFACE.
2221  */
2222 HRESULT WINAPI QISearch(
2223         LPVOID w,           /* [in]   Table of interfaces */
2224         IFACE_INDEX_TBL *x, /* [in]   Array of REFIIDs and indexes into the table */
2225         REFIID riid,        /* [in]   REFIID to get interface for */
2226         LPVOID *ppv)          /* [out]  Destination for interface pointer */
2227 {
2228         HRESULT ret;
2229         IUnknown *a_vtbl;
2230         IFACE_INDEX_TBL *xmove;
2231
2232         TRACE("(%p %p %s %p)\n", w,x,debugstr_guid(riid),ppv);
2233         if (ppv) {
2234             xmove = x;
2235             while (xmove->refid) {
2236                 TRACE("trying (indx %d) %s\n", xmove->indx, debugstr_guid(xmove->refid));
2237                 if (IsEqualIID(riid, xmove->refid)) {
2238                     a_vtbl = (IUnknown*)(xmove->indx + (LPBYTE)w);
2239                     TRACE("matched, returning (%p)\n", a_vtbl);
2240                     *ppv = (LPVOID)a_vtbl;
2241                     IUnknown_AddRef(a_vtbl);
2242                     return S_OK;
2243                 }
2244                 xmove++;
2245             }
2246
2247             if (IsEqualIID(riid, &IID_IUnknown)) {
2248                 a_vtbl = (IUnknown*)(x->indx + (LPBYTE)w);
2249                 TRACE("returning first for IUnknown (%p)\n", a_vtbl);
2250                 *ppv = (LPVOID)a_vtbl;
2251                 IUnknown_AddRef(a_vtbl);
2252                 return S_OK;
2253             }
2254             *ppv = 0;
2255             ret = E_NOINTERFACE;
2256         } else
2257             ret = E_POINTER;
2258
2259         TRACE("-- 0x%08x\n", ret);
2260         return ret;
2261 }
2262
2263 /*************************************************************************
2264  *      @       [SHLWAPI.221]
2265  *
2266  * Remove the "PropDlgFont" property from a window.
2267  *
2268  * PARAMS
2269  *  hWnd [I] Window to remove the property from
2270  *
2271  * RETURNS
2272  *  A handle to the removed property, or NULL if it did not exist.
2273  */
2274 HANDLE WINAPI SHRemoveDefaultDialogFont(HWND hWnd)
2275 {
2276   HANDLE hProp;
2277
2278   TRACE("(%p)\n", hWnd);
2279
2280   hProp = GetPropA(hWnd, "PropDlgFont");
2281
2282   if(hProp)
2283   {
2284     DeleteObject(hProp);
2285     hProp = RemovePropA(hWnd, "PropDlgFont");
2286   }
2287   return hProp;
2288 }
2289
2290 /*************************************************************************
2291  *      @       [SHLWAPI.236]
2292  *
2293  * Load the in-process server of a given GUID.
2294  *
2295  * PARAMS
2296  *  refiid [I] GUID of the server to load.
2297  *
2298  * RETURNS
2299  *  Success: A handle to the loaded server dll.
2300  *  Failure: A NULL handle.
2301  */
2302 HMODULE WINAPI SHPinDllOfCLSID(REFIID refiid)
2303 {
2304     HKEY newkey;
2305     DWORD type, count;
2306     CHAR value[MAX_PATH], string[MAX_PATH];
2307
2308     strcpy(string, "CLSID\\");
2309     SHStringFromGUIDA(refiid, string + 6, sizeof(string)/sizeof(char) - 6);
2310     strcat(string, "\\InProcServer32");
2311
2312     count = MAX_PATH;
2313     RegOpenKeyExA(HKEY_CLASSES_ROOT, string, 0, 1, &newkey);
2314     RegQueryValueExA(newkey, 0, 0, &type, (PBYTE)value, &count);
2315     RegCloseKey(newkey);
2316     return LoadLibraryExA(value, 0, 0);
2317 }
2318
2319 /*************************************************************************
2320  *      @       [SHLWAPI.237]
2321  *
2322  * Unicode version of SHLWAPI_183.
2323  */
2324 DWORD WINAPI SHRegisterClassW(WNDCLASSW * lpWndClass)
2325 {
2326         WNDCLASSW WndClass;
2327
2328         TRACE("(%p %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
2329
2330         if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
2331                 return TRUE;
2332         return RegisterClassW(lpWndClass);
2333 }
2334
2335 /*************************************************************************
2336  *      @       [SHLWAPI.238]
2337  *
2338  * Unregister a list of classes.
2339  *
2340  * PARAMS
2341  *  hInst      [I] Application instance that registered the classes
2342  *  lppClasses [I] List of class names
2343  *  iCount     [I] Number of names in lppClasses
2344  *
2345  * RETURNS
2346  *  Nothing.
2347  */
2348 void WINAPI SHUnregisterClassesA(HINSTANCE hInst, LPCSTR *lppClasses, INT iCount)
2349 {
2350   WNDCLASSA WndClass;
2351
2352   TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2353
2354   while (iCount > 0)
2355   {
2356     if (GetClassInfoA(hInst, *lppClasses, &WndClass))
2357       UnregisterClassA(*lppClasses, hInst);
2358     lppClasses++;
2359     iCount--;
2360   }
2361 }
2362
2363 /*************************************************************************
2364  *      @       [SHLWAPI.239]
2365  *
2366  * Unicode version of SHUnregisterClassesA.
2367  */
2368 void WINAPI SHUnregisterClassesW(HINSTANCE hInst, LPCWSTR *lppClasses, INT iCount)
2369 {
2370   WNDCLASSW WndClass;
2371
2372   TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2373
2374   while (iCount > 0)
2375   {
2376     if (GetClassInfoW(hInst, *lppClasses, &WndClass))
2377       UnregisterClassW(*lppClasses, hInst);
2378     lppClasses++;
2379     iCount--;
2380   }
2381 }
2382
2383 /*************************************************************************
2384  *      @       [SHLWAPI.240]
2385  *
2386  * Call The correct (Ascii/Unicode) default window procedure for a window.
2387  *
2388  * PARAMS
2389  *  hWnd     [I] Window to call the default procedure for
2390  *  uMessage [I] Message ID
2391  *  wParam   [I] WPARAM of message
2392  *  lParam   [I] LPARAM of message
2393  *
2394  * RETURNS
2395  *  The result of calling DefWindowProcA() or DefWindowProcW().
2396  */
2397 LRESULT CALLBACK SHDefWindowProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
2398 {
2399         if (IsWindowUnicode(hWnd))
2400                 return DefWindowProcW(hWnd, uMessage, wParam, lParam);
2401         return DefWindowProcA(hWnd, uMessage, wParam, lParam);
2402 }
2403
2404 /*************************************************************************
2405  *      @       [SHLWAPI.256]
2406  */
2407 HRESULT WINAPI IUnknown_GetSite(LPUNKNOWN lpUnknown, REFIID iid, PVOID *lppSite)
2408 {
2409   HRESULT hRet = E_INVALIDARG;
2410   LPOBJECTWITHSITE lpSite = NULL;
2411
2412   TRACE("(%p,%s,%p)\n", lpUnknown, debugstr_guid(iid), lppSite);
2413
2414   if (lpUnknown && iid && lppSite)
2415   {
2416     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IObjectWithSite,
2417                                    (void**)&lpSite);
2418     if (SUCCEEDED(hRet) && lpSite)
2419     {
2420       hRet = IObjectWithSite_GetSite(lpSite, iid, lppSite);
2421       IObjectWithSite_Release(lpSite);
2422     }
2423   }
2424   return hRet;
2425 }
2426
2427 /*************************************************************************
2428  *      @       [SHLWAPI.257]
2429  *
2430  * Create a worker window using CreateWindowExA().
2431  *
2432  * PARAMS
2433  *  wndProc    [I] Window procedure
2434  *  hWndParent [I] Parent window
2435  *  dwExStyle  [I] Extra style flags
2436  *  dwStyle    [I] Style flags
2437  *  hMenu      [I] Window menu
2438  *  z          [I] Unknown
2439  *
2440  * RETURNS
2441  *  Success: The window handle of the newly created window.
2442  *  Failure: 0.
2443  */
2444 HWND WINAPI SHCreateWorkerWindowA(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2445                         DWORD dwStyle, HMENU hMenu, LONG z)
2446 {
2447   static const char szClass[] = "WorkerA";
2448   WNDCLASSA wc;
2449   HWND hWnd;
2450
2451   TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2452          wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2453
2454   /* Create Window class */
2455   wc.style         = 0;
2456   wc.lpfnWndProc   = DefWindowProcA;
2457   wc.cbClsExtra    = 0;
2458   wc.cbWndExtra    = 4;
2459   wc.hInstance     = shlwapi_hInstance;
2460   wc.hIcon         = NULL;
2461   wc.hCursor       = LoadCursorA(NULL, (LPSTR)IDC_ARROW);
2462   wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2463   wc.lpszMenuName  = NULL;
2464   wc.lpszClassName = szClass;
2465
2466   SHRegisterClassA(&wc); /* Register class */
2467
2468   /* FIXME: Set extra bits in dwExStyle */
2469
2470   hWnd = CreateWindowExA(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2471                          hWndParent, hMenu, shlwapi_hInstance, 0);
2472   if (hWnd)
2473   {
2474     SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2475
2476     if (wndProc)
2477       SetWindowLongPtrA(hWnd, GWLP_WNDPROC, wndProc);
2478   }
2479   return hWnd;
2480 }
2481
2482 typedef struct tagPOLICYDATA
2483 {
2484   DWORD policy;        /* flags value passed to SHRestricted */
2485   LPCWSTR appstr;      /* application str such as "Explorer" */
2486   LPCWSTR keystr;      /* name of the actual registry key / policy */
2487 } POLICYDATA, *LPPOLICYDATA;
2488
2489 #define SHELL_NO_POLICY 0xffffffff
2490
2491 /* default shell policy registry key */
2492 static const WCHAR strRegistryPolicyW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2493                                       's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2494                                       'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2495                                       '\\','P','o','l','i','c','i','e','s',0};
2496
2497 /*************************************************************************
2498  * @                          [SHLWAPI.271]
2499  *
2500  * Retrieve a policy value from the registry.
2501  *
2502  * PARAMS
2503  *  lpSubKey   [I]   registry key name
2504  *  lpSubName  [I]   subname of registry key
2505  *  lpValue    [I]   value name of registry value
2506  *
2507  * RETURNS
2508  *  the value associated with the registry key or 0 if not found
2509  */
2510 DWORD WINAPI SHGetRestriction(LPCWSTR lpSubKey, LPCWSTR lpSubName, LPCWSTR lpValue)
2511 {
2512         DWORD retval, datsize = sizeof(retval);
2513         HKEY hKey;
2514
2515         if (!lpSubKey)
2516           lpSubKey = strRegistryPolicyW;
2517
2518         retval = RegOpenKeyW(HKEY_LOCAL_MACHINE, lpSubKey, &hKey);
2519     if (retval != ERROR_SUCCESS)
2520           retval = RegOpenKeyW(HKEY_CURRENT_USER, lpSubKey, &hKey);
2521         if (retval != ERROR_SUCCESS)
2522           return 0;
2523
2524         SHGetValueW(hKey, lpSubName, lpValue, NULL, (LPBYTE)&retval, &datsize);
2525         RegCloseKey(hKey);
2526         return retval;
2527 }
2528
2529 /*************************************************************************
2530  * @                         [SHLWAPI.266]
2531  *
2532  * Helper function to retrieve the possibly cached value for a specific policy
2533  *
2534  * PARAMS
2535  *  policy     [I]   The policy to look for
2536  *  initial    [I]   Main registry key to open, if NULL use default
2537  *  polTable   [I]   Table of known policies, 0 terminated
2538  *  polArr     [I]   Cache array of policy values
2539  *
2540  * RETURNS
2541  *  The retrieved policy value or 0 if not successful
2542  *
2543  * NOTES
2544  *  This function is used by the native SHRestricted function to search for the
2545  *  policy and cache it once retrieved. The current Wine implementation uses a
2546  *  different POLICYDATA structure and implements a similar algorithm adapted to
2547  *  that structure.
2548  */
2549 DWORD WINAPI SHRestrictionLookup(
2550         DWORD policy,
2551         LPCWSTR initial,
2552         LPPOLICYDATA polTable,
2553         LPDWORD polArr)
2554 {
2555         TRACE("(0x%08x %s %p %p)\n", policy, debugstr_w(initial), polTable, polArr);
2556
2557         if (!polTable || !polArr)
2558           return 0;
2559
2560         for (;polTable->policy; polTable++, polArr++)
2561         {
2562           if (policy == polTable->policy)
2563           {
2564             /* we have a known policy */
2565
2566             /* check if this policy has been cached */
2567                 if (*polArr == SHELL_NO_POLICY)
2568               *polArr = SHGetRestriction(initial, polTable->appstr, polTable->keystr);
2569             return *polArr;
2570           }
2571         }
2572         /* we don't know this policy, return 0 */
2573         TRACE("unknown policy: (%08x)\n", policy);
2574         return 0;
2575 }
2576
2577 /*************************************************************************
2578  *      @       [SHLWAPI.267]
2579  *
2580  * Get an interface from an object.
2581  *
2582  * RETURNS
2583  *  Success: S_OK. ppv contains the requested interface.
2584  *  Failure: An HRESULT error code.
2585  *
2586  * NOTES
2587  *   This QueryInterface asks the inner object for an interface. In case
2588  *   of aggregation this request would be forwarded by the inner to the
2589  *   outer object. This function asks the inner object directly for the
2590  *   interface circumventing the forwarding to the outer object.
2591  */
2592 HRESULT WINAPI SHWeakQueryInterface(
2593         IUnknown * pUnk,   /* [in] Outer object */
2594         IUnknown * pInner, /* [in] Inner object */
2595         IID * riid, /* [in] Interface GUID to query for */
2596         LPVOID* ppv) /* [out] Destination for queried interface */
2597 {
2598         HRESULT hret = E_NOINTERFACE;
2599         TRACE("(pUnk=%p pInner=%p\n\tIID:  %s %p)\n",pUnk,pInner,debugstr_guid(riid), ppv);
2600
2601         *ppv = NULL;
2602         if(pUnk && pInner) {
2603             hret = IUnknown_QueryInterface(pInner, riid, (LPVOID*)ppv);
2604             if (SUCCEEDED(hret)) IUnknown_Release(pUnk);
2605         }
2606         TRACE("-- 0x%08x\n", hret);
2607         return hret;
2608 }
2609
2610 /*************************************************************************
2611  *      @       [SHLWAPI.268]
2612  *
2613  * Move a reference from one interface to another.
2614  *
2615  * PARAMS
2616  *   lpDest     [O] Destination to receive the reference
2617  *   lppUnknown [O] Source to give up the reference to lpDest
2618  *
2619  * RETURNS
2620  *  Nothing.
2621  */
2622 VOID WINAPI SHWeakReleaseInterface(IUnknown *lpDest, IUnknown **lppUnknown)
2623 {
2624   TRACE("(%p,%p)\n", lpDest, lppUnknown);
2625
2626   if (*lppUnknown)
2627   {
2628     /* Copy Reference*/
2629     IUnknown_AddRef(lpDest);
2630     IUnknown_AtomicRelease(lppUnknown); /* Release existing interface */
2631   }
2632 }
2633
2634 /*************************************************************************
2635  *      @       [SHLWAPI.269]
2636  *
2637  * Convert an ASCII string of a CLSID into a CLSID.
2638  *
2639  * PARAMS
2640  *  idstr [I] String representing a CLSID in registry format
2641  *  id    [O] Destination for the converted CLSID
2642  *
2643  * RETURNS
2644  *  Success: TRUE. id contains the converted CLSID.
2645  *  Failure: FALSE.
2646  */
2647 BOOL WINAPI GUIDFromStringA(LPCSTR idstr, CLSID *id)
2648 {
2649   WCHAR wClsid[40];
2650   MultiByteToWideChar(CP_ACP, 0, idstr, -1, wClsid, sizeof(wClsid)/sizeof(WCHAR));
2651   return SUCCEEDED(CLSIDFromString(wClsid, id));
2652 }
2653
2654 /*************************************************************************
2655  *      @       [SHLWAPI.270]
2656  *
2657  * Unicode version of GUIDFromStringA.
2658  */
2659 BOOL WINAPI GUIDFromStringW(LPCWSTR idstr, CLSID *id)
2660 {
2661     return SUCCEEDED(CLSIDFromString((LPOLESTR)idstr, id));
2662 }
2663
2664 /*************************************************************************
2665  *      @       [SHLWAPI.276]
2666  *
2667  * Determine if the browser is integrated into the shell, and set a registry
2668  * key accordingly.
2669  *
2670  * PARAMS
2671  *  None.
2672  *
2673  * RETURNS
2674  *  1, If the browser is not integrated.
2675  *  2, If the browser is integrated.
2676  *
2677  * NOTES
2678  *  The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2679  *  either set to TRUE, or removed depending on whether the browser is deemed
2680  *  to be integrated.
2681  */
2682 DWORD WINAPI WhichPlatform(void)
2683 {
2684   static const char szIntegratedBrowser[] = "IntegratedBrowser";
2685   static DWORD dwState = 0;
2686   HKEY hKey;
2687   DWORD dwRet, dwData, dwSize;
2688   HMODULE hshell32;
2689
2690   if (dwState)
2691     return dwState;
2692
2693   /* If shell32 exports DllGetVersion(), the browser is integrated */
2694   dwState = 1;
2695   hshell32 = LoadLibraryA("shell32.dll");
2696   if (hshell32)
2697   {
2698     FARPROC pDllGetVersion;
2699     pDllGetVersion = GetProcAddress(hshell32, "DllGetVersion");
2700     dwState = pDllGetVersion ? 2 : 1;
2701     FreeLibrary(hshell32);
2702   }
2703
2704   /* Set or delete the key accordingly */
2705   dwRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2706                         "Software\\Microsoft\\Internet Explorer", 0,
2707                          KEY_ALL_ACCESS, &hKey);
2708   if (!dwRet)
2709   {
2710     dwRet = RegQueryValueExA(hKey, szIntegratedBrowser, 0, 0,
2711                              (LPBYTE)&dwData, &dwSize);
2712
2713     if (!dwRet && dwState == 1)
2714     {
2715       /* Value exists but browser is not integrated */
2716       RegDeleteValueA(hKey, szIntegratedBrowser);
2717     }
2718     else if (dwRet && dwState == 2)
2719     {
2720       /* Browser is integrated but value does not exist */
2721       dwData = TRUE;
2722       RegSetValueExA(hKey, szIntegratedBrowser, 0, REG_DWORD,
2723                      (LPBYTE)&dwData, sizeof(dwData));
2724     }
2725     RegCloseKey(hKey);
2726   }
2727   return dwState;
2728 }
2729
2730 /*************************************************************************
2731  *      @       [SHLWAPI.278]
2732  *
2733  * Unicode version of SHCreateWorkerWindowA.
2734  */
2735 HWND WINAPI SHCreateWorkerWindowW(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2736                         DWORD dwStyle, HMENU hMenu, LONG z)
2737 {
2738   static const WCHAR szClass[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', '\0' };
2739   WNDCLASSW wc;
2740   HWND hWnd;
2741
2742   TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2743          wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2744
2745   /* If our OS is natively ASCII, use the ASCII version */
2746   if (!(GetVersion() & 0x80000000))  /* NT */
2747     return SHCreateWorkerWindowA(wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2748
2749   /* Create Window class */
2750   wc.style         = 0;
2751   wc.lpfnWndProc   = DefWindowProcW;
2752   wc.cbClsExtra    = 0;
2753   wc.cbWndExtra    = 4;
2754   wc.hInstance     = shlwapi_hInstance;
2755   wc.hIcon         = NULL;
2756   wc.hCursor       = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
2757   wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2758   wc.lpszMenuName  = NULL;
2759   wc.lpszClassName = szClass;
2760
2761   SHRegisterClassW(&wc); /* Register class */
2762
2763   /* FIXME: Set extra bits in dwExStyle */
2764
2765   hWnd = CreateWindowExW(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2766                          hWndParent, hMenu, shlwapi_hInstance, 0);
2767   if (hWnd)
2768   {
2769     SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2770
2771     if (wndProc)
2772       SetWindowLongPtrW(hWnd, GWLP_WNDPROC, wndProc);
2773   }
2774   return hWnd;
2775 }
2776
2777 /*************************************************************************
2778  *      @       [SHLWAPI.279]
2779  *
2780  * Get and show a context menu from a shell folder.
2781  *
2782  * PARAMS
2783  *  hWnd           [I] Window displaying the shell folder
2784  *  lpFolder       [I] IShellFolder interface
2785  *  lpApidl        [I] Id for the particular folder desired
2786  *
2787  * RETURNS
2788  *  Success: S_OK.
2789  *  Failure: An HRESULT error code indicating the error.
2790  */
2791 HRESULT WINAPI SHInvokeDefaultCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl)
2792 {
2793   return SHInvokeCommand(hWnd, lpFolder, lpApidl, FALSE);
2794 }
2795
2796 /*************************************************************************
2797  *      @       [SHLWAPI.281]
2798  *
2799  * _SHPackDispParamsV
2800  */
2801 HRESULT WINAPI SHPackDispParamsV(DISPPARAMS *params, VARIANTARG *args, UINT cnt, va_list valist)
2802 {
2803   VARIANTARG *iter;
2804
2805   TRACE("(%p %p %u ...)\n", params, args, cnt);
2806
2807   params->rgvarg = args;
2808   params->rgdispidNamedArgs = NULL;
2809   params->cArgs = cnt;
2810   params->cNamedArgs = 0;
2811
2812   iter = args+cnt;
2813
2814   while(iter-- > args) {
2815     V_VT(iter) = va_arg(valist, enum VARENUM);
2816
2817     TRACE("vt=%d\n", V_VT(iter));
2818
2819     if(V_VT(iter) & VT_BYREF) {
2820       V_BYREF(iter) = va_arg(valist, LPVOID);
2821     } else {
2822       switch(V_VT(iter)) {
2823       case VT_I4:
2824         V_I4(iter) = va_arg(valist, LONG);
2825         break;
2826       case VT_BSTR:
2827         V_BSTR(iter) = va_arg(valist, BSTR);
2828         break;
2829       case VT_DISPATCH:
2830         V_DISPATCH(iter) = va_arg(valist, IDispatch*);
2831         break;
2832       case VT_BOOL:
2833         V_BOOL(iter) = va_arg(valist, int);
2834         break;
2835       case VT_UNKNOWN:
2836         V_UNKNOWN(iter) = va_arg(valist, IUnknown*);
2837         break;
2838       default:
2839         V_VT(iter) = VT_I4;
2840         V_I4(iter) = va_arg(valist, LONG);
2841       }
2842     }
2843   }
2844
2845   return S_OK;
2846 }
2847
2848 /*************************************************************************
2849  *      @       [SHLWAPI.282]
2850  *
2851  * SHPackDispParams
2852  */
2853 HRESULT WINAPIV SHPackDispParams(DISPPARAMS *params, VARIANTARG *args, UINT cnt, ...)
2854 {
2855   va_list valist;
2856   HRESULT hres;
2857
2858   va_start(valist, cnt);
2859
2860   hres = SHPackDispParamsV(params, args, cnt, valist);
2861
2862   va_end(valist);
2863   return hres;
2864 }
2865
2866 /*************************************************************************
2867  *      SHLWAPI_InvokeByIID
2868  *
2869  *   This helper function calls IDispatch::Invoke for each sink
2870  * which implements given iid or IDispatch.
2871  *
2872  */
2873 static HRESULT SHLWAPI_InvokeByIID(
2874         IConnectionPoint* iCP,
2875         REFIID iid,
2876         DISPID dispId,
2877         DISPPARAMS* dispParams)
2878 {
2879   IEnumConnections *enumerator;
2880   CONNECTDATA rgcd;
2881
2882   HRESULT result = IConnectionPoint_EnumConnections(iCP, &enumerator);
2883   if (FAILED(result))
2884     return result;
2885
2886   while(IEnumConnections_Next(enumerator, 1, &rgcd, NULL)==S_OK)
2887   {
2888     IDispatch *dispIface;
2889     if (SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, iid, (LPVOID*)&dispIface)) ||
2890         SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, &IID_IDispatch, (LPVOID*)&dispIface)))
2891     {
2892       IDispatch_Invoke(dispIface, dispId, &IID_NULL, 0, DISPATCH_METHOD, dispParams, NULL, NULL, NULL);
2893       IDispatch_Release(dispIface);
2894     }
2895   }
2896
2897   IEnumConnections_Release(enumerator);
2898
2899   return S_OK;
2900 }
2901
2902 /*************************************************************************
2903  *      @       [SHLWAPI.284]
2904  *
2905  *  IConnectionPoint_SimpleInvoke
2906  */
2907 HRESULT WINAPI IConnectionPoint_SimpleInvoke(
2908         IConnectionPoint* iCP,
2909         DISPID dispId,
2910         DISPPARAMS* dispParams)
2911 {
2912   IID iid;
2913   HRESULT result;
2914
2915   TRACE("(%p)->(0x%x %p)\n",iCP,dispId,dispParams);
2916
2917   result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
2918   if (SUCCEEDED(result))
2919     result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
2920
2921   return result;
2922 }
2923
2924 /*************************************************************************
2925  *      @       [SHLWAPI.285]
2926  *
2927  * Notify an IConnectionPoint object of changes.
2928  *
2929  * PARAMS
2930  *  lpCP   [I] Object to notify
2931  *  dispID [I]
2932  *
2933  * RETURNS
2934  *  Success: S_OK.
2935  *  Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
2936  *           IConnectionPoint interface.
2937  */
2938 HRESULT WINAPI IConnectionPoint_OnChanged(IConnectionPoint* lpCP, DISPID dispID)
2939 {
2940   IEnumConnections *lpEnum;
2941   HRESULT hRet = E_NOINTERFACE;
2942
2943   TRACE("(%p,0x%8X)\n", lpCP, dispID);
2944
2945   /* Get an enumerator for the connections */
2946   if (lpCP)
2947     hRet = IConnectionPoint_EnumConnections(lpCP, &lpEnum);
2948
2949   if (SUCCEEDED(hRet))
2950   {
2951     IPropertyNotifySink *lpSink;
2952     CONNECTDATA connData;
2953     ULONG ulFetched;
2954
2955     /* Call OnChanged() for every notify sink in the connection point */
2956     while (IEnumConnections_Next(lpEnum, 1, &connData, &ulFetched) == S_OK)
2957     {
2958       if (SUCCEEDED(IUnknown_QueryInterface(connData.pUnk, &IID_IPropertyNotifySink, (void**)&lpSink)) &&
2959           lpSink)
2960       {
2961         IPropertyNotifySink_OnChanged(lpSink, dispID);
2962         IPropertyNotifySink_Release(lpSink);
2963       }
2964       IUnknown_Release(connData.pUnk);
2965     }
2966
2967     IEnumConnections_Release(lpEnum);
2968   }
2969   return hRet;
2970 }
2971
2972 /*************************************************************************
2973  *      @       [SHLWAPI.286]
2974  *
2975  *  IUnknown_CPContainerInvokeParam
2976  */
2977 HRESULT WINAPIV IUnknown_CPContainerInvokeParam(
2978         IUnknown *container,
2979         REFIID riid,
2980         DISPID dispId,
2981         VARIANTARG* buffer,
2982         DWORD cParams, ...)
2983 {
2984   HRESULT result;
2985   IConnectionPoint *iCP;
2986   IConnectionPointContainer *iCPC;
2987   DISPPARAMS dispParams = {buffer, NULL, cParams, 0};
2988   va_list valist;
2989
2990   if (!container)
2991     return E_NOINTERFACE;
2992
2993   result = IUnknown_QueryInterface(container, &IID_IConnectionPointContainer,(LPVOID*) &iCPC);
2994   if (FAILED(result))
2995       return result;
2996
2997   result = IConnectionPointContainer_FindConnectionPoint(iCPC, riid, &iCP);
2998   IConnectionPointContainer_Release(iCPC);
2999   if(FAILED(result))
3000       return result;
3001
3002   va_start(valist, cParams);
3003   SHPackDispParamsV(&dispParams, buffer, cParams, valist);
3004   va_end(valist);
3005
3006   result = SHLWAPI_InvokeByIID(iCP, riid, dispId, &dispParams);
3007   IConnectionPoint_Release(iCP);
3008
3009   return result;
3010 }
3011
3012 /*************************************************************************
3013  *      @       [SHLWAPI.287]
3014  *
3015  * Notify an IConnectionPointContainer object of changes.
3016  *
3017  * PARAMS
3018  *  lpUnknown [I] Object to notify
3019  *  dispID    [I]
3020  *
3021  * RETURNS
3022  *  Success: S_OK.
3023  *  Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
3024  *           IConnectionPointContainer interface.
3025  */
3026 HRESULT WINAPI IUnknown_CPContainerOnChanged(IUnknown *lpUnknown, DISPID dispID)
3027 {
3028   IConnectionPointContainer* lpCPC = NULL;
3029   HRESULT hRet = E_NOINTERFACE;
3030
3031   TRACE("(%p,0x%8X)\n", lpUnknown, dispID);
3032
3033   if (lpUnknown)
3034     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer, (void**)&lpCPC);
3035
3036   if (SUCCEEDED(hRet))
3037   {
3038     IConnectionPoint* lpCP;
3039
3040     hRet = IConnectionPointContainer_FindConnectionPoint(lpCPC, &IID_IPropertyNotifySink, &lpCP);
3041     IConnectionPointContainer_Release(lpCPC);
3042
3043     hRet = IConnectionPoint_OnChanged(lpCP, dispID);
3044     IConnectionPoint_Release(lpCP);
3045   }
3046   return hRet;
3047 }
3048
3049 /*************************************************************************
3050  *      @       [SHLWAPI.289]
3051  *
3052  * See PlaySoundW.
3053  */
3054 BOOL WINAPI PlaySoundWrapW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
3055 {
3056     return PlaySoundW(pszSound, hmod, fdwSound);
3057 }
3058
3059 /*************************************************************************
3060  *      @       [SHLWAPI.294]
3061  */
3062 BOOL WINAPI SHGetIniStringW(LPCWSTR str1, LPCWSTR str2, LPWSTR pStr, DWORD some_len, LPCWSTR lpStr2)
3063 {
3064     FIXME("(%s,%s,%p,%08x,%s): stub!\n", debugstr_w(str1), debugstr_w(str2),
3065         pStr, some_len, debugstr_w(lpStr2));
3066     return TRUE;
3067 }
3068
3069 /*************************************************************************
3070  *      @       [SHLWAPI.295]
3071  *
3072  * Called by ICQ2000b install via SHDOCVW:
3073  * str1: "InternetShortcut"
3074  * x: some unknown pointer
3075  * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
3076  * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
3077  *
3078  * In short: this one maybe creates a desktop link :-)
3079  */
3080 BOOL WINAPI SHSetIniStringW(LPWSTR str1, LPVOID x, LPWSTR str2, LPWSTR str3)
3081 {
3082     FIXME("(%s, %p, %s, %s), stub.\n", debugstr_w(str1), x, debugstr_w(str2), debugstr_w(str3));
3083     return TRUE;
3084 }
3085
3086 /*************************************************************************
3087  *      @       [SHLWAPI.313]
3088  *
3089  * See SHGetFileInfoW.
3090  */
3091 DWORD WINAPI SHGetFileInfoWrapW(LPCWSTR path, DWORD dwFileAttributes,
3092                          SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
3093 {
3094     return SHGetFileInfoW(path, dwFileAttributes, psfi, sizeofpsfi, flags);
3095 }
3096
3097 /*************************************************************************
3098  *      @       [SHLWAPI.318]
3099  *
3100  * See DragQueryFileW.
3101  */
3102 UINT WINAPI DragQueryFileWrapW(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
3103 {
3104     return DragQueryFileW(hDrop, lFile, lpszFile, lLength);
3105 }
3106
3107 /*************************************************************************
3108  *      @       [SHLWAPI.333]
3109  *
3110  * See SHBrowseForFolderW.
3111  */
3112 LPITEMIDLIST WINAPI SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi)
3113 {
3114     return SHBrowseForFolderW(lpBi);
3115 }
3116
3117 /*************************************************************************
3118  *      @       [SHLWAPI.334]
3119  *
3120  * See SHGetPathFromIDListW.
3121  */
3122 BOOL WINAPI SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl,LPWSTR pszPath)
3123 {
3124     return SHGetPathFromIDListW(pidl, pszPath);
3125 }
3126
3127 /*************************************************************************
3128  *      @       [SHLWAPI.335]
3129  *
3130  * See ShellExecuteExW.
3131  */
3132 BOOL WINAPI ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo)
3133 {
3134     return ShellExecuteExW(lpExecInfo);
3135 }
3136
3137 /*************************************************************************
3138  *      @       [SHLWAPI.336]
3139  *
3140  * See SHFileOperationW.
3141  */
3142 INT WINAPI SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp)
3143 {
3144     return SHFileOperationW(lpFileOp);
3145 }
3146
3147 /*************************************************************************
3148  *      @       [SHLWAPI.342]
3149  *
3150  */
3151 PVOID WINAPI SHInterlockedCompareExchange( PVOID *dest, PVOID xchg, PVOID compare )
3152 {
3153     return InterlockedCompareExchangePointer( dest, xchg, compare );
3154 }
3155
3156 /*************************************************************************
3157  *      @       [SHLWAPI.350]
3158  *
3159  * See GetFileVersionInfoSizeW.
3160  */
3161 DWORD WINAPI GetFileVersionInfoSizeWrapW( LPCWSTR filename, LPDWORD handle )
3162 {
3163     return GetFileVersionInfoSizeW( filename, handle );
3164 }
3165
3166 /*************************************************************************
3167  *      @       [SHLWAPI.351]
3168  *
3169  * See GetFileVersionInfoW.
3170  */
3171 BOOL  WINAPI GetFileVersionInfoWrapW( LPCWSTR filename, DWORD handle,
3172                                       DWORD datasize, LPVOID data )
3173 {
3174     return GetFileVersionInfoW( filename, handle, datasize, data );
3175 }
3176
3177 /*************************************************************************
3178  *      @       [SHLWAPI.352]
3179  *
3180  * See VerQueryValueW.
3181  */
3182 WORD WINAPI VerQueryValueWrapW( LPVOID pBlock, LPCWSTR lpSubBlock,
3183                                 LPVOID *lplpBuffer, UINT *puLen )
3184 {
3185     return VerQueryValueW( pBlock, lpSubBlock, lplpBuffer, puLen );
3186 }
3187
3188 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3189 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3190 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3191
3192 /*************************************************************************
3193  *      @       [SHLWAPI.355]
3194  *
3195  * Change the modality of a shell object.
3196  *
3197  * PARAMS
3198  *  lpUnknown [I] Object to make modeless
3199  *  bModeless [I] TRUE=Make modeless, FALSE=Make modal
3200  *
3201  * RETURNS
3202  *  Success: S_OK. The modality lpUnknown is changed.
3203  *  Failure: An HRESULT error code indicating the error.
3204  *
3205  * NOTES
3206  *  lpUnknown must support the IOleInPlaceFrame interface, the
3207  *  IInternetSecurityMgrSite interface, the IShellBrowser interface
3208  *  the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3209  *  or this call will fail.
3210  */
3211 HRESULT WINAPI IUnknown_EnableModeless(IUnknown *lpUnknown, BOOL bModeless)
3212 {
3213   IUnknown *lpObj;
3214   HRESULT hRet;
3215
3216   TRACE("(%p,%d)\n", lpUnknown, bModeless);
3217
3218   if (!lpUnknown)
3219     return E_FAIL;
3220
3221   if (IsIface(IOleInPlaceActiveObject))
3222     EnableModeless(IOleInPlaceActiveObject);
3223   else if (IsIface(IOleInPlaceFrame))
3224     EnableModeless(IOleInPlaceFrame);
3225   else if (IsIface(IShellBrowser))
3226     EnableModeless(IShellBrowser);
3227   else if (IsIface(IInternetSecurityMgrSite))
3228     EnableModeless(IInternetSecurityMgrSite);
3229   else if (IsIface(IDocHostUIHandler))
3230     EnableModeless(IDocHostUIHandler);
3231   else
3232     return hRet;
3233
3234   IUnknown_Release(lpObj);
3235   return S_OK;
3236 }
3237
3238 /*************************************************************************
3239  *      @       [SHLWAPI.357]
3240  *
3241  * See SHGetNewLinkInfoW.
3242  */
3243 BOOL WINAPI SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName,
3244                         BOOL *pfMustCopy, UINT uFlags)
3245 {
3246     return SHGetNewLinkInfoW(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
3247 }
3248
3249 /*************************************************************************
3250  *      @       [SHLWAPI.358]
3251  *
3252  * See SHDefExtractIconW.
3253  */
3254 UINT WINAPI SHDefExtractIconWrapW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON* phiconLarge,
3255                          HICON* phiconSmall, UINT nIconSize)
3256 {
3257     return SHDefExtractIconW(pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
3258 }
3259
3260 /*************************************************************************
3261  *      @       [SHLWAPI.363]
3262  *
3263  * Get and show a context menu from a shell folder.
3264  *
3265  * PARAMS
3266  *  hWnd           [I] Window displaying the shell folder
3267  *  lpFolder       [I] IShellFolder interface
3268  *  lpApidl        [I] Id for the particular folder desired
3269  *  bInvokeDefault [I] Whether to invoke the default menu item
3270  *
3271  * RETURNS
3272  *  Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3273  *           executed.
3274  *  Failure: An HRESULT error code indicating the error.
3275  */
3276 HRESULT WINAPI SHInvokeCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl, BOOL bInvokeDefault)
3277 {
3278   IContextMenu *iContext;
3279   HRESULT hRet = E_FAIL;
3280
3281   TRACE("(%p,%p,%p,%d)\n", hWnd, lpFolder, lpApidl, bInvokeDefault);
3282
3283   if (!lpFolder)
3284     return hRet;
3285
3286   /* Get the context menu from the shell folder */
3287   hRet = IShellFolder_GetUIObjectOf(lpFolder, hWnd, 1, &lpApidl,
3288                                     &IID_IContextMenu, 0, (void**)&iContext);
3289   if (SUCCEEDED(hRet))
3290   {
3291     HMENU hMenu;
3292     if ((hMenu = CreatePopupMenu()))
3293     {
3294       HRESULT hQuery;
3295       DWORD dwDefaultId = 0;
3296
3297       /* Add the context menu entries to the popup */
3298       hQuery = IContextMenu_QueryContextMenu(iContext, hMenu, 0, 1, 0x7FFF,
3299                                              bInvokeDefault ? CMF_NORMAL : CMF_DEFAULTONLY);
3300
3301       if (SUCCEEDED(hQuery))
3302       {
3303         if (bInvokeDefault &&
3304             (dwDefaultId = GetMenuDefaultItem(hMenu, 0, 0)) != 0xFFFFFFFF)
3305         {
3306           CMINVOKECOMMANDINFO cmIci;
3307           /* Invoke the default item */
3308           memset(&cmIci,0,sizeof(cmIci));
3309           cmIci.cbSize = sizeof(cmIci);
3310           cmIci.fMask = CMIC_MASK_ASYNCOK;
3311           cmIci.hwnd = hWnd;
3312           cmIci.lpVerb = MAKEINTRESOURCEA(dwDefaultId);
3313           cmIci.nShow = SW_SCROLLCHILDREN;
3314
3315           hRet = IContextMenu_InvokeCommand(iContext, &cmIci);
3316         }
3317       }
3318       DestroyMenu(hMenu);
3319     }
3320     IContextMenu_Release(iContext);
3321   }
3322   return hRet;
3323 }
3324
3325 /*************************************************************************
3326  *      @       [SHLWAPI.370]
3327  *
3328  * See ExtractIconW.
3329  */
3330 HICON WINAPI ExtractIconWrapW(HINSTANCE hInstance, LPCWSTR lpszExeFileName,
3331                          UINT nIconIndex)
3332 {
3333     return ExtractIconW(hInstance, lpszExeFileName, nIconIndex);
3334 }
3335
3336 /*************************************************************************
3337  *      @       [SHLWAPI.377]
3338  *
3339  * Load a library from the directory of a particular process.
3340  *
3341  * PARAMS
3342  *  new_mod        [I] Library name
3343  *  inst_hwnd      [I] Module whose directory is to be used
3344  *  dwCrossCodePage [I] Should be FALSE (currently ignored)
3345  *
3346  * RETURNS
3347  *  Success: A handle to the loaded module
3348  *  Failure: A NULL handle.
3349  */
3350 HMODULE WINAPI MLLoadLibraryA(LPCSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3351 {
3352   /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3353    *        each call here.
3354    * FIXME: Native shows calls to:
3355    *  SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3356    *                      CheckVersion
3357    *  RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3358    *  RegQueryValueExA for "LPKInstalled"
3359    *  RegCloseKey
3360    *  RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3361    *  RegQueryValueExA for "ResourceLocale"
3362    *  RegCloseKey
3363    *  RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3364    *  RegQueryValueExA for "Locale"
3365    *  RegCloseKey
3366    *  and then tests the Locale ("en" for me).
3367    *     code below
3368    *  after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3369    */
3370     CHAR mod_path[2*MAX_PATH];
3371     LPSTR ptr;
3372     DWORD len;
3373
3374     FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, dwCrossCodePage);
3375     len = GetModuleFileNameA(inst_hwnd, mod_path, sizeof(mod_path));
3376     if (!len || len >= sizeof(mod_path)) return NULL;
3377
3378     ptr = strrchr(mod_path, '\\');
3379     if (ptr) {
3380         strcpy(ptr+1, new_mod);
3381         TRACE("loading %s\n", debugstr_a(mod_path));
3382         return LoadLibraryA(mod_path);
3383     }
3384     return NULL;
3385 }
3386
3387 /*************************************************************************
3388  *      @       [SHLWAPI.378]
3389  *
3390  * Unicode version of MLLoadLibraryA.
3391  */
3392 HMODULE WINAPI MLLoadLibraryW(LPCWSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3393 {
3394     WCHAR mod_path[2*MAX_PATH];
3395     LPWSTR ptr;
3396     DWORD len;
3397
3398     FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwCrossCodePage);
3399     len = GetModuleFileNameW(inst_hwnd, mod_path, sizeof(mod_path) / sizeof(WCHAR));
3400     if (!len || len >= sizeof(mod_path) / sizeof(WCHAR)) return NULL;
3401
3402     ptr = strrchrW(mod_path, '\\');
3403     if (ptr) {
3404         strcpyW(ptr+1, new_mod);
3405         TRACE("loading %s\n", debugstr_w(mod_path));
3406         return LoadLibraryW(mod_path);
3407     }
3408     return NULL;
3409 }
3410
3411 /*************************************************************************
3412  * ColorAdjustLuma      [SHLWAPI.@]
3413  *
3414  * Adjust the luminosity of a color
3415  *
3416  * PARAMS
3417  *  cRGB         [I] RGB value to convert
3418  *  dwLuma       [I] Luma adjustment
3419  *  bUnknown     [I] Unknown
3420  *
3421  * RETURNS
3422  *  The adjusted RGB color.
3423  */
3424 COLORREF WINAPI ColorAdjustLuma(COLORREF cRGB, int dwLuma, BOOL bUnknown)
3425 {
3426   TRACE("(0x%8x,%d,%d)\n", cRGB, dwLuma, bUnknown);
3427
3428   if (dwLuma)
3429   {
3430     WORD wH, wL, wS;
3431
3432     ColorRGBToHLS(cRGB, &wH, &wL, &wS);
3433
3434     FIXME("Ignoring luma adjustment\n");
3435
3436     /* FIXME: The adjustment is not linear */
3437
3438     cRGB = ColorHLSToRGB(wH, wL, wS);
3439   }
3440   return cRGB;
3441 }
3442
3443 /*************************************************************************
3444  *      @       [SHLWAPI.389]
3445  *
3446  * See GetSaveFileNameW.
3447  */
3448 BOOL WINAPI GetSaveFileNameWrapW(LPOPENFILENAMEW ofn)
3449 {
3450     return GetSaveFileNameW(ofn);
3451 }
3452
3453 /*************************************************************************
3454  *      @       [SHLWAPI.390]
3455  *
3456  * See WNetRestoreConnectionW.
3457  */
3458 DWORD WINAPI WNetRestoreConnectionWrapW(HWND hwndOwner, LPWSTR lpszDevice)
3459 {
3460     return WNetRestoreConnectionW(hwndOwner, lpszDevice);
3461 }
3462
3463 /*************************************************************************
3464  *      @       [SHLWAPI.391]
3465  *
3466  * See WNetGetLastErrorW.
3467  */
3468 DWORD WINAPI WNetGetLastErrorWrapW(LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize,
3469                          LPWSTR lpNameBuf, DWORD nNameBufSize)
3470 {
3471     return WNetGetLastErrorW(lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize);
3472 }
3473
3474 /*************************************************************************
3475  *      @       [SHLWAPI.401]
3476  *
3477  * See PageSetupDlgW.
3478  */
3479 BOOL WINAPI PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg)
3480 {
3481     return PageSetupDlgW(pagedlg);
3482 }
3483
3484 /*************************************************************************
3485  *      @       [SHLWAPI.402]
3486  *
3487  * See PrintDlgW.
3488  */
3489 BOOL WINAPI PrintDlgWrapW(LPPRINTDLGW printdlg)
3490 {
3491     return PrintDlgW(printdlg);
3492 }
3493
3494 /*************************************************************************
3495  *      @       [SHLWAPI.403]
3496  *
3497  * See GetOpenFileNameW.
3498  */
3499 BOOL WINAPI GetOpenFileNameWrapW(LPOPENFILENAMEW ofn)
3500 {
3501     return GetOpenFileNameW(ofn);
3502 }
3503
3504 /*************************************************************************
3505  *      @       [SHLWAPI.404]
3506  */
3507 HRESULT WINAPI SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder, HWND hwnd, SHCONTF flags, IEnumIDList **ppenum)
3508 {
3509     IPersist *persist;
3510     HRESULT hr;
3511
3512     hr = IShellFolder_QueryInterface(lpFolder, &IID_IPersist, (LPVOID)&persist);
3513     if(SUCCEEDED(hr))
3514     {
3515         CLSID clsid;
3516         hr = IPersist_GetClassID(persist, &clsid);
3517         if(SUCCEEDED(hr))
3518         {
3519             if(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder))
3520                 hr = IShellFolder_EnumObjects(lpFolder, hwnd, flags, ppenum);
3521             else
3522                 hr = E_FAIL;
3523         }
3524         IPersist_Release(persist);
3525     }
3526     return hr;
3527 }
3528
3529 /* INTERNAL: Map from HLS color space to RGB */
3530 static WORD WINAPI ConvertHue(int wHue, WORD wMid1, WORD wMid2)
3531 {
3532   wHue = wHue > 240 ? wHue - 240 : wHue < 0 ? wHue + 240 : wHue;
3533
3534   if (wHue > 160)
3535     return wMid1;
3536   else if (wHue > 120)
3537     wHue = 160 - wHue;
3538   else if (wHue > 40)
3539     return wMid2;
3540
3541   return ((wHue * (wMid2 - wMid1) + 20) / 40) + wMid1;
3542 }
3543
3544 /* Convert to RGB and scale into RGB range (0..255) */
3545 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3546
3547 /*************************************************************************
3548  *      ColorHLSToRGB   [SHLWAPI.@]
3549  *
3550  * Convert from hls color space into an rgb COLORREF.
3551  *
3552  * PARAMS
3553  *  wHue        [I] Hue amount
3554  *  wLuminosity [I] Luminosity amount
3555  *  wSaturation [I] Saturation amount
3556  *
3557  * RETURNS
3558  *  A COLORREF representing the converted color.
3559  *
3560  * NOTES
3561  *  Input hls values are constrained to the range (0..240).
3562  */
3563 COLORREF WINAPI ColorHLSToRGB(WORD wHue, WORD wLuminosity, WORD wSaturation)
3564 {
3565   WORD wRed;
3566
3567   if (wSaturation)
3568   {
3569     WORD wGreen, wBlue, wMid1, wMid2;
3570
3571     if (wLuminosity > 120)
3572       wMid2 = wSaturation + wLuminosity - (wSaturation * wLuminosity + 120) / 240;
3573     else
3574       wMid2 = ((wSaturation + 240) * wLuminosity + 120) / 240;
3575
3576     wMid1 = wLuminosity * 2 - wMid2;
3577
3578     wRed   = GET_RGB(wHue + 80);
3579     wGreen = GET_RGB(wHue);
3580     wBlue  = GET_RGB(wHue - 80);
3581
3582     return RGB(wRed, wGreen, wBlue);
3583   }
3584
3585   wRed = wLuminosity * 255 / 240;
3586   return RGB(wRed, wRed, wRed);
3587 }
3588
3589 /*************************************************************************
3590  *      @       [SHLWAPI.413]
3591  *
3592  * Get the current docking status of the system.
3593  *
3594  * PARAMS
3595  *  dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3596  *
3597  * RETURNS
3598  *  One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3599  *  a notebook.
3600  */
3601 DWORD WINAPI SHGetMachineInfo(DWORD dwFlags)
3602 {
3603   HW_PROFILE_INFOA hwInfo;
3604
3605   TRACE("(0x%08x)\n", dwFlags);
3606
3607   GetCurrentHwProfileA(&hwInfo);
3608   switch (hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED))
3609   {
3610   case DOCKINFO_DOCKED:
3611   case DOCKINFO_UNDOCKED:
3612     return hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED);
3613   default:
3614     return 0;
3615   }
3616 }
3617
3618 /*************************************************************************
3619  *      @       [SHLWAPI.418]
3620  *
3621  * Function seems to do FreeLibrary plus other things.
3622  *
3623  * FIXME native shows the following calls:
3624  *   RtlEnterCriticalSection
3625  *   LocalFree
3626  *   GetProcAddress(Comctl32??, 150L)
3627  *   DPA_DeletePtr
3628  *   RtlLeaveCriticalSection
3629  *  followed by the FreeLibrary.
3630  *  The above code may be related to .377 above.
3631  */
3632 BOOL WINAPI MLFreeLibrary(HMODULE hModule)
3633 {
3634         FIXME("(%p) semi-stub\n", hModule);
3635         return FreeLibrary(hModule);
3636 }
3637
3638 /*************************************************************************
3639  *      @       [SHLWAPI.419]
3640  */
3641 BOOL WINAPI SHFlushSFCacheWrap(void) {
3642   FIXME(": stub\n");
3643   return TRUE;
3644 }
3645
3646 /*************************************************************************
3647  *      @      [SHLWAPI.429]
3648  * FIXME I have no idea what this function does or what its arguments are.
3649  */
3650 BOOL WINAPI MLIsMLHInstance(HINSTANCE hInst)
3651 {
3652        FIXME("(%p) stub\n", hInst);
3653        return FALSE;
3654 }
3655
3656
3657 /*************************************************************************
3658  *      @       [SHLWAPI.430]
3659  */
3660 DWORD WINAPI MLSetMLHInstance(HINSTANCE hInst, HANDLE hHeap)
3661 {
3662         FIXME("(%p,%p) stub\n", hInst, hHeap);
3663         return E_FAIL;   /* This is what is used if shlwapi not loaded */
3664 }
3665
3666 /*************************************************************************
3667  *      @       [SHLWAPI.431]
3668  */
3669 DWORD WINAPI MLClearMLHInstance(DWORD x)
3670 {
3671         FIXME("(0x%08x)stub\n", x);
3672         return 0xabba1247;
3673 }
3674
3675 /*************************************************************************
3676  *      @       [SHLWAPI.436]
3677  *
3678  * Convert an Unicode string CLSID into a CLSID.
3679  *
3680  * PARAMS
3681  *  idstr      [I]   string containing a CLSID in text form
3682  *  id         [O]   CLSID extracted from the string
3683  *
3684  * RETURNS
3685  *  S_OK on success or E_INVALIDARG on failure
3686  */
3687 HRESULT WINAPI CLSIDFromStringWrap(LPCWSTR idstr, CLSID *id)
3688 {
3689     return CLSIDFromString((LPOLESTR)idstr, id);
3690 }
3691
3692 /*************************************************************************
3693  *      @       [SHLWAPI.437]
3694  *
3695  * Determine if the OS supports a given feature.
3696  *
3697  * PARAMS
3698  *  dwFeature [I] Feature requested (undocumented)
3699  *
3700  * RETURNS
3701  *  TRUE  If the feature is available.
3702  *  FALSE If the feature is not available.
3703  */
3704 BOOL WINAPI IsOS(DWORD feature)
3705 {
3706     OSVERSIONINFOA osvi;
3707     DWORD platform, majorv, minorv;
3708
3709     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
3710     if(!GetVersionExA(&osvi))  {
3711         ERR("GetVersionEx failed\n");
3712         return FALSE;
3713     }
3714
3715     majorv = osvi.dwMajorVersion;
3716     minorv = osvi.dwMinorVersion;
3717     platform = osvi.dwPlatformId;
3718
3719 #define ISOS_RETURN(x) \
3720     TRACE("(0x%x) ret=%d\n",feature,(x)); \
3721     return (x);
3722
3723     switch(feature)  {
3724     case OS_WIN32SORGREATER:
3725         ISOS_RETURN(platform == VER_PLATFORM_WIN32s
3726                  || platform == VER_PLATFORM_WIN32_WINDOWS)
3727     case OS_NT:
3728         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3729     case OS_WIN95ORGREATER:
3730         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS)
3731     case OS_NT4ORGREATER:
3732         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 4)
3733     case OS_WIN2000ORGREATER_ALT:
3734     case OS_WIN2000ORGREATER:
3735         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3736     case OS_WIN98ORGREATER:
3737         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 10)
3738     case OS_WIN98_GOLD:
3739         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 10)
3740     case OS_WIN2000PRO:
3741         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3742     case OS_WIN2000SERVER:
3743         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3744     case OS_WIN2000ADVSERVER:
3745         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3746     case OS_WIN2000DATACENTER:
3747         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3748     case OS_WIN2000TERMINAL:
3749         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3750     case OS_EMBEDDED:
3751         FIXME("(OS_EMBEDDED) What should we return here?\n");
3752         return FALSE;
3753     case OS_TERMINALCLIENT:
3754         FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
3755         return FALSE;
3756     case OS_TERMINALREMOTEADMIN:
3757         FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
3758         return FALSE;
3759     case OS_WIN95_GOLD:
3760         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 0)
3761     case OS_MEORGREATER:
3762         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 90)
3763     case OS_XPORGREATER:
3764         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
3765     case OS_HOME:
3766         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
3767     case OS_PROFESSIONAL:
3768         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3769     case OS_DATACENTER:
3770         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3771     case OS_ADVSERVER:
3772         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3773     case OS_SERVER:
3774         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3775     case OS_TERMINALSERVER:
3776         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3777     case OS_PERSONALTERMINALSERVER:
3778         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && minorv >= 1 && majorv >= 5)
3779     case OS_FASTUSERSWITCHING:
3780         FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
3781         return TRUE;
3782     case OS_WELCOMELOGONUI:
3783         FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
3784         return FALSE;
3785     case OS_DOMAINMEMBER:
3786         FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
3787         return TRUE;
3788     case OS_ANYSERVER:
3789         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3790     case OS_WOW6432:
3791         FIXME("(OS_WOW6432) Should we check this?\n");
3792         return FALSE;
3793     case OS_WEBSERVER:
3794         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3795     case OS_SMALLBUSINESSSERVER:
3796         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3797     case OS_TABLETPC:
3798         FIXME("(OS_TABLEPC) What should we return here?\n");
3799         return FALSE;
3800     case OS_SERVERADMINUI:
3801         FIXME("(OS_SERVERADMINUI) What should we return here?\n");
3802         return FALSE;
3803     case OS_MEDIACENTER:
3804         FIXME("(OS_MEDIACENTER) What should we return here?\n");
3805         return FALSE;
3806     case OS_APPLIANCE:
3807         FIXME("(OS_APPLIANCE) What should we return here?\n");
3808         return FALSE;
3809     }
3810
3811 #undef ISOS_RETURN
3812
3813     WARN("(0x%x) unknown parameter\n",feature);
3814
3815     return FALSE;
3816 }
3817
3818 /*************************************************************************
3819  * @  [SHLWAPI.439]
3820  */
3821 HRESULT WINAPI SHLoadRegUIStringW(HKEY hkey, LPCWSTR value, LPWSTR buf, DWORD size)
3822 {
3823     DWORD type, sz = size;
3824
3825     if(RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)buf, &sz) != ERROR_SUCCESS)
3826         return E_FAIL;
3827
3828     return SHLoadIndirectString(buf, buf, size, NULL);
3829 }
3830
3831 /*************************************************************************
3832  * @  [SHLWAPI.478]
3833  *
3834  * Call IInputObject_TranslateAcceleratorIO() on an object.
3835  *
3836  * PARAMS
3837  *  lpUnknown [I] Object supporting the IInputObject interface.
3838  *  lpMsg     [I] Key message to be processed.
3839  *
3840  * RETURNS
3841  *  Success: S_OK.
3842  *  Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
3843  */
3844 HRESULT WINAPI IUnknown_TranslateAcceleratorIO(IUnknown *lpUnknown, LPMSG lpMsg)
3845 {
3846   IInputObject* lpInput = NULL;
3847   HRESULT hRet = E_INVALIDARG;
3848
3849   TRACE("(%p,%p)\n", lpUnknown, lpMsg);
3850   if (lpUnknown)
3851   {
3852     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObject,
3853                                    (void**)&lpInput);
3854     if (SUCCEEDED(hRet) && lpInput)
3855     {
3856       hRet = IInputObject_TranslateAcceleratorIO(lpInput, lpMsg);
3857       IInputObject_Release(lpInput);
3858     }
3859   }
3860   return hRet;
3861 }
3862
3863 /*************************************************************************
3864  * @  [SHLWAPI.481]
3865  *
3866  * Call IInputObject_HasFocusIO() on an object.
3867  *
3868  * PARAMS
3869  *  lpUnknown [I] Object supporting the IInputObject interface.
3870  *
3871  * RETURNS
3872  *  Success: S_OK, if lpUnknown is an IInputObject object and has the focus,
3873  *           or S_FALSE otherwise.
3874  *  Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
3875  */
3876 HRESULT WINAPI IUnknown_HasFocusIO(IUnknown *lpUnknown)
3877 {
3878   IInputObject* lpInput = NULL;
3879   HRESULT hRet = E_INVALIDARG;
3880
3881   TRACE("(%p)\n", lpUnknown);
3882   if (lpUnknown)
3883   {
3884     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObject,
3885                                    (void**)&lpInput);
3886     if (SUCCEEDED(hRet) && lpInput)
3887     {
3888       hRet = IInputObject_HasFocusIO(lpInput);
3889       IInputObject_Release(lpInput);
3890     }
3891   }
3892   return hRet;
3893 }
3894
3895 /*************************************************************************
3896  *      ColorRGBToHLS   [SHLWAPI.@]
3897  *
3898  * Convert an rgb COLORREF into the hls color space.
3899  *
3900  * PARAMS
3901  *  cRGB         [I] Source rgb value
3902  *  pwHue        [O] Destination for converted hue
3903  *  pwLuminance  [O] Destination for converted luminance
3904  *  pwSaturation [O] Destination for converted saturation
3905  *
3906  * RETURNS
3907  *  Nothing. pwHue, pwLuminance and pwSaturation are set to the converted
3908  *  values.
3909  *
3910  * NOTES
3911  *  Output HLS values are constrained to the range (0..240).
3912  *  For Achromatic conversions, Hue is set to 160.
3913  */
3914 VOID WINAPI ColorRGBToHLS(COLORREF cRGB, LPWORD pwHue,
3915                           LPWORD pwLuminance, LPWORD pwSaturation)
3916 {
3917   int wR, wG, wB, wMax, wMin, wHue, wLuminosity, wSaturation;
3918
3919   TRACE("(%08x,%p,%p,%p)\n", cRGB, pwHue, pwLuminance, pwSaturation);
3920
3921   wR = GetRValue(cRGB);
3922   wG = GetGValue(cRGB);
3923   wB = GetBValue(cRGB);
3924
3925   wMax = max(wR, max(wG, wB));
3926   wMin = min(wR, min(wG, wB));
3927
3928   /* Luminosity */
3929   wLuminosity = ((wMax + wMin) * 240 + 255) / 510;
3930
3931   if (wMax == wMin)
3932   {
3933     /* Achromatic case */
3934     wSaturation = 0;
3935     /* Hue is now unrepresentable, but this is what native returns... */
3936     wHue = 160;
3937   }
3938   else
3939   {
3940     /* Chromatic case */
3941     int wDelta = wMax - wMin, wRNorm, wGNorm, wBNorm;
3942
3943     /* Saturation */
3944     if (wLuminosity <= 120)
3945       wSaturation = ((wMax + wMin)/2 + wDelta * 240) / (wMax + wMin);
3946     else
3947       wSaturation = ((510 - wMax - wMin)/2 + wDelta * 240) / (510 - wMax - wMin);
3948
3949     /* Hue */
3950     wRNorm = (wDelta/2 + wMax * 40 - wR * 40) / wDelta;
3951     wGNorm = (wDelta/2 + wMax * 40 - wG * 40) / wDelta;
3952     wBNorm = (wDelta/2 + wMax * 40 - wB * 40) / wDelta;
3953
3954     if (wR == wMax)
3955       wHue = wBNorm - wGNorm;
3956     else if (wG == wMax)
3957       wHue = 80 + wRNorm - wBNorm;
3958     else
3959       wHue = 160 + wGNorm - wRNorm;
3960     if (wHue < 0)
3961       wHue += 240;
3962     else if (wHue > 240)
3963       wHue -= 240;
3964   }
3965   if (pwHue)
3966     *pwHue = wHue;
3967   if (pwLuminance)
3968     *pwLuminance = wLuminosity;
3969   if (pwSaturation)
3970     *pwSaturation = wSaturation;
3971 }
3972
3973 /*************************************************************************
3974  *      SHCreateShellPalette    [SHLWAPI.@]
3975  */
3976 HPALETTE WINAPI SHCreateShellPalette(HDC hdc)
3977 {
3978         FIXME("stub\n");
3979         return CreateHalftonePalette(hdc);
3980 }
3981
3982 /*************************************************************************
3983  *      SHGetInverseCMAP (SHLWAPI.@)
3984  *
3985  * Get an inverse color map table.
3986  *
3987  * PARAMS
3988  *  lpCmap  [O] Destination for color map
3989  *  dwSize  [I] Size of memory pointed to by lpCmap
3990  *
3991  * RETURNS
3992  *  Success: S_OK.
3993  *  Failure: E_POINTER,    If lpCmap is invalid.
3994  *           E_INVALIDARG, If dwFlags is invalid
3995  *           E_OUTOFMEMORY, If there is no memory available
3996  *
3997  * NOTES
3998  *  dwSize may only be CMAP_PTR_SIZE (4) or CMAP_SIZE (8192).
3999  *  If dwSize = CMAP_PTR_SIZE, *lpCmap is set to the address of this DLL's
4000  *  internal CMap.
4001  *  If dwSize = CMAP_SIZE, lpCmap is filled with a copy of the data from
4002  *  this DLL's internal CMap.
4003  */
4004 HRESULT WINAPI SHGetInverseCMAP(LPDWORD dest, DWORD dwSize)
4005 {
4006     if (dwSize == 4) {
4007         FIXME(" - returning bogus address for SHGetInverseCMAP\n");
4008         *dest = (DWORD)0xabba1249;
4009         return 0;
4010     }
4011     FIXME("(%p, %#x) stub\n", dest, dwSize);
4012     return 0;
4013 }
4014
4015 /*************************************************************************
4016  *      SHIsLowMemoryMachine    [SHLWAPI.@]
4017  *
4018  * Determine if the current computer has low memory.
4019  *
4020  * PARAMS
4021  *  x [I] FIXME
4022  *
4023  * RETURNS
4024  *  TRUE if the users machine has 16 Megabytes of memory or less,
4025  *  FALSE otherwise.
4026  */
4027 BOOL WINAPI SHIsLowMemoryMachine (DWORD x)
4028 {
4029   FIXME("(0x%08x) stub\n", x);
4030   return FALSE;
4031 }
4032
4033 /*************************************************************************
4034  *      GetMenuPosFromID        [SHLWAPI.@]
4035  *
4036  * Return the position of a menu item from its Id.
4037  *
4038  * PARAMS
4039  *   hMenu [I] Menu containing the item
4040  *   wID   [I] Id of the menu item
4041  *
4042  * RETURNS
4043  *  Success: The index of the menu item in hMenu.
4044  *  Failure: -1, If the item is not found.
4045  */
4046 INT WINAPI GetMenuPosFromID(HMENU hMenu, UINT wID)
4047 {
4048  MENUITEMINFOW mi;
4049  INT nCount = GetMenuItemCount(hMenu), nIter = 0;
4050
4051  while (nIter < nCount)
4052  {
4053    mi.cbSize = sizeof(mi);
4054    mi.fMask = MIIM_ID;
4055    if (GetMenuItemInfoW(hMenu, nIter, TRUE, &mi) && mi.wID == wID)
4056      return nIter;
4057    nIter++;
4058  }
4059  return -1;
4060 }
4061
4062 /*************************************************************************
4063  *      @       [SHLWAPI.179]
4064  *
4065  * Same as SHLWAPI.GetMenuPosFromID
4066  */
4067 DWORD WINAPI SHMenuIndexFromID(HMENU hMenu, UINT uID)
4068 {
4069     return GetMenuPosFromID(hMenu, uID);
4070 }
4071
4072
4073 /*************************************************************************
4074  *      @       [SHLWAPI.448]
4075  */
4076 VOID WINAPI FixSlashesAndColonW(LPWSTR lpwstr)
4077 {
4078     while (*lpwstr)
4079     {
4080         if (*lpwstr == '/')
4081             *lpwstr = '\\';
4082         lpwstr++;
4083     }
4084 }
4085
4086
4087 /*************************************************************************
4088  *      @       [SHLWAPI.461]
4089  */
4090 DWORD WINAPI SHGetAppCompatFlags(DWORD dwUnknown)
4091 {
4092   FIXME("(0x%08x) stub\n", dwUnknown);
4093   return 0;
4094 }
4095
4096
4097 /*************************************************************************
4098  *      @       [SHLWAPI.549]
4099  */
4100 HRESULT WINAPI SHCoCreateInstanceAC(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
4101                                     DWORD dwClsContext, REFIID iid, LPVOID *ppv)
4102 {
4103     return CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, ppv);
4104 }
4105
4106 /*************************************************************************
4107  * SHSkipJunction       [SHLWAPI.@]
4108  *
4109  * Determine if a bind context can be bound to an object
4110  *
4111  * PARAMS
4112  *  pbc    [I] Bind context to check
4113  *  pclsid [I] CLSID of object to be bound to
4114  *
4115  * RETURNS
4116  *  TRUE: If it is safe to bind
4117  *  FALSE: If pbc is invalid or binding would not be safe
4118  *
4119  */
4120 BOOL WINAPI SHSkipJunction(IBindCtx *pbc, const CLSID *pclsid)
4121 {
4122   static WCHAR szSkipBinding[] = { 'S','k','i','p',' ',
4123     'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
4124   BOOL bRet = FALSE;
4125
4126   if (pbc)
4127   {
4128     IUnknown* lpUnk;
4129
4130     if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)szSkipBinding, &lpUnk)))
4131     {
4132       CLSID clsid;
4133
4134       if (SUCCEEDED(IUnknown_GetClassID(lpUnk, &clsid)) &&
4135           IsEqualGUID(pclsid, &clsid))
4136         bRet = TRUE;
4137
4138       IUnknown_Release(lpUnk);
4139     }
4140   }
4141   return bRet;
4142 }
4143
4144 /***********************************************************************
4145  *              SHGetShellKey (SHLWAPI.@)
4146  */
4147 DWORD WINAPI SHGetShellKey(DWORD a, DWORD b, DWORD c)
4148 {
4149     FIXME("(%x, %x, %x): stub\n", a, b, c);
4150     return 0x50;
4151 }
4152
4153 /***********************************************************************
4154  *              SHQueueUserWorkItem (SHLWAPI.@)
4155  */
4156 BOOL WINAPI SHQueueUserWorkItem(LPTHREAD_START_ROUTINE pfnCallback,
4157         LPVOID pContext, LONG lPriority, DWORD_PTR dwTag,
4158         DWORD_PTR *pdwId, LPCSTR pszModule, DWORD dwFlags)
4159 {
4160     TRACE("(%p, %p, %d, %lx, %p, %s, %08x)\n", pfnCallback, pContext,
4161           lPriority, dwTag, pdwId, debugstr_a(pszModule), dwFlags);
4162
4163     if(lPriority || dwTag || pdwId || pszModule || dwFlags)
4164         FIXME("Unsupported arguments\n");
4165
4166     return QueueUserWorkItem(pfnCallback, pContext, 0);
4167 }
4168
4169 /***********************************************************************
4170  *              SHSetTimerQueueTimer (SHLWAPI.263)
4171  */
4172 HANDLE WINAPI SHSetTimerQueueTimer(HANDLE hQueue,
4173         WAITORTIMERCALLBACK pfnCallback, LPVOID pContext, DWORD dwDueTime,
4174         DWORD dwPeriod, LPCSTR lpszLibrary, DWORD dwFlags)
4175 {
4176     HANDLE hNewTimer;
4177
4178     /* SHSetTimerQueueTimer flags -> CreateTimerQueueTimer flags */
4179     if (dwFlags & TPS_LONGEXECTIME) {
4180         dwFlags &= ~TPS_LONGEXECTIME;
4181         dwFlags |= WT_EXECUTELONGFUNCTION;
4182     }
4183     if (dwFlags & TPS_EXECUTEIO) {
4184         dwFlags &= ~TPS_EXECUTEIO;
4185         dwFlags |= WT_EXECUTEINIOTHREAD;
4186     }
4187
4188     if (!CreateTimerQueueTimer(&hNewTimer, hQueue, pfnCallback, pContext,
4189                                dwDueTime, dwPeriod, dwFlags))
4190         return NULL;
4191
4192     return hNewTimer;
4193 }
4194
4195 /***********************************************************************
4196  *              IUnknown_OnFocusChangeIS (SHLWAPI.@)
4197  */
4198 HRESULT WINAPI IUnknown_OnFocusChangeIS(LPUNKNOWN lpUnknown, LPUNKNOWN pFocusObject, BOOL bFocus)
4199 {
4200     IInputObjectSite *pIOS = NULL;
4201     HRESULT hRet = E_INVALIDARG;
4202
4203     TRACE("(%p, %p, %s)\n", lpUnknown, pFocusObject, bFocus ? "TRUE" : "FALSE");
4204
4205     if (lpUnknown)
4206     {
4207         hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObjectSite,
4208                                        (void **)&pIOS);
4209         if (SUCCEEDED(hRet) && pIOS)
4210         {
4211             hRet = IInputObjectSite_OnFocusChangeIS(pIOS, pFocusObject, bFocus);
4212             IInputObjectSite_Release(pIOS);
4213         }
4214     }
4215     return hRet;
4216 }
4217
4218 /***********************************************************************
4219  *              SHGetValueW (SHLWAPI.@)
4220  */
4221 HRESULT WINAPI SKGetValueW(DWORD a, LPWSTR b, LPWSTR c, DWORD d, DWORD e, DWORD f)
4222 {
4223     FIXME("(%x, %s, %s, %x, %x, %x): stub\n", a, debugstr_w(b), debugstr_w(c), d, e, f);
4224     return E_FAIL;
4225 }
4226
4227 typedef HRESULT (WINAPI *DllGetVersion_func)(DLLVERSIONINFO *);
4228
4229 /***********************************************************************
4230  *              GetUIVersion (SHLWAPI.452)
4231  */
4232 DWORD WINAPI GetUIVersion(void)
4233 {
4234     static DWORD version;
4235
4236     if (!version)
4237     {
4238         DllGetVersion_func pDllGetVersion;
4239         HMODULE dll = LoadLibraryA("shell32.dll");
4240         if (!dll) return 0;
4241
4242         pDllGetVersion = (DllGetVersion_func)GetProcAddress(dll, "DllGetVersion");
4243         if (pDllGetVersion)
4244         {
4245             DLLVERSIONINFO dvi;
4246             dvi.cbSize = sizeof(DLLVERSIONINFO);
4247             if (pDllGetVersion(&dvi) == S_OK) version = dvi.dwMajorVersion;
4248         }
4249         FreeLibrary( dll );
4250         if (!version) version = 3;  /* old shell dlls don't have DllGetVersion */
4251     }
4252     return version;
4253 }
4254
4255 /***********************************************************************
4256  *              ShellMessageBoxWrapW [SHLWAPI.388]
4257  *
4258  * See shell32.ShellMessageBoxW
4259  *
4260  * NOTE:
4261  * shlwapi.ShellMessageBoxWrapW is a duplicate of shell32.ShellMessageBoxW
4262  * because we can't forward to it in the .spec file since it's exported by
4263  * ordinal. If you change the implementation here please update the code in
4264  * shell32 as well.
4265  */
4266 INT WINAPIV ShellMessageBoxWrapW(HINSTANCE hInstance, HWND hWnd, LPCWSTR lpText,
4267                                  LPCWSTR lpCaption, UINT uType, ...)
4268 {
4269     WCHAR szText[100], szTitle[100];
4270     LPCWSTR pszText = szText, pszTitle = szTitle;
4271     LPWSTR pszTemp;
4272     va_list args;
4273     int ret;
4274
4275     va_start(args, uType);
4276
4277     TRACE("(%p,%p,%p,%p,%08x)\n", hInstance, hWnd, lpText, lpCaption, uType);
4278
4279     if (IS_INTRESOURCE(lpCaption))
4280         LoadStringW(hInstance, LOWORD(lpCaption), szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
4281     else
4282         pszTitle = lpCaption;
4283
4284     if (IS_INTRESOURCE(lpText))
4285         LoadStringW(hInstance, LOWORD(lpText), szText, sizeof(szText)/sizeof(szText[0]));
4286     else
4287         pszText = lpText;
4288
4289     FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
4290                    pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
4291
4292     va_end(args);
4293
4294     ret = MessageBoxW(hWnd, pszTemp, pszTitle, uType);
4295     LocalFree((HLOCAL)pszTemp);
4296     return ret;
4297 }
4298
4299 HRESULT WINAPI IUnknown_QueryServiceExec(IUnknown *unk, REFIID service, REFIID clsid,
4300                                          DWORD x1, DWORD x2, DWORD x3, void **ppvOut)
4301 {
4302     FIXME("%p %s %s %08x %08x %08x %p\n", unk,
4303           debugstr_guid(service), debugstr_guid(clsid), x1, x2, x3, ppvOut);
4304     return E_NOTIMPL;
4305 }
4306
4307 HRESULT WINAPI IUnknown_ProfferService(IUnknown *unk, void *x0, void *x1, void *x2)
4308 {
4309     FIXME("%p %p %p %p\n", unk, x0, x1, x2);
4310     return E_NOTIMPL;
4311 }
4312
4313 /***********************************************************************
4314  *              ZoneComputePaneSize [SHLWAPI.382]
4315  */
4316 UINT WINAPI ZoneComputePaneSize(HWND hwnd)
4317 {
4318     FIXME("\n");
4319     return 0x95;
4320 }
4321
4322 /***********************************************************************
4323  *              SHChangeNotifyWrap [SHLWAPI.394]
4324  */
4325 void WINAPI SHChangeNotifyWrap(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
4326 {
4327     SHChangeNotify(wEventId, uFlags, dwItem1, dwItem2);
4328 }
4329
4330 typedef struct SHELL_USER_SID {   /* according to MSDN this should be in shlobj.h... */
4331     SID_IDENTIFIER_AUTHORITY sidAuthority;
4332     DWORD                    dwUserGroupID;
4333     DWORD                    dwUserID;
4334 } SHELL_USER_SID, *PSHELL_USER_SID;
4335
4336 typedef struct SHELL_USER_PERMISSION { /* ...and this should be in shlwapi.h */
4337     SHELL_USER_SID susID;
4338     DWORD          dwAccessType;
4339     BOOL           fInherit;
4340     DWORD          dwAccessMask;
4341     DWORD          dwInheritMask;
4342     DWORD          dwInheritAccessMask;
4343 } SHELL_USER_PERMISSION, *PSHELL_USER_PERMISSION;
4344
4345 /***********************************************************************
4346  *             GetShellSecurityDescriptor [SHLWAPI.475]
4347  *
4348  * prepares SECURITY_DESCRIPTOR from a set of ACEs
4349  *
4350  * PARAMS
4351  *  apUserPerm [I] array of pointers to SHELL_USER_PERMISSION structures,
4352  *                 each of which describes permissions to apply
4353  *  cUserPerm  [I] number of entries in apUserPerm array
4354  *
4355  * RETURNS
4356  *  success: pointer to SECURITY_DESCRIPTOR
4357  *  failure: NULL
4358  *
4359  * NOTES
4360  *  Call should free returned descriptor with LocalFree
4361  */
4362 PSECURITY_DESCRIPTOR WINAPI GetShellSecurityDescriptor(PSHELL_USER_PERMISSION *apUserPerm, int cUserPerm)
4363 {
4364     PSID *sidlist;
4365     PSID  cur_user = NULL;
4366     BYTE  tuUser[2000];
4367     DWORD acl_size;
4368     int   sid_count, i;
4369     PSECURITY_DESCRIPTOR psd = NULL;
4370
4371     TRACE("%p %d\n", apUserPerm, cUserPerm);
4372
4373     if (apUserPerm == NULL || cUserPerm <= 0)
4374         return NULL;
4375
4376     sidlist = HeapAlloc(GetProcessHeap(), 0, cUserPerm * sizeof(PSID));
4377     if (!sidlist)
4378         return NULL;
4379
4380     acl_size = sizeof(ACL);
4381
4382     for(sid_count = 0; sid_count < cUserPerm; sid_count++)
4383     {
4384         static SHELL_USER_SID null_sid = {{SECURITY_NULL_SID_AUTHORITY}, 0, 0};
4385         PSHELL_USER_PERMISSION perm = apUserPerm[sid_count];
4386         PSHELL_USER_SID sid = &perm->susID;
4387         PSID pSid;
4388         BOOL ret = TRUE;
4389
4390         if (!memcmp((void*)sid, (void*)&null_sid, sizeof(SHELL_USER_SID)))
4391         {  /* current user's SID */
4392             if (!cur_user)
4393             {
4394                 HANDLE Token;
4395                 DWORD bufsize = sizeof(tuUser);
4396
4397                 ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &Token);
4398                 if (ret)
4399                 {
4400                     ret = GetTokenInformation(Token, TokenUser, (void*)tuUser, bufsize, &bufsize );
4401                     if (ret)
4402                         cur_user = ((PTOKEN_USER)&tuUser)->User.Sid;
4403                     CloseHandle(Token);
4404                 }
4405             }
4406             pSid = cur_user;
4407         } else if (sid->dwUserID==0) /* one sub-authority */
4408             ret = AllocateAndInitializeSid(&sid->sidAuthority, 1, sid->dwUserGroupID, 0,
4409                     0, 0, 0, 0, 0, 0, &pSid);
4410         else
4411             ret = AllocateAndInitializeSid(&sid->sidAuthority, 2, sid->dwUserGroupID, sid->dwUserID,
4412                     0, 0, 0, 0, 0, 0, &pSid);
4413         if (!ret)
4414             goto free_sids;
4415
4416         sidlist[sid_count] = pSid;
4417         /* increment acl_size (1 ACE for non-inheritable and 2 ACEs for inheritable records */
4418         acl_size += (sizeof(ACCESS_ALLOWED_ACE)-sizeof(DWORD) + GetLengthSid(pSid)) * (perm->fInherit ? 2 : 1);
4419     }
4420
4421     psd = LocalAlloc(0, sizeof(SECURITY_DESCRIPTOR) + acl_size);
4422
4423     if (psd != NULL)
4424     {
4425         PACL pAcl = (PACL)(((BYTE*)psd)+sizeof(SECURITY_DESCRIPTOR));
4426
4427         if (!InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION))
4428             goto error;
4429
4430         if (!InitializeAcl(pAcl, acl_size, ACL_REVISION))
4431             goto error;
4432
4433         for(i = 0; i < sid_count; i++)
4434         {
4435             PSHELL_USER_PERMISSION sup = apUserPerm[i];
4436             PSID sid = sidlist[i];
4437
4438             switch(sup->dwAccessType)
4439             {
4440                 case ACCESS_ALLOWED_ACE_TYPE:
4441                     if (!AddAccessAllowedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
4442                         goto error;
4443                     if (sup->fInherit && !AddAccessAllowedAceEx(pAcl, ACL_REVISION,
4444                                 (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
4445                         goto error;
4446                     break;
4447                 case ACCESS_DENIED_ACE_TYPE:
4448                     if (!AddAccessDeniedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
4449                         goto error;
4450                     if (sup->fInherit && !AddAccessDeniedAceEx(pAcl, ACL_REVISION,
4451                                 (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
4452                         goto error;
4453                     break;
4454                 default:
4455                     goto error;
4456             }
4457         }
4458
4459         if (!SetSecurityDescriptorDacl(psd, TRUE, pAcl, FALSE))
4460             goto error;
4461     }
4462     goto free_sids;
4463
4464 error:
4465     LocalFree(psd);
4466     psd = NULL;
4467 free_sids:
4468     for(i = 0; i < sid_count; i++)
4469     {
4470         if (!cur_user || sidlist[i] != cur_user)
4471             FreeSid(sidlist[i]);
4472     }
4473     HeapFree(GetProcessHeap(), 0, sidlist);
4474
4475     return psd;
4476 }