git.oblomov.eu Git - wine/blob - 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 "shlobj.h"
  23
  24 #include "wine/debug.h"
  25 #include "wine/unicode.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(wshom);
  28
  29 const char *debugstr_variant(const VARIANT *v)
  30 {
  31     if(!v)
  32         return "(null)";
  33
  34     switch(V_VT(v)) {
  35     case VT_EMPTY:
  36         return "{VT_EMPTY}";
  37     case VT_NULL:
  38         return "{VT_NULL}";
  39     case VT_I4:
  40         return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
  41     case VT_R8:
  42         return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
  43     case VT_BSTR:
  44         return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
  45     case VT_DISPATCH:
  46         return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
  47     case VT_BOOL:
  48         return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
  49     case VT_UNKNOWN:
  50         return wine_dbg_sprintf("{VT_UNKNOWN: %p}", V_UNKNOWN(v));
  51     case VT_UINT:
  52         return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v));
  53     case VT_BSTR|VT_BYREF:
  54         return wine_dbg_sprintf("{VT_BSTR|VT_BYREF: ptr %p, data %s}",
  55             V_BSTRREF(v), debugstr_w(V_BSTRREF(v) ? *V_BSTRREF(v) : NULL));
  56     default:
  57         return wine_dbg_sprintf("{vt %d}", V_VT(v));
  58     }
  59 }
  60
  61 static IWshShell3 WshShell3;
  62
  63 typedef struct
  64 {
  65     IWshCollection IWshCollection_iface;
  66     LONG ref;
  67 } WshCollection;
  68
  69 typedef struct
  70 {
  71     IWshShortcut IWshShortcut_iface;
  72     LONG ref;
  73
  74     IShellLinkW *link;
  75     BSTR path_link;
  76 } WshShortcut;
  77
  78 static inline WshCollection *impl_from_IWshCollection( IWshCollection *iface )
  79 {
  80     return CONTAINING_RECORD(iface, WshCollection, IWshCollection_iface);
  81 }
  82
  83 static inline WshShortcut *impl_from_IWshShortcut( IWshShortcut *iface )
  84 {
  85     return CONTAINING_RECORD(iface, WshShortcut, IWshShortcut_iface);
  86 }
  87
  88 static HRESULT WINAPI WshCollection_QueryInterface(IWshCollection *iface, REFIID riid, void **ppv)
  89 {
  90     WshCollection *This = impl_from_IWshCollection(iface);
  91
  92     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
  93
  94     if (IsEqualGUID(riid, &IID_IUnknown)  ||
  95         IsEqualGUID(riid, &IID_IDispatch) ||
  96         IsEqualGUID(riid, &IID_IWshCollection))
  97     {
  98         *ppv = iface;
  99     }else {
 100         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 101         *ppv = NULL;
 102         return E_NOINTERFACE;
 103     }
 104
 105     IUnknown_AddRef((IUnknown*)*ppv);
 106     return S_OK;
 107 }
 108
 109 static ULONG WINAPI WshCollection_AddRef(IWshCollection *iface)
 110 {
 111     WshCollection *This = impl_from_IWshCollection(iface);
 112     LONG ref = InterlockedIncrement(&This->ref);
 113     TRACE("(%p) ref = %d\n", This, ref);
 114     return ref;
 115 }
 116
 117 static ULONG WINAPI WshCollection_Release(IWshCollection *iface)
 118 {
 119     WshCollection *This = impl_from_IWshCollection(iface);
 120     LONG ref = InterlockedDecrement(&This->ref);
 121     TRACE("(%p) ref = %d\n", This, ref);
 122
 123     if (!ref)
 124         HeapFree(GetProcessHeap(), 0, This);
 125
 126     return ref;
 127 }
 128
 129 static HRESULT WINAPI WshCollection_GetTypeInfoCount(IWshCollection *iface, UINT *pctinfo)
 130 {
 131     WshCollection *This = impl_from_IWshCollection(iface);
 132     TRACE("(%p)->(%p)\n", This, pctinfo);
 133     *pctinfo = 1;
 134     return S_OK;
 135 }
 136
 137 static HRESULT WINAPI WshCollection_GetTypeInfo(IWshCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 138 {
 139     WshCollection *This = impl_from_IWshCollection(iface);
 140     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 141     return get_typeinfo(IWshCollection_tid, ppTInfo);
 142 }
 143
 144 static HRESULT WINAPI WshCollection_GetIDsOfNames(IWshCollection *iface, REFIID riid, LPOLESTR *rgszNames,
 145         UINT cNames, LCID lcid, DISPID *rgDispId)
 146 {
 147     WshCollection *This = impl_from_IWshCollection(iface);
 148     ITypeInfo *typeinfo;
 149     HRESULT hr;
 150
 151     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 152
 153     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 154     if(SUCCEEDED(hr))
 155     {
 156         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 157         ITypeInfo_Release(typeinfo);
 158     }
 159
 160     return hr;
 161 }
 162
 163 static HRESULT WINAPI WshCollection_Invoke(IWshCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 164         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 165 {
 166     WshCollection *This = impl_from_IWshCollection(iface);
 167     ITypeInfo *typeinfo;
 168     HRESULT hr;
 169
 170     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 171           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 172
 173     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 174     if(SUCCEEDED(hr))
 175     {
 176         hr = ITypeInfo_Invoke(typeinfo, &This->IWshCollection_iface, dispIdMember, wFlags,
 177                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 178         ITypeInfo_Release(typeinfo);
 179     }
 180
 181     return hr;
 182 }
 183
 184 static HRESULT WINAPI WshCollection_Item(IWshCollection *iface, VARIANT *index, VARIANT *value)
 185 {
 186     WshCollection *This = impl_from_IWshCollection(iface);
 187     static const WCHAR allusersdesktopW[] = {'A','l','l','U','s','e','r','s','D','e','s','k','t','o','p',0};
 188     static const WCHAR allusersprogramsW[] = {'A','l','l','U','s','e','r','s','P','r','o','g','r','a','m','s',0};
 189     static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
 190     PIDLIST_ABSOLUTE pidl;
 191     WCHAR pathW[MAX_PATH];
 192     int kind = 0;
 193     BSTR folder;
 194     HRESULT hr;
 195
 196     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(index), value);
 197
 198     if (V_VT(index) != VT_BSTR)
 199     {
 200         FIXME("only BSTR index supported, got %d\n", V_VT(index));
 201         return E_NOTIMPL;
 202     }
 203
 204     folder = V_BSTR(index);
 205     if (!strcmpiW(folder, desktopW))
 206         kind = CSIDL_DESKTOP;
 207     else if (!strcmpiW(folder, allusersdesktopW))
 208         kind = CSIDL_COMMON_DESKTOPDIRECTORY;
 209     else if (!strcmpiW(folder, allusersprogramsW))
 210         kind = CSIDL_COMMON_PROGRAMS;
 211     else
 212     {
 213         FIXME("folder kind %s not supported\n", debugstr_w(folder));
 214         return E_NOTIMPL;
 215     }
 216
 217     hr = SHGetSpecialFolderLocation(NULL, kind, &pidl);
 218     if (hr != S_OK) return hr;
 219
 220     if (SHGetPathFromIDListW(pidl, pathW))
 221     {
 222         V_VT(value) = VT_BSTR;
 223         V_BSTR(value) = SysAllocString(pathW);
 224         hr = V_BSTR(value) ? S_OK : E_OUTOFMEMORY;
 225     }
 226     else
 227         hr = E_FAIL;
 228
 229     CoTaskMemFree(pidl);
 230
 231     return hr;
 232 }
 233
 234 static HRESULT WINAPI WshCollection_Count(IWshCollection *iface, LONG *count)
 235 {
 236     WshCollection *This = impl_from_IWshCollection(iface);
 237     FIXME("(%p)->(%p): stub\n", This, count);
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI WshCollection_get_length(IWshCollection *iface, LONG *count)
 242 {
 243     WshCollection *This = impl_from_IWshCollection(iface);
 244     FIXME("(%p)->(%p): stub\n", This, count);
 245     return E_NOTIMPL;
 246 }
 247
 248 static HRESULT WINAPI WshCollection__NewEnum(IWshCollection *iface, IUnknown *Enum)
 249 {
 250     WshCollection *This = impl_from_IWshCollection(iface);
 251     FIXME("(%p)->(%p): stub\n", This, Enum);
 252     return E_NOTIMPL;
 253 }
 254
 255 static const IWshCollectionVtbl WshCollectionVtbl = {
 256     WshCollection_QueryInterface,
 257     WshCollection_AddRef,
 258     WshCollection_Release,
 259     WshCollection_GetTypeInfoCount,
 260     WshCollection_GetTypeInfo,
 261     WshCollection_GetIDsOfNames,
 262     WshCollection_Invoke,
 263     WshCollection_Item,
 264     WshCollection_Count,
 265     WshCollection_get_length,
 266     WshCollection__NewEnum
 267 };
 268
 269 static HRESULT WshCollection_Create(IWshCollection **collection)
 270 {
 271     WshCollection *This;
 272
 273     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 274     if (!This) return E_OUTOFMEMORY;
 275
 276     This->IWshCollection_iface.lpVtbl = &WshCollectionVtbl;
 277     This->ref = 1;
 278
 279     *collection = &This->IWshCollection_iface;
 280
 281     return S_OK;
 282 }
 283
 284 /* IWshShortcut */
 285 static HRESULT WINAPI WshShortcut_QueryInterface(IWshShortcut *iface, REFIID riid, void **ppv)
 286 {
 287     WshShortcut *This = impl_from_IWshShortcut(iface);
 288
 289     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 290
 291     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 292         IsEqualGUID(riid, &IID_IDispatch) ||
 293         IsEqualGUID(riid, &IID_IWshShortcut))
 294     {
 295         *ppv = iface;
 296     }else {
 297         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 298         *ppv = NULL;
 299         return E_NOINTERFACE;
 300     }
 301
 302     IUnknown_AddRef((IUnknown*)*ppv);
 303     return S_OK;
 304 }
 305
 306 static ULONG WINAPI WshShortcut_AddRef(IWshShortcut *iface)
 307 {
 308     WshShortcut *This = impl_from_IWshShortcut(iface);
 309     LONG ref = InterlockedIncrement(&This->ref);
 310     TRACE("(%p) ref = %d\n", This, ref);
 311     return ref;
 312 }
 313
 314 static ULONG WINAPI WshShortcut_Release(IWshShortcut *iface)
 315 {
 316     WshShortcut *This = impl_from_IWshShortcut(iface);
 317     LONG ref = InterlockedDecrement(&This->ref);
 318     TRACE("(%p) ref = %d\n", This, ref);
 319
 320     if (!ref)
 321     {
 322         SysFreeString(This->path_link);
 323         IShellLinkW_Release(This->link);
 324         HeapFree(GetProcessHeap(), 0, This);
 325     }
 326
 327     return ref;
 328 }
 329
 330 static HRESULT WINAPI WshShortcut_GetTypeInfoCount(IWshShortcut *iface, UINT *pctinfo)
 331 {
 332     WshShortcut *This = impl_from_IWshShortcut(iface);
 333     TRACE("(%p)->(%p)\n", This, pctinfo);
 334     *pctinfo = 1;
 335     return S_OK;
 336 }
 337
 338 static HRESULT WINAPI WshShortcut_GetTypeInfo(IWshShortcut *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 339 {
 340     WshShortcut *This = impl_from_IWshShortcut(iface);
 341     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 342     return get_typeinfo(IWshShortcut_tid, ppTInfo);
 343 }
 344
 345 static HRESULT WINAPI WshShortcut_GetIDsOfNames(IWshShortcut *iface, REFIID riid, LPOLESTR *rgszNames,
 346         UINT cNames, LCID lcid, DISPID *rgDispId)
 347 {
 348     WshShortcut *This = impl_from_IWshShortcut(iface);
 349     ITypeInfo *typeinfo;
 350     HRESULT hr;
 351
 352     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 353
 354     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 355     if(SUCCEEDED(hr))
 356     {
 357         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 358         ITypeInfo_Release(typeinfo);
 359     }
 360
 361     return hr;
 362 }
 363
 364 static HRESULT WINAPI WshShortcut_Invoke(IWshShortcut *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 365         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 366 {
 367     WshShortcut *This = impl_from_IWshShortcut(iface);
 368     ITypeInfo *typeinfo;
 369     HRESULT hr;
 370
 371     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 372           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 373
 374     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 375     if(SUCCEEDED(hr))
 376     {
 377         hr = ITypeInfo_Invoke(typeinfo, &This->IWshShortcut_iface, dispIdMember, wFlags,
 378                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 379         ITypeInfo_Release(typeinfo);
 380     }
 381
 382     return hr;
 383 }
 384
 385 static HRESULT WINAPI WshShortcut_get_FullName(IWshShortcut *iface, BSTR *name)
 386 {
 387     WshShortcut *This = impl_from_IWshShortcut(iface);
 388     FIXME("(%p)->(%p): stub\n", This, name);
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI WshShortcut_get_Arguments(IWshShortcut *iface, BSTR *Arguments)
 393 {
 394     WshShortcut *This = impl_from_IWshShortcut(iface);
 395     FIXME("(%p)->(%p): stub\n", This, Arguments);
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI WshShortcut_put_Arguments(IWshShortcut *iface, BSTR Arguments)
 400 {
 401     WshShortcut *This = impl_from_IWshShortcut(iface);
 402     FIXME("(%p)->(%s): stub\n", This, debugstr_w(Arguments));
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI WshShortcut_get_Description(IWshShortcut *iface, BSTR *Description)
 407 {
 408     WshShortcut *This = impl_from_IWshShortcut(iface);
 409     FIXME("(%p)->(%p): stub\n", This, Description);
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI WshShortcut_put_Description(IWshShortcut *iface, BSTR Description)
 414 {
 415     WshShortcut *This = impl_from_IWshShortcut(iface);
 416     TRACE("(%p)->(%s)\n", This, debugstr_w(Description));
 417     return IShellLinkW_SetDescription(This->link, Description);
 418 }
 419
 420 static HRESULT WINAPI WshShortcut_get_Hotkey(IWshShortcut *iface, BSTR *Hotkey)
 421 {
 422     WshShortcut *This = impl_from_IWshShortcut(iface);
 423     FIXME("(%p)->(%p): stub\n", This, Hotkey);
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI WshShortcut_put_Hotkey(IWshShortcut *iface, BSTR Hotkey)
 428 {
 429     WshShortcut *This = impl_from_IWshShortcut(iface);
 430     FIXME("(%p)->(%s): stub\n", This, debugstr_w(Hotkey));
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI WshShortcut_get_IconLocation(IWshShortcut *iface, BSTR *IconPath)
 435 {
 436     WshShortcut *This = impl_from_IWshShortcut(iface);
 437     FIXME("(%p)->(%p): stub\n", This, IconPath);
 438     return E_NOTIMPL;
 439 }
 440
 441 static HRESULT WINAPI WshShortcut_put_IconLocation(IWshShortcut *iface, BSTR IconPath)
 442 {
 443     WshShortcut *This = impl_from_IWshShortcut(iface);
 444     FIXME("(%p)->(%s): stub\n", This, debugstr_w(IconPath));
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI WshShortcut_put_RelativePath(IWshShortcut *iface, BSTR rhs)
 449 {
 450     WshShortcut *This = impl_from_IWshShortcut(iface);
 451     FIXME("(%p)->(%s): stub\n", This, debugstr_w(rhs));
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI WshShortcut_get_TargetPath(IWshShortcut *iface, BSTR *Path)
 456 {
 457     WshShortcut *This = impl_from_IWshShortcut(iface);
 458     FIXME("(%p)->(%p): stub\n", This, Path);
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI WshShortcut_put_TargetPath(IWshShortcut *iface, BSTR Path)
 463 {
 464     WshShortcut *This = impl_from_IWshShortcut(iface);
 465     FIXME("(%p)->(%s): stub\n", This, debugstr_w(Path));
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI WshShortcut_get_WindowStyle(IWshShortcut *iface, int *ShowCmd)
 470 {
 471     WshShortcut *This = impl_from_IWshShortcut(iface);
 472     FIXME("(%p)->(%p): stub\n", This, ShowCmd);
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI WshShortcut_put_WindowStyle(IWshShortcut *iface, int ShowCmd)
 477 {
 478     WshShortcut *This = impl_from_IWshShortcut(iface);
 479     FIXME("(%p)->(%d): stub\n", This, ShowCmd);
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI WshShortcut_get_WorkingDirectory(IWshShortcut *iface, BSTR *WorkingDirectory)
 484 {
 485     WshShortcut *This = impl_from_IWshShortcut(iface);
 486     FIXME("(%p)->(%p): stub\n", This, WorkingDirectory);
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI WshShortcut_put_WorkingDirectory(IWshShortcut *iface, BSTR WorkingDirectory)
 491 {
 492     WshShortcut *This = impl_from_IWshShortcut(iface);
 493     TRACE("(%p)->(%s): stub\n", This, debugstr_w(WorkingDirectory));
 494     return IShellLinkW_SetWorkingDirectory(This->link, WorkingDirectory);
 495 }
 496
 497 static HRESULT WINAPI WshShortcut_Load(IWshShortcut *iface, BSTR PathLink)
 498 {
 499     WshShortcut *This = impl_from_IWshShortcut(iface);
 500     FIXME("(%p)->(%s): stub\n", This, debugstr_w(PathLink));
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI WshShortcut_Save(IWshShortcut *iface)
 505 {
 506     WshShortcut *This = impl_from_IWshShortcut(iface);
 507     FIXME("(%p): stub\n", This);
 508     return E_NOTIMPL;
 509 }
 510
 511 static const IWshShortcutVtbl WshShortcutVtbl = {
 512     WshShortcut_QueryInterface,
 513     WshShortcut_AddRef,
 514     WshShortcut_Release,
 515     WshShortcut_GetTypeInfoCount,
 516     WshShortcut_GetTypeInfo,
 517     WshShortcut_GetIDsOfNames,
 518     WshShortcut_Invoke,
 519     WshShortcut_get_FullName,
 520     WshShortcut_get_Arguments,
 521     WshShortcut_put_Arguments,
 522     WshShortcut_get_Description,
 523     WshShortcut_put_Description,
 524     WshShortcut_get_Hotkey,
 525     WshShortcut_put_Hotkey,
 526     WshShortcut_get_IconLocation,
 527     WshShortcut_put_IconLocation,
 528     WshShortcut_put_RelativePath,
 529     WshShortcut_get_TargetPath,
 530     WshShortcut_put_TargetPath,
 531     WshShortcut_get_WindowStyle,
 532     WshShortcut_put_WindowStyle,
 533     WshShortcut_get_WorkingDirectory,
 534     WshShortcut_put_WorkingDirectory,
 535     WshShortcut_Load,
 536     WshShortcut_Save
 537 };
 538
 539 static HRESULT WshShortcut_Create(const WCHAR *path, IDispatch **shortcut)
 540 {
 541     WshShortcut *This;
 542     HRESULT hr;
 543
 544     *shortcut = NULL;
 545
 546     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 547     if (!This) return E_OUTOFMEMORY;
 548
 549     This->IWshShortcut_iface.lpVtbl = &WshShortcutVtbl;
 550     This->ref = 1;
 551
 552     hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
 553             &IID_IShellLinkW, (void**)&This->link);
 554     if (FAILED(hr))
 555     {
 556         HeapFree(GetProcessHeap(), 0, This);
 557         return hr;
 558     }
 559
 560     This->path_link = SysAllocString(path);
 561     *shortcut = (IDispatch*)&This->IWshShortcut_iface;
 562
 563     return S_OK;
 564 }
 565
 566 static HRESULT WINAPI WshShell3_QueryInterface(IWshShell3 *iface, REFIID riid, void **ppv)
 567 {
 568     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 569
 570     if(IsEqualGUID(riid, &IID_IUnknown)  ||
 571        IsEqualGUID(riid, &IID_IDispatch) ||
 572        IsEqualGUID(riid, &IID_IWshShell3))
 573     {
 574         *ppv = iface;
 575     }else {
 576         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 577         *ppv = NULL;
 578         return E_NOINTERFACE;
 579     }
 580
 581     IWshShell3_AddRef(iface);
 582     return S_OK;
 583 }
 584
 585 static ULONG WINAPI WshShell3_AddRef(IWshShell3 *iface)
 586 {
 587     TRACE("()\n");
 588     return 2;
 589 }
 590
 591 static ULONG WINAPI WshShell3_Release(IWshShell3 *iface)
 592 {
 593     TRACE("()\n");
 594     return 2;
 595 }
 596
 597 static HRESULT WINAPI WshShell3_GetTypeInfoCount(IWshShell3 *iface, UINT *pctinfo)
 598 {
 599     TRACE("(%p)\n", pctinfo);
 600     *pctinfo = 1;
 601     return S_OK;
 602 }
 603
 604 static HRESULT WINAPI WshShell3_GetTypeInfo(IWshShell3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 605 {
 606     TRACE("(%u %u %p)\n", iTInfo, lcid, ppTInfo);
 607     return get_typeinfo(IWshShell3_tid, ppTInfo);
 608 }
 609
 610 static HRESULT WINAPI WshShell3_GetIDsOfNames(IWshShell3 *iface, REFIID riid, LPOLESTR *rgszNames,
 611         UINT cNames, LCID lcid, DISPID *rgDispId)
 612 {
 613     ITypeInfo *typeinfo;
 614     HRESULT hr;
 615
 616     TRACE("(%s %p %u %u %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 617
 618     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
 619     if(SUCCEEDED(hr))
 620     {
 621         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 622         ITypeInfo_Release(typeinfo);
 623     }
 624
 625     return hr;
 626 }
 627
 628 static HRESULT WINAPI WshShell3_Invoke(IWshShell3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 629         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 630 {
 631     ITypeInfo *typeinfo;
 632     HRESULT hr;
 633
 634     TRACE("(%d %s %d %d %p %p %p %p)\n", dispIdMember, debugstr_guid(riid),
 635           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 636
 637     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
 638     if(SUCCEEDED(hr))
 639     {
 640         hr = ITypeInfo_Invoke(typeinfo, &WshShell3, dispIdMember, wFlags,
 641                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 642         ITypeInfo_Release(typeinfo);
 643     }
 644
 645     return hr;
 646 }
 647
 648 static HRESULT WINAPI WshShell3_get_SpecialFolders(IWshShell3 *iface, IWshCollection **folders)
 649 {
 650     TRACE("(%p)\n", folders);
 651     return WshCollection_Create(folders);
 652 }
 653
 654 static HRESULT WINAPI WshShell3_get_Environment(IWshShell3 *iface, VARIANT *Type, IWshEnvironment **out_Env)
 655 {
 656     FIXME("(%p %p): stub\n", Type, out_Env);
 657     return E_NOTIMPL;
 658 }
 659
 660 static HRESULT WINAPI WshShell3_Run(IWshShell3 *iface, BSTR Command, VARIANT *WindowStyle, VARIANT *WaitOnReturn, int *out_ExitCode)
 661 {
 662     FIXME("(%s %s %p): stub\n", debugstr_variant(WindowStyle), debugstr_variant(WaitOnReturn), out_ExitCode);
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI WshShell3_Popup(IWshShell3 *iface, BSTR Text, VARIANT* SecondsToWait, VARIANT *Title, VARIANT *Type, int *button)
 667 {
 668     FIXME("(%s %s %s %s %p): stub\n", debugstr_w(Text), debugstr_variant(SecondsToWait),
 669         debugstr_variant(Title), debugstr_variant(Type), button);
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI WshShell3_CreateShortcut(IWshShell3 *iface, BSTR PathLink, IDispatch** Shortcut)
 674 {
 675     TRACE("(%s %p)\n", debugstr_w(PathLink), Shortcut);
 676     return WshShortcut_Create(PathLink, Shortcut);
 677 }
 678
 679 static HRESULT WINAPI WshShell3_ExpandEnvironmentStrings(IWshShell3 *iface, BSTR Src, BSTR* out_Dst)
 680 {
 681     FIXME("(%s %p): stub\n", debugstr_w(Src), out_Dst);
 682     return E_NOTIMPL;
 683 }
 684
 685 static HRESULT WINAPI WshShell3_RegRead(IWshShell3 *iface, BSTR Name, VARIANT* out_Value)
 686 {
 687     FIXME("(%s %p): stub\n", debugstr_w(Name), out_Value);
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI WshShell3_RegWrite(IWshShell3 *iface, BSTR Name, VARIANT *Value, VARIANT *Type)
 692 {
 693     FIXME("(%s %s %s): stub\n", debugstr_w(Name), debugstr_variant(Value), debugstr_variant(Type));
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI WshShell3_RegDelete(IWshShell3 *iface, BSTR Name)
 698 {
 699     FIXME("(%s): stub\n", debugstr_w(Name));
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI WshShell3_LogEvent(IWshShell3 *iface, VARIANT *Type, BSTR Message, BSTR Target, VARIANT_BOOL *out_Success)
 704 {
 705     FIXME("(%s %s %s %p): stub\n", debugstr_variant(Type), debugstr_w(Message), debugstr_w(Target), out_Success);
 706     return E_NOTIMPL;
 707 }
 708
 709 static HRESULT WINAPI WshShell3_AppActivate(IWshShell3 *iface, VARIANT *App, VARIANT *Wait, VARIANT_BOOL *out_Success)
 710 {
 711     FIXME("(%s %s %p): stub\n", debugstr_variant(App), debugstr_variant(Wait), out_Success);
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI WshShell3_SendKeys(IWshShell3 *iface, BSTR Keys, VARIANT *Wait)
 716 {
 717     FIXME("(%s %p): stub\n", debugstr_w(Keys), Wait);
 718     return E_NOTIMPL;
 719 }
 720
 721 static const IWshShell3Vtbl WshShell3Vtbl = {
 722     WshShell3_QueryInterface,
 723     WshShell3_AddRef,
 724     WshShell3_Release,
 725     WshShell3_GetTypeInfoCount,
 726     WshShell3_GetTypeInfo,
 727     WshShell3_GetIDsOfNames,
 728     WshShell3_Invoke,
 729     WshShell3_get_SpecialFolders,
 730     WshShell3_get_Environment,
 731     WshShell3_Run,
 732     WshShell3_Popup,
 733     WshShell3_CreateShortcut,
 734     WshShell3_ExpandEnvironmentStrings,
 735     WshShell3_RegRead,
 736     WshShell3_RegWrite,
 737     WshShell3_RegDelete,
 738     WshShell3_LogEvent,
 739     WshShell3_AppActivate,
 740     WshShell3_SendKeys
 741 };
 742
 743 static IWshShell3 WshShell3 = { &WshShell3Vtbl };
 744
 745 HRESULT WINAPI WshShellFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 746 {
 747     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 748
 749     return IWshShell3_QueryInterface(&WshShell3, riid, ppv);
 750 }