dlls/wshom.ocx/shell.c

   1 /*
   2  * Copyright 2011 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "wshom_private.h"
  20 #include "wshom.h"
  21
  22 #include "shellapi.h"
  23 #include "shlobj.h"
  24 #include "dispex.h"
  25
  26 #include "wine/debug.h"
  27 #include "wine/unicode.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(wshom);
  30
  31 static IWshShell3 WshShell3;
  32
  33 typedef struct
  34 {
  35     IWshCollection IWshCollection_iface;
  36     LONG ref;
  37 } WshCollection;
  38
  39 typedef struct
  40 {
  41     IWshShortcut IWshShortcut_iface;
  42     LONG ref;
  43
  44     IShellLinkW *link;
  45     BSTR path_link;
  46 } WshShortcut;
  47
  48 typedef struct
  49 {
  50     IWshEnvironment IWshEnvironment_iface;
  51     LONG ref;
  52 } WshEnvironment;
  53
  54 static inline WshCollection *impl_from_IWshCollection( IWshCollection *iface )
  55 {
  56     return CONTAINING_RECORD(iface, WshCollection, IWshCollection_iface);
  57 }
  58
  59 static inline WshShortcut *impl_from_IWshShortcut( IWshShortcut *iface )
  60 {
  61     return CONTAINING_RECORD(iface, WshShortcut, IWshShortcut_iface);
  62 }
  63
  64 static inline WshEnvironment *impl_from_IWshEnvironment( IWshEnvironment *iface )
  65 {
  66     return CONTAINING_RECORD(iface, WshEnvironment, IWshEnvironment_iface);
  67 }
  68
  69 static HRESULT WINAPI WshEnvironment_QueryInterface(IWshEnvironment *iface, REFIID riid, void **obj)
  70 {
  71     WshEnvironment *This = impl_from_IWshEnvironment(iface);
  72
  73     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
  74
  75     if (IsEqualGUID(riid, &IID_IUnknown)  ||
  76         IsEqualGUID(riid, &IID_IDispatch) ||
  77         IsEqualGUID(riid, &IID_IWshEnvironment))
  78     {
  79         *obj = iface;
  80     }else {
  81         FIXME("Unknown iface %s\n", debugstr_guid(riid));
  82         *obj = NULL;
  83         return E_NOINTERFACE;
  84     }
  85
  86     IUnknown_AddRef((IUnknown*)*obj);
  87     return S_OK;
  88 }
  89
  90 static ULONG WINAPI WshEnvironment_AddRef(IWshEnvironment *iface)
  91 {
  92     WshEnvironment *This = impl_from_IWshEnvironment(iface);
  93     LONG ref = InterlockedIncrement(&This->ref);
  94     TRACE("(%p) ref = %d\n", This, ref);
  95     return ref;
  96 }
  97
  98 static ULONG WINAPI WshEnvironment_Release(IWshEnvironment *iface)
  99 {
 100     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 101     LONG ref = InterlockedDecrement(&This->ref);
 102     TRACE("(%p) ref = %d\n", This, ref);
 103
 104     if (!ref)
 105         HeapFree(GetProcessHeap(), 0, This);
 106
 107     return ref;
 108 }
 109
 110 static HRESULT WINAPI WshEnvironment_GetTypeInfoCount(IWshEnvironment *iface, UINT *pctinfo)
 111 {
 112     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 113     TRACE("(%p)->(%p)\n", This, pctinfo);
 114     *pctinfo = 1;
 115     return S_OK;
 116 }
 117
 118 static HRESULT WINAPI WshEnvironment_GetTypeInfo(IWshEnvironment *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 119 {
 120     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 121     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 122     return get_typeinfo(IWshEnvironment_tid, ppTInfo);
 123 }
 124
 125 static HRESULT WINAPI WshEnvironment_GetIDsOfNames(IWshEnvironment *iface, REFIID riid, LPOLESTR *rgszNames,
 126         UINT cNames, LCID lcid, DISPID *rgDispId)
 127 {
 128     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 129     ITypeInfo *typeinfo;
 130     HRESULT hr;
 131
 132     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 133
 134     hr = get_typeinfo(IWshEnvironment_tid, &typeinfo);
 135     if(SUCCEEDED(hr))
 136     {
 137         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 138         ITypeInfo_Release(typeinfo);
 139     }
 140
 141     return hr;
 142 }
 143
 144 static HRESULT WINAPI WshEnvironment_Invoke(IWshEnvironment *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 145         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 146 {
 147     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 148     ITypeInfo *typeinfo;
 149     HRESULT hr;
 150
 151     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 152           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 153
 154     hr = get_typeinfo(IWshEnvironment_tid, &typeinfo);
 155     if(SUCCEEDED(hr))
 156     {
 157         hr = ITypeInfo_Invoke(typeinfo, &This->IWshEnvironment_iface, dispIdMember, wFlags,
 158                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 159         ITypeInfo_Release(typeinfo);
 160     }
 161
 162     return hr;
 163 }
 164
 165 static HRESULT WINAPI WshEnvironment_get_Item(IWshEnvironment *iface, BSTR name, BSTR *value)
 166 {
 167     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 168     DWORD len;
 169
 170     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), value);
 171
 172     if (!value)
 173         return E_POINTER;
 174
 175     len = GetEnvironmentVariableW(name, NULL, 0);
 176     *value = SysAllocStringLen(NULL, len);
 177     if (!*value)
 178         return E_OUTOFMEMORY;
 179
 180     if (len)
 181         GetEnvironmentVariableW(name, *value, len+1);
 182
 183     return S_OK;
 184 }
 185
 186 static HRESULT WINAPI WshEnvironment_put_Item(IWshEnvironment *iface, BSTR name, BSTR value)
 187 {
 188     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 189     FIXME("(%p)->(%s %s): stub\n", This, debugstr_w(name), debugstr_w(value));
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI WshEnvironment_Count(IWshEnvironment *iface, LONG *count)
 194 {
 195     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 196     FIXME("(%p)->(%p): stub\n", This, count);
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI WshEnvironment_get_length(IWshEnvironment *iface, LONG *len)
 201 {
 202     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 203     FIXME("(%p)->(%p): stub\n", This, len);
 204     return E_NOTIMPL;
 205 }
 206
 207 static HRESULT WINAPI WshEnvironment__NewEnum(IWshEnvironment *iface, IUnknown **penum)
 208 {
 209     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 210     FIXME("(%p)->(%p): stub\n", This, penum);
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI WshEnvironment_Remove(IWshEnvironment *iface, BSTR name)
 215 {
 216     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 217     FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
 218     return E_NOTIMPL;
 219 }
 220
 221 static const IWshEnvironmentVtbl WshEnvironmentVtbl = {
 222     WshEnvironment_QueryInterface,
 223     WshEnvironment_AddRef,
 224     WshEnvironment_Release,
 225     WshEnvironment_GetTypeInfoCount,
 226     WshEnvironment_GetTypeInfo,
 227     WshEnvironment_GetIDsOfNames,
 228     WshEnvironment_Invoke,
 229     WshEnvironment_get_Item,
 230     WshEnvironment_put_Item,
 231     WshEnvironment_Count,
 232     WshEnvironment_get_length,
 233     WshEnvironment__NewEnum,
 234     WshEnvironment_Remove
 235 };
 236
 237 static HRESULT WshEnvironment_Create(IWshEnvironment **env)
 238 {
 239     WshEnvironment *This;
 240
 241     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 242     if (!This) return E_OUTOFMEMORY;
 243
 244     This->IWshEnvironment_iface.lpVtbl = &WshEnvironmentVtbl;
 245     This->ref = 1;
 246
 247     *env = &This->IWshEnvironment_iface;
 248
 249     return S_OK;
 250 }
 251
 252 static HRESULT WINAPI WshCollection_QueryInterface(IWshCollection *iface, REFIID riid, void **ppv)
 253 {
 254     WshCollection *This = impl_from_IWshCollection(iface);
 255
 256     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 257
 258     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 259         IsEqualGUID(riid, &IID_IDispatch) ||
 260         IsEqualGUID(riid, &IID_IWshCollection))
 261     {
 262         *ppv = iface;
 263     }else {
 264         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 265         *ppv = NULL;
 266         return E_NOINTERFACE;
 267     }
 268
 269     IUnknown_AddRef((IUnknown*)*ppv);
 270     return S_OK;
 271 }
 272
 273 static ULONG WINAPI WshCollection_AddRef(IWshCollection *iface)
 274 {
 275     WshCollection *This = impl_from_IWshCollection(iface);
 276     LONG ref = InterlockedIncrement(&This->ref);
 277     TRACE("(%p) ref = %d\n", This, ref);
 278     return ref;
 279 }
 280
 281 static ULONG WINAPI WshCollection_Release(IWshCollection *iface)
 282 {
 283     WshCollection *This = impl_from_IWshCollection(iface);
 284     LONG ref = InterlockedDecrement(&This->ref);
 285     TRACE("(%p) ref = %d\n", This, ref);
 286
 287     if (!ref)
 288         HeapFree(GetProcessHeap(), 0, This);
 289
 290     return ref;
 291 }
 292
 293 static HRESULT WINAPI WshCollection_GetTypeInfoCount(IWshCollection *iface, UINT *pctinfo)
 294 {
 295     WshCollection *This = impl_from_IWshCollection(iface);
 296     TRACE("(%p)->(%p)\n", This, pctinfo);
 297     *pctinfo = 1;
 298     return S_OK;
 299 }
 300
 301 static HRESULT WINAPI WshCollection_GetTypeInfo(IWshCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 302 {
 303     WshCollection *This = impl_from_IWshCollection(iface);
 304     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 305     return get_typeinfo(IWshCollection_tid, ppTInfo);
 306 }
 307
 308 static HRESULT WINAPI WshCollection_GetIDsOfNames(IWshCollection *iface, REFIID riid, LPOLESTR *rgszNames,
 309         UINT cNames, LCID lcid, DISPID *rgDispId)
 310 {
 311     WshCollection *This = impl_from_IWshCollection(iface);
 312     ITypeInfo *typeinfo;
 313     HRESULT hr;
 314
 315     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 316
 317     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 318     if(SUCCEEDED(hr))
 319     {
 320         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 321         ITypeInfo_Release(typeinfo);
 322     }
 323
 324     return hr;
 325 }
 326
 327 static HRESULT WINAPI WshCollection_Invoke(IWshCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 328         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 329 {
 330     WshCollection *This = impl_from_IWshCollection(iface);
 331     ITypeInfo *typeinfo;
 332     HRESULT hr;
 333
 334     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 335           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 336
 337     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 338     if(SUCCEEDED(hr))
 339     {
 340         hr = ITypeInfo_Invoke(typeinfo, &This->IWshCollection_iface, dispIdMember, wFlags,
 341                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 342         ITypeInfo_Release(typeinfo);
 343     }
 344
 345     return hr;
 346 }
 347
 348 static HRESULT WINAPI WshCollection_Item(IWshCollection *iface, VARIANT *index, VARIANT *value)
 349 {
 350     WshCollection *This = impl_from_IWshCollection(iface);
 351     static const WCHAR allusersdesktopW[] = {'A','l','l','U','s','e','r','s','D','e','s','k','t','o','p',0};
 352     static const WCHAR allusersprogramsW[] = {'A','l','l','U','s','e','r','s','P','r','o','g','r','a','m','s',0};
 353     static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
 354     PIDLIST_ABSOLUTE pidl;
 355     WCHAR pathW[MAX_PATH];
 356     int kind = 0;
 357     BSTR folder;
 358     HRESULT hr;
 359
 360     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(index), value);
 361
 362     if (V_VT(index) != VT_BSTR)
 363     {
 364         FIXME("only BSTR index supported, got %d\n", V_VT(index));
 365         return E_NOTIMPL;
 366     }
 367
 368     folder = V_BSTR(index);
 369     if (!strcmpiW(folder, desktopW))
 370         kind = CSIDL_DESKTOP;
 371     else if (!strcmpiW(folder, allusersdesktopW))
 372         kind = CSIDL_COMMON_DESKTOPDIRECTORY;
 373     else if (!strcmpiW(folder, allusersprogramsW))
 374         kind = CSIDL_COMMON_PROGRAMS;
 375     else
 376     {
 377         FIXME("folder kind %s not supported\n", debugstr_w(folder));
 378         return E_NOTIMPL;
 379     }
 380
 381     hr = SHGetSpecialFolderLocation(NULL, kind, &pidl);
 382     if (hr != S_OK) return hr;
 383
 384     if (SHGetPathFromIDListW(pidl, pathW))
 385     {
 386         V_VT(value) = VT_BSTR;
 387         V_BSTR(value) = SysAllocString(pathW);
 388         hr = V_BSTR(value) ? S_OK : E_OUTOFMEMORY;
 389     }
 390     else
 391         hr = E_FAIL;
 392
 393     CoTaskMemFree(pidl);
 394
 395     return hr;
 396 }
 397
 398 static HRESULT WINAPI WshCollection_Count(IWshCollection *iface, LONG *count)
 399 {
 400     WshCollection *This = impl_from_IWshCollection(iface);
 401     FIXME("(%p)->(%p): stub\n", This, count);
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT WINAPI WshCollection_get_length(IWshCollection *iface, LONG *count)
 406 {
 407     WshCollection *This = impl_from_IWshCollection(iface);
 408     FIXME("(%p)->(%p): stub\n", This, count);
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI WshCollection__NewEnum(IWshCollection *iface, IUnknown *Enum)
 413 {
 414     WshCollection *This = impl_from_IWshCollection(iface);
 415     FIXME("(%p)->(%p): stub\n", This, Enum);
 416     return E_NOTIMPL;
 417 }
 418
 419 static const IWshCollectionVtbl WshCollectionVtbl = {
 420     WshCollection_QueryInterface,
 421     WshCollection_AddRef,
 422     WshCollection_Release,
 423     WshCollection_GetTypeInfoCount,
 424     WshCollection_GetTypeInfo,
 425     WshCollection_GetIDsOfNames,
 426     WshCollection_Invoke,
 427     WshCollection_Item,
 428     WshCollection_Count,
 429     WshCollection_get_length,
 430     WshCollection__NewEnum
 431 };
 432
 433 static HRESULT WshCollection_Create(IWshCollection **collection)
 434 {
 435     WshCollection *This;
 436
 437     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 438     if (!This) return E_OUTOFMEMORY;
 439
 440     This->IWshCollection_iface.lpVtbl = &WshCollectionVtbl;
 441     This->ref = 1;
 442
 443     *collection = &This->IWshCollection_iface;
 444
 445     return S_OK;
 446 }
 447
 448 /* IWshShortcut */
 449 static HRESULT WINAPI WshShortcut_QueryInterface(IWshShortcut *iface, REFIID riid, void **ppv)
 450 {
 451     WshShortcut *This = impl_from_IWshShortcut(iface);
 452
 453     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 454
 455     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 456         IsEqualGUID(riid, &IID_IDispatch) ||
 457         IsEqualGUID(riid, &IID_IWshShortcut))
 458     {
 459         *ppv = iface;
 460     }else {
 461         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 462         *ppv = NULL;
 463         return E_NOINTERFACE;
 464     }
 465
 466     IUnknown_AddRef((IUnknown*)*ppv);
 467     return S_OK;
 468 }
 469
 470 static ULONG WINAPI WshShortcut_AddRef(IWshShortcut *iface)
 471 {
 472     WshShortcut *This = impl_from_IWshShortcut(iface);
 473     LONG ref = InterlockedIncrement(&This->ref);
 474     TRACE("(%p) ref = %d\n", This, ref);
 475     return ref;
 476 }
 477
 478 static ULONG WINAPI WshShortcut_Release(IWshShortcut *iface)
 479 {
 480     WshShortcut *This = impl_from_IWshShortcut(iface);
 481     LONG ref = InterlockedDecrement(&This->ref);
 482     TRACE("(%p) ref = %d\n", This, ref);
 483
 484     if (!ref)
 485     {
 486         SysFreeString(This->path_link);
 487         IShellLinkW_Release(This->link);
 488         HeapFree(GetProcessHeap(), 0, This);
 489     }
 490
 491     return ref;
 492 }
 493
 494 static HRESULT WINAPI WshShortcut_GetTypeInfoCount(IWshShortcut *iface, UINT *pctinfo)
 495 {
 496     WshShortcut *This = impl_from_IWshShortcut(iface);
 497     TRACE("(%p)->(%p)\n", This, pctinfo);
 498     *pctinfo = 1;
 499     return S_OK;
 500 }
 501
 502 static HRESULT WINAPI WshShortcut_GetTypeInfo(IWshShortcut *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 503 {
 504     WshShortcut *This = impl_from_IWshShortcut(iface);
 505     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 506     return get_typeinfo(IWshShortcut_tid, ppTInfo);
 507 }
 508
 509 static HRESULT WINAPI WshShortcut_GetIDsOfNames(IWshShortcut *iface, REFIID riid, LPOLESTR *rgszNames,
 510         UINT cNames, LCID lcid, DISPID *rgDispId)
 511 {
 512     WshShortcut *This = impl_from_IWshShortcut(iface);
 513     ITypeInfo *typeinfo;
 514     HRESULT hr;
 515
 516     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 517
 518     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 519     if(SUCCEEDED(hr))
 520     {
 521         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 522         ITypeInfo_Release(typeinfo);
 523     }
 524
 525     return hr;
 526 }
 527
 528 static HRESULT WINAPI WshShortcut_Invoke(IWshShortcut *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 529         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 530 {
 531     WshShortcut *This = impl_from_IWshShortcut(iface);
 532     ITypeInfo *typeinfo;
 533     HRESULT hr;
 534
 535     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 536           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 537
 538     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 539     if(SUCCEEDED(hr))
 540     {
 541         hr = ITypeInfo_Invoke(typeinfo, &This->IWshShortcut_iface, dispIdMember, wFlags,
 542                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 543         ITypeInfo_Release(typeinfo);
 544     }
 545
 546     return hr;
 547 }
 548
 549 static HRESULT WINAPI WshShortcut_get_FullName(IWshShortcut *iface, BSTR *name)
 550 {
 551     WshShortcut *This = impl_from_IWshShortcut(iface);
 552     FIXME("(%p)->(%p): stub\n", This, name);
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI WshShortcut_get_Arguments(IWshShortcut *iface, BSTR *Arguments)
 557 {
 558     WshShortcut *This = impl_from_IWshShortcut(iface);
 559     WCHAR buffW[INFOTIPSIZE];
 560     HRESULT hr;
 561
 562     TRACE("(%p)->(%p)\n", This, Arguments);
 563
 564     if (!Arguments)
 565         return E_POINTER;
 566
 567     *Arguments = NULL;
 568
 569     hr = IShellLinkW_GetArguments(This->link, buffW, sizeof(buffW)/sizeof(WCHAR));
 570     if (FAILED(hr))
 571         return hr;
 572
 573     *Arguments = SysAllocString(buffW);
 574     return *Arguments ? S_OK : E_OUTOFMEMORY;
 575 }
 576
 577 static HRESULT WINAPI WshShortcut_put_Arguments(IWshShortcut *iface, BSTR Arguments)
 578 {
 579     WshShortcut *This = impl_from_IWshShortcut(iface);
 580
 581     TRACE("(%p)->(%s)\n", This, debugstr_w(Arguments));
 582
 583     return IShellLinkW_SetArguments(This->link, Arguments);
 584 }
 585
 586 static HRESULT WINAPI WshShortcut_get_Description(IWshShortcut *iface, BSTR *Description)
 587 {
 588     WshShortcut *This = impl_from_IWshShortcut(iface);
 589     FIXME("(%p)->(%p): stub\n", This, Description);
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI WshShortcut_put_Description(IWshShortcut *iface, BSTR Description)
 594 {
 595     WshShortcut *This = impl_from_IWshShortcut(iface);
 596     TRACE("(%p)->(%s)\n", This, debugstr_w(Description));
 597     return IShellLinkW_SetDescription(This->link, Description);
 598 }
 599
 600 static HRESULT WINAPI WshShortcut_get_Hotkey(IWshShortcut *iface, BSTR *Hotkey)
 601 {
 602     WshShortcut *This = impl_from_IWshShortcut(iface);
 603     FIXME("(%p)->(%p): stub\n", This, Hotkey);
 604     return E_NOTIMPL;
 605 }
 606
 607 static HRESULT WINAPI WshShortcut_put_Hotkey(IWshShortcut *iface, BSTR Hotkey)
 608 {
 609     WshShortcut *This = impl_from_IWshShortcut(iface);
 610     FIXME("(%p)->(%s): stub\n", This, debugstr_w(Hotkey));
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI WshShortcut_get_IconLocation(IWshShortcut *iface, BSTR *IconPath)
 615 {
 616     static const WCHAR fmtW[] = {'%','s',',',' ','%','d',0};
 617     WshShortcut *This = impl_from_IWshShortcut(iface);
 618     WCHAR buffW[MAX_PATH], pathW[MAX_PATH];
 619     INT icon = 0;
 620     HRESULT hr;
 621
 622     TRACE("(%p)->(%p)\n", This, IconPath);
 623
 624     if (!IconPath)
 625         return E_POINTER;
 626
 627     hr = IShellLinkW_GetIconLocation(This->link, buffW, sizeof(buffW)/sizeof(WCHAR), &icon);
 628     if (FAILED(hr)) return hr;
 629
 630     sprintfW(pathW, fmtW, buffW, icon);
 631     *IconPath = SysAllocString(pathW);
 632     if (!*IconPath) return E_OUTOFMEMORY;
 633
 634     return S_OK;
 635 }
 636
 637 static HRESULT WINAPI WshShortcut_put_IconLocation(IWshShortcut *iface, BSTR IconPath)
 638 {
 639     WshShortcut *This = impl_from_IWshShortcut(iface);
 640     HRESULT hr;
 641     WCHAR *ptr;
 642     BSTR path;
 643     INT icon;
 644
 645     TRACE("(%p)->(%s)\n", This, debugstr_w(IconPath));
 646
 647     /* scan for icon id */
 648     ptr = strrchrW(IconPath, ',');
 649     if (!ptr)
 650     {
 651         WARN("icon index not found\n");
 652         return E_FAIL;
 653     }
 654
 655     path = SysAllocStringLen(IconPath, ptr-IconPath);
 656
 657     /* skip spaces if any */
 658     while (isspaceW(*++ptr))
 659         ;
 660
 661     icon = atoiW(ptr);
 662
 663     hr = IShellLinkW_SetIconLocation(This->link, path, icon);
 664     SysFreeString(path);
 665
 666     return hr;
 667 }
 668
 669 static HRESULT WINAPI WshShortcut_put_RelativePath(IWshShortcut *iface, BSTR rhs)
 670 {
 671     WshShortcut *This = impl_from_IWshShortcut(iface);
 672     FIXME("(%p)->(%s): stub\n", This, debugstr_w(rhs));
 673     return E_NOTIMPL;
 674 }
 675
 676 static HRESULT WINAPI WshShortcut_get_TargetPath(IWshShortcut *iface, BSTR *Path)
 677 {
 678     WshShortcut *This = impl_from_IWshShortcut(iface);
 679     FIXME("(%p)->(%p): stub\n", This, Path);
 680     return E_NOTIMPL;
 681 }
 682
 683 static HRESULT WINAPI WshShortcut_put_TargetPath(IWshShortcut *iface, BSTR Path)
 684 {
 685     WshShortcut *This = impl_from_IWshShortcut(iface);
 686     TRACE("(%p)->(%s)\n", This, debugstr_w(Path));
 687     return IShellLinkW_SetPath(This->link, Path);
 688 }
 689
 690 static HRESULT WINAPI WshShortcut_get_WindowStyle(IWshShortcut *iface, int *ShowCmd)
 691 {
 692     WshShortcut *This = impl_from_IWshShortcut(iface);
 693     TRACE("(%p)->(%p)\n", This, ShowCmd);
 694     return IShellLinkW_GetShowCmd(This->link, ShowCmd);
 695 }
 696
 697 static HRESULT WINAPI WshShortcut_put_WindowStyle(IWshShortcut *iface, int ShowCmd)
 698 {
 699     WshShortcut *This = impl_from_IWshShortcut(iface);
 700     TRACE("(%p)->(%d)\n", This, ShowCmd);
 701     return IShellLinkW_SetShowCmd(This->link, ShowCmd);
 702 }
 703
 704 static HRESULT WINAPI WshShortcut_get_WorkingDirectory(IWshShortcut *iface, BSTR *WorkingDirectory)
 705 {
 706     WshShortcut *This = impl_from_IWshShortcut(iface);
 707     WCHAR buffW[MAX_PATH];
 708     HRESULT hr;
 709
 710     TRACE("(%p)->(%p)\n", This, WorkingDirectory);
 711
 712     if (!WorkingDirectory)
 713         return E_POINTER;
 714
 715     *WorkingDirectory = NULL;
 716     hr = IShellLinkW_GetWorkingDirectory(This->link, buffW, sizeof(buffW)/sizeof(WCHAR));
 717     if (FAILED(hr)) return hr;
 718
 719     *WorkingDirectory = SysAllocString(buffW);
 720     return *WorkingDirectory ? S_OK : E_OUTOFMEMORY;
 721 }
 722
 723 static HRESULT WINAPI WshShortcut_put_WorkingDirectory(IWshShortcut *iface, BSTR WorkingDirectory)
 724 {
 725     WshShortcut *This = impl_from_IWshShortcut(iface);
 726     TRACE("(%p)->(%s)\n", This, debugstr_w(WorkingDirectory));
 727     return IShellLinkW_SetWorkingDirectory(This->link, WorkingDirectory);
 728 }
 729
 730 static HRESULT WINAPI WshShortcut_Load(IWshShortcut *iface, BSTR PathLink)
 731 {
 732     WshShortcut *This = impl_from_IWshShortcut(iface);
 733     FIXME("(%p)->(%s): stub\n", This, debugstr_w(PathLink));
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI WshShortcut_Save(IWshShortcut *iface)
 738 {
 739     WshShortcut *This = impl_from_IWshShortcut(iface);
 740     IPersistFile *file;
 741     HRESULT hr;
 742
 743     TRACE("(%p)\n", This);
 744
 745     IShellLinkW_QueryInterface(This->link, &IID_IPersistFile, (void**)&file);
 746     hr = IPersistFile_Save(file, This->path_link, TRUE);
 747     IPersistFile_Release(file);
 748
 749     return hr;
 750 }
 751
 752 static const IWshShortcutVtbl WshShortcutVtbl = {
 753     WshShortcut_QueryInterface,
 754     WshShortcut_AddRef,
 755     WshShortcut_Release,
 756     WshShortcut_GetTypeInfoCount,
 757     WshShortcut_GetTypeInfo,
 758     WshShortcut_GetIDsOfNames,
 759     WshShortcut_Invoke,
 760     WshShortcut_get_FullName,
 761     WshShortcut_get_Arguments,
 762     WshShortcut_put_Arguments,
 763     WshShortcut_get_Description,
 764     WshShortcut_put_Description,
 765     WshShortcut_get_Hotkey,
 766     WshShortcut_put_Hotkey,
 767     WshShortcut_get_IconLocation,
 768     WshShortcut_put_IconLocation,
 769     WshShortcut_put_RelativePath,
 770     WshShortcut_get_TargetPath,
 771     WshShortcut_put_TargetPath,
 772     WshShortcut_get_WindowStyle,
 773     WshShortcut_put_WindowStyle,
 774     WshShortcut_get_WorkingDirectory,
 775     WshShortcut_put_WorkingDirectory,
 776     WshShortcut_Load,
 777     WshShortcut_Save
 778 };
 779
 780 static HRESULT WshShortcut_Create(const WCHAR *path, IDispatch **shortcut)
 781 {
 782     WshShortcut *This;
 783     HRESULT hr;
 784
 785     *shortcut = NULL;
 786
 787     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 788     if (!This) return E_OUTOFMEMORY;
 789
 790     This->IWshShortcut_iface.lpVtbl = &WshShortcutVtbl;
 791     This->ref = 1;
 792
 793     hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
 794             &IID_IShellLinkW, (void**)&This->link);
 795     if (FAILED(hr))
 796     {
 797         HeapFree(GetProcessHeap(), 0, This);
 798         return hr;
 799     }
 800
 801     This->path_link = SysAllocString(path);
 802     if (!This->path_link)
 803     {
 804         IShellLinkW_Release(This->link);
 805         HeapFree(GetProcessHeap(), 0, This);
 806         return E_OUTOFMEMORY;
 807     }
 808
 809     *shortcut = (IDispatch*)&This->IWshShortcut_iface;
 810
 811     return S_OK;
 812 }
 813
 814 static HRESULT WINAPI WshShell3_QueryInterface(IWshShell3 *iface, REFIID riid, void **ppv)
 815 {
 816     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 817
 818     *ppv = NULL;
 819
 820     if(IsEqualGUID(riid, &IID_IUnknown)  ||
 821        IsEqualGUID(riid, &IID_IDispatch) ||
 822        IsEqualGUID(riid, &IID_IWshShell3))
 823     {
 824         *ppv = iface;
 825     }
 826     else if (IsEqualGUID(riid, &IID_IDispatchEx))
 827     {
 828         return E_NOINTERFACE;
 829     }
 830     else
 831     {
 832         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 833         return E_NOINTERFACE;
 834     }
 835
 836     IWshShell3_AddRef(iface);
 837     return S_OK;
 838 }
 839
 840 static ULONG WINAPI WshShell3_AddRef(IWshShell3 *iface)
 841 {
 842     TRACE("()\n");
 843     return 2;
 844 }
 845
 846 static ULONG WINAPI WshShell3_Release(IWshShell3 *iface)
 847 {
 848     TRACE("()\n");
 849     return 2;
 850 }
 851
 852 static HRESULT WINAPI WshShell3_GetTypeInfoCount(IWshShell3 *iface, UINT *pctinfo)
 853 {
 854     TRACE("(%p)\n", pctinfo);
 855     *pctinfo = 1;
 856     return S_OK;
 857 }
 858
 859 static HRESULT WINAPI WshShell3_GetTypeInfo(IWshShell3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 860 {
 861     TRACE("(%u %u %p)\n", iTInfo, lcid, ppTInfo);
 862     return get_typeinfo(IWshShell3_tid, ppTInfo);
 863 }
 864
 865 static HRESULT WINAPI WshShell3_GetIDsOfNames(IWshShell3 *iface, REFIID riid, LPOLESTR *rgszNames,
 866         UINT cNames, LCID lcid, DISPID *rgDispId)
 867 {
 868     ITypeInfo *typeinfo;
 869     HRESULT hr;
 870
 871     TRACE("(%s %p %u %u %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 872
 873     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
 874     if(SUCCEEDED(hr))
 875     {
 876         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 877         ITypeInfo_Release(typeinfo);
 878     }
 879
 880     return hr;
 881 }
 882
 883 static HRESULT WINAPI WshShell3_Invoke(IWshShell3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 884         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 885 {
 886     ITypeInfo *typeinfo;
 887     HRESULT hr;
 888
 889     TRACE("(%d %s %d %d %p %p %p %p)\n", dispIdMember, debugstr_guid(riid),
 890           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 891
 892     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
 893     if(SUCCEEDED(hr))
 894     {
 895         hr = ITypeInfo_Invoke(typeinfo, &WshShell3, dispIdMember, wFlags,
 896                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 897         ITypeInfo_Release(typeinfo);
 898     }
 899
 900     return hr;
 901 }
 902
 903 static HRESULT WINAPI WshShell3_get_SpecialFolders(IWshShell3 *iface, IWshCollection **folders)
 904 {
 905     TRACE("(%p)\n", folders);
 906     return WshCollection_Create(folders);
 907 }
 908
 909 static HRESULT WINAPI WshShell3_get_Environment(IWshShell3 *iface, VARIANT *type, IWshEnvironment **env)
 910 {
 911     FIXME("(%s %p): semi-stub\n", debugstr_variant(type), env);
 912     return WshEnvironment_Create(env);
 913 }
 914
 915 static HRESULT WINAPI WshShell3_Run(IWshShell3 *iface, BSTR cmd, VARIANT *style, VARIANT *WaitOnReturn, int *exit_code)
 916 {
 917     SHELLEXECUTEINFOW info;
 918     int waitforprocess;
 919     VARIANT s, w;
 920     HRESULT hr;
 921
 922     TRACE("(%s %s %s %p)\n", debugstr_w(cmd), debugstr_variant(style), debugstr_variant(WaitOnReturn), exit_code);
 923
 924     VariantInit(&s);
 925     hr = VariantChangeType(&s, style, 0, VT_I4);
 926     if (FAILED(hr))
 927     {
 928         ERR("failed to convert style argument, 0x%08x\n", hr);
 929         return hr;
 930     }
 931
 932     VariantInit(&w);
 933     hr = VariantChangeType(&w, WaitOnReturn, 0, VT_I4);
 934     if (FAILED(hr))
 935     {
 936         ERR("failed to convert wait argument, 0x%08x\n", hr);
 937         return hr;
 938     }
 939
 940     memset(&info, 0, sizeof(info));
 941     info.cbSize = sizeof(info);
 942
 943     waitforprocess = V_I4(&w);
 944
 945     info.fMask = waitforprocess ? SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS : SEE_MASK_DEFAULT;
 946     info.lpFile = cmd;
 947     info.nShow = V_I4(&s);
 948
 949     if (!ShellExecuteExW(&info))
 950     {
 951         TRACE("ShellExecute failed, %d\n", GetLastError());
 952         return HRESULT_FROM_WIN32(GetLastError());
 953     }
 954     else
 955     {
 956         if (waitforprocess)
 957         {
 958             if (exit_code)
 959             {
 960                 DWORD code;
 961                 GetExitCodeProcess(info.hProcess, &code);
 962                 *exit_code = code;
 963             }
 964             CloseHandle(info.hProcess);
 965         }
 966         else
 967             if (exit_code) *exit_code = 0;
 968
 969         return S_OK;
 970     }
 971 }
 972
 973 static HRESULT WINAPI WshShell3_Popup(IWshShell3 *iface, BSTR Text, VARIANT* SecondsToWait, VARIANT *Title, VARIANT *Type, int *button)
 974 {
 975     FIXME("(%s %s %s %s %p): stub\n", debugstr_w(Text), debugstr_variant(SecondsToWait),
 976         debugstr_variant(Title), debugstr_variant(Type), button);
 977     return E_NOTIMPL;
 978 }
 979
 980 static HRESULT WINAPI WshShell3_CreateShortcut(IWshShell3 *iface, BSTR PathLink, IDispatch** Shortcut)
 981 {
 982     TRACE("(%s %p)\n", debugstr_w(PathLink), Shortcut);
 983     return WshShortcut_Create(PathLink, Shortcut);
 984 }
 985
 986 static HRESULT WINAPI WshShell3_ExpandEnvironmentStrings(IWshShell3 *iface, BSTR Src, BSTR* Dst)
 987 {
 988     DWORD ret;
 989
 990     TRACE("(%s %p)\n", debugstr_w(Src), Dst);
 991
 992     if (!Src || !Dst) return E_POINTER;
 993
 994     ret = ExpandEnvironmentStringsW(Src, NULL, 0);
 995     *Dst = SysAllocStringLen(NULL, ret);
 996     if (!*Dst) return E_OUTOFMEMORY;
 997
 998     if (ExpandEnvironmentStringsW(Src, *Dst, ret))
 999         return S_OK;
1000     else
1001     {
1002         SysFreeString(*Dst);
1003         *Dst = NULL;
1004         return HRESULT_FROM_WIN32(GetLastError());
1005     }
1006 }
1007
1008 static HRESULT WINAPI WshShell3_RegRead(IWshShell3 *iface, BSTR Name, VARIANT* out_Value)
1009 {
1010     FIXME("(%s %p): stub\n", debugstr_w(Name), out_Value);
1011     return E_NOTIMPL;
1012 }
1013
1014 static HRESULT WINAPI WshShell3_RegWrite(IWshShell3 *iface, BSTR Name, VARIANT *Value, VARIANT *Type)
1015 {
1016     FIXME("(%s %s %s): stub\n", debugstr_w(Name), debugstr_variant(Value), debugstr_variant(Type));
1017     return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI WshShell3_RegDelete(IWshShell3 *iface, BSTR Name)
1021 {
1022     FIXME("(%s): stub\n", debugstr_w(Name));
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI WshShell3_LogEvent(IWshShell3 *iface, VARIANT *Type, BSTR Message, BSTR Target, VARIANT_BOOL *out_Success)
1027 {
1028     FIXME("(%s %s %s %p): stub\n", debugstr_variant(Type), debugstr_w(Message), debugstr_w(Target), out_Success);
1029     return E_NOTIMPL;
1030 }
1031
1032 static HRESULT WINAPI WshShell3_AppActivate(IWshShell3 *iface, VARIANT *App, VARIANT *Wait, VARIANT_BOOL *out_Success)
1033 {
1034     FIXME("(%s %s %p): stub\n", debugstr_variant(App), debugstr_variant(Wait), out_Success);
1035     return E_NOTIMPL;
1036 }
1037
1038 static HRESULT WINAPI WshShell3_SendKeys(IWshShell3 *iface, BSTR Keys, VARIANT *Wait)
1039 {
1040     FIXME("(%s %p): stub\n", debugstr_w(Keys), Wait);
1041     return E_NOTIMPL;
1042 }
1043
1044 static const IWshShell3Vtbl WshShell3Vtbl = {
1045     WshShell3_QueryInterface,
1046     WshShell3_AddRef,
1047     WshShell3_Release,
1048     WshShell3_GetTypeInfoCount,
1049     WshShell3_GetTypeInfo,
1050     WshShell3_GetIDsOfNames,
1051     WshShell3_Invoke,
1052     WshShell3_get_SpecialFolders,
1053     WshShell3_get_Environment,
1054     WshShell3_Run,
1055     WshShell3_Popup,
1056     WshShell3_CreateShortcut,
1057     WshShell3_ExpandEnvironmentStrings,
1058     WshShell3_RegRead,
1059     WshShell3_RegWrite,
1060     WshShell3_RegDelete,
1061     WshShell3_LogEvent,
1062     WshShell3_AppActivate,
1063     WshShell3_SendKeys
1064 };
1065
1066 static IWshShell3 WshShell3 = { &WshShell3Vtbl };
1067
1068 HRESULT WINAPI WshShellFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1069 {
1070     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
1071
1072     return IWshShell3_QueryInterface(&WshShell3, riid, ppv);
1073 }