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, &lpUnknown1)))
1254     return FALSE;
1255
1256   if (FAILED(IUnknown_QueryInterface(lpInt2, &IID_IUnknown, &lpUnknown2)))
1257     return FALSE;
1258
1259   if (lpUnknown1 == lpUnknown2)
1260     return TRUE;
1261
1262   return FALSE;
1263 }
1264
1265 /*************************************************************************
1266  *      @       [SHLWAPI.172]
1267  *
1268  * Get the window handle of an object.
1269  *
1270  * PARAMS
1271  *  lpUnknown [I] Object to get the window handle of
1272  *  lphWnd    [O] Destination for window handle
1273  *
1274  * RETURNS
1275  *  Success: S_OK. lphWnd contains the objects window handle.
1276  *  Failure: An HRESULT error code.
1277  *
1278  * NOTES
1279  *  lpUnknown is expected to support one of the following interfaces:
1280  *  IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1281  */
1282 HRESULT WINAPI IUnknown_GetWindow(IUnknown *lpUnknown, HWND *lphWnd)
1283 {
1284   IUnknown *lpOle;
1285   HRESULT hRet = E_FAIL;
1286
1287   TRACE("(%p,%p)\n", lpUnknown, lphWnd);
1288
1289   if (!lpUnknown)
1290     return hRet;
1291
1292   hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleWindow, (void**)&lpOle);
1293
1294   if (FAILED(hRet))
1295   {
1296     hRet = IUnknown_QueryInterface(lpUnknown,&IID_IShellView, (void**)&lpOle);
1297
1298     if (FAILED(hRet))
1299     {
1300       hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInternetSecurityMgrSite,
1301                                       (void**)&lpOle);
1302     }
1303   }
1304
1305   if (SUCCEEDED(hRet))
1306   {
1307     /* Lazyness here - Since GetWindow() is the first method for the above 3
1308      * interfaces, we use the same call for them all.
1309      */
1310     hRet = IOleWindow_GetWindow((IOleWindow*)lpOle, lphWnd);
1311     IUnknown_Release(lpOle);
1312     if (lphWnd)
1313       TRACE("Returning HWND=%p\n", *lphWnd);
1314   }
1315
1316   return hRet;
1317 }
1318
1319 /*************************************************************************
1320  *      @       [SHLWAPI.173]
1321  *
1322  * Call a method on as as yet unidentified object.
1323  *
1324  * PARAMS
1325  *  pUnk [I] Object supporting the unidentified interface,
1326  *  arg  [I] Argument for the call on the object.
1327  *
1328  * RETURNS
1329  *  S_OK.
1330  */
1331 HRESULT WINAPI IUnknown_SetOwner(IUnknown *pUnk, ULONG arg)
1332 {
1333   static const GUID guid_173 = {
1334     0x5836fb00, 0x8187, 0x11cf, { 0xa1,0x2b,0x00,0xaa,0x00,0x4a,0xe8,0x37 }
1335   };
1336   IMalloc *pUnk2;
1337
1338   TRACE("(%p,%d)\n", pUnk, arg);
1339
1340   /* Note: arg may not be a ULONG and pUnk2 is for sure not an IMalloc -
1341    *       We use this interface as its vtable entry is compatible with the
1342    *       object in question.
1343    * FIXME: Find out what this object is and where it should be defined.
1344    */
1345   if (pUnk &&
1346       SUCCEEDED(IUnknown_QueryInterface(pUnk, &guid_173, (void**)&pUnk2)))
1347   {
1348     IMalloc_Alloc(pUnk2, arg); /* Faked call!! */
1349     IMalloc_Release(pUnk2);
1350   }
1351   return S_OK;
1352 }
1353
1354 /*************************************************************************
1355  *      @       [SHLWAPI.174]
1356  *
1357  * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
1358  * an object.
1359  *
1360  */
1361 HRESULT WINAPI IUnknown_SetSite(
1362         IUnknown *obj,        /* [in]   OLE object     */
1363         IUnknown *site)       /* [in]   Site interface */
1364 {
1365     HRESULT hr;
1366     IObjectWithSite *iobjwithsite;
1367     IInternetSecurityManager *isecmgr;
1368
1369     if (!obj) return E_FAIL;
1370
1371     hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (LPVOID *)&iobjwithsite);
1372     TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr, iobjwithsite);
1373     if (SUCCEEDED(hr))
1374     {
1375         hr = IObjectWithSite_SetSite(iobjwithsite, site);
1376         TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr);
1377         IUnknown_Release(iobjwithsite);
1378     }
1379     else
1380     {
1381         hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (LPVOID *)&isecmgr);
1382         TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr, isecmgr);
1383         if (FAILED(hr)) return hr;
1384
1385         hr = IInternetSecurityManager_SetSecuritySite(isecmgr, (IInternetSecurityMgrSite *)site);
1386         TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr);
1387         IUnknown_Release(isecmgr);
1388     }
1389     return hr;
1390 }
1391
1392 /*************************************************************************
1393  *      @       [SHLWAPI.175]
1394  *
1395  * Call IPersist_GetClassID() on an object.
1396  *
1397  * PARAMS
1398  *  lpUnknown [I] Object supporting the IPersist interface
1399  *  lpClassId [O] Destination for Class Id
1400  *
1401  * RETURNS
1402  *  Success: S_OK. lpClassId contains the Class Id requested.
1403  *  Failure: E_FAIL, If lpUnknown is NULL,
1404  *           E_NOINTERFACE If lpUnknown does not support IPersist,
1405  *           Or an HRESULT error code.
1406  */
1407 HRESULT WINAPI IUnknown_GetClassID(IUnknown *lpUnknown, CLSID* lpClassId)
1408 {
1409   IPersist* lpPersist;
1410   HRESULT hRet = E_FAIL;
1411
1412   TRACE("(%p,%p)\n", lpUnknown, debugstr_guid(lpClassId));
1413
1414   if (lpUnknown)
1415   {
1416     hRet = IUnknown_QueryInterface(lpUnknown,&IID_IPersist,(void**)&lpPersist);
1417     if (SUCCEEDED(hRet))
1418     {
1419       IPersist_GetClassID(lpPersist, lpClassId);
1420       IPersist_Release(lpPersist);
1421     }
1422   }
1423   return hRet;
1424 }
1425
1426 /*************************************************************************
1427  *      @       [SHLWAPI.176]
1428  *
1429  * Retrieve a Service Interface from an object.
1430  *
1431  * PARAMS
1432  *  lpUnknown [I] Object to get an IServiceProvider interface from
1433  *  sid       [I] Service ID for IServiceProvider_QueryService() call
1434  *  riid      [I] Function requested for QueryService call
1435  *  lppOut    [O] Destination for the service interface pointer
1436  *
1437  * RETURNS
1438  *  Success: S_OK. lppOut contains an object providing the requested service
1439  *  Failure: An HRESULT error code
1440  *
1441  * NOTES
1442  *  lpUnknown is expected to support the IServiceProvider interface.
1443  */
1444 HRESULT WINAPI IUnknown_QueryService(IUnknown* lpUnknown, REFGUID sid, REFIID riid,
1445                            LPVOID *lppOut)
1446 {
1447   IServiceProvider* pService = NULL;
1448   HRESULT hRet;
1449
1450   if (!lppOut)
1451     return E_FAIL;
1452
1453   *lppOut = NULL;
1454
1455   if (!lpUnknown)
1456     return E_FAIL;
1457
1458   /* Get an IServiceProvider interface from the object */
1459   hRet = IUnknown_QueryInterface(lpUnknown, &IID_IServiceProvider,
1460                                  (LPVOID*)&pService);
1461
1462   if (hRet == S_OK && pService)
1463   {
1464     TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService);
1465
1466     /* Get a Service interface from the object */
1467     hRet = IServiceProvider_QueryService(pService, sid, riid, lppOut);
1468
1469     TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService, *lppOut);
1470
1471     /* Release the IServiceProvider interface */
1472     IUnknown_Release(pService);
1473   }
1474   return hRet;
1475 }
1476
1477 /*************************************************************************
1478  *      @       [SHLWAPI.177]
1479  *
1480  * Loads a popup menu.
1481  *
1482  * PARAMS
1483  *  hInst  [I] Instance handle
1484  *  szName [I] Menu name
1485  *
1486  * RETURNS
1487  *  Success: TRUE.
1488  *  Failure: FALSE.
1489  */
1490 BOOL WINAPI SHLoadMenuPopup(HINSTANCE hInst, LPCWSTR szName)
1491 {
1492   HMENU hMenu;
1493
1494   if ((hMenu = LoadMenuW(hInst, szName)))
1495   {
1496     if (GetSubMenu(hMenu, 0))
1497       RemoveMenu(hMenu, 0, MF_BYPOSITION);
1498
1499     DestroyMenu(hMenu);
1500     return TRUE;
1501   }
1502   return FALSE;
1503 }
1504
1505 typedef struct _enumWndData
1506 {
1507   UINT   uiMsgId;
1508   WPARAM wParam;
1509   LPARAM lParam;
1510   LRESULT (WINAPI *pfnPost)(HWND,UINT,WPARAM,LPARAM);
1511 } enumWndData;
1512
1513 /* Callback for SHLWAPI_178 */
1514 static BOOL CALLBACK SHLWAPI_EnumChildProc(HWND hWnd, LPARAM lParam)
1515 {
1516   enumWndData *data = (enumWndData *)lParam;
1517
1518   TRACE("(%p,%p)\n", hWnd, data);
1519   data->pfnPost(hWnd, data->uiMsgId, data->wParam, data->lParam);
1520   return TRUE;
1521 }
1522
1523 /*************************************************************************
1524  * @  [SHLWAPI.178]
1525  *
1526  * Send or post a message to every child of a window.
1527  *
1528  * PARAMS
1529  *  hWnd    [I] Window whose children will get the messages
1530  *  uiMsgId [I] Message Id
1531  *  wParam  [I] WPARAM of message
1532  *  lParam  [I] LPARAM of message
1533  *  bSend   [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1534  *
1535  * RETURNS
1536  *  Nothing.
1537  *
1538  * NOTES
1539  *  The appropriate ASCII or Unicode function is called for the window.
1540  */
1541 void WINAPI SHPropagateMessage(HWND hWnd, UINT uiMsgId, WPARAM wParam, LPARAM lParam, BOOL bSend)
1542 {
1543   enumWndData data;
1544
1545   TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd, uiMsgId, wParam, lParam, bSend);
1546
1547   if(hWnd)
1548   {
1549     data.uiMsgId = uiMsgId;
1550     data.wParam  = wParam;
1551     data.lParam  = lParam;
1552
1553     if (bSend)
1554       data.pfnPost = IsWindowUnicode(hWnd) ? (void*)SendMessageW : (void*)SendMessageA;
1555     else
1556       data.pfnPost = IsWindowUnicode(hWnd) ? (void*)PostMessageW : (void*)PostMessageA;
1557
1558     EnumChildWindows(hWnd, SHLWAPI_EnumChildProc, (LPARAM)&data);
1559   }
1560 }
1561
1562 /*************************************************************************
1563  *      @       [SHLWAPI.180]
1564  *
1565  * Remove all sub-menus from a menu.
1566  *
1567  * PARAMS
1568  *  hMenu [I] Menu to remove sub-menus from
1569  *
1570  * RETURNS
1571  *  Success: 0.  All sub-menus under hMenu are removed
1572  *  Failure: -1, if any parameter is invalid
1573  */
1574 DWORD WINAPI SHRemoveAllSubMenus(HMENU hMenu)
1575 {
1576   int iItemCount = GetMenuItemCount(hMenu) - 1;
1577   while (iItemCount >= 0)
1578   {
1579     HMENU hSubMenu = GetSubMenu(hMenu, iItemCount);
1580     if (hSubMenu)
1581       RemoveMenu(hMenu, iItemCount, MF_BYPOSITION);
1582     iItemCount--;
1583   }
1584   return iItemCount;
1585 }
1586
1587 /*************************************************************************
1588  *      @       [SHLWAPI.181]
1589  *
1590  * Enable or disable a menu item.
1591  *
1592  * PARAMS
1593  *  hMenu   [I] Menu holding menu item
1594  *  uID     [I] ID of menu item to enable/disable
1595  *  bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1596  *
1597  * RETURNS
1598  *  The return code from EnableMenuItem.
1599  */
1600 UINT WINAPI SHEnableMenuItem(HMENU hMenu, UINT wItemID, BOOL bEnable)
1601 {
1602   return EnableMenuItem(hMenu, wItemID, bEnable ? MF_ENABLED : MF_GRAYED);
1603 }
1604
1605 /*************************************************************************
1606  * @    [SHLWAPI.182]
1607  *
1608  * Check or uncheck a menu item.
1609  *
1610  * PARAMS
1611  *  hMenu  [I] Menu holding menu item
1612  *  uID    [I] ID of menu item to check/uncheck
1613  *  bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1614  *
1615  * RETURNS
1616  *  The return code from CheckMenuItem.
1617  */
1618 DWORD WINAPI SHCheckMenuItem(HMENU hMenu, UINT uID, BOOL bCheck)
1619 {
1620   return CheckMenuItem(hMenu, uID, bCheck ? MF_CHECKED : MF_UNCHECKED);
1621 }
1622
1623 /*************************************************************************
1624  *      @       [SHLWAPI.183]
1625  *
1626  * Register a window class if it isn't already.
1627  *
1628  * PARAMS
1629  *  lpWndClass [I] Window class to register
1630  *
1631  * RETURNS
1632  *  The result of the RegisterClassA call.
1633  */
1634 DWORD WINAPI SHRegisterClassA(WNDCLASSA *wndclass)
1635 {
1636   WNDCLASSA wca;
1637   if (GetClassInfoA(wndclass->hInstance, wndclass->lpszClassName, &wca))
1638     return TRUE;
1639   return (DWORD)RegisterClassA(wndclass);
1640 }
1641
1642 /*************************************************************************
1643  *      @       [SHLWAPI.186]
1644  */
1645 BOOL WINAPI SHSimulateDrop(IDropTarget *pDrop, IDataObject *pDataObj,
1646                            DWORD grfKeyState, PPOINTL lpPt, DWORD* pdwEffect)
1647 {
1648   DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
1649   POINTL pt = { 0, 0 };
1650
1651   if (!lpPt)
1652     lpPt = &pt;
1653
1654   if (!pdwEffect)
1655     pdwEffect = &dwEffect;
1656
1657   IDropTarget_DragEnter(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1658
1659   if (*pdwEffect)
1660     return IDropTarget_Drop(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1661
1662   IDropTarget_DragLeave(pDrop);
1663   return TRUE;
1664 }
1665
1666 /*************************************************************************
1667  *      @       [SHLWAPI.187]
1668  *
1669  * Call IPersistPropertyBag_Load() on an object.
1670  *
1671  * PARAMS
1672  *  lpUnknown [I] Object supporting the IPersistPropertyBag interface
1673  *  lpPropBag [O] Destination for loaded IPropertyBag
1674  *
1675  * RETURNS
1676  *  Success: S_OK.
1677  *  Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1678  */
1679 DWORD WINAPI SHLoadFromPropertyBag(IUnknown *lpUnknown, IPropertyBag* lpPropBag)
1680 {
1681   IPersistPropertyBag* lpPPBag;
1682   HRESULT hRet = E_FAIL;
1683
1684   TRACE("(%p,%p)\n", lpUnknown, lpPropBag);
1685
1686   if (lpUnknown)
1687   {
1688     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IPersistPropertyBag,
1689                                    (void**)&lpPPBag);
1690     if (SUCCEEDED(hRet) && lpPPBag)
1691     {
1692       hRet = IPersistPropertyBag_Load(lpPPBag, lpPropBag, NULL);
1693       IPersistPropertyBag_Release(lpPPBag);
1694     }
1695   }
1696   return hRet;
1697 }
1698
1699 /*************************************************************************
1700  * @  [SHLWAPI.188]
1701  *
1702  * Call IOleControlSite_TranslateAccelerator()  on an object.
1703  *
1704  * PARAMS
1705  *  lpUnknown   [I] Object supporting the IOleControlSite interface.
1706  *  lpMsg       [I] Key message to be processed.
1707  *  dwModifiers [I] Flags containing the state of the modifier keys.
1708  *
1709  * RETURNS
1710  *  Success: S_OK.
1711  *  Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
1712  */
1713 HRESULT WINAPI IUnknown_TranslateAcceleratorOCS(IUnknown *lpUnknown, LPMSG lpMsg, DWORD dwModifiers)
1714 {
1715   IOleControlSite* lpCSite = NULL;
1716   HRESULT hRet = E_INVALIDARG;
1717
1718   TRACE("(%p,%p,0x%08x)\n", lpUnknown, lpMsg, dwModifiers);
1719   if (lpUnknown)
1720   {
1721     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1722                                    (void**)&lpCSite);
1723     if (SUCCEEDED(hRet) && lpCSite)
1724     {
1725       hRet = IOleControlSite_TranslateAccelerator(lpCSite, lpMsg, dwModifiers);
1726       IOleControlSite_Release(lpCSite);
1727     }
1728   }
1729   return hRet;
1730 }
1731
1732
1733 /*************************************************************************
1734  * @  [SHLWAPI.189]
1735  *
1736  * Call IOleControlSite_OnFocus() on an object.
1737  *
1738  * PARAMS
1739  *  lpUnknown [I] Object supporting the IOleControlSite interface.
1740  *  fGotFocus [I] Whether focus was gained (TRUE) or lost (FALSE).
1741  *
1742  * RETURNS
1743  *  Success: S_OK.
1744  *  Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1745  */
1746 HRESULT WINAPI IUnknown_OnFocusOCS(IUnknown *lpUnknown, BOOL fGotFocus)
1747 {
1748   IOleControlSite* lpCSite = NULL;
1749   HRESULT hRet = E_FAIL;
1750
1751   TRACE("(%p,%s)\n", lpUnknown, fGotFocus ? "TRUE" : "FALSE");
1752   if (lpUnknown)
1753   {
1754     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1755                                    (void**)&lpCSite);
1756     if (SUCCEEDED(hRet) && lpCSite)
1757     {
1758       hRet = IOleControlSite_OnFocus(lpCSite, fGotFocus);
1759       IOleControlSite_Release(lpCSite);
1760     }
1761   }
1762   return hRet;
1763 }
1764
1765 /*************************************************************************
1766  * @    [SHLWAPI.190]
1767  */
1768 HRESULT WINAPI IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown, PVOID lpArg1,
1769                                         PVOID lpArg2, PVOID lpArg3, PVOID lpArg4)
1770 {
1771   /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
1772   static const DWORD service_id[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1773   /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
1774   static const DWORD function_id[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1775   HRESULT hRet = E_INVALIDARG;
1776   LPUNKNOWN lpUnkInner = NULL; /* FIXME: Real type is unknown */
1777
1778   TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown, lpArg1, lpArg2, lpArg3, lpArg4);
1779
1780   if (lpUnknown && lpArg4)
1781   {
1782      hRet = IUnknown_QueryService(lpUnknown, (REFGUID)service_id,
1783                                   (REFGUID)function_id, (void**)&lpUnkInner);
1784
1785      if (SUCCEEDED(hRet) && lpUnkInner)
1786      {
1787        /* FIXME: The type of service object requested is unknown, however
1788         * testing shows that its first method is called with 4 parameters.
1789         * Fake this by using IParseDisplayName_ParseDisplayName since the
1790         * signature and position in the vtable matches our unknown object type.
1791         */
1792        hRet = IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME)lpUnkInner,
1793                                                  lpArg1, lpArg2, lpArg3, lpArg4);
1794        IUnknown_Release(lpUnkInner);
1795      }
1796   }
1797   return hRet;
1798 }
1799
1800 /*************************************************************************
1801  * @    [SHLWAPI.192]
1802  *
1803  * Get a sub-menu from a menu item.
1804  *
1805  * PARAMS
1806  *  hMenu [I] Menu to get sub-menu from
1807  *  uID   [I] ID of menu item containing sub-menu
1808  *
1809  * RETURNS
1810  *  The sub-menu of the item, or a NULL handle if any parameters are invalid.
1811  */
1812 HMENU WINAPI SHGetMenuFromID(HMENU hMenu, UINT uID)
1813 {
1814   MENUITEMINFOW mi;
1815
1816   TRACE("(%p,%u)\n", hMenu, uID);
1817
1818   mi.cbSize = sizeof(mi);
1819   mi.fMask = MIIM_SUBMENU;
1820
1821   if (!GetMenuItemInfoW(hMenu, uID, FALSE, &mi))
1822     return NULL;
1823
1824   return mi.hSubMenu;
1825 }
1826
1827 /*************************************************************************
1828  *      @       [SHLWAPI.193]
1829  *
1830  * Get the color depth of the primary display.
1831  *
1832  * PARAMS
1833  *  None.
1834  *
1835  * RETURNS
1836  *  The color depth of the primary display.
1837  */
1838 DWORD WINAPI SHGetCurColorRes(void)
1839 {
1840     HDC hdc;
1841     DWORD ret;
1842
1843     TRACE("()\n");
1844
1845     hdc = GetDC(0);
1846     ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
1847     ReleaseDC(0, hdc);
1848     return ret;
1849 }
1850
1851 /*************************************************************************
1852  *      @       [SHLWAPI.194]
1853  *
1854  * Wait for a message to arrive, with a timeout.
1855  *
1856  * PARAMS
1857  *  hand      [I] Handle to query
1858  *  dwTimeout [I] Timeout in ticks or INFINITE to never timeout
1859  *
1860  * RETURNS
1861  *  STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
1862  *  Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
1863  *  message is available.
1864  */
1865 DWORD WINAPI SHWaitForSendMessageThread(HANDLE hand, DWORD dwTimeout)
1866 {
1867   DWORD dwEndTicks = GetTickCount() + dwTimeout;
1868   DWORD dwRet;
1869
1870   while ((dwRet = MsgWaitForMultipleObjectsEx(1, &hand, dwTimeout, QS_SENDMESSAGE, 0)) == 1)
1871   {
1872     MSG msg;
1873
1874     PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
1875
1876     if (dwTimeout != INFINITE)
1877     {
1878         if ((int)(dwTimeout = dwEndTicks - GetTickCount()) <= 0)
1879             return WAIT_TIMEOUT;
1880     }
1881   }
1882
1883   return dwRet;
1884 }
1885
1886 /*************************************************************************
1887  *      @       [SHLWAPI.195]
1888  *
1889  * Determine if a shell folder can be expanded.
1890  *
1891  * PARAMS
1892  *  lpFolder [I] Parent folder containing the object to test.
1893  *  pidl     [I] Id of the object to test.
1894  *
1895  * RETURNS
1896  *  Success: S_OK, if the object is expandable, S_FALSE otherwise.
1897  *  Failure: E_INVALIDARG, if any argument is invalid.
1898  *
1899  * NOTES
1900  *  If the object to be tested does not expose the IQueryInfo() interface it
1901  *  will not be identified as an expandable folder.
1902  */
1903 HRESULT WINAPI SHIsExpandableFolder(LPSHELLFOLDER lpFolder, LPCITEMIDLIST pidl)
1904 {
1905   HRESULT hRet = E_INVALIDARG;
1906   IQueryInfo *lpInfo;
1907
1908   if (lpFolder && pidl)
1909   {
1910     hRet = IShellFolder_GetUIObjectOf(lpFolder, NULL, 1, &pidl, &IID_IQueryInfo,
1911                                       NULL, (void**)&lpInfo);
1912     if (FAILED(hRet))
1913       hRet = S_FALSE; /* Doesn't expose IQueryInfo */
1914     else
1915     {
1916       DWORD dwFlags = 0;
1917
1918       /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
1919        * currently used". Really? You wouldn't be holding out on me would you?
1920        */
1921       hRet = IQueryInfo_GetInfoFlags(lpInfo, &dwFlags);
1922
1923       if (SUCCEEDED(hRet))
1924       {
1925         /* 0x2 is an undocumented flag apparently indicating expandability */
1926         hRet = dwFlags & 0x2 ? S_OK : S_FALSE;
1927       }
1928
1929       IQueryInfo_Release(lpInfo);
1930     }
1931   }
1932   return hRet;
1933 }
1934
1935 /*************************************************************************
1936  *      @       [SHLWAPI.197]
1937  *
1938  * Blank out a region of text by drawing the background only.
1939  *
1940  * PARAMS
1941  *  hDC   [I] Device context to draw in
1942  *  pRect [I] Area to draw in
1943  *  cRef  [I] Color to draw in
1944  *
1945  * RETURNS
1946  *  Nothing.
1947  */
1948 DWORD WINAPI SHFillRectClr(HDC hDC, LPCRECT pRect, COLORREF cRef)
1949 {
1950     COLORREF cOldColor = SetBkColor(hDC, cRef);
1951     ExtTextOutA(hDC, 0, 0, ETO_OPAQUE, pRect, 0, 0, 0);
1952     SetBkColor(hDC, cOldColor);
1953     return 0;
1954 }
1955
1956 /*************************************************************************
1957  *      @       [SHLWAPI.198]
1958  *
1959  * Return the value associated with a key in a map.
1960  *
1961  * PARAMS
1962  *  lpKeys   [I] A list of keys of length iLen
1963  *  lpValues [I] A list of values associated with lpKeys, of length iLen
1964  *  iLen     [I] Length of both lpKeys and lpValues
1965  *  iKey     [I] The key value to look up in lpKeys
1966  *
1967  * RETURNS
1968  *  The value in lpValues associated with iKey, or -1 if iKey is not
1969  *  found in lpKeys.
1970  *
1971  * NOTES
1972  *  - If two elements in the map share the same key, this function returns
1973  *    the value closest to the start of the map
1974  *  - The native version of this function crashes if lpKeys or lpValues is NULL.
1975  */
1976 int WINAPI SHSearchMapInt(const int *lpKeys, const int *lpValues, int iLen, int iKey)
1977 {
1978   if (lpKeys && lpValues)
1979   {
1980     int i = 0;
1981
1982     while (i < iLen)
1983     {
1984       if (lpKeys[i] == iKey)
1985         return lpValues[i]; /* Found */
1986       i++;
1987     }
1988   }
1989   return -1; /* Not found */
1990 }
1991
1992
1993 /*************************************************************************
1994  *      @       [SHLWAPI.199]
1995  *
1996  * Copy an interface pointer
1997  *
1998  * PARAMS
1999  *   lppDest   [O] Destination for copy
2000  *   lpUnknown [I] Source for copy
2001  *
2002  * RETURNS
2003  *  Nothing.
2004  */
2005 VOID WINAPI IUnknown_Set(IUnknown **lppDest, IUnknown *lpUnknown)
2006 {
2007   TRACE("(%p,%p)\n", lppDest, lpUnknown);
2008
2009   if (lppDest)
2010     IUnknown_AtomicRelease(lppDest); /* Release existing interface */
2011
2012   if (lpUnknown)
2013   {
2014     /* Copy */
2015     IUnknown_AddRef(lpUnknown);
2016     *lppDest = lpUnknown;
2017   }
2018 }
2019
2020 /*************************************************************************
2021  *      @       [SHLWAPI.200]
2022  *
2023  */
2024 HRESULT WINAPI MayQSForward(IUnknown* lpUnknown, PVOID lpReserved,
2025                             REFGUID riidCmdGrp, ULONG cCmds,
2026                             OLECMD *prgCmds, OLECMDTEXT* pCmdText)
2027 {
2028   FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
2029         lpUnknown, lpReserved, riidCmdGrp, cCmds, prgCmds, pCmdText);
2030
2031   /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
2032   return DRAGDROP_E_NOTREGISTERED;
2033 }
2034
2035 /*************************************************************************
2036  *      @       [SHLWAPI.201]
2037  *
2038  */
2039 HRESULT WINAPI MayExecForward(IUnknown* lpUnknown, INT iUnk, REFGUID pguidCmdGroup,
2040                            DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
2041                            VARIANT* pvaOut)
2042 {
2043   FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown, iUnk, pguidCmdGroup,
2044         nCmdID, nCmdexecopt, pvaIn, pvaOut);
2045   return DRAGDROP_E_NOTREGISTERED;
2046 }
2047
2048 /*************************************************************************
2049  *      @       [SHLWAPI.202]
2050  *
2051  */
2052 HRESULT WINAPI IsQSForward(REFGUID pguidCmdGroup,ULONG cCmds, OLECMD *prgCmds)
2053 {
2054   FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup, cCmds, prgCmds);
2055   return DRAGDROP_E_NOTREGISTERED;
2056 }
2057
2058 /*************************************************************************
2059  * @    [SHLWAPI.204]
2060  *
2061  * Determine if a window is not a child of another window.
2062  *
2063  * PARAMS
2064  * hParent [I] Suspected parent window
2065  * hChild  [I] Suspected child window
2066  *
2067  * RETURNS
2068  * TRUE:  If hChild is a child window of hParent
2069  * FALSE: If hChild is not a child window of hParent, or they are equal
2070  */
2071 BOOL WINAPI SHIsChildOrSelf(HWND hParent, HWND hChild)
2072 {
2073   TRACE("(%p,%p)\n", hParent, hChild);
2074
2075   if (!hParent || !hChild)
2076     return TRUE;
2077   else if(hParent == hChild)
2078     return FALSE;
2079   return !IsChild(hParent, hChild);
2080 }
2081
2082 /*************************************************************************
2083  *    FDSA functions.  Manage a dynamic array of fixed size memory blocks.
2084  */
2085
2086 typedef struct
2087 {
2088     DWORD num_items;       /* Number of elements inserted */
2089     void *mem;             /* Ptr to array */
2090     DWORD blocks_alloced;  /* Number of elements allocated */
2091     BYTE inc;              /* Number of elements to grow by when we need to expand */
2092     BYTE block_size;       /* Size in bytes of an element */
2093     BYTE flags;            /* Flags */
2094 } FDSA_info;
2095
2096 #define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
2097
2098 /*************************************************************************
2099  *      @       [SHLWAPI.208]
2100  *
2101  * Initialize an FDSA array.
2102  */
2103 BOOL WINAPI FDSA_Initialize(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
2104                             DWORD init_blocks)
2105 {
2106     TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size, inc, info, mem, init_blocks);
2107
2108     if(inc == 0)
2109         inc = 1;
2110
2111     if(mem)
2112         memset(mem, 0, block_size * init_blocks);
2113
2114     info->num_items = 0;
2115     info->inc = inc;
2116     info->mem = mem;
2117     info->blocks_alloced = init_blocks;
2118     info->block_size = block_size;
2119     info->flags = 0;
2120
2121     return TRUE;
2122 }
2123
2124 /*************************************************************************
2125  *      @       [SHLWAPI.209]
2126  *
2127  * Destroy an FDSA array
2128  */
2129 BOOL WINAPI FDSA_Destroy(FDSA_info *info)
2130 {
2131     TRACE("(%p)\n", info);
2132
2133     if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
2134     {
2135         HeapFree(GetProcessHeap(), 0, info->mem);
2136         return FALSE;
2137     }
2138
2139     return TRUE;
2140 }
2141
2142 /*************************************************************************
2143  *      @       [SHLWAPI.210]
2144  *
2145  * Insert element into an FDSA array
2146  */
2147 DWORD WINAPI FDSA_InsertItem(FDSA_info *info, DWORD where, const void *block)
2148 {
2149     TRACE("(%p 0x%08x %p)\n", info, where, block);
2150     if(where > info->num_items)
2151         where = info->num_items;
2152
2153     if(info->num_items >= info->blocks_alloced)
2154     {
2155         DWORD size = (info->blocks_alloced + info->inc) * info->block_size;
2156         if(info->flags & 0x1)
2157             info->mem = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->mem, size);
2158         else
2159         {
2160             void *old_mem = info->mem;
2161             info->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2162             memcpy(info->mem, old_mem, info->blocks_alloced * info->block_size);
2163         }
2164         info->blocks_alloced += info->inc;
2165         info->flags |= 0x1;
2166     }
2167
2168     if(where < info->num_items)
2169     {
2170         memmove((char*)info->mem + (where + 1) * info->block_size,
2171                 (char*)info->mem + where * info->block_size,
2172                 (info->num_items - where) * info->block_size);
2173     }
2174     memcpy((char*)info->mem + where * info->block_size, block, info->block_size);
2175
2176     info->num_items++;
2177     return where;
2178 }
2179
2180 /*************************************************************************
2181  *      @       [SHLWAPI.211]
2182  *
2183  * Delete an element from an FDSA array.
2184  */
2185 BOOL WINAPI FDSA_DeleteItem(FDSA_info *info, DWORD where)
2186 {
2187     TRACE("(%p 0x%08x)\n", info, where);
2188
2189     if(where >= info->num_items)
2190         return FALSE;
2191
2192     if(where < info->num_items - 1)
2193     {
2194         memmove((char*)info->mem + where * info->block_size,
2195                 (char*)info->mem + (where + 1) * info->block_size,
2196                 (info->num_items - where - 1) * info->block_size);
2197     }
2198     memset((char*)info->mem + (info->num_items - 1) * info->block_size,
2199            0, info->block_size);
2200     info->num_items--;
2201     return TRUE;
2202 }
2203
2204
2205 typedef struct {
2206     REFIID   refid;
2207     DWORD    indx;
2208 } IFACE_INDEX_TBL;
2209
2210 /*************************************************************************
2211  *      @       [SHLWAPI.219]
2212  *
2213  * Call IUnknown_QueryInterface() on a table of objects.
2214  *
2215  * RETURNS
2216  *  Success: S_OK.
2217  *  Failure: E_POINTER or E_NOINTERFACE.
2218  */
2219 HRESULT WINAPI QISearch(
2220         LPVOID w,           /* [in]   Table of interfaces */
2221         IFACE_INDEX_TBL *x, /* [in]   Array of REFIIDs and indexes into the table */
2222         REFIID riid,        /* [in]   REFIID to get interface for */
2223         LPVOID *ppv)          /* [out]  Destination for interface pointer */
2224 {
2225         HRESULT ret;
2226         IUnknown *a_vtbl;
2227         IFACE_INDEX_TBL *xmove;
2228
2229         TRACE("(%p %p %s %p)\n", w,x,debugstr_guid(riid),ppv);
2230         if (ppv) {
2231             xmove = x;
2232             while (xmove->refid) {
2233                 TRACE("trying (indx %d) %s\n", xmove->indx, debugstr_guid(xmove->refid));
2234                 if (IsEqualIID(riid, xmove->refid)) {
2235                     a_vtbl = (IUnknown*)(xmove->indx + (LPBYTE)w);
2236                     TRACE("matched, returning (%p)\n", a_vtbl);
2237                     *ppv = a_vtbl;
2238                     IUnknown_AddRef(a_vtbl);
2239                     return S_OK;
2240                 }
2241                 xmove++;
2242             }
2243
2244             if (IsEqualIID(riid, &IID_IUnknown)) {
2245                 a_vtbl = (IUnknown*)(x->indx + (LPBYTE)w);
2246                 TRACE("returning first for IUnknown (%p)\n", a_vtbl);
2247                 *ppv = a_vtbl;
2248                 IUnknown_AddRef(a_vtbl);
2249                 return S_OK;
2250             }
2251             *ppv = 0;
2252             ret = E_NOINTERFACE;
2253         } else
2254             ret = E_POINTER;
2255
2256         TRACE("-- 0x%08x\n", ret);
2257         return ret;
2258 }
2259
2260 /*************************************************************************
2261  * @ [SHLWAPI.220]
2262  *
2263  * Set the Font for a window and the "PropDlgFont" property of the parent window.
2264  *
2265  * PARAMS
2266  *  hWnd [I] Parent Window to set the property
2267  *  id   [I] Index of child Window to set the Font
2268  *
2269  * RETURNS
2270  *  Success: S_OK
2271  *
2272  */
2273 HRESULT WINAPI SHSetDefaultDialogFont(HWND hWnd, INT id)
2274 {
2275     FIXME("(%p, %d) stub\n", hWnd, id);
2276     return S_OK;
2277 }
2278
2279 /*************************************************************************
2280  *      @       [SHLWAPI.221]
2281  *
2282  * Remove the "PropDlgFont" property from a window.
2283  *
2284  * PARAMS
2285  *  hWnd [I] Window to remove the property from
2286  *
2287  * RETURNS
2288  *  A handle to the removed property, or NULL if it did not exist.
2289  */
2290 HANDLE WINAPI SHRemoveDefaultDialogFont(HWND hWnd)
2291 {
2292   HANDLE hProp;
2293
2294   TRACE("(%p)\n", hWnd);
2295
2296   hProp = GetPropA(hWnd, "PropDlgFont");
2297
2298   if(hProp)
2299   {
2300     DeleteObject(hProp);
2301     hProp = RemovePropA(hWnd, "PropDlgFont");
2302   }
2303   return hProp;
2304 }
2305
2306 /*************************************************************************
2307  *      @       [SHLWAPI.236]
2308  *
2309  * Load the in-process server of a given GUID.
2310  *
2311  * PARAMS
2312  *  refiid [I] GUID of the server to load.
2313  *
2314  * RETURNS
2315  *  Success: A handle to the loaded server dll.
2316  *  Failure: A NULL handle.
2317  */
2318 HMODULE WINAPI SHPinDllOfCLSID(REFIID refiid)
2319 {
2320     HKEY newkey;
2321     DWORD type, count;
2322     CHAR value[MAX_PATH], string[MAX_PATH];
2323
2324     strcpy(string, "CLSID\\");
2325     SHStringFromGUIDA(refiid, string + 6, sizeof(string)/sizeof(char) - 6);
2326     strcat(string, "\\InProcServer32");
2327
2328     count = MAX_PATH;
2329     RegOpenKeyExA(HKEY_CLASSES_ROOT, string, 0, 1, &newkey);
2330     RegQueryValueExA(newkey, 0, 0, &type, (PBYTE)value, &count);
2331     RegCloseKey(newkey);
2332     return LoadLibraryExA(value, 0, 0);
2333 }
2334
2335 /*************************************************************************
2336  *      @       [SHLWAPI.237]
2337  *
2338  * Unicode version of SHLWAPI_183.
2339  */
2340 DWORD WINAPI SHRegisterClassW(WNDCLASSW * lpWndClass)
2341 {
2342         WNDCLASSW WndClass;
2343
2344         TRACE("(%p %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
2345
2346         if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
2347                 return TRUE;
2348         return RegisterClassW(lpWndClass);
2349 }
2350
2351 /*************************************************************************
2352  *      @       [SHLWAPI.238]
2353  *
2354  * Unregister a list of classes.
2355  *
2356  * PARAMS
2357  *  hInst      [I] Application instance that registered the classes
2358  *  lppClasses [I] List of class names
2359  *  iCount     [I] Number of names in lppClasses
2360  *
2361  * RETURNS
2362  *  Nothing.
2363  */
2364 void WINAPI SHUnregisterClassesA(HINSTANCE hInst, LPCSTR *lppClasses, INT iCount)
2365 {
2366   WNDCLASSA WndClass;
2367
2368   TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2369
2370   while (iCount > 0)
2371   {
2372     if (GetClassInfoA(hInst, *lppClasses, &WndClass))
2373       UnregisterClassA(*lppClasses, hInst);
2374     lppClasses++;
2375     iCount--;
2376   }
2377 }
2378
2379 /*************************************************************************
2380  *      @       [SHLWAPI.239]
2381  *
2382  * Unicode version of SHUnregisterClassesA.
2383  */
2384 void WINAPI SHUnregisterClassesW(HINSTANCE hInst, LPCWSTR *lppClasses, INT iCount)
2385 {
2386   WNDCLASSW WndClass;
2387
2388   TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2389
2390   while (iCount > 0)
2391   {
2392     if (GetClassInfoW(hInst, *lppClasses, &WndClass))
2393       UnregisterClassW(*lppClasses, hInst);
2394     lppClasses++;
2395     iCount--;
2396   }
2397 }
2398
2399 /*************************************************************************
2400  *      @       [SHLWAPI.240]
2401  *
2402  * Call The correct (Ascii/Unicode) default window procedure for a window.
2403  *
2404  * PARAMS
2405  *  hWnd     [I] Window to call the default procedure for
2406  *  uMessage [I] Message ID
2407  *  wParam   [I] WPARAM of message
2408  *  lParam   [I] LPARAM of message
2409  *
2410  * RETURNS
2411  *  The result of calling DefWindowProcA() or DefWindowProcW().
2412  */
2413 LRESULT CALLBACK SHDefWindowProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
2414 {
2415         if (IsWindowUnicode(hWnd))
2416                 return DefWindowProcW(hWnd, uMessage, wParam, lParam);
2417         return DefWindowProcA(hWnd, uMessage, wParam, lParam);
2418 }
2419
2420 /*************************************************************************
2421  *      @       [SHLWAPI.256]
2422  */
2423 HRESULT WINAPI IUnknown_GetSite(LPUNKNOWN lpUnknown, REFIID iid, PVOID *lppSite)
2424 {
2425   HRESULT hRet = E_INVALIDARG;
2426   LPOBJECTWITHSITE lpSite = NULL;
2427
2428   TRACE("(%p,%s,%p)\n", lpUnknown, debugstr_guid(iid), lppSite);
2429
2430   if (lpUnknown && iid && lppSite)
2431   {
2432     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IObjectWithSite,
2433                                    (void**)&lpSite);
2434     if (SUCCEEDED(hRet) && lpSite)
2435     {
2436       hRet = IObjectWithSite_GetSite(lpSite, iid, lppSite);
2437       IObjectWithSite_Release(lpSite);
2438     }
2439   }
2440   return hRet;
2441 }
2442
2443 /*************************************************************************
2444  *      @       [SHLWAPI.257]
2445  *
2446  * Create a worker window using CreateWindowExA().
2447  *
2448  * PARAMS
2449  *  wndProc    [I] Window procedure
2450  *  hWndParent [I] Parent window
2451  *  dwExStyle  [I] Extra style flags
2452  *  dwStyle    [I] Style flags
2453  *  hMenu      [I] Window menu
2454  *  z          [I] Unknown
2455  *
2456  * RETURNS
2457  *  Success: The window handle of the newly created window.
2458  *  Failure: 0.
2459  */
2460 HWND WINAPI SHCreateWorkerWindowA(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2461                         DWORD dwStyle, HMENU hMenu, LONG z)
2462 {
2463   static const char szClass[] = "WorkerA";
2464   WNDCLASSA wc;
2465   HWND hWnd;
2466
2467   TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2468          wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2469
2470   /* Create Window class */
2471   wc.style         = 0;
2472   wc.lpfnWndProc   = DefWindowProcA;
2473   wc.cbClsExtra    = 0;
2474   wc.cbWndExtra    = 4;
2475   wc.hInstance     = shlwapi_hInstance;
2476   wc.hIcon         = NULL;
2477   wc.hCursor       = LoadCursorA(NULL, (LPSTR)IDC_ARROW);
2478   wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2479   wc.lpszMenuName  = NULL;
2480   wc.lpszClassName = szClass;
2481
2482   SHRegisterClassA(&wc); /* Register class */
2483
2484   /* FIXME: Set extra bits in dwExStyle */
2485
2486   hWnd = CreateWindowExA(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2487                          hWndParent, hMenu, shlwapi_hInstance, 0);
2488   if (hWnd)
2489   {
2490     SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2491
2492     if (wndProc)
2493       SetWindowLongPtrA(hWnd, GWLP_WNDPROC, wndProc);
2494   }
2495   return hWnd;
2496 }
2497
2498 typedef struct tagPOLICYDATA
2499 {
2500   DWORD policy;        /* flags value passed to SHRestricted */
2501   LPCWSTR appstr;      /* application str such as "Explorer" */
2502   LPCWSTR keystr;      /* name of the actual registry key / policy */
2503 } POLICYDATA, *LPPOLICYDATA;
2504
2505 #define SHELL_NO_POLICY 0xffffffff
2506
2507 /* default shell policy registry key */
2508 static const WCHAR strRegistryPolicyW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2509                                       's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2510                                       'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2511                                       '\\','P','o','l','i','c','i','e','s',0};
2512
2513 /*************************************************************************
2514  * @                          [SHLWAPI.271]
2515  *
2516  * Retrieve a policy value from the registry.
2517  *
2518  * PARAMS
2519  *  lpSubKey   [I]   registry key name
2520  *  lpSubName  [I]   subname of registry key
2521  *  lpValue    [I]   value name of registry value
2522  *
2523  * RETURNS
2524  *  the value associated with the registry key or 0 if not found
2525  */
2526 DWORD WINAPI SHGetRestriction(LPCWSTR lpSubKey, LPCWSTR lpSubName, LPCWSTR lpValue)
2527 {
2528         DWORD retval, datsize = sizeof(retval);
2529         HKEY hKey;
2530
2531         if (!lpSubKey)
2532           lpSubKey = strRegistryPolicyW;
2533
2534         retval = RegOpenKeyW(HKEY_LOCAL_MACHINE, lpSubKey, &hKey);
2535     if (retval != ERROR_SUCCESS)
2536           retval = RegOpenKeyW(HKEY_CURRENT_USER, lpSubKey, &hKey);
2537         if (retval != ERROR_SUCCESS)
2538           return 0;
2539
2540         SHGetValueW(hKey, lpSubName, lpValue, NULL, &retval, &datsize);
2541         RegCloseKey(hKey);
2542         return retval;
2543 }
2544
2545 /*************************************************************************
2546  * @                         [SHLWAPI.266]
2547  *
2548  * Helper function to retrieve the possibly cached value for a specific policy
2549  *
2550  * PARAMS
2551  *  policy     [I]   The policy to look for
2552  *  initial    [I]   Main registry key to open, if NULL use default
2553  *  polTable   [I]   Table of known policies, 0 terminated
2554  *  polArr     [I]   Cache array of policy values
2555  *
2556  * RETURNS
2557  *  The retrieved policy value or 0 if not successful
2558  *
2559  * NOTES
2560  *  This function is used by the native SHRestricted function to search for the
2561  *  policy and cache it once retrieved. The current Wine implementation uses a
2562  *  different POLICYDATA structure and implements a similar algorithm adapted to
2563  *  that structure.
2564  */
2565 DWORD WINAPI SHRestrictionLookup(
2566         DWORD policy,
2567         LPCWSTR initial,
2568         LPPOLICYDATA polTable,
2569         LPDWORD polArr)
2570 {
2571         TRACE("(0x%08x %s %p %p)\n", policy, debugstr_w(initial), polTable, polArr);
2572
2573         if (!polTable || !polArr)
2574           return 0;
2575
2576         for (;polTable->policy; polTable++, polArr++)
2577         {
2578           if (policy == polTable->policy)
2579           {
2580             /* we have a known policy */
2581
2582             /* check if this policy has been cached */
2583                 if (*polArr == SHELL_NO_POLICY)
2584               *polArr = SHGetRestriction(initial, polTable->appstr, polTable->keystr);
2585             return *polArr;
2586           }
2587         }
2588         /* we don't know this policy, return 0 */
2589         TRACE("unknown policy: (%08x)\n", policy);
2590         return 0;
2591 }
2592
2593 /*************************************************************************
2594  *      @       [SHLWAPI.267]
2595  *
2596  * Get an interface from an object.
2597  *
2598  * RETURNS
2599  *  Success: S_OK. ppv contains the requested interface.
2600  *  Failure: An HRESULT error code.
2601  *
2602  * NOTES
2603  *   This QueryInterface asks the inner object for an interface. In case
2604  *   of aggregation this request would be forwarded by the inner to the
2605  *   outer object. This function asks the inner object directly for the
2606  *   interface circumventing the forwarding to the outer object.
2607  */
2608 HRESULT WINAPI SHWeakQueryInterface(
2609         IUnknown * pUnk,   /* [in] Outer object */
2610         IUnknown * pInner, /* [in] Inner object */
2611         IID * riid, /* [in] Interface GUID to query for */
2612         LPVOID* ppv) /* [out] Destination for queried interface */
2613 {
2614         HRESULT hret = E_NOINTERFACE;
2615         TRACE("(pUnk=%p pInner=%p\n\tIID:  %s %p)\n",pUnk,pInner,debugstr_guid(riid), ppv);
2616
2617         *ppv = NULL;
2618         if(pUnk && pInner) {
2619             hret = IUnknown_QueryInterface(pInner, riid, ppv);
2620             if (SUCCEEDED(hret)) IUnknown_Release(pUnk);
2621         }
2622         TRACE("-- 0x%08x\n", hret);
2623         return hret;
2624 }
2625
2626 /*************************************************************************
2627  *      @       [SHLWAPI.268]
2628  *
2629  * Move a reference from one interface to another.
2630  *
2631  * PARAMS
2632  *   lpDest     [O] Destination to receive the reference
2633  *   lppUnknown [O] Source to give up the reference to lpDest
2634  *
2635  * RETURNS
2636  *  Nothing.
2637  */
2638 VOID WINAPI SHWeakReleaseInterface(IUnknown *lpDest, IUnknown **lppUnknown)
2639 {
2640   TRACE("(%p,%p)\n", lpDest, lppUnknown);
2641
2642   if (*lppUnknown)
2643   {
2644     /* Copy Reference*/
2645     IUnknown_AddRef(lpDest);
2646     IUnknown_AtomicRelease(lppUnknown); /* Release existing interface */
2647   }
2648 }
2649
2650 /*************************************************************************
2651  *      @       [SHLWAPI.269]
2652  *
2653  * Convert an ASCII string of a CLSID into a CLSID.
2654  *
2655  * PARAMS
2656  *  idstr [I] String representing a CLSID in registry format
2657  *  id    [O] Destination for the converted CLSID
2658  *
2659  * RETURNS
2660  *  Success: TRUE. id contains the converted CLSID.
2661  *  Failure: FALSE.
2662  */
2663 BOOL WINAPI GUIDFromStringA(LPCSTR idstr, CLSID *id)
2664 {
2665   WCHAR wClsid[40];
2666   MultiByteToWideChar(CP_ACP, 0, idstr, -1, wClsid, sizeof(wClsid)/sizeof(WCHAR));
2667   return SUCCEEDED(CLSIDFromString(wClsid, id));
2668 }
2669
2670 /*************************************************************************
2671  *      @       [SHLWAPI.270]
2672  *
2673  * Unicode version of GUIDFromStringA.
2674  */
2675 BOOL WINAPI GUIDFromStringW(LPCWSTR idstr, CLSID *id)
2676 {
2677     return SUCCEEDED(CLSIDFromString((LPOLESTR)idstr, id));
2678 }
2679
2680 /*************************************************************************
2681  *      @       [SHLWAPI.276]
2682  *
2683  * Determine if the browser is integrated into the shell, and set a registry
2684  * key accordingly.
2685  *
2686  * PARAMS
2687  *  None.
2688  *
2689  * RETURNS
2690  *  1, If the browser is not integrated.
2691  *  2, If the browser is integrated.
2692  *
2693  * NOTES
2694  *  The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2695  *  either set to TRUE, or removed depending on whether the browser is deemed
2696  *  to be integrated.
2697  */
2698 DWORD WINAPI WhichPlatform(void)
2699 {
2700   static const char szIntegratedBrowser[] = "IntegratedBrowser";
2701   static DWORD dwState = 0;
2702   HKEY hKey;
2703   DWORD dwRet, dwData, dwSize;
2704   HMODULE hshell32;
2705
2706   if (dwState)
2707     return dwState;
2708
2709   /* If shell32 exports DllGetVersion(), the browser is integrated */
2710   dwState = 1;
2711   hshell32 = LoadLibraryA("shell32.dll");
2712   if (hshell32)
2713   {
2714     FARPROC pDllGetVersion;
2715     pDllGetVersion = GetProcAddress(hshell32, "DllGetVersion");
2716     dwState = pDllGetVersion ? 2 : 1;
2717     FreeLibrary(hshell32);
2718   }
2719
2720   /* Set or delete the key accordingly */
2721   dwRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2722                         "Software\\Microsoft\\Internet Explorer", 0,
2723                          KEY_ALL_ACCESS, &hKey);
2724   if (!dwRet)
2725   {
2726     dwRet = RegQueryValueExA(hKey, szIntegratedBrowser, 0, 0,
2727                              (LPBYTE)&dwData, &dwSize);
2728
2729     if (!dwRet && dwState == 1)
2730     {
2731       /* Value exists but browser is not integrated */
2732       RegDeleteValueA(hKey, szIntegratedBrowser);
2733     }
2734     else if (dwRet && dwState == 2)
2735     {
2736       /* Browser is integrated but value does not exist */
2737       dwData = TRUE;
2738       RegSetValueExA(hKey, szIntegratedBrowser, 0, REG_DWORD,
2739                      (LPBYTE)&dwData, sizeof(dwData));
2740     }
2741     RegCloseKey(hKey);
2742   }
2743   return dwState;
2744 }
2745
2746 /*************************************************************************
2747  *      @       [SHLWAPI.278]
2748  *
2749  * Unicode version of SHCreateWorkerWindowA.
2750  */
2751 HWND WINAPI SHCreateWorkerWindowW(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2752                         DWORD dwStyle, HMENU hMenu, LONG z)
2753 {
2754   static const WCHAR szClass[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', '\0' };
2755   WNDCLASSW wc;
2756   HWND hWnd;
2757
2758   TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2759          wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2760
2761   /* If our OS is natively ASCII, use the ASCII version */
2762   if (!(GetVersion() & 0x80000000))  /* NT */
2763     return SHCreateWorkerWindowA(wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2764
2765   /* Create Window class */
2766   wc.style         = 0;
2767   wc.lpfnWndProc   = DefWindowProcW;
2768   wc.cbClsExtra    = 0;
2769   wc.cbWndExtra    = 4;
2770   wc.hInstance     = shlwapi_hInstance;
2771   wc.hIcon         = NULL;
2772   wc.hCursor       = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
2773   wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2774   wc.lpszMenuName  = NULL;
2775   wc.lpszClassName = szClass;
2776
2777   SHRegisterClassW(&wc); /* Register class */
2778
2779   /* FIXME: Set extra bits in dwExStyle */
2780
2781   hWnd = CreateWindowExW(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2782                          hWndParent, hMenu, shlwapi_hInstance, 0);
2783   if (hWnd)
2784   {
2785     SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2786
2787     if (wndProc)
2788       SetWindowLongPtrW(hWnd, GWLP_WNDPROC, wndProc);
2789   }
2790   return hWnd;
2791 }
2792
2793 /*************************************************************************
2794  *      @       [SHLWAPI.279]
2795  *
2796  * Get and show a context menu from a shell folder.
2797  *
2798  * PARAMS
2799  *  hWnd           [I] Window displaying the shell folder
2800  *  lpFolder       [I] IShellFolder interface
2801  *  lpApidl        [I] Id for the particular folder desired
2802  *
2803  * RETURNS
2804  *  Success: S_OK.
2805  *  Failure: An HRESULT error code indicating the error.
2806  */
2807 HRESULT WINAPI SHInvokeDefaultCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl)
2808 {
2809   return SHInvokeCommand(hWnd, lpFolder, lpApidl, FALSE);
2810 }
2811
2812 /*************************************************************************
2813  *      @       [SHLWAPI.281]
2814  *
2815  * _SHPackDispParamsV
2816  */
2817 HRESULT WINAPI SHPackDispParamsV(DISPPARAMS *params, VARIANTARG *args, UINT cnt, __ms_va_list valist)
2818 {
2819   VARIANTARG *iter;
2820
2821   TRACE("(%p %p %u ...)\n", params, args, cnt);
2822
2823   params->rgvarg = args;
2824   params->rgdispidNamedArgs = NULL;
2825   params->cArgs = cnt;
2826   params->cNamedArgs = 0;
2827
2828   iter = args+cnt;
2829
2830   while(iter-- > args) {
2831     V_VT(iter) = va_arg(valist, enum VARENUM);
2832
2833     TRACE("vt=%d\n", V_VT(iter));
2834
2835     if(V_VT(iter) & VT_BYREF) {
2836       V_BYREF(iter) = va_arg(valist, LPVOID);
2837     } else {
2838       switch(V_VT(iter)) {
2839       case VT_I4:
2840         V_I4(iter) = va_arg(valist, LONG);
2841         break;
2842       case VT_BSTR:
2843         V_BSTR(iter) = va_arg(valist, BSTR);
2844         break;
2845       case VT_DISPATCH:
2846         V_DISPATCH(iter) = va_arg(valist, IDispatch*);
2847         break;
2848       case VT_BOOL:
2849         V_BOOL(iter) = va_arg(valist, int);
2850         break;
2851       case VT_UNKNOWN:
2852         V_UNKNOWN(iter) = va_arg(valist, IUnknown*);
2853         break;
2854       default:
2855         V_VT(iter) = VT_I4;
2856         V_I4(iter) = va_arg(valist, LONG);
2857       }
2858     }
2859   }
2860
2861   return S_OK;
2862 }
2863
2864 /*************************************************************************
2865  *      @       [SHLWAPI.282]
2866  *
2867  * SHPackDispParams
2868  */
2869 HRESULT WINAPIV SHPackDispParams(DISPPARAMS *params, VARIANTARG *args, UINT cnt, ...)
2870 {
2871   __ms_va_list valist;
2872   HRESULT hres;
2873
2874   __ms_va_start(valist, cnt);
2875   hres = SHPackDispParamsV(params, args, cnt, valist);
2876   __ms_va_end(valist);
2877   return hres;
2878 }
2879
2880 /*************************************************************************
2881  *      SHLWAPI_InvokeByIID
2882  *
2883  *   This helper function calls IDispatch::Invoke for each sink
2884  * which implements given iid or IDispatch.
2885  *
2886  */
2887 static HRESULT SHLWAPI_InvokeByIID(
2888         IConnectionPoint* iCP,
2889         REFIID iid,
2890         DISPID dispId,
2891         DISPPARAMS* dispParams)
2892 {
2893   IEnumConnections *enumerator;
2894   CONNECTDATA rgcd;
2895
2896   HRESULT result = IConnectionPoint_EnumConnections(iCP, &enumerator);
2897   if (FAILED(result))
2898     return result;
2899
2900   while(IEnumConnections_Next(enumerator, 1, &rgcd, NULL)==S_OK)
2901   {
2902     IDispatch *dispIface;
2903     if (SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, iid, (LPVOID*)&dispIface)) ||
2904         SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, &IID_IDispatch, (LPVOID*)&dispIface)))
2905     {
2906       IDispatch_Invoke(dispIface, dispId, &IID_NULL, 0, DISPATCH_METHOD, dispParams, NULL, NULL, NULL);
2907       IDispatch_Release(dispIface);
2908     }
2909   }
2910
2911   IEnumConnections_Release(enumerator);
2912
2913   return S_OK;
2914 }
2915
2916 /*************************************************************************
2917  *      @       [SHLWAPI.284]
2918  *
2919  *  IConnectionPoint_SimpleInvoke
2920  */
2921 HRESULT WINAPI IConnectionPoint_SimpleInvoke(
2922         IConnectionPoint* iCP,
2923         DISPID dispId,
2924         DISPPARAMS* dispParams)
2925 {
2926   IID iid;
2927   HRESULT result;
2928
2929   TRACE("(%p)->(0x%x %p)\n",iCP,dispId,dispParams);
2930
2931   result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
2932   if (SUCCEEDED(result))
2933     result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
2934
2935   return result;
2936 }
2937
2938 /*************************************************************************
2939  *      @       [SHLWAPI.285]
2940  *
2941  * Notify an IConnectionPoint object of changes.
2942  *
2943  * PARAMS
2944  *  lpCP   [I] Object to notify
2945  *  dispID [I]
2946  *
2947  * RETURNS
2948  *  Success: S_OK.
2949  *  Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
2950  *           IConnectionPoint interface.
2951  */
2952 HRESULT WINAPI IConnectionPoint_OnChanged(IConnectionPoint* lpCP, DISPID dispID)
2953 {
2954   IEnumConnections *lpEnum;
2955   HRESULT hRet = E_NOINTERFACE;
2956
2957   TRACE("(%p,0x%8X)\n", lpCP, dispID);
2958
2959   /* Get an enumerator for the connections */
2960   if (lpCP)
2961     hRet = IConnectionPoint_EnumConnections(lpCP, &lpEnum);
2962
2963   if (SUCCEEDED(hRet))
2964   {
2965     IPropertyNotifySink *lpSink;
2966     CONNECTDATA connData;
2967     ULONG ulFetched;
2968
2969     /* Call OnChanged() for every notify sink in the connection point */
2970     while (IEnumConnections_Next(lpEnum, 1, &connData, &ulFetched) == S_OK)
2971     {
2972       if (SUCCEEDED(IUnknown_QueryInterface(connData.pUnk, &IID_IPropertyNotifySink, (void**)&lpSink)) &&
2973           lpSink)
2974       {
2975         IPropertyNotifySink_OnChanged(lpSink, dispID);
2976         IPropertyNotifySink_Release(lpSink);
2977       }
2978       IUnknown_Release(connData.pUnk);
2979     }
2980
2981     IEnumConnections_Release(lpEnum);
2982   }
2983   return hRet;
2984 }
2985
2986 /*************************************************************************
2987  *      @       [SHLWAPI.286]
2988  *
2989  *  IUnknown_CPContainerInvokeParam
2990  */
2991 HRESULT WINAPIV IUnknown_CPContainerInvokeParam(
2992         IUnknown *container,
2993         REFIID riid,
2994         DISPID dispId,
2995         VARIANTARG* buffer,
2996         DWORD cParams, ...)
2997 {
2998   HRESULT result;
2999   IConnectionPoint *iCP;
3000   IConnectionPointContainer *iCPC;
3001   DISPPARAMS dispParams = {buffer, NULL, cParams, 0};
3002   __ms_va_list valist;
3003
3004   if (!container)
3005     return E_NOINTERFACE;
3006
3007   result = IUnknown_QueryInterface(container, &IID_IConnectionPointContainer,(LPVOID*) &iCPC);
3008   if (FAILED(result))
3009       return result;
3010
3011   result = IConnectionPointContainer_FindConnectionPoint(iCPC, riid, &iCP);
3012   IConnectionPointContainer_Release(iCPC);
3013   if(FAILED(result))
3014       return result;
3015
3016   __ms_va_start(valist, cParams);
3017   SHPackDispParamsV(&dispParams, buffer, cParams, valist);
3018   __ms_va_end(valist);
3019
3020   result = SHLWAPI_InvokeByIID(iCP, riid, dispId, &dispParams);
3021   IConnectionPoint_Release(iCP);
3022
3023   return result;
3024 }
3025
3026 /*************************************************************************
3027  *      @       [SHLWAPI.287]
3028  *
3029  * Notify an IConnectionPointContainer object of changes.
3030  *
3031  * PARAMS
3032  *  lpUnknown [I] Object to notify
3033  *  dispID    [I]
3034  *
3035  * RETURNS
3036  *  Success: S_OK.
3037  *  Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
3038  *           IConnectionPointContainer interface.
3039  */
3040 HRESULT WINAPI IUnknown_CPContainerOnChanged(IUnknown *lpUnknown, DISPID dispID)
3041 {
3042   IConnectionPointContainer* lpCPC = NULL;
3043   HRESULT hRet = E_NOINTERFACE;
3044
3045   TRACE("(%p,0x%8X)\n", lpUnknown, dispID);
3046
3047   if (lpUnknown)
3048     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer, (void**)&lpCPC);
3049
3050   if (SUCCEEDED(hRet))
3051   {
3052     IConnectionPoint* lpCP;
3053
3054     hRet = IConnectionPointContainer_FindConnectionPoint(lpCPC, &IID_IPropertyNotifySink, &lpCP);
3055     IConnectionPointContainer_Release(lpCPC);
3056
3057     hRet = IConnectionPoint_OnChanged(lpCP, dispID);
3058     IConnectionPoint_Release(lpCP);
3059   }
3060   return hRet;
3061 }
3062
3063 /*************************************************************************
3064  *      @       [SHLWAPI.289]
3065  *
3066  * See PlaySoundW.
3067  */
3068 BOOL WINAPI PlaySoundWrapW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
3069 {
3070     return PlaySoundW(pszSound, hmod, fdwSound);
3071 }
3072
3073 /*************************************************************************
3074  *      @       [SHLWAPI.294]
3075  */
3076 BOOL WINAPI SHGetIniStringW(LPCWSTR str1, LPCWSTR str2, LPWSTR pStr, DWORD some_len, LPCWSTR lpStr2)
3077 {
3078     FIXME("(%s,%s,%p,%08x,%s): stub!\n", debugstr_w(str1), debugstr_w(str2),
3079         pStr, some_len, debugstr_w(lpStr2));
3080     return TRUE;
3081 }
3082
3083 /*************************************************************************
3084  *      @       [SHLWAPI.295]
3085  *
3086  * Called by ICQ2000b install via SHDOCVW:
3087  * str1: "InternetShortcut"
3088  * x: some unknown pointer
3089  * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
3090  * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
3091  *
3092  * In short: this one maybe creates a desktop link :-)
3093  */
3094 BOOL WINAPI SHSetIniStringW(LPWSTR str1, LPVOID x, LPWSTR str2, LPWSTR str3)
3095 {
3096     FIXME("(%s, %p, %s, %s), stub.\n", debugstr_w(str1), x, debugstr_w(str2), debugstr_w(str3));
3097     return TRUE;
3098 }
3099
3100 /*************************************************************************
3101  *      @       [SHLWAPI.313]
3102  *
3103  * See SHGetFileInfoW.
3104  */
3105 DWORD WINAPI SHGetFileInfoWrapW(LPCWSTR path, DWORD dwFileAttributes,
3106                          SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
3107 {
3108     return SHGetFileInfoW(path, dwFileAttributes, psfi, sizeofpsfi, flags);
3109 }
3110
3111 /*************************************************************************
3112  *      @       [SHLWAPI.318]
3113  *
3114  * See DragQueryFileW.
3115  */
3116 UINT WINAPI DragQueryFileWrapW(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
3117 {
3118     return DragQueryFileW(hDrop, lFile, lpszFile, lLength);
3119 }
3120
3121 /*************************************************************************
3122  *      @       [SHLWAPI.333]
3123  *
3124  * See SHBrowseForFolderW.
3125  */
3126 LPITEMIDLIST WINAPI SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi)
3127 {
3128     return SHBrowseForFolderW(lpBi);
3129 }
3130
3131 /*************************************************************************
3132  *      @       [SHLWAPI.334]
3133  *
3134  * See SHGetPathFromIDListW.
3135  */
3136 BOOL WINAPI SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl,LPWSTR pszPath)
3137 {
3138     return SHGetPathFromIDListW(pidl, pszPath);
3139 }
3140
3141 /*************************************************************************
3142  *      @       [SHLWAPI.335]
3143  *
3144  * See ShellExecuteExW.
3145  */
3146 BOOL WINAPI ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo)
3147 {
3148     return ShellExecuteExW(lpExecInfo);
3149 }
3150
3151 /*************************************************************************
3152  *      @       [SHLWAPI.336]
3153  *
3154  * See SHFileOperationW.
3155  */
3156 INT WINAPI SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp)
3157 {
3158     return SHFileOperationW(lpFileOp);
3159 }
3160
3161 /*************************************************************************
3162  *      @       [SHLWAPI.342]
3163  *
3164  */
3165 PVOID WINAPI SHInterlockedCompareExchange( PVOID *dest, PVOID xchg, PVOID compare )
3166 {
3167     return InterlockedCompareExchangePointer( dest, xchg, compare );
3168 }
3169
3170 /*************************************************************************
3171  *      @       [SHLWAPI.350]
3172  *
3173  * See GetFileVersionInfoSizeW.
3174  */
3175 DWORD WINAPI GetFileVersionInfoSizeWrapW( LPCWSTR filename, LPDWORD handle )
3176 {
3177     return GetFileVersionInfoSizeW( filename, handle );
3178 }
3179
3180 /*************************************************************************
3181  *      @       [SHLWAPI.351]
3182  *
3183  * See GetFileVersionInfoW.
3184  */
3185 BOOL  WINAPI GetFileVersionInfoWrapW( LPCWSTR filename, DWORD handle,
3186                                       DWORD datasize, LPVOID data )
3187 {
3188     return GetFileVersionInfoW( filename, handle, datasize, data );
3189 }
3190
3191 /*************************************************************************
3192  *      @       [SHLWAPI.352]
3193  *
3194  * See VerQueryValueW.
3195  */
3196 WORD WINAPI VerQueryValueWrapW( LPVOID pBlock, LPCWSTR lpSubBlock,
3197                                 LPVOID *lplpBuffer, UINT *puLen )
3198 {
3199     return VerQueryValueW( pBlock, lpSubBlock, lplpBuffer, puLen );
3200 }
3201
3202 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3203 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3204 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3205
3206 /*************************************************************************
3207  *      @       [SHLWAPI.355]
3208  *
3209  * Change the modality of a shell object.
3210  *
3211  * PARAMS
3212  *  lpUnknown [I] Object to make modeless
3213  *  bModeless [I] TRUE=Make modeless, FALSE=Make modal
3214  *
3215  * RETURNS
3216  *  Success: S_OK. The modality lpUnknown is changed.
3217  *  Failure: An HRESULT error code indicating the error.
3218  *
3219  * NOTES
3220  *  lpUnknown must support the IOleInPlaceFrame interface, the
3221  *  IInternetSecurityMgrSite interface, the IShellBrowser interface
3222  *  the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3223  *  or this call will fail.
3224  */
3225 HRESULT WINAPI IUnknown_EnableModeless(IUnknown *lpUnknown, BOOL bModeless)
3226 {
3227   IUnknown *lpObj;
3228   HRESULT hRet;
3229
3230   TRACE("(%p,%d)\n", lpUnknown, bModeless);
3231
3232   if (!lpUnknown)
3233     return E_FAIL;
3234
3235   if (IsIface(IOleInPlaceActiveObject))
3236     EnableModeless(IOleInPlaceActiveObject);
3237   else if (IsIface(IOleInPlaceFrame))
3238     EnableModeless(IOleInPlaceFrame);
3239   else if (IsIface(IShellBrowser))
3240     EnableModeless(IShellBrowser);
3241   else if (IsIface(IInternetSecurityMgrSite))
3242     EnableModeless(IInternetSecurityMgrSite);
3243   else if (IsIface(IDocHostUIHandler))
3244     EnableModeless(IDocHostUIHandler);
3245   else
3246     return hRet;
3247
3248   IUnknown_Release(lpObj);
3249   return S_OK;
3250 }
3251
3252 /*************************************************************************
3253  *      @       [SHLWAPI.357]
3254  *
3255  * See SHGetNewLinkInfoW.
3256  */
3257 BOOL WINAPI SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName,
3258                         BOOL *pfMustCopy, UINT uFlags)
3259 {
3260     return SHGetNewLinkInfoW(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
3261 }
3262
3263 /*************************************************************************
3264  *      @       [SHLWAPI.358]
3265  *
3266  * See SHDefExtractIconW.
3267  */
3268 UINT WINAPI SHDefExtractIconWrapW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON* phiconLarge,
3269                          HICON* phiconSmall, UINT nIconSize)
3270 {
3271     return SHDefExtractIconW(pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
3272 }
3273
3274 /*************************************************************************
3275  *      @       [SHLWAPI.363]
3276  *
3277  * Get and show a context menu from a shell folder.
3278  *
3279  * PARAMS
3280  *  hWnd           [I] Window displaying the shell folder
3281  *  lpFolder       [I] IShellFolder interface
3282  *  lpApidl        [I] Id for the particular folder desired
3283  *  bInvokeDefault [I] Whether to invoke the default menu item
3284  *
3285  * RETURNS
3286  *  Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3287  *           executed.
3288  *  Failure: An HRESULT error code indicating the error.
3289  */
3290 HRESULT WINAPI SHInvokeCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl, BOOL bInvokeDefault)
3291 {
3292   IContextMenu *iContext;
3293   HRESULT hRet = E_FAIL;
3294
3295   TRACE("(%p,%p,%p,%d)\n", hWnd, lpFolder, lpApidl, bInvokeDefault);
3296
3297   if (!lpFolder)
3298     return hRet;
3299
3300   /* Get the context menu from the shell folder */
3301   hRet = IShellFolder_GetUIObjectOf(lpFolder, hWnd, 1, &lpApidl,
3302                                     &IID_IContextMenu, 0, (void**)&iContext);
3303   if (SUCCEEDED(hRet))
3304   {
3305     HMENU hMenu;
3306     if ((hMenu = CreatePopupMenu()))
3307     {
3308       HRESULT hQuery;
3309       DWORD dwDefaultId = 0;
3310
3311       /* Add the context menu entries to the popup */
3312       hQuery = IContextMenu_QueryContextMenu(iContext, hMenu, 0, 1, 0x7FFF,
3313                                              bInvokeDefault ? CMF_NORMAL : CMF_DEFAULTONLY);
3314
3315       if (SUCCEEDED(hQuery))
3316       {
3317         if (bInvokeDefault &&
3318             (dwDefaultId = GetMenuDefaultItem(hMenu, 0, 0)) != 0xFFFFFFFF)
3319         {
3320           CMINVOKECOMMANDINFO cmIci;
3321           /* Invoke the default item */
3322           memset(&cmIci,0,sizeof(cmIci));
3323           cmIci.cbSize = sizeof(cmIci);
3324           cmIci.fMask = CMIC_MASK_ASYNCOK;
3325           cmIci.hwnd = hWnd;
3326           cmIci.lpVerb = MAKEINTRESOURCEA(dwDefaultId);
3327           cmIci.nShow = SW_SCROLLCHILDREN;
3328
3329           hRet = IContextMenu_InvokeCommand(iContext, &cmIci);
3330         }
3331       }
3332       DestroyMenu(hMenu);
3333     }
3334     IContextMenu_Release(iContext);
3335   }
3336   return hRet;
3337 }
3338
3339 /*************************************************************************
3340  *      @       [SHLWAPI.370]
3341  *
3342  * See ExtractIconW.
3343  */
3344 HICON WINAPI ExtractIconWrapW(HINSTANCE hInstance, LPCWSTR lpszExeFileName,
3345                          UINT nIconIndex)
3346 {
3347     return ExtractIconW(hInstance, lpszExeFileName, nIconIndex);
3348 }
3349
3350 /*************************************************************************
3351  *      @       [SHLWAPI.377]
3352  *
3353  * Load a library from the directory of a particular process.
3354  *
3355  * PARAMS
3356  *  new_mod        [I] Library name
3357  *  inst_hwnd      [I] Module whose directory is to be used
3358  *  dwCrossCodePage [I] Should be FALSE (currently ignored)
3359  *
3360  * RETURNS
3361  *  Success: A handle to the loaded module
3362  *  Failure: A NULL handle.
3363  */
3364 HMODULE WINAPI MLLoadLibraryA(LPCSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3365 {
3366   /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3367    *        each call here.
3368    * FIXME: Native shows calls to:
3369    *  SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3370    *                      CheckVersion
3371    *  RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3372    *  RegQueryValueExA for "LPKInstalled"
3373    *  RegCloseKey
3374    *  RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3375    *  RegQueryValueExA for "ResourceLocale"
3376    *  RegCloseKey
3377    *  RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3378    *  RegQueryValueExA for "Locale"
3379    *  RegCloseKey
3380    *  and then tests the Locale ("en" for me).
3381    *     code below
3382    *  after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3383    */
3384     CHAR mod_path[2*MAX_PATH];
3385     LPSTR ptr;
3386     DWORD len;
3387
3388     FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, dwCrossCodePage);
3389     len = GetModuleFileNameA(inst_hwnd, mod_path, sizeof(mod_path));
3390     if (!len || len >= sizeof(mod_path)) return NULL;
3391
3392     ptr = strrchr(mod_path, '\\');
3393     if (ptr) {
3394         strcpy(ptr+1, new_mod);
3395         TRACE("loading %s\n", debugstr_a(mod_path));
3396         return LoadLibraryA(mod_path);
3397     }
3398     return NULL;
3399 }
3400
3401 /*************************************************************************
3402  *      @       [SHLWAPI.378]
3403  *
3404  * Unicode version of MLLoadLibraryA.
3405  */
3406 HMODULE WINAPI MLLoadLibraryW(LPCWSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3407 {
3408     WCHAR mod_path[2*MAX_PATH];
3409     LPWSTR ptr;
3410     DWORD len;
3411
3412     FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwCrossCodePage);
3413     len = GetModuleFileNameW(inst_hwnd, mod_path, sizeof(mod_path) / sizeof(WCHAR));
3414     if (!len || len >= sizeof(mod_path) / sizeof(WCHAR)) return NULL;
3415
3416     ptr = strrchrW(mod_path, '\\');
3417     if (ptr) {
3418         strcpyW(ptr+1, new_mod);
3419         TRACE("loading %s\n", debugstr_w(mod_path));
3420         return LoadLibraryW(mod_path);
3421     }
3422     return NULL;
3423 }
3424
3425 /*************************************************************************
3426  * ColorAdjustLuma      [SHLWAPI.@]
3427  *
3428  * Adjust the luminosity of a color
3429  *
3430  * PARAMS
3431  *  cRGB         [I] RGB value to convert
3432  *  dwLuma       [I] Luma adjustment
3433  *  bUnknown     [I] Unknown
3434  *
3435  * RETURNS
3436  *  The adjusted RGB color.
3437  */
3438 COLORREF WINAPI ColorAdjustLuma(COLORREF cRGB, int dwLuma, BOOL bUnknown)
3439 {
3440   TRACE("(0x%8x,%d,%d)\n", cRGB, dwLuma, bUnknown);
3441
3442   if (dwLuma)
3443   {
3444     WORD wH, wL, wS;
3445
3446     ColorRGBToHLS(cRGB, &wH, &wL, &wS);
3447
3448     FIXME("Ignoring luma adjustment\n");
3449
3450     /* FIXME: The adjustment is not linear */
3451
3452     cRGB = ColorHLSToRGB(wH, wL, wS);
3453   }
3454   return cRGB;
3455 }
3456
3457 /*************************************************************************
3458  *      @       [SHLWAPI.389]
3459  *
3460  * See GetSaveFileNameW.
3461  */
3462 BOOL WINAPI GetSaveFileNameWrapW(LPOPENFILENAMEW ofn)
3463 {
3464     return GetSaveFileNameW(ofn);
3465 }
3466
3467 /*************************************************************************
3468  *      @       [SHLWAPI.390]
3469  *
3470  * See WNetRestoreConnectionW.
3471  */
3472 DWORD WINAPI WNetRestoreConnectionWrapW(HWND hwndOwner, LPWSTR lpszDevice)
3473 {
3474     return WNetRestoreConnectionW(hwndOwner, lpszDevice);
3475 }
3476
3477 /*************************************************************************
3478  *      @       [SHLWAPI.391]
3479  *
3480  * See WNetGetLastErrorW.
3481  */
3482 DWORD WINAPI WNetGetLastErrorWrapW(LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize,
3483                          LPWSTR lpNameBuf, DWORD nNameBufSize)
3484 {
3485     return WNetGetLastErrorW(lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize);
3486 }
3487
3488 /*************************************************************************
3489  *      @       [SHLWAPI.401]
3490  *
3491  * See PageSetupDlgW.
3492  */
3493 BOOL WINAPI PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg)
3494 {
3495     return PageSetupDlgW(pagedlg);
3496 }
3497
3498 /*************************************************************************
3499  *      @       [SHLWAPI.402]
3500  *
3501  * See PrintDlgW.
3502  */
3503 BOOL WINAPI PrintDlgWrapW(LPPRINTDLGW printdlg)
3504 {
3505     return PrintDlgW(printdlg);
3506 }
3507
3508 /*************************************************************************
3509  *      @       [SHLWAPI.403]
3510  *
3511  * See GetOpenFileNameW.
3512  */
3513 BOOL WINAPI GetOpenFileNameWrapW(LPOPENFILENAMEW ofn)
3514 {
3515     return GetOpenFileNameW(ofn);
3516 }
3517
3518 /*************************************************************************
3519  *      @       [SHLWAPI.404]
3520  */
3521 HRESULT WINAPI SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder, HWND hwnd, SHCONTF flags, IEnumIDList **ppenum)
3522 {
3523     IPersist *persist;
3524     HRESULT hr;
3525
3526     hr = IShellFolder_QueryInterface(lpFolder, &IID_IPersist, (LPVOID)&persist);
3527     if(SUCCEEDED(hr))
3528     {
3529         CLSID clsid;
3530         hr = IPersist_GetClassID(persist, &clsid);
3531         if(SUCCEEDED(hr))
3532         {
3533             if(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder))
3534                 hr = IShellFolder_EnumObjects(lpFolder, hwnd, flags, ppenum);
3535             else
3536                 hr = E_FAIL;
3537         }
3538         IPersist_Release(persist);
3539     }
3540     return hr;
3541 }
3542
3543 /* INTERNAL: Map from HLS color space to RGB */
3544 static WORD ConvertHue(int wHue, WORD wMid1, WORD wMid2)
3545 {
3546   wHue = wHue > 240 ? wHue - 240 : wHue < 0 ? wHue + 240 : wHue;
3547
3548   if (wHue > 160)
3549     return wMid1;
3550   else if (wHue > 120)
3551     wHue = 160 - wHue;
3552   else if (wHue > 40)
3553     return wMid2;
3554
3555   return ((wHue * (wMid2 - wMid1) + 20) / 40) + wMid1;
3556 }
3557
3558 /* Convert to RGB and scale into RGB range (0..255) */
3559 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3560
3561 /*************************************************************************
3562  *      ColorHLSToRGB   [SHLWAPI.@]
3563  *
3564  * Convert from hls color space into an rgb COLORREF.
3565  *
3566  * PARAMS
3567  *  wHue        [I] Hue amount
3568  *  wLuminosity [I] Luminosity amount
3569  *  wSaturation [I] Saturation amount
3570  *
3571  * RETURNS
3572  *  A COLORREF representing the converted color.
3573  *
3574  * NOTES
3575  *  Input hls values are constrained to the range (0..240).
3576  */
3577 COLORREF WINAPI ColorHLSToRGB(WORD wHue, WORD wLuminosity, WORD wSaturation)
3578 {
3579   WORD wRed;
3580
3581   if (wSaturation)
3582   {
3583     WORD wGreen, wBlue, wMid1, wMid2;
3584
3585     if (wLuminosity > 120)
3586       wMid2 = wSaturation + wLuminosity - (wSaturation * wLuminosity + 120) / 240;
3587     else
3588       wMid2 = ((wSaturation + 240) * wLuminosity + 120) / 240;
3589
3590     wMid1 = wLuminosity * 2 - wMid2;
3591
3592     wRed   = GET_RGB(wHue + 80);
3593     wGreen = GET_RGB(wHue);
3594     wBlue  = GET_RGB(wHue - 80);
3595
3596     return RGB(wRed, wGreen, wBlue);
3597   }
3598
3599   wRed = wLuminosity * 255 / 240;
3600   return RGB(wRed, wRed, wRed);
3601 }
3602
3603 /*************************************************************************
3604  *      @       [SHLWAPI.413]
3605  *
3606  * Get the current docking status of the system.
3607  *
3608  * PARAMS
3609  *  dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3610  *
3611  * RETURNS
3612  *  One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3613  *  a notebook.
3614  */
3615 DWORD WINAPI SHGetMachineInfo(DWORD dwFlags)
3616 {
3617   HW_PROFILE_INFOA hwInfo;
3618
3619   TRACE("(0x%08x)\n", dwFlags);
3620
3621   GetCurrentHwProfileA(&hwInfo);
3622   switch (hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED))
3623   {
3624   case DOCKINFO_DOCKED:
3625   case DOCKINFO_UNDOCKED:
3626     return hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED);
3627   default:
3628     return 0;
3629   }
3630 }
3631
3632 /*************************************************************************
3633  *      @       [SHLWAPI.418]
3634  *
3635  * Function seems to do FreeLibrary plus other things.
3636  *
3637  * FIXME native shows the following calls:
3638  *   RtlEnterCriticalSection
3639  *   LocalFree
3640  *   GetProcAddress(Comctl32??, 150L)
3641  *   DPA_DeletePtr
3642  *   RtlLeaveCriticalSection
3643  *  followed by the FreeLibrary.
3644  *  The above code may be related to .377 above.
3645  */
3646 BOOL WINAPI MLFreeLibrary(HMODULE hModule)
3647 {
3648         FIXME("(%p) semi-stub\n", hModule);
3649         return FreeLibrary(hModule);
3650 }
3651
3652 /*************************************************************************
3653  *      @       [SHLWAPI.419]
3654  */
3655 BOOL WINAPI SHFlushSFCacheWrap(void) {
3656   FIXME(": stub\n");
3657   return TRUE;
3658 }
3659
3660 /*************************************************************************
3661  *      @      [SHLWAPI.429]
3662  * FIXME I have no idea what this function does or what its arguments are.
3663  */
3664 BOOL WINAPI MLIsMLHInstance(HINSTANCE hInst)
3665 {
3666        FIXME("(%p) stub\n", hInst);
3667        return FALSE;
3668 }
3669
3670
3671 /*************************************************************************
3672  *      @       [SHLWAPI.430]
3673  */
3674 DWORD WINAPI MLSetMLHInstance(HINSTANCE hInst, HANDLE hHeap)
3675 {
3676         FIXME("(%p,%p) stub\n", hInst, hHeap);
3677         return E_FAIL;   /* This is what is used if shlwapi not loaded */
3678 }
3679
3680 /*************************************************************************
3681  *      @       [SHLWAPI.431]
3682  */
3683 DWORD WINAPI MLClearMLHInstance(DWORD x)
3684 {
3685         FIXME("(0x%08x)stub\n", x);
3686         return 0xabba1247;
3687 }
3688
3689 /*************************************************************************
3690  * @ [SHLWAPI.432]
3691  *
3692  * See SHSendMessageBroadcastW
3693  *
3694  */
3695 DWORD WINAPI SHSendMessageBroadcastA(UINT uMsg, WPARAM wParam, LPARAM lParam)
3696 {
3697     return SendMessageTimeoutA(HWND_BROADCAST, uMsg, wParam, lParam,
3698                                SMTO_ABORTIFHUNG, 2000, NULL);
3699 }
3700
3701 /*************************************************************************
3702  * @ [SHLWAPI.433]
3703  *
3704  * A wrapper for sending Broadcast Messages to all top level Windows
3705  *
3706  */
3707 DWORD WINAPI SHSendMessageBroadcastW(UINT uMsg, WPARAM wParam, LPARAM lParam)
3708 {
3709     return SendMessageTimeoutW(HWND_BROADCAST, uMsg, wParam, lParam,
3710                                SMTO_ABORTIFHUNG, 2000, NULL);
3711 }
3712
3713 /*************************************************************************
3714  *      @       [SHLWAPI.436]
3715  *
3716  * Convert a Unicode string CLSID into a CLSID.
3717  *
3718  * PARAMS
3719  *  idstr      [I]   string containing a CLSID in text form
3720  *  id         [O]   CLSID extracted from the string
3721  *
3722  * RETURNS
3723  *  S_OK on success or E_INVALIDARG on failure
3724  */
3725 HRESULT WINAPI CLSIDFromStringWrap(LPCWSTR idstr, CLSID *id)
3726 {
3727     return CLSIDFromString((LPOLESTR)idstr, id);
3728 }
3729
3730 /*************************************************************************
3731  *      @       [SHLWAPI.437]
3732  *
3733  * Determine if the OS supports a given feature.
3734  *
3735  * PARAMS
3736  *  dwFeature [I] Feature requested (undocumented)
3737  *
3738  * RETURNS
3739  *  TRUE  If the feature is available.
3740  *  FALSE If the feature is not available.
3741  */
3742 BOOL WINAPI IsOS(DWORD feature)
3743 {
3744     OSVERSIONINFOA osvi;
3745     DWORD platform, majorv, minorv;
3746
3747     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
3748     if(!GetVersionExA(&osvi))  {
3749         ERR("GetVersionEx failed\n");
3750         return FALSE;
3751     }
3752
3753     majorv = osvi.dwMajorVersion;
3754     minorv = osvi.dwMinorVersion;
3755     platform = osvi.dwPlatformId;
3756
3757 #define ISOS_RETURN(x) \
3758     TRACE("(0x%x) ret=%d\n",feature,(x)); \
3759     return (x);
3760
3761     switch(feature)  {
3762     case OS_WIN32SORGREATER:
3763         ISOS_RETURN(platform == VER_PLATFORM_WIN32s
3764                  || platform == VER_PLATFORM_WIN32_WINDOWS)
3765     case OS_NT:
3766         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3767     case OS_WIN95ORGREATER:
3768         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS)
3769     case OS_NT4ORGREATER:
3770         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 4)
3771     case OS_WIN2000ORGREATER_ALT:
3772     case OS_WIN2000ORGREATER:
3773         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3774     case OS_WIN98ORGREATER:
3775         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 10)
3776     case OS_WIN98_GOLD:
3777         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 10)
3778     case OS_WIN2000PRO:
3779         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3780     case OS_WIN2000SERVER:
3781         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3782     case OS_WIN2000ADVSERVER:
3783         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3784     case OS_WIN2000DATACENTER:
3785         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3786     case OS_WIN2000TERMINAL:
3787         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3788     case OS_EMBEDDED:
3789         FIXME("(OS_EMBEDDED) What should we return here?\n");
3790         return FALSE;
3791     case OS_TERMINALCLIENT:
3792         FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
3793         return FALSE;
3794     case OS_TERMINALREMOTEADMIN:
3795         FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
3796         return FALSE;
3797     case OS_WIN95_GOLD:
3798         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 0)
3799     case OS_MEORGREATER:
3800         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 90)
3801     case OS_XPORGREATER:
3802         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
3803     case OS_HOME:
3804         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
3805     case OS_PROFESSIONAL:
3806         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3807     case OS_DATACENTER:
3808         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3809     case OS_ADVSERVER:
3810         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3811     case OS_SERVER:
3812         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3813     case OS_TERMINALSERVER:
3814         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3815     case OS_PERSONALTERMINALSERVER:
3816         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && minorv >= 1 && majorv >= 5)
3817     case OS_FASTUSERSWITCHING:
3818         FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
3819         return TRUE;
3820     case OS_WELCOMELOGONUI:
3821         FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
3822         return FALSE;
3823     case OS_DOMAINMEMBER:
3824         FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
3825         return TRUE;
3826     case OS_ANYSERVER:
3827         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3828     case OS_WOW6432:
3829         FIXME("(OS_WOW6432) Should we check this?\n");
3830         return FALSE;
3831     case OS_WEBSERVER:
3832         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3833     case OS_SMALLBUSINESSSERVER:
3834         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3835     case OS_TABLETPC:
3836         FIXME("(OS_TABLEPC) What should we return here?\n");
3837         return FALSE;
3838     case OS_SERVERADMINUI:
3839         FIXME("(OS_SERVERADMINUI) What should we return here?\n");
3840         return FALSE;
3841     case OS_MEDIACENTER:
3842         FIXME("(OS_MEDIACENTER) What should we return here?\n");
3843         return FALSE;
3844     case OS_APPLIANCE:
3845         FIXME("(OS_APPLIANCE) What should we return here?\n");
3846         return FALSE;
3847     }
3848
3849 #undef ISOS_RETURN
3850
3851     WARN("(0x%x) unknown parameter\n",feature);
3852
3853     return FALSE;
3854 }
3855
3856 /*************************************************************************
3857  * @  [SHLWAPI.439]
3858  */
3859 HRESULT WINAPI SHLoadRegUIStringW(HKEY hkey, LPCWSTR value, LPWSTR buf, DWORD size)
3860 {
3861     DWORD type, sz = size;
3862
3863     if(RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)buf, &sz) != ERROR_SUCCESS)
3864         return E_FAIL;
3865
3866     return SHLoadIndirectString(buf, buf, size, NULL);
3867 }
3868
3869 /*************************************************************************
3870  * @  [SHLWAPI.478]
3871  *
3872  * Call IInputObject_TranslateAcceleratorIO() on an object.
3873  *
3874  * PARAMS
3875  *  lpUnknown [I] Object supporting the IInputObject interface.
3876  *  lpMsg     [I] Key message to be processed.
3877  *
3878  * RETURNS
3879  *  Success: S_OK.
3880  *  Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
3881  */
3882 HRESULT WINAPI IUnknown_TranslateAcceleratorIO(IUnknown *lpUnknown, LPMSG lpMsg)
3883 {
3884   IInputObject* lpInput = NULL;
3885   HRESULT hRet = E_INVALIDARG;
3886
3887   TRACE("(%p,%p)\n", lpUnknown, lpMsg);
3888   if (lpUnknown)
3889   {
3890     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObject,
3891                                    (void**)&lpInput);
3892     if (SUCCEEDED(hRet) && lpInput)
3893     {
3894       hRet = IInputObject_TranslateAcceleratorIO(lpInput, lpMsg);
3895       IInputObject_Release(lpInput);
3896     }
3897   }
3898   return hRet;
3899 }
3900
3901 /*************************************************************************
3902  * @  [SHLWAPI.481]
3903  *
3904  * Call IInputObject_HasFocusIO() on an object.
3905  *
3906  * PARAMS
3907  *  lpUnknown [I] Object supporting the IInputObject interface.
3908  *
3909  * RETURNS
3910  *  Success: S_OK, if lpUnknown is an IInputObject object and has the focus,
3911  *           or S_FALSE otherwise.
3912  *  Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
3913  */
3914 HRESULT WINAPI IUnknown_HasFocusIO(IUnknown *lpUnknown)
3915 {
3916   IInputObject* lpInput = NULL;
3917   HRESULT hRet = E_INVALIDARG;
3918
3919   TRACE("(%p)\n", lpUnknown);
3920   if (lpUnknown)
3921   {
3922     hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObject,
3923                                    (void**)&lpInput);
3924     if (SUCCEEDED(hRet) && lpInput)
3925     {
3926       hRet = IInputObject_HasFocusIO(lpInput);
3927       IInputObject_Release(lpInput);
3928     }
3929   }
3930   return hRet;
3931 }
3932
3933 /*************************************************************************
3934  *      ColorRGBToHLS   [SHLWAPI.@]
3935  *
3936  * Convert an rgb COLORREF into the hls color space.
3937  *
3938  * PARAMS
3939  *  cRGB         [I] Source rgb value
3940  *  pwHue        [O] Destination for converted hue
3941  *  pwLuminance  [O] Destination for converted luminance
3942  *  pwSaturation [O] Destination for converted saturation
3943  *
3944  * RETURNS
3945  *  Nothing. pwHue, pwLuminance and pwSaturation are set to the converted
3946  *  values.
3947  *
3948  * NOTES
3949  *  Output HLS values are constrained to the range (0..240).
3950  *  For Achromatic conversions, Hue is set to 160.
3951  */
3952 VOID WINAPI ColorRGBToHLS(COLORREF cRGB, LPWORD pwHue,
3953                           LPWORD pwLuminance, LPWORD pwSaturation)
3954 {
3955   int wR, wG, wB, wMax, wMin, wHue, wLuminosity, wSaturation;
3956
3957   TRACE("(%08x,%p,%p,%p)\n", cRGB, pwHue, pwLuminance, pwSaturation);
3958
3959   wR = GetRValue(cRGB);
3960   wG = GetGValue(cRGB);
3961   wB = GetBValue(cRGB);
3962
3963   wMax = max(wR, max(wG, wB));
3964   wMin = min(wR, min(wG, wB));
3965
3966   /* Luminosity */
3967   wLuminosity = ((wMax + wMin) * 240 + 255) / 510;
3968
3969   if (wMax == wMin)
3970   {
3971     /* Achromatic case */
3972     wSaturation = 0;
3973     /* Hue is now unrepresentable, but this is what native returns... */
3974     wHue = 160;
3975   }
3976   else
3977   {
3978     /* Chromatic case */
3979     int wDelta = wMax - wMin, wRNorm, wGNorm, wBNorm;
3980
3981     /* Saturation */
3982     if (wLuminosity <= 120)
3983       wSaturation = ((wMax + wMin)/2 + wDelta * 240) / (wMax + wMin);
3984     else
3985       wSaturation = ((510 - wMax - wMin)/2 + wDelta * 240) / (510 - wMax - wMin);
3986
3987     /* Hue */
3988     wRNorm = (wDelta/2 + wMax * 40 - wR * 40) / wDelta;
3989     wGNorm = (wDelta/2 + wMax * 40 - wG * 40) / wDelta;
3990     wBNorm = (wDelta/2 + wMax * 40 - wB * 40) / wDelta;
3991
3992     if (wR == wMax)
3993       wHue = wBNorm - wGNorm;
3994     else if (wG == wMax)
3995       wHue = 80 + wRNorm - wBNorm;
3996     else
3997       wHue = 160 + wGNorm - wRNorm;
3998     if (wHue < 0)
3999       wHue += 240;
4000     else if (wHue > 240)
4001       wHue -= 240;
4002   }
4003   if (pwHue)
4004     *pwHue = wHue;
4005   if (pwLuminance)
4006     *pwLuminance = wLuminosity;
4007   if (pwSaturation)
4008     *pwSaturation = wSaturation;
4009 }
4010
4011 /*************************************************************************
4012  *      SHCreateShellPalette    [SHLWAPI.@]
4013  */
4014 HPALETTE WINAPI SHCreateShellPalette(HDC hdc)
4015 {
4016         FIXME("stub\n");
4017         return CreateHalftonePalette(hdc);
4018 }
4019
4020 /*************************************************************************
4021  *      SHGetInverseCMAP (SHLWAPI.@)
4022  *
4023  * Get an inverse color map table.
4024  *
4025  * PARAMS
4026  *  lpCmap  [O] Destination for color map
4027  *  dwSize  [I] Size of memory pointed to by lpCmap
4028  *
4029  * RETURNS
4030  *  Success: S_OK.
4031  *  Failure: E_POINTER,    If lpCmap is invalid.
4032  *           E_INVALIDARG, If dwFlags is invalid
4033  *           E_OUTOFMEMORY, If there is no memory available
4034  *
4035  * NOTES
4036  *  dwSize may only be CMAP_PTR_SIZE (4) or CMAP_SIZE (8192).
4037  *  If dwSize = CMAP_PTR_SIZE, *lpCmap is set to the address of this DLL's
4038  *  internal CMap.
4039  *  If dwSize = CMAP_SIZE, lpCmap is filled with a copy of the data from
4040  *  this DLL's internal CMap.
4041  */
4042 HRESULT WINAPI SHGetInverseCMAP(LPDWORD dest, DWORD dwSize)
4043 {
4044     if (dwSize == 4) {
4045         FIXME(" - returning bogus address for SHGetInverseCMAP\n");
4046         *dest = (DWORD)0xabba1249;
4047         return 0;
4048     }
4049     FIXME("(%p, %#x) stub\n", dest, dwSize);
4050     return 0;
4051 }
4052
4053 /*************************************************************************
4054  *      SHIsLowMemoryMachine    [SHLWAPI.@]
4055  *
4056  * Determine if the current computer has low memory.
4057  *
4058  * PARAMS
4059  *  x [I] FIXME
4060  *
4061  * RETURNS
4062  *  TRUE if the users machine has 16 Megabytes of memory or less,
4063  *  FALSE otherwise.
4064  */
4065 BOOL WINAPI SHIsLowMemoryMachine (DWORD x)
4066 {
4067   FIXME("(0x%08x) stub\n", x);
4068   return FALSE;
4069 }
4070
4071 /*************************************************************************
4072  *      GetMenuPosFromID        [SHLWAPI.@]
4073  *
4074  * Return the position of a menu item from its Id.
4075  *
4076  * PARAMS
4077  *   hMenu [I] Menu containing the item
4078  *   wID   [I] Id of the menu item
4079  *
4080  * RETURNS
4081  *  Success: The index of the menu item in hMenu.
4082  *  Failure: -1, If the item is not found.
4083  */
4084 INT WINAPI GetMenuPosFromID(HMENU hMenu, UINT wID)
4085 {
4086  MENUITEMINFOW mi;
4087  INT nCount = GetMenuItemCount(hMenu), nIter = 0;
4088
4089  while (nIter < nCount)
4090  {
4091    mi.cbSize = sizeof(mi);
4092    mi.fMask = MIIM_ID;
4093    if (GetMenuItemInfoW(hMenu, nIter, TRUE, &mi) && mi.wID == wID)
4094      return nIter;
4095    nIter++;
4096  }
4097  return -1;
4098 }
4099
4100 /*************************************************************************
4101  *      @       [SHLWAPI.179]
4102  *
4103  * Same as SHLWAPI.GetMenuPosFromID
4104  */
4105 DWORD WINAPI SHMenuIndexFromID(HMENU hMenu, UINT uID)
4106 {
4107     return GetMenuPosFromID(hMenu, uID);
4108 }
4109
4110
4111 /*************************************************************************
4112  *      @       [SHLWAPI.448]
4113  */
4114 VOID WINAPI FixSlashesAndColonW(LPWSTR lpwstr)
4115 {
4116     while (*lpwstr)
4117     {
4118         if (*lpwstr == '/')
4119             *lpwstr = '\\';
4120         lpwstr++;
4121     }
4122 }
4123
4124
4125 /*************************************************************************
4126  *      @       [SHLWAPI.461]
4127  */
4128 DWORD WINAPI SHGetAppCompatFlags(DWORD dwUnknown)
4129 {
4130   FIXME("(0x%08x) stub\n", dwUnknown);
4131   return 0;
4132 }
4133
4134
4135 /*************************************************************************
4136  *      @       [SHLWAPI.549]
4137  */
4138 HRESULT WINAPI SHCoCreateInstanceAC(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
4139                                     DWORD dwClsContext, REFIID iid, LPVOID *ppv)
4140 {
4141     return CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, ppv);
4142 }
4143
4144 /*************************************************************************
4145  * SHSkipJunction       [SHLWAPI.@]
4146  *
4147  * Determine if a bind context can be bound to an object
4148  *
4149  * PARAMS
4150  *  pbc    [I] Bind context to check
4151  *  pclsid [I] CLSID of object to be bound to
4152  *
4153  * RETURNS
4154  *  TRUE: If it is safe to bind
4155  *  FALSE: If pbc is invalid or binding would not be safe
4156  *
4157  */
4158 BOOL WINAPI SHSkipJunction(IBindCtx *pbc, const CLSID *pclsid)
4159 {
4160   static WCHAR szSkipBinding[] = { 'S','k','i','p',' ',
4161     'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
4162   BOOL bRet = FALSE;
4163
4164   if (pbc)
4165   {
4166     IUnknown* lpUnk;
4167
4168     if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, szSkipBinding, &lpUnk)))
4169     {
4170       CLSID clsid;
4171
4172       if (SUCCEEDED(IUnknown_GetClassID(lpUnk, &clsid)) &&
4173           IsEqualGUID(pclsid, &clsid))
4174         bRet = TRUE;
4175
4176       IUnknown_Release(lpUnk);
4177     }
4178   }
4179   return bRet;
4180 }
4181
4182 /***********************************************************************
4183  *              SHGetShellKey (SHLWAPI.@)
4184  */
4185 DWORD WINAPI SHGetShellKey(DWORD a, DWORD b, DWORD c)
4186 {
4187     FIXME("(%x, %x, %x): stub\n", a, b, c);
4188     return 0x50;
4189 }
4190
4191 /***********************************************************************
4192  *              SHQueueUserWorkItem (SHLWAPI.@)
4193  */
4194 BOOL WINAPI SHQueueUserWorkItem(LPTHREAD_START_ROUTINE pfnCallback,
4195         LPVOID pContext, LONG lPriority, DWORD_PTR dwTag,
4196         DWORD_PTR *pdwId, LPCSTR pszModule, DWORD dwFlags)
4197 {
4198     TRACE("(%p, %p, %d, %lx, %p, %s, %08x)\n", pfnCallback, pContext,
4199           lPriority, dwTag, pdwId, debugstr_a(pszModule), dwFlags);
4200
4201     if(lPriority || dwTag || pdwId || pszModule || dwFlags)
4202         FIXME("Unsupported arguments\n");
4203
4204     return QueueUserWorkItem(pfnCallback, pContext, 0);
4205 }
4206
4207 /***********************************************************************
4208  *              SHSetTimerQueueTimer (SHLWAPI.263)
4209  */
4210 HANDLE WINAPI SHSetTimerQueueTimer(HANDLE hQueue,
4211         WAITORTIMERCALLBACK pfnCallback, LPVOID pContext, DWORD dwDueTime,
4212         DWORD dwPeriod, LPCSTR lpszLibrary, DWORD dwFlags)
4213 {
4214     HANDLE hNewTimer;
4215
4216     /* SHSetTimerQueueTimer flags -> CreateTimerQueueTimer flags */
4217     if (dwFlags & TPS_LONGEXECTIME) {
4218         dwFlags &= ~TPS_LONGEXECTIME;
4219         dwFlags |= WT_EXECUTELONGFUNCTION;
4220     }
4221     if (dwFlags & TPS_EXECUTEIO) {
4222         dwFlags &= ~TPS_EXECUTEIO;
4223         dwFlags |= WT_EXECUTEINIOTHREAD;
4224     }
4225
4226     if (!CreateTimerQueueTimer(&hNewTimer, hQueue, pfnCallback, pContext,
4227                                dwDueTime, dwPeriod, dwFlags))
4228         return NULL;
4229
4230     return hNewTimer;
4231 }
4232
4233 /***********************************************************************
4234  *              IUnknown_OnFocusChangeIS (SHLWAPI.@)
4235  */
4236 HRESULT WINAPI IUnknown_OnFocusChangeIS(LPUNKNOWN lpUnknown, LPUNKNOWN pFocusObject, BOOL bFocus)
4237 {
4238     IInputObjectSite *pIOS = NULL;
4239     HRESULT hRet = E_INVALIDARG;
4240
4241     TRACE("(%p, %p, %s)\n", lpUnknown, pFocusObject, bFocus ? "TRUE" : "FALSE");
4242
4243     if (lpUnknown)
4244     {
4245         hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObjectSite,
4246                                        (void **)&pIOS);
4247         if (SUCCEEDED(hRet) && pIOS)
4248         {
4249             hRet = IInputObjectSite_OnFocusChangeIS(pIOS, pFocusObject, bFocus);
4250             IInputObjectSite_Release(pIOS);
4251         }
4252     }
4253     return hRet;
4254 }
4255
4256 /***********************************************************************
4257  *              SHGetValueW (SHLWAPI.@)
4258  */
4259 HRESULT WINAPI SKGetValueW(DWORD a, LPWSTR b, LPWSTR c, DWORD d, DWORD e, DWORD f)
4260 {
4261     FIXME("(%x, %s, %s, %x, %x, %x): stub\n", a, debugstr_w(b), debugstr_w(c), d, e, f);
4262     return E_FAIL;
4263 }
4264
4265 typedef HRESULT (WINAPI *DllGetVersion_func)(DLLVERSIONINFO *);
4266
4267 /***********************************************************************
4268  *              GetUIVersion (SHLWAPI.452)
4269  */
4270 DWORD WINAPI GetUIVersion(void)
4271 {
4272     static DWORD version;
4273
4274     if (!version)
4275     {
4276         DllGetVersion_func pDllGetVersion;
4277         HMODULE dll = LoadLibraryA("shell32.dll");
4278         if (!dll) return 0;
4279
4280         pDllGetVersion = (DllGetVersion_func)GetProcAddress(dll, "DllGetVersion");
4281         if (pDllGetVersion)
4282         {
4283             DLLVERSIONINFO dvi;
4284             dvi.cbSize = sizeof(DLLVERSIONINFO);
4285             if (pDllGetVersion(&dvi) == S_OK) version = dvi.dwMajorVersion;
4286         }
4287         FreeLibrary( dll );
4288         if (!version) version = 3;  /* old shell dlls don't have DllGetVersion */
4289     }
4290     return version;
4291 }
4292
4293 /***********************************************************************
4294  *              ShellMessageBoxWrapW [SHLWAPI.388]
4295  *
4296  * See shell32.ShellMessageBoxW
4297  *
4298  * NOTE:
4299  * shlwapi.ShellMessageBoxWrapW is a duplicate of shell32.ShellMessageBoxW
4300  * because we can't forward to it in the .spec file since it's exported by
4301  * ordinal. If you change the implementation here please update the code in
4302  * shell32 as well.
4303  */
4304 INT WINAPIV ShellMessageBoxWrapW(HINSTANCE hInstance, HWND hWnd, LPCWSTR lpText,
4305                                  LPCWSTR lpCaption, UINT uType, ...)
4306 {
4307     WCHAR szText[100], szTitle[100];
4308     LPCWSTR pszText = szText, pszTitle = szTitle;
4309     LPWSTR pszTemp;
4310     __ms_va_list args;
4311     int ret;
4312
4313     __ms_va_start(args, uType);
4314
4315     TRACE("(%p,%p,%p,%p,%08x)\n", hInstance, hWnd, lpText, lpCaption, uType);
4316
4317     if (IS_INTRESOURCE(lpCaption))
4318         LoadStringW(hInstance, LOWORD(lpCaption), szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
4319     else
4320         pszTitle = lpCaption;
4321
4322     if (IS_INTRESOURCE(lpText))
4323         LoadStringW(hInstance, LOWORD(lpText), szText, sizeof(szText)/sizeof(szText[0]));
4324     else
4325         pszText = lpText;
4326
4327     FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
4328                    pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
4329
4330     __ms_va_end(args);
4331
4332     ret = MessageBoxW(hWnd, pszTemp, pszTitle, uType);
4333     LocalFree(pszTemp);
4334     return ret;
4335 }
4336
4337 HRESULT WINAPI IUnknown_QueryServiceExec(IUnknown *unk, REFIID service, REFIID clsid,
4338                                          DWORD x1, DWORD x2, DWORD x3, void **ppvOut)
4339 {
4340     FIXME("%p %s %s %08x %08x %08x %p\n", unk,
4341           debugstr_guid(service), debugstr_guid(clsid), x1, x2, x3, ppvOut);
4342     return E_NOTIMPL;
4343 }
4344
4345 HRESULT WINAPI IUnknown_ProfferService(IUnknown *unk, void *x0, void *x1, void *x2)
4346 {
4347     FIXME("%p %p %p %p\n", unk, x0, x1, x2);
4348     return E_NOTIMPL;
4349 }
4350
4351 /***********************************************************************
4352  *              ZoneComputePaneSize [SHLWAPI.382]
4353  */
4354 UINT WINAPI ZoneComputePaneSize(HWND hwnd)
4355 {
4356     FIXME("\n");
4357     return 0x95;
4358 }
4359
4360 /***********************************************************************
4361  *              SHChangeNotifyWrap [SHLWAPI.394]
4362  */
4363 void WINAPI SHChangeNotifyWrap(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
4364 {
4365     SHChangeNotify(wEventId, uFlags, dwItem1, dwItem2);
4366 }
4367
4368 typedef struct SHELL_USER_SID {   /* according to MSDN this should be in shlobj.h... */
4369     SID_IDENTIFIER_AUTHORITY sidAuthority;
4370     DWORD                    dwUserGroupID;
4371     DWORD                    dwUserID;
4372 } SHELL_USER_SID, *PSHELL_USER_SID;
4373
4374 typedef struct SHELL_USER_PERMISSION { /* ...and this should be in shlwapi.h */
4375     SHELL_USER_SID susID;
4376     DWORD          dwAccessType;
4377     BOOL           fInherit;
4378     DWORD          dwAccessMask;
4379     DWORD          dwInheritMask;
4380     DWORD          dwInheritAccessMask;
4381 } SHELL_USER_PERMISSION, *PSHELL_USER_PERMISSION;
4382
4383 /***********************************************************************
4384  *             GetShellSecurityDescriptor [SHLWAPI.475]
4385  *
4386  * prepares SECURITY_DESCRIPTOR from a set of ACEs
4387  *
4388  * PARAMS
4389  *  apUserPerm [I] array of pointers to SHELL_USER_PERMISSION structures,
4390  *                 each of which describes permissions to apply
4391  *  cUserPerm  [I] number of entries in apUserPerm array
4392  *
4393  * RETURNS
4394  *  success: pointer to SECURITY_DESCRIPTOR
4395  *  failure: NULL
4396  *
4397  * NOTES
4398  *  Call should free returned descriptor with LocalFree
4399  */
4400 PSECURITY_DESCRIPTOR WINAPI GetShellSecurityDescriptor(PSHELL_USER_PERMISSION *apUserPerm, int cUserPerm)
4401 {
4402     PSID *sidlist;
4403     PSID  cur_user = NULL;
4404     BYTE  tuUser[2000];
4405     DWORD acl_size;
4406     int   sid_count, i;
4407     PSECURITY_DESCRIPTOR psd = NULL;
4408
4409     TRACE("%p %d\n", apUserPerm, cUserPerm);
4410
4411     if (apUserPerm == NULL || cUserPerm <= 0)
4412         return NULL;
4413
4414     sidlist = HeapAlloc(GetProcessHeap(), 0, cUserPerm * sizeof(PSID));
4415     if (!sidlist)
4416         return NULL;
4417
4418     acl_size = sizeof(ACL);
4419
4420     for(sid_count = 0; sid_count < cUserPerm; sid_count++)
4421     {
4422         static SHELL_USER_SID null_sid = {{SECURITY_NULL_SID_AUTHORITY}, 0, 0};
4423         PSHELL_USER_PERMISSION perm = apUserPerm[sid_count];
4424         PSHELL_USER_SID sid = &perm->susID;
4425         PSID pSid;
4426         BOOL ret = TRUE;
4427
4428         if (!memcmp((void*)sid, (void*)&null_sid, sizeof(SHELL_USER_SID)))
4429         {  /* current user's SID */
4430             if (!cur_user)
4431             {
4432                 HANDLE Token;
4433                 DWORD bufsize = sizeof(tuUser);
4434
4435                 ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &Token);
4436                 if (ret)
4437                 {
4438                     ret = GetTokenInformation(Token, TokenUser, (void*)tuUser, bufsize, &bufsize );
4439                     if (ret)
4440                         cur_user = ((PTOKEN_USER)tuUser)->User.Sid;
4441                     CloseHandle(Token);
4442                 }
4443             }
4444             pSid = cur_user;
4445         } else if (sid->dwUserID==0) /* one sub-authority */
4446             ret = AllocateAndInitializeSid(&sid->sidAuthority, 1, sid->dwUserGroupID, 0,
4447                     0, 0, 0, 0, 0, 0, &pSid);
4448         else
4449             ret = AllocateAndInitializeSid(&sid->sidAuthority, 2, sid->dwUserGroupID, sid->dwUserID,
4450                     0, 0, 0, 0, 0, 0, &pSid);
4451         if (!ret)
4452             goto free_sids;
4453
4454         sidlist[sid_count] = pSid;
4455         /* increment acl_size (1 ACE for non-inheritable and 2 ACEs for inheritable records */
4456         acl_size += (sizeof(ACCESS_ALLOWED_ACE)-sizeof(DWORD) + GetLengthSid(pSid)) * (perm->fInherit ? 2 : 1);
4457     }
4458
4459     psd = LocalAlloc(0, sizeof(SECURITY_DESCRIPTOR) + acl_size);
4460
4461     if (psd != NULL)
4462     {
4463         PACL pAcl = (PACL)(((BYTE*)psd)+sizeof(SECURITY_DESCRIPTOR));
4464
4465         if (!InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION))
4466             goto error;
4467
4468         if (!InitializeAcl(pAcl, acl_size, ACL_REVISION))
4469             goto error;
4470
4471         for(i = 0; i < sid_count; i++)
4472         {
4473             PSHELL_USER_PERMISSION sup = apUserPerm[i];
4474             PSID sid = sidlist[i];
4475
4476             switch(sup->dwAccessType)
4477             {
4478                 case ACCESS_ALLOWED_ACE_TYPE:
4479                     if (!AddAccessAllowedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
4480                         goto error;
4481                     if (sup->fInherit && !AddAccessAllowedAceEx(pAcl, ACL_REVISION,
4482                                 (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
4483                         goto error;
4484                     break;
4485                 case ACCESS_DENIED_ACE_TYPE:
4486                     if (!AddAccessDeniedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
4487                         goto error;
4488                     if (sup->fInherit && !AddAccessDeniedAceEx(pAcl, ACL_REVISION,
4489                                 (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
4490                         goto error;
4491                     break;
4492                 default:
4493                     goto error;
4494             }
4495         }
4496
4497         if (!SetSecurityDescriptorDacl(psd, TRUE, pAcl, FALSE))
4498             goto error;
4499     }
4500     goto free_sids;
4501
4502 error:
4503     LocalFree(psd);
4504     psd = NULL;
4505 free_sids:
4506     for(i = 0; i < sid_count; i++)
4507     {
4508         if (!cur_user || sidlist[i] != cur_user)
4509             FreeSid(sidlist[i]);
4510     }
4511     HeapFree(GetProcessHeap(), 0, sidlist);
4512
4513     return psd;
4514 }