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