ReactOS 0.4.15-dev-7887-g64a59a1
shell.c
Go to the documentation of this file.
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#ifdef __REACTOS__
20#include <wchar.h>
21#endif
22
23#include "wshom_private.h"
24#include "wshom.h"
25
26#include "shellapi.h"
27#include "shlobj.h"
28#include "dispex.h"
29
30#include "wine/debug.h"
31#include "wine/heap.h"
32
34
35typedef struct
36{
38 IWshShell3 IWshShell3_iface;
41
42typedef struct
43{
45 IWshCollection IWshCollection_iface;
48
49typedef struct
50{
52 IWshShortcut IWshShortcut_iface;
54
58
59typedef struct
60{
62 IWshEnvironment IWshEnvironment_iface;
65
66typedef struct
67{
73
74static inline WshCollection *impl_from_IWshCollection( IWshCollection *iface )
75{
76 return CONTAINING_RECORD(iface, WshCollection, IWshCollection_iface);
77}
78
79static inline WshShortcut *impl_from_IWshShortcut( IWshShortcut *iface )
80{
81 return CONTAINING_RECORD(iface, WshShortcut, IWshShortcut_iface);
82}
83
84static inline WshEnvironment *impl_from_IWshEnvironment( IWshEnvironment *iface )
85{
86 return CONTAINING_RECORD(iface, WshEnvironment, IWshEnvironment_iface);
87}
88
89static inline WshExecImpl *impl_from_IWshExec( IWshExec *iface )
90{
91 return CONTAINING_RECORD(iface, WshExecImpl, IWshExec_iface);
92}
93
94static HRESULT WINAPI WshExec_QueryInterface(IWshExec *iface, REFIID riid, void **obj)
95{
97
98 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
99
101 IsEqualGUID(riid, &IID_IWshExec) ||
103 {
104 *obj = iface;
105 }
107 {
108 *obj = &This->classinfo.IProvideClassInfo_iface;
109 }
110 else {
111 FIXME("Unknown iface %s\n", debugstr_guid(riid));
112 *obj = NULL;
113 return E_NOINTERFACE;
114 }
115
116 IUnknown_AddRef((IUnknown *)*obj);
117 return S_OK;
118}
119
120static ULONG WINAPI WshExec_AddRef(IWshExec *iface)
121{
124 TRACE("(%p) ref = %d\n", This, ref);
125 return ref;
126}
127
128static ULONG WINAPI WshExec_Release(IWshExec *iface)
129{
132 TRACE("(%p) ref = %d\n", This, ref);
133
134 if (!ref) {
135 CloseHandle(This->info.hThread);
136 CloseHandle(This->info.hProcess);
138 }
139
140 return ref;
141}
142
143static HRESULT WINAPI WshExec_GetTypeInfoCount(IWshExec *iface, UINT *pctinfo)
144{
146 TRACE("(%p)->(%p)\n", This, pctinfo);
147 *pctinfo = 1;
148 return S_OK;
149}
150
151static HRESULT WINAPI WshExec_GetTypeInfo(IWshExec *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
152{
154 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
155 return get_typeinfo(IWshExec_tid, ppTInfo);
156}
157
158static HRESULT WINAPI WshExec_GetIDsOfNames(IWshExec *iface, REFIID riid, LPOLESTR *rgszNames,
159 UINT cNames, LCID lcid, DISPID *rgDispId)
160{
163 HRESULT hr;
164
165 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
166
168 if(SUCCEEDED(hr))
169 {
170 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
171 ITypeInfo_Release(typeinfo);
172 }
173
174 return hr;
175}
176
177static HRESULT WINAPI WshExec_Invoke(IWshExec *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
178 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
179{
182 HRESULT hr;
183
184 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
185 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
186
188 if(SUCCEEDED(hr))
189 {
190 hr = ITypeInfo_Invoke(typeinfo, &This->IWshExec_iface, dispIdMember, wFlags,
191 pDispParams, pVarResult, pExcepInfo, puArgErr);
192 ITypeInfo_Release(typeinfo);
193 }
194
195 return hr;
196}
197
198static HRESULT WINAPI WshExec_get_Status(IWshExec *iface, WshExecStatus *status)
199{
201 DWORD code;
202
203 TRACE("(%p)->(%p)\n", This, status);
204
205 if (!status)
206 return E_INVALIDARG;
207
208 if (!GetExitCodeProcess(This->info.hProcess, &code))
210
211 switch (code)
212 {
213 case 0:
214 *status = WshFinished;
215 break;
216 case STILL_ACTIVE:
217 *status = WshRunning;
218 break;
219 default:
220 *status = WshFailed;
221 }
222
223 return S_OK;
224}
225
226static HRESULT WINAPI WshExec_get_StdIn(IWshExec *iface, ITextStream **stream)
227{
229
230 FIXME("(%p)->(%p): stub\n", This, stream);
231
232 return E_NOTIMPL;
233}
234
235static HRESULT WINAPI WshExec_get_StdOut(IWshExec *iface, ITextStream **stream)
236{
238
239 FIXME("(%p)->(%p): stub\n", This, stream);
240
241 return E_NOTIMPL;
242}
243
244static HRESULT WINAPI WshExec_get_StdErr(IWshExec *iface, ITextStream **stream)
245{
247
248 FIXME("(%p)->(%p): stub\n", This, stream);
249
250 return E_NOTIMPL;
251}
252
254{
256
257 TRACE("(%p)->(%p)\n", This, pid);
258
259 if (!pid)
260 return E_INVALIDARG;
261
262 *pid = This->info.dwProcessId;
263 return S_OK;
264}
265
267{
269
270 FIXME("(%p)->(%p): stub\n", This, code);
271
272 return E_NOTIMPL;
273}
274
276{
277 INT *count = (INT*)lParam;
278
279 (*count)++;
280 PostMessageW(hwnd, WM_CLOSE, 0, 0);
281 /* try to send it to all windows, even if failed for some */
282 return TRUE;
283}
284
285static HRESULT WINAPI WshExec_Terminate(IWshExec *iface)
286{
288 BOOL ret, kill = FALSE;
289 INT count = 0;
290
291 TRACE("(%p)\n", This);
292
294 if (ret && count) {
295 /* manual testing shows that it waits 2 seconds before forcing termination */
296 if (WaitForSingleObject(This->info.hProcess, 2000) != WAIT_OBJECT_0)
297 kill = TRUE;
298 }
299 else
300 kill = TRUE;
301
302 if (kill)
303 TerminateProcess(This->info.hProcess, 0);
304
305 return S_OK;
306}
307
308static const IWshExecVtbl WshExecVtbl = {
323};
324
326{
327 STARTUPINFOW si = {0};
329
330 *ret = NULL;
331
332 This = heap_alloc(sizeof(*This));
333 if (!This)
334 return E_OUTOFMEMORY;
335
336 This->IWshExec_iface.lpVtbl = &WshExecVtbl;
337 This->ref = 1;
338
339 if (!CreateProcessW(NULL, command, NULL, NULL, FALSE, 0, NULL, NULL, &si, &This->info)) {
342 }
343
344 init_classinfo(&CLSID_WshExec, (IUnknown *)&This->IWshExec_iface, &This->classinfo);
345 *ret = &This->IWshExec_iface;
346 return S_OK;
347}
348
349static HRESULT WINAPI WshEnvironment_QueryInterface(IWshEnvironment *iface, REFIID riid, void **obj)
350{
352
353 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
354
357 IsEqualGUID(riid, &IID_IWshEnvironment))
358 {
359 *obj = iface;
360 }
362 {
363 *obj = &This->classinfo.IProvideClassInfo_iface;
364 }
365 else {
366 FIXME("Unknown iface %s\n", debugstr_guid(riid));
367 *obj = NULL;
368 return E_NOINTERFACE;
369 }
370
371 IUnknown_AddRef((IUnknown*)*obj);
372 return S_OK;
373}
374
375static ULONG WINAPI WshEnvironment_AddRef(IWshEnvironment *iface)
376{
379 TRACE("(%p) ref = %d\n", This, ref);
380 return ref;
381}
382
383static ULONG WINAPI WshEnvironment_Release(IWshEnvironment *iface)
384{
387 TRACE("(%p) ref = %d\n", This, ref);
388
389 if (!ref)
391
392 return ref;
393}
394
395static HRESULT WINAPI WshEnvironment_GetTypeInfoCount(IWshEnvironment *iface, UINT *pctinfo)
396{
398 TRACE("(%p)->(%p)\n", This, pctinfo);
399 *pctinfo = 1;
400 return S_OK;
401}
402
403static HRESULT WINAPI WshEnvironment_GetTypeInfo(IWshEnvironment *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
404{
406 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
407 return get_typeinfo(IWshEnvironment_tid, ppTInfo);
408}
409
410static HRESULT WINAPI WshEnvironment_GetIDsOfNames(IWshEnvironment *iface, REFIID riid, LPOLESTR *rgszNames,
411 UINT cNames, LCID lcid, DISPID *rgDispId)
412{
415 HRESULT hr;
416
417 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
418
420 if(SUCCEEDED(hr))
421 {
422 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
423 ITypeInfo_Release(typeinfo);
424 }
425
426 return hr;
427}
428
429static HRESULT WINAPI WshEnvironment_Invoke(IWshEnvironment *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
430 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
431{
434 HRESULT hr;
435
436 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
437 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
438
440 if(SUCCEEDED(hr))
441 {
442 hr = ITypeInfo_Invoke(typeinfo, &This->IWshEnvironment_iface, dispIdMember, wFlags,
443 pDispParams, pVarResult, pExcepInfo, puArgErr);
444 ITypeInfo_Release(typeinfo);
445 }
446
447 return hr;
448}
449
450static HRESULT WINAPI WshEnvironment_get_Item(IWshEnvironment *iface, BSTR name, BSTR *value)
451{
453 DWORD len;
454
455 TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), value);
456
457 if (!value)
458 return E_POINTER;
459
461 if (len)
462 {
464 if (*value)
466 }
467 else
469
470 return *value ? S_OK : E_OUTOFMEMORY;
471}
472
473static HRESULT WINAPI WshEnvironment_put_Item(IWshEnvironment *iface, BSTR name, BSTR value)
474{
476 FIXME("(%p)->(%s %s): stub\n", This, debugstr_w(name), debugstr_w(value));
477 return E_NOTIMPL;
478}
479
480static HRESULT WINAPI WshEnvironment_Count(IWshEnvironment *iface, LONG *count)
481{
483 FIXME("(%p)->(%p): stub\n", This, count);
484 return E_NOTIMPL;
485}
486
487static HRESULT WINAPI WshEnvironment_get_length(IWshEnvironment *iface, LONG *len)
488{
490 FIXME("(%p)->(%p): stub\n", This, len);
491 return E_NOTIMPL;
492}
493
494static HRESULT WINAPI WshEnvironment__NewEnum(IWshEnvironment *iface, IUnknown **penum)
495{
497 FIXME("(%p)->(%p): stub\n", This, penum);
498 return E_NOTIMPL;
499}
500
501static HRESULT WINAPI WshEnvironment_Remove(IWshEnvironment *iface, BSTR name)
502{
504 FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
505 return E_NOTIMPL;
506}
507
508static const IWshEnvironmentVtbl WshEnvironmentVtbl = {
522};
523
524static HRESULT WshEnvironment_Create(IWshEnvironment **env)
525{
527
528 This = heap_alloc(sizeof(*This));
529 if (!This) return E_OUTOFMEMORY;
530
531 This->IWshEnvironment_iface.lpVtbl = &WshEnvironmentVtbl;
532 This->ref = 1;
533
534 init_classinfo(&IID_IWshEnvironment, (IUnknown *)&This->IWshEnvironment_iface, &This->classinfo);
535 *env = &This->IWshEnvironment_iface;
536
537 return S_OK;
538}
539
540static HRESULT WINAPI WshCollection_QueryInterface(IWshCollection *iface, REFIID riid, void **ppv)
541{
543
544 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
545
548 IsEqualGUID(riid, &IID_IWshCollection))
549 {
550 *ppv = iface;
551 }
553 {
554 *ppv = &This->classinfo.IProvideClassInfo_iface;
555 }
556 else {
557 FIXME("Unknown iface %s\n", debugstr_guid(riid));
558 *ppv = NULL;
559 return E_NOINTERFACE;
560 }
561
562 IUnknown_AddRef((IUnknown*)*ppv);
563 return S_OK;
564}
565
566static ULONG WINAPI WshCollection_AddRef(IWshCollection *iface)
567{
570 TRACE("(%p) ref = %d\n", This, ref);
571 return ref;
572}
573
574static ULONG WINAPI WshCollection_Release(IWshCollection *iface)
575{
578 TRACE("(%p) ref = %d\n", This, ref);
579
580 if (!ref)
582
583 return ref;
584}
585
586static HRESULT WINAPI WshCollection_GetTypeInfoCount(IWshCollection *iface, UINT *pctinfo)
587{
589 TRACE("(%p)->(%p)\n", This, pctinfo);
590 *pctinfo = 1;
591 return S_OK;
592}
593
594static HRESULT WINAPI WshCollection_GetTypeInfo(IWshCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
595{
597 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
598 return get_typeinfo(IWshCollection_tid, ppTInfo);
599}
600
601static HRESULT WINAPI WshCollection_GetIDsOfNames(IWshCollection *iface, REFIID riid, LPOLESTR *rgszNames,
602 UINT cNames, LCID lcid, DISPID *rgDispId)
603{
606 HRESULT hr;
607
608 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
609
611 if(SUCCEEDED(hr))
612 {
613 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
614 ITypeInfo_Release(typeinfo);
615 }
616
617 return hr;
618}
619
620static HRESULT WINAPI WshCollection_Invoke(IWshCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
621 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
622{
625 HRESULT hr;
626
627 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
628 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
629
631 if(SUCCEEDED(hr))
632 {
633 hr = ITypeInfo_Invoke(typeinfo, &This->IWshCollection_iface, dispIdMember, wFlags,
634 pDispParams, pVarResult, pExcepInfo, puArgErr);
635 ITypeInfo_Release(typeinfo);
636 }
637
638 return hr;
639}
640
641static HRESULT WINAPI WshCollection_Item(IWshCollection *iface, VARIANT *index, VARIANT *value)
642{
644 static const WCHAR allusersdesktopW[] = {'A','l','l','U','s','e','r','s','D','e','s','k','t','o','p',0};
645 static const WCHAR allusersprogramsW[] = {'A','l','l','U','s','e','r','s','P','r','o','g','r','a','m','s',0};
646 static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
647 PIDLIST_ABSOLUTE pidl;
648 WCHAR pathW[MAX_PATH];
649 int kind = 0;
650 BSTR folder;
651 HRESULT hr;
652
653 TRACE("(%p)->(%s %p)\n", This, debugstr_variant(index), value);
654
655 if (V_VT(index) != VT_BSTR)
656 {
657 FIXME("only BSTR index supported, got %d\n", V_VT(index));
658 return E_NOTIMPL;
659 }
660
662 if (!wcsicmp(folder, desktopW))
663 kind = CSIDL_DESKTOP;
664 else if (!wcsicmp(folder, allusersdesktopW))
666 else if (!wcsicmp(folder, allusersprogramsW))
668 else
669 {
670 FIXME("folder kind %s not supported\n", debugstr_w(folder));
671 return E_NOTIMPL;
672 }
673
674 hr = SHGetSpecialFolderLocation(NULL, kind, &pidl);
675 if (hr != S_OK) return hr;
676
677 if (SHGetPathFromIDListW(pidl, pathW))
678 {
679 V_VT(value) = VT_BSTR;
680 V_BSTR(value) = SysAllocString(pathW);
682 }
683 else
684 hr = E_FAIL;
685
686 CoTaskMemFree(pidl);
687
688 return hr;
689}
690
691static HRESULT WINAPI WshCollection_Count(IWshCollection *iface, LONG *count)
692{
694 FIXME("(%p)->(%p): stub\n", This, count);
695 return E_NOTIMPL;
696}
697
698static HRESULT WINAPI WshCollection_get_length(IWshCollection *iface, LONG *count)
699{
701 FIXME("(%p)->(%p): stub\n", This, count);
702 return E_NOTIMPL;
703}
704
705static HRESULT WINAPI WshCollection__NewEnum(IWshCollection *iface, IUnknown **Enum)
706{
708 FIXME("(%p)->(%p): stub\n", This, Enum);
709 return E_NOTIMPL;
710}
711
712static const IWshCollectionVtbl WshCollectionVtbl = {
724};
725
727{
729
730 This = heap_alloc(sizeof(*This));
731 if (!This) return E_OUTOFMEMORY;
732
733 This->IWshCollection_iface.lpVtbl = &WshCollectionVtbl;
734 This->ref = 1;
735
736 init_classinfo(&IID_IWshCollection, (IUnknown *)&This->IWshCollection_iface, &This->classinfo);
737 *collection = &This->IWshCollection_iface;
738
739 return S_OK;
740}
741
742/* IWshShortcut */
743static HRESULT WINAPI WshShortcut_QueryInterface(IWshShortcut *iface, REFIID riid, void **ppv)
744{
746
747 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
748
751 IsEqualGUID(riid, &IID_IWshShortcut))
752 {
753 *ppv = iface;
754 }
756 {
757 *ppv = &This->classinfo.IProvideClassInfo_iface;
758 }
759 else {
760 FIXME("Unknown iface %s\n", debugstr_guid(riid));
761 *ppv = NULL;
762 return E_NOINTERFACE;
763 }
764
765 IUnknown_AddRef((IUnknown*)*ppv);
766 return S_OK;
767}
768
769static ULONG WINAPI WshShortcut_AddRef(IWshShortcut *iface)
770{
773 TRACE("(%p) ref = %d\n", This, ref);
774 return ref;
775}
776
777static ULONG WINAPI WshShortcut_Release(IWshShortcut *iface)
778{
781 TRACE("(%p) ref = %d\n", This, ref);
782
783 if (!ref)
784 {
785 SysFreeString(This->path_link);
786 IShellLinkW_Release(This->link);
788 }
789
790 return ref;
791}
792
793static HRESULT WINAPI WshShortcut_GetTypeInfoCount(IWshShortcut *iface, UINT *pctinfo)
794{
796 TRACE("(%p)->(%p)\n", This, pctinfo);
797 *pctinfo = 1;
798 return S_OK;
799}
800
801static HRESULT WINAPI WshShortcut_GetTypeInfo(IWshShortcut *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
802{
804 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
805 return get_typeinfo(IWshShortcut_tid, ppTInfo);
806}
807
808static HRESULT WINAPI WshShortcut_GetIDsOfNames(IWshShortcut *iface, REFIID riid, LPOLESTR *rgszNames,
809 UINT cNames, LCID lcid, DISPID *rgDispId)
810{
813 HRESULT hr;
814
815 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
816
818 if(SUCCEEDED(hr))
819 {
820 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
821 ITypeInfo_Release(typeinfo);
822 }
823
824 return hr;
825}
826
827static HRESULT WINAPI WshShortcut_Invoke(IWshShortcut *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
828 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
829{
832 HRESULT hr;
833
834 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
835 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
836
838 if(SUCCEEDED(hr))
839 {
840 hr = ITypeInfo_Invoke(typeinfo, &This->IWshShortcut_iface, dispIdMember, wFlags,
841 pDispParams, pVarResult, pExcepInfo, puArgErr);
842 ITypeInfo_Release(typeinfo);
843 }
844
845 return hr;
846}
847
848static HRESULT WINAPI WshShortcut_get_FullName(IWshShortcut *iface, BSTR *name)
849{
851 FIXME("(%p)->(%p): stub\n", This, name);
852 return E_NOTIMPL;
853}
854
855static HRESULT WINAPI WshShortcut_get_Arguments(IWshShortcut *iface, BSTR *Arguments)
856{
858 WCHAR buffW[INFOTIPSIZE];
859 HRESULT hr;
860
861 TRACE("(%p)->(%p)\n", This, Arguments);
862
863 if (!Arguments)
864 return E_POINTER;
865
866 *Arguments = NULL;
867
868 hr = IShellLinkW_GetArguments(This->link, buffW, ARRAY_SIZE(buffW));
869 if (FAILED(hr))
870 return hr;
871
872 *Arguments = SysAllocString(buffW);
873 return *Arguments ? S_OK : E_OUTOFMEMORY;
874}
875
876static HRESULT WINAPI WshShortcut_put_Arguments(IWshShortcut *iface, BSTR Arguments)
877{
879
880 TRACE("(%p)->(%s)\n", This, debugstr_w(Arguments));
881
882 return IShellLinkW_SetArguments(This->link, Arguments);
883}
884
886{
888 FIXME("(%p)->(%p): stub\n", This, Description);
889 return E_NOTIMPL;
890}
891
893{
895 TRACE("(%p)->(%s)\n", This, debugstr_w(Description));
896 return IShellLinkW_SetDescription(This->link, Description);
897}
898
899static HRESULT WINAPI WshShortcut_get_Hotkey(IWshShortcut *iface, BSTR *Hotkey)
900{
902 FIXME("(%p)->(%p): stub\n", This, Hotkey);
903 return E_NOTIMPL;
904}
905
906static HRESULT WINAPI WshShortcut_put_Hotkey(IWshShortcut *iface, BSTR Hotkey)
907{
909 FIXME("(%p)->(%s): stub\n", This, debugstr_w(Hotkey));
910 return E_NOTIMPL;
911}
912
914{
915 static const WCHAR fmtW[] = {'%','s',',',' ','%','d',0};
917 WCHAR buffW[MAX_PATH], pathW[MAX_PATH];
918 INT icon = 0;
919 HRESULT hr;
920
921 TRACE("(%p)->(%p)\n", This, IconPath);
922
923 if (!IconPath)
924 return E_POINTER;
925
926 hr = IShellLinkW_GetIconLocation(This->link, buffW, ARRAY_SIZE(buffW), &icon);
927 if (FAILED(hr)) return hr;
928
929 swprintf(pathW, fmtW, buffW, icon);
930 *IconPath = SysAllocString(pathW);
931 if (!*IconPath) return E_OUTOFMEMORY;
932
933 return S_OK;
934}
935
937{
939 HRESULT hr;
940 WCHAR *ptr;
941 BSTR path;
942 INT icon;
943
944 TRACE("(%p)->(%s)\n", This, debugstr_w(IconPath));
945
946 /* scan for icon id */
947 ptr = wcsrchr(IconPath, ',');
948 if (!ptr)
949 {
950 WARN("icon index not found\n");
951 return E_FAIL;
952 }
953
955
956 /* skip spaces if any */
957 while (iswspace(*++ptr))
958 ;
959
960 icon = wcstol(ptr, NULL, 10);
961
962 hr = IShellLinkW_SetIconLocation(This->link, path, icon);
964
965 return hr;
966}
967
968static HRESULT WINAPI WshShortcut_put_RelativePath(IWshShortcut *iface, BSTR rhs)
969{
971 FIXME("(%p)->(%s): stub\n", This, debugstr_w(rhs));
972 return E_NOTIMPL;
973}
974
975static HRESULT WINAPI WshShortcut_get_TargetPath(IWshShortcut *iface, BSTR *Path)
976{
978 FIXME("(%p)->(%p): stub\n", This, Path);
979 return E_NOTIMPL;
980}
981
983{
985 TRACE("(%p)->(%s)\n", This, debugstr_w(Path));
986 return IShellLinkW_SetPath(This->link, Path);
987}
988
989static HRESULT WINAPI WshShortcut_get_WindowStyle(IWshShortcut *iface, int *ShowCmd)
990{
992 TRACE("(%p)->(%p)\n", This, ShowCmd);
993 return IShellLinkW_GetShowCmd(This->link, ShowCmd);
994}
995
996static HRESULT WINAPI WshShortcut_put_WindowStyle(IWshShortcut *iface, int ShowCmd)
997{
999 TRACE("(%p)->(%d)\n", This, ShowCmd);
1000 return IShellLinkW_SetShowCmd(This->link, ShowCmd);
1001}
1002
1003static HRESULT WINAPI WshShortcut_get_WorkingDirectory(IWshShortcut *iface, BSTR *WorkingDirectory)
1004{
1006 WCHAR buffW[MAX_PATH];
1007 HRESULT hr;
1008
1009 TRACE("(%p)->(%p)\n", This, WorkingDirectory);
1010
1011 if (!WorkingDirectory)
1012 return E_POINTER;
1013
1014 *WorkingDirectory = NULL;
1015 hr = IShellLinkW_GetWorkingDirectory(This->link, buffW, ARRAY_SIZE(buffW));
1016 if (FAILED(hr)) return hr;
1017
1018 *WorkingDirectory = SysAllocString(buffW);
1019 return *WorkingDirectory ? S_OK : E_OUTOFMEMORY;
1020}
1021
1022static HRESULT WINAPI WshShortcut_put_WorkingDirectory(IWshShortcut *iface, BSTR WorkingDirectory)
1023{
1025 TRACE("(%p)->(%s)\n", This, debugstr_w(WorkingDirectory));
1026 return IShellLinkW_SetWorkingDirectory(This->link, WorkingDirectory);
1027}
1028
1029static HRESULT WINAPI WshShortcut_Load(IWshShortcut *iface, BSTR PathLink)
1030{
1032 FIXME("(%p)->(%s): stub\n", This, debugstr_w(PathLink));
1033 return E_NOTIMPL;
1034}
1035
1036static HRESULT WINAPI WshShortcut_Save(IWshShortcut *iface)
1037{
1040 HRESULT hr;
1041
1042 TRACE("(%p)\n", This);
1043
1044 IShellLinkW_QueryInterface(This->link, &IID_IPersistFile, (void**)&file);
1045 hr = IPersistFile_Save(file, This->path_link, TRUE);
1046 IPersistFile_Release(file);
1047
1048 return hr;
1049}
1050
1051static const IWshShortcutVtbl WshShortcutVtbl = {
1077};
1078
1080{
1082 HRESULT hr;
1083
1084 *shortcut = NULL;
1085
1086 This = heap_alloc(sizeof(*This));
1087 if (!This) return E_OUTOFMEMORY;
1088
1089 This->IWshShortcut_iface.lpVtbl = &WshShortcutVtbl;
1090 This->ref = 1;
1091
1092 hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
1093 &IID_IShellLinkW, (void**)&This->link);
1094 if (FAILED(hr))
1095 {
1096 heap_free(This);
1097 return hr;
1098 }
1099
1100 This->path_link = SysAllocString(path);
1101 if (!This->path_link)
1102 {
1103 IShellLinkW_Release(This->link);
1104 heap_free(This);
1105 return E_OUTOFMEMORY;
1106 }
1107
1108 init_classinfo(&IID_IWshShortcut, (IUnknown *)&This->IWshShortcut_iface, &This->classinfo);
1109 *shortcut = (IDispatch*)&This->IWshShortcut_iface;
1110
1111 return S_OK;
1112}
1113
1114static HRESULT WINAPI WshShell3_QueryInterface(IWshShell3 *iface, REFIID riid, void **ppv)
1115{
1116 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1117
1118 *ppv = NULL;
1119
1121 IsEqualGUID(riid, &IID_IWshShell3) ||
1122 IsEqualGUID(riid, &IID_IWshShell2) ||
1123 IsEqualGUID(riid, &IID_IWshShell) ||
1125 {
1126 *ppv = iface;
1127 }
1128 else if (IsEqualGUID(riid, &IID_IDispatchEx))
1129 {
1130 return E_NOINTERFACE;
1131 }
1133 {
1134 *ppv = &WshShell3.classinfo.IProvideClassInfo_iface;
1135 }
1136 else
1137 {
1138 WARN("unknown iface %s\n", debugstr_guid(riid));
1139 return E_NOINTERFACE;
1140 }
1141
1142 IUnknown_AddRef((IUnknown *)*ppv);
1143 return S_OK;
1144}
1145
1146static ULONG WINAPI WshShell3_AddRef(IWshShell3 *iface)
1147{
1148 TRACE("()\n");
1149 return 2;
1150}
1151
1152static ULONG WINAPI WshShell3_Release(IWshShell3 *iface)
1153{
1154 TRACE("()\n");
1155 return 2;
1156}
1157
1158static HRESULT WINAPI WshShell3_GetTypeInfoCount(IWshShell3 *iface, UINT *pctinfo)
1159{
1160 TRACE("(%p)\n", pctinfo);
1161 *pctinfo = 1;
1162 return S_OK;
1163}
1164
1165static HRESULT WINAPI WshShell3_GetTypeInfo(IWshShell3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1166{
1167 TRACE("(%u %u %p)\n", iTInfo, lcid, ppTInfo);
1168 return get_typeinfo(IWshShell3_tid, ppTInfo);
1169}
1170
1171static HRESULT WINAPI WshShell3_GetIDsOfNames(IWshShell3 *iface, REFIID riid, LPOLESTR *rgszNames,
1172 UINT cNames, LCID lcid, DISPID *rgDispId)
1173{
1175 HRESULT hr;
1176
1177 TRACE("(%s %p %u %u %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1178
1180 if(SUCCEEDED(hr))
1181 {
1182 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1183 ITypeInfo_Release(typeinfo);
1184 }
1185
1186 return hr;
1187}
1188
1189static HRESULT WINAPI WshShell3_Invoke(IWshShell3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1190 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1191{
1193 HRESULT hr;
1194
1195 TRACE("(%d %s %d %d %p %p %p %p)\n", dispIdMember, debugstr_guid(riid),
1196 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1197
1199 if(SUCCEEDED(hr))
1200 {
1201 hr = ITypeInfo_Invoke(typeinfo, &WshShell3.IWshShell3_iface, dispIdMember, wFlags,
1202 pDispParams, pVarResult, pExcepInfo, puArgErr);
1203 ITypeInfo_Release(typeinfo);
1204 }
1205
1206 return hr;
1207}
1208
1209static HRESULT WINAPI WshShell3_get_SpecialFolders(IWshShell3 *iface, IWshCollection **folders)
1210{
1211 TRACE("(%p)\n", folders);
1212 return WshCollection_Create(folders);
1213}
1214
1215static HRESULT WINAPI WshShell3_get_Environment(IWshShell3 *iface, VARIANT *type, IWshEnvironment **env)
1216{
1217 FIXME("(%s %p): semi-stub\n", debugstr_variant(type), env);
1218 return WshEnvironment_Create(env);
1219}
1220
1222{
1223 return V_VT(arg) == VT_ERROR && V_ERROR(arg) == DISP_E_PARAMNOTFOUND;
1224}
1225
1227{
1228 WCHAR *ret, *ptr;
1229 BOOL in_quotes = FALSE;
1230
1231 if (!(ret = heap_alloc((lstrlenW(cmd) + 1) * sizeof(WCHAR)))) return NULL;
1232 lstrcpyW( ret, cmd );
1233
1234 *params = NULL;
1235 for (ptr = ret; *ptr; ptr++)
1236 {
1237 if (*ptr == '"') in_quotes = !in_quotes;
1238 else if (*ptr == ' ' && !in_quotes)
1239 {
1240 *ptr = 0;
1241 *params = ptr + 1;
1242 break;
1243 }
1244 }
1245
1246 return ret;
1247}
1248
1250{
1252 int waitforprocess;
1253 WCHAR *file, *params;
1254 VARIANT s;
1255 HRESULT hr;
1256 BOOL ret;
1257
1258 TRACE("(%s %s %s %p)\n", debugstr_w(cmd), debugstr_variant(style), debugstr_variant(wait), exit_code);
1259
1260 if (!style || !wait || !exit_code)
1261 return E_POINTER;
1262
1263 VariantInit(&s);
1264#ifdef __REACTOS__
1266 {
1267 V_VT(&s) = VT_I4;
1268 V_I4(&s) = SW_SHOW;
1269 hr = S_OK;
1270 }
1271 else
1272#endif
1273 hr = VariantChangeType(&s, style, 0, VT_I4);
1274 if (FAILED(hr))
1275 {
1276 ERR("failed to convert style argument, 0x%08x\n", hr);
1277 return hr;
1278 }
1279
1280 if (is_optional_argument(wait))
1281 waitforprocess = 0;
1282 else {
1283 VARIANT w;
1284
1285 VariantInit(&w);
1286 hr = VariantChangeType(&w, wait, 0, VT_I4);
1287 if (FAILED(hr))
1288 return hr;
1289
1290 waitforprocess = V_I4(&w);
1291 }
1292
1293 if (!(file = split_command(cmd, &params))) return E_OUTOFMEMORY;
1294
1295 memset(&info, 0, sizeof(info));
1296 info.cbSize = sizeof(info);
1298 info.lpFile = file;
1299 info.lpParameters = params;
1300 info.nShow = V_I4(&s);
1301
1303 heap_free( file );
1304 if (!ret)
1305 {
1306 TRACE("ShellExecute failed, %d\n", GetLastError());
1308 }
1309 else
1310 {
1311 if (waitforprocess)
1312 {
1315 CloseHandle(info.hProcess);
1316 }
1317 else
1318 *exit_code = 0;
1319
1320 return S_OK;
1321 }
1322}
1323
1325{
1330};
1331
1333{
1334 static const WCHAR defaulttitleW[] = {'W','i','n','d','o','w','s',' ','S','c','r','i','p','t',' ','H','o','s','t',0};
1335 struct popup_thread_param *param = (struct popup_thread_param *)arg;
1336
1337 param->button = MessageBoxW(NULL, param->text, is_optional_argument(&param->title) ?
1338 defaulttitleW : V_BSTR(&param->title), V_I4(&param->type));
1339 return 0;
1340}
1341
1342static HRESULT WINAPI WshShell3_Popup(IWshShell3 *iface, BSTR text, VARIANT *seconds_to_wait, VARIANT *title,
1343 VARIANT *type, int *button)
1344{
1346 DWORD tid, status;
1348 HANDLE hthread;
1349 HRESULT hr;
1350
1351 TRACE("(%s %s %s %s %p)\n", debugstr_w(text), debugstr_variant(seconds_to_wait), debugstr_variant(title),
1353
1354 if (!seconds_to_wait || !title || !type || !button)
1355 return E_POINTER;
1356
1358 if (!is_optional_argument(seconds_to_wait))
1359 {
1360 hr = VariantChangeType(&timeout, seconds_to_wait, 0, VT_I4);
1361 if (FAILED(hr))
1362 return hr;
1363 }
1364#ifdef __REACTOS__
1365 else
1366 {
1368 }
1369#endif
1370
1371 VariantInit(&param.type);
1373 {
1374 hr = VariantChangeType(&param.type, type, 0, VT_I4);
1375 if (FAILED(hr))
1376 return hr;
1377 }
1378#ifdef __REACTOS__
1379 else
1380 {
1381 VariantChangeType(&param.type, &param.type, 0, VT_I4);
1382 }
1383#endif
1384
1386 param.title = *title;
1387 else
1388 {
1389 VariantInit(&param.title);
1390 hr = VariantChangeType(&param.title, title, 0, VT_BSTR);
1391 if (FAILED(hr))
1392 return hr;
1393 }
1394
1395 param.text = text;
1396 param.button = -1;
1397 hthread = CreateThread(NULL, 0, popup_thread_proc, &param, 0, &tid);
1398 status = MsgWaitForMultipleObjects(1, &hthread, FALSE, V_I4(&timeout) ? V_I4(&timeout) * 1000: INFINITE, 0);
1399 if (status == WAIT_TIMEOUT)
1400 {
1402 MsgWaitForMultipleObjects(1, &hthread, FALSE, INFINITE, 0);
1403 param.button = -1;
1404 }
1405 *button = param.button;
1406
1407 VariantClear(&param.title);
1408 CloseHandle(hthread);
1409
1410 return S_OK;
1411}
1412
1413static HRESULT WINAPI WshShell3_CreateShortcut(IWshShell3 *iface, BSTR PathLink, IDispatch** Shortcut)
1414{
1415 TRACE("(%s %p)\n", debugstr_w(PathLink), Shortcut);
1416 return WshShortcut_Create(PathLink, Shortcut);
1417}
1418
1420{
1421 DWORD ret;
1422
1423 TRACE("(%s %p)\n", debugstr_w(Src), Dst);
1424
1425 if (!Src || !Dst) return E_POINTER;
1426
1429 if (!*Dst) return E_OUTOFMEMORY;
1430
1431 if (ExpandEnvironmentStringsW(Src, *Dst, ret))
1432 return S_OK;
1433 else
1434 {
1436 *Dst = NULL;
1438 }
1439}
1440
1442{
1443 static const struct {
1444 const WCHAR full[20];
1445 const WCHAR abbrev[5];
1446 HKEY hkey;
1447 } rootkeys[] = {
1448 { {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0}, {'H','K','C','U',0}, HKEY_CURRENT_USER },
1449 { {'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0}, {'H','K','L','M',0}, HKEY_LOCAL_MACHINE },
1450 { {'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0}, {'H','K','C','R',0}, HKEY_CLASSES_ROOT },
1451 { {'H','K','E','Y','_','U','S','E','R','S',0}, {0}, HKEY_USERS },
1452 { {'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0}, {0}, HKEY_CURRENT_CONFIG }
1453 };
1454 int i;
1455
1456 for (i = 0; i < ARRAY_SIZE(rootkeys); i++) {
1457 if (!wcsncmp(path, rootkeys[i].full, lstrlenW(rootkeys[i].full)))
1458 return rootkeys[i].hkey;
1459 if (rootkeys[i].abbrev[0] && !wcsncmp(path, rootkeys[i].abbrev, lstrlenW(rootkeys[i].abbrev)))
1460 return rootkeys[i].hkey;
1461 }
1462
1463 return NULL;
1464}
1465
1466/* Caller is responsible to free 'subkey' if 'value' is not NULL */
1467static HRESULT split_reg_path(const WCHAR *path, WCHAR **subkey, WCHAR **value)
1468{
1469 *value = NULL;
1470
1471 /* at least one separator should be present */
1472 *subkey = wcschr(path, '\\');
1473 if (!*subkey)
1475
1476 /* default value or not */
1477 if ((*subkey)[lstrlenW(*subkey)-1] == '\\') {
1478 (*subkey)++;
1479 *value = NULL;
1480 }
1481 else {
1482 *value = wcsrchr(*subkey, '\\');
1483 if (*value - *subkey > 1) {
1484 unsigned int len = *value - *subkey - 1;
1485 WCHAR *ret;
1486
1487 ret = heap_alloc((len + 1)*sizeof(WCHAR));
1488 if (!ret)
1489 return E_OUTOFMEMORY;
1490
1491 memcpy(ret, *subkey + 1, len*sizeof(WCHAR));
1492 ret[len] = 0;
1493 *subkey = ret;
1494 }
1495 (*value)++;
1496 }
1497
1498 return S_OK;
1499}
1500
1502{
1504 WCHAR *subkey, *val;
1505 HRESULT hr;
1506 HKEY root;
1507
1508 TRACE("(%s %p)\n", debugstr_w(name), value);
1509
1510 if (!name || !value)
1511 return E_POINTER;
1512
1514 if (!root)
1516
1517 hr = split_reg_path(name, &subkey, &val);
1518 if (FAILED(hr))
1519 return hr;
1520
1521 type = REG_NONE;
1522 datalen = 0;
1523 ret = RegGetValueW(root, subkey, val, RRF_RT_ANY, &type, NULL, &datalen);
1524 if (ret == ERROR_SUCCESS) {
1525 void *data;
1526
1528 if (!data) {
1529 hr = E_OUTOFMEMORY;
1530 goto fail;
1531 }
1532
1533 ret = RegGetValueW(root, subkey, val, RRF_RT_ANY, &type, data, &datalen);
1534 if (ret) {
1535 heap_free(data);
1537 goto fail;
1538 }
1539
1540 switch (type) {
1541 case REG_SZ:
1542 case REG_EXPAND_SZ:
1543 V_VT(value) = VT_BSTR;
1545 if (!V_BSTR(value))
1546 hr = E_OUTOFMEMORY;
1547 break;
1548 case REG_DWORD:
1549 V_VT(value) = VT_I4;
1550 V_I4(value) = *(DWORD*)data;
1551 break;
1552 case REG_BINARY:
1553 {
1554 BYTE *ptr = (BYTE*)data;
1555 SAFEARRAYBOUND bound;
1556 unsigned int i;
1557 SAFEARRAY *sa;
1558 VARIANT *v;
1559
1560 bound.lLbound = 0;
1561 bound.cElements = datalen;
1562 sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
1563 if (!sa)
1564 break;
1565
1566 hr = SafeArrayAccessData(sa, (void**)&v);
1567 if (FAILED(hr)) {
1569 break;
1570 }
1571
1572 for (i = 0; i < datalen; i++) {
1573 V_VT(&v[i]) = VT_UI1;
1574 V_UI1(&v[i]) = ptr[i];
1575 }
1577
1579 V_ARRAY(value) = sa;
1580 break;
1581 }
1582 case REG_MULTI_SZ:
1583 {
1584 WCHAR *ptr = (WCHAR*)data;
1585 SAFEARRAYBOUND bound;
1586 SAFEARRAY *sa;
1587 VARIANT *v;
1588
1589 /* get element count first */
1590 bound.lLbound = 0;
1591 bound.cElements = 0;
1592 while (*ptr) {
1593 bound.cElements++;
1594 ptr += lstrlenW(ptr)+1;
1595 }
1596
1597 sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
1598 if (!sa)
1599 break;
1600
1601 hr = SafeArrayAccessData(sa, (void**)&v);
1602 if (FAILED(hr)) {
1604 break;
1605 }
1606
1607 ptr = (WCHAR*)data;
1608 while (*ptr) {
1609 V_VT(v) = VT_BSTR;
1611 ptr += lstrlenW(ptr)+1;
1612 v++;
1613 }
1614
1617 V_ARRAY(value) = sa;
1618 break;
1619 }
1620 default:
1621 FIXME("value type %d not supported\n", type);
1622 hr = E_FAIL;
1623 };
1624
1625 heap_free(data);
1626 if (FAILED(hr))
1628 }
1629 else
1631
1632fail:
1633 if (val)
1634 heap_free(subkey);
1635 return hr;
1636}
1637
1639{
1640 static const WCHAR regexpandszW[] = {'R','E','G','_','E','X','P','A','N','D','_','S','Z',0};
1641 static const WCHAR regszW[] = {'R','E','G','_','S','Z',0};
1642 static const WCHAR regdwordW[] = {'R','E','G','_','D','W','O','R','D',0};
1643 static const WCHAR regbinaryW[] = {'R','E','G','_','B','I','N','A','R','Y',0};
1644
1645 DWORD regtype, data_len;
1646 WCHAR *subkey, *val;
1647 const BYTE *data;
1648 HRESULT hr;
1649 HKEY root;
1650 VARIANT v;
1651 LONG ret;
1652
1654
1655 if (!name || !value || !type)
1656 return E_POINTER;
1657
1659 if (!root)
1661
1662 /* value type */
1664 regtype = REG_SZ;
1665 else {
1666 if (V_VT(type) != VT_BSTR)
1667 return E_INVALIDARG;
1668
1669 if (!wcscmp(V_BSTR(type), regszW))
1670 regtype = REG_SZ;
1671 else if (!wcscmp(V_BSTR(type), regdwordW))
1672 regtype = REG_DWORD;
1673 else if (!wcscmp(V_BSTR(type), regexpandszW))
1674 regtype = REG_EXPAND_SZ;
1675 else if (!wcscmp(V_BSTR(type), regbinaryW))
1676 regtype = REG_BINARY;
1677 else {
1678 FIXME("unrecognized value type %s\n", debugstr_w(V_BSTR(type)));
1679 return E_FAIL;
1680 }
1681 }
1682
1683 /* it's always a string or a DWORD */
1684 VariantInit(&v);
1685 switch (regtype)
1686 {
1687 case REG_SZ:
1688 case REG_EXPAND_SZ:
1690 if (hr == S_OK) {
1691 data = (BYTE*)V_BSTR(&v);
1692 data_len = SysStringByteLen(V_BSTR(&v)) + sizeof(WCHAR);
1693 }
1694 break;
1695 case REG_DWORD:
1696 case REG_BINARY:
1697 hr = VariantChangeType(&v, value, 0, VT_I4);
1698 data = (BYTE*)&V_I4(&v);
1699 data_len = sizeof(DWORD);
1700 break;
1701 default:
1702 FIXME("unexpected regtype %d\n", regtype);
1703 return E_FAIL;
1704 };
1705
1706 if (FAILED(hr)) {
1707 FIXME("failed to convert value, regtype %d, 0x%08x\n", regtype, hr);
1708 return hr;
1709 }
1710
1711 hr = split_reg_path(name, &subkey, &val);
1712 if (FAILED(hr))
1713 goto fail;
1714
1715 ret = RegSetKeyValueW(root, subkey, val, regtype, data, data_len);
1716 if (ret)
1718
1719fail:
1720 VariantClear(&v);
1721 if (val)
1722 heap_free(subkey);
1723 return hr;
1724}
1725
1726static HRESULT WINAPI WshShell3_RegDelete(IWshShell3 *iface, BSTR Name)
1727{
1728 FIXME("(%s): stub\n", debugstr_w(Name));
1729 return E_NOTIMPL;
1730}
1731
1733{
1734 FIXME("(%s %s %s %p): stub\n", debugstr_variant(Type), debugstr_w(Message), debugstr_w(Target), out_Success);
1735 return E_NOTIMPL;
1736}
1737
1738static HRESULT WINAPI WshShell3_AppActivate(IWshShell3 *iface, VARIANT *App, VARIANT *Wait, VARIANT_BOOL *out_Success)
1739{
1740 FIXME("(%s %s %p): stub\n", debugstr_variant(App), debugstr_variant(Wait), out_Success);
1741 return E_NOTIMPL;
1742}
1743
1744static HRESULT WINAPI WshShell3_SendKeys(IWshShell3 *iface, BSTR Keys, VARIANT *Wait)
1745{
1746 FIXME("(%s %p): stub\n", debugstr_w(Keys), Wait);
1747 return E_NOTIMPL;
1748}
1749
1750static HRESULT WINAPI WshShell3_Exec(IWshShell3 *iface, BSTR command, IWshExec **ret)
1751{
1752 TRACE("(%s %p)\n", debugstr_w(command), ret);
1753
1754 if (!ret)
1755 return E_POINTER;
1756
1757 if (!command)
1758 return DISP_E_EXCEPTION;
1759
1760 return WshExec_create(command, ret);
1761}
1762
1764{
1765 DWORD ret;
1766
1767 TRACE("(%p)\n", dir);
1768
1770 if (!ret)
1772
1774 if (!*dir)
1775 return E_OUTOFMEMORY;
1776
1778 if (!ret) {
1780 *dir = NULL;
1782 }
1783
1784 return S_OK;
1785}
1786
1788{
1789 TRACE("(%s)\n", debugstr_w(dir));
1790
1791 if (!dir)
1792 return E_INVALIDARG;
1793
1796
1797 return S_OK;
1798}
1799
1800static const IWshShell3Vtbl WshShell3Vtbl = {
1823};
1824
1826{
1827 TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
1828
1831 return IWshShell3_QueryInterface(&WshShell3.IWshShell3_iface, riid, ppv);
1832}
PRTL_UNICODE_STRING_BUFFER Path
Type
Definition: Type.h:7
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
Arabic default style
Definition: afstyles.h:94
unsigned int dir
Definition: maze.c:112
HRESULT get_typeinfo(enum type_id tid, ITypeInfo **ret)
Definition: apps.c:124
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define ARRAY_SIZE(A)
Definition: main.h:33
const GUID IID_IUnknown
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
struct _root root
classinfo
Definition: clsfactory.c:43
LPARAM lParam
Definition: combotst.c:139
static LPCWSTR LPCWSTR LPCWSTR env
Definition: db.cpp:170
#define WAIT_TIMEOUT
Definition: dderror.h:14
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
LSTATUS WINAPI RegGetValueW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:1931
LONG WINAPI RegSetKeyValueW(IN HKEY hKey, IN LPCWSTR lpSubKey OPTIONAL, IN LPCWSTR lpValueName OPTIONAL, IN DWORD dwType, IN LPCVOID lpData OPTIONAL, IN DWORD cbData)
Definition: reg.c:2139
static const WCHAR Description[]
Definition: oid.c:1266
#define CloseHandle
Definition: compat.h:739
#define wcschr
Definition: compat.h:17
#define GetCurrentDirectoryW(x, y)
Definition: compat.h:756
#define wcsrchr
Definition: compat.h:16
#define GetEnvironmentVariableW(x, y, z)
Definition: compat.h:755
OLECHAR * BSTR
Definition: compat.h:2293
#define MAX_PATH
Definition: compat.h:34
#define CALLBACK
Definition: compat.h:35
#define lstrcpyW
Definition: compat.h:749
short VARIANT_BOOL
Definition: compat.h:2290
@ VT_BSTR
Definition: compat.h:2303
@ VT_ERROR
Definition: compat.h:2305
@ VT_ARRAY
Definition: compat.h:2341
@ VT_VARIANT
Definition: compat.h:2307
@ VT_I4
Definition: compat.h:2298
@ VT_UI1
Definition: compat.h:2311
#define wcsicmp
Definition: compat.h:15
#define lstrlenW
Definition: compat.h:750
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
BOOL WINAPI SetCurrentDirectoryW(IN LPCWSTR lpPathName)
Definition: path.c:2249
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4592
BOOL WINAPI GetExitCodeProcess(IN HANDLE hProcess, IN LPDWORD lpExitCode)
Definition: proc.c:1168
BOOL WINAPI TerminateProcess(IN HANDLE hProcess, IN UINT uExitCode)
Definition: proc.c:1532
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
const WCHAR * text
Definition: package.c:1799
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
static const WCHAR desktopW[]
Definition: main.c:46
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
Definition: safearray.c:1137
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
Definition: safearray.c:1168
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
Definition: safearray.c:1347
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
Definition: safearray.c:600
static const WCHAR IconPath[]
Definition: install.c:51
HRESULT WINAPI SHGetSpecialFolderLocation(HWND hwndOwner, INT nFolder, LPITEMIDLIST *ppidl)
Definition: shellpath.c:3225
MIXER_STATUS Enum(IN PVOID EnumContext, IN ULONG DeviceIndex, OUT LPWSTR *DeviceName, OUT PHANDLE OutHandle, OUT PHANDLE OutKey)
Definition: mmixer.c:220
#define swprintf
Definition: precomp.h:40
static const WCHAR Message[]
Definition: register.c:74
static ULONG WINAPI WshExec_Release(IWshExec *iface)
Definition: shell.c:128
static HRESULT WINAPI WshShell3_GetTypeInfoCount(IWshShell3 *iface, UINT *pctinfo)
Definition: shell.c:1158
static HRESULT WINAPI WshShortcut_get_WindowStyle(IWshShortcut *iface, int *ShowCmd)
Definition: shell.c:989
static HRESULT WINAPI WshCollection_QueryInterface(IWshCollection *iface, REFIID riid, void **ppv)
Definition: shell.c:540
static WshShellImpl WshShell3
Definition: shell.c:40
static HRESULT WINAPI WshEnvironment_GetTypeInfoCount(IWshEnvironment *iface, UINT *pctinfo)
Definition: shell.c:395
static HRESULT WINAPI WshShortcut_put_Hotkey(IWshShortcut *iface, BSTR Hotkey)
Definition: shell.c:906
static HRESULT WINAPI WshShell3_AppActivate(IWshShell3 *iface, VARIANT *App, VARIANT *Wait, VARIANT_BOOL *out_Success)
Definition: shell.c:1738
static WshEnvironment * impl_from_IWshEnvironment(IWshEnvironment *iface)
Definition: shell.c:84
static HRESULT WINAPI WshShortcut_put_Arguments(IWshShortcut *iface, BSTR Arguments)
Definition: shell.c:876
static HRESULT WINAPI WshShortcut_get_Arguments(IWshShortcut *iface, BSTR *Arguments)
Definition: shell.c:855
static HRESULT WINAPI WshShell3_RegDelete(IWshShell3 *iface, BSTR Name)
Definition: shell.c:1726
static HRESULT WINAPI WshCollection_Item(IWshCollection *iface, VARIANT *index, VARIANT *value)
Definition: shell.c:641
static HRESULT WshEnvironment_Create(IWshEnvironment **env)
Definition: shell.c:524
static HRESULT WINAPI WshShortcut_get_WorkingDirectory(IWshShortcut *iface, BSTR *WorkingDirectory)
Definition: shell.c:1003
static HRESULT WINAPI WshExec_Terminate(IWshExec *iface)
Definition: shell.c:285
static HRESULT WINAPI WshShell3_get_CurrentDirectory(IWshShell3 *iface, BSTR *dir)
Definition: shell.c:1763
static HRESULT WINAPI WshCollection_Invoke(IWshCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: shell.c:620
static WshExecImpl * impl_from_IWshExec(IWshExec *iface)
Definition: shell.c:89
static ULONG WINAPI WshShell3_Release(IWshShell3 *iface)
Definition: shell.c:1152
static HRESULT WINAPI WshEnvironment__NewEnum(IWshEnvironment *iface, IUnknown **penum)
Definition: shell.c:494
static HRESULT WINAPI WshExec_QueryInterface(IWshExec *iface, REFIID riid, void **obj)
Definition: shell.c:94
static HRESULT WINAPI WshShortcut_put_WorkingDirectory(IWshShortcut *iface, BSTR WorkingDirectory)
Definition: shell.c:1022
static HRESULT WINAPI WshEnvironment_GetTypeInfo(IWshEnvironment *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: shell.c:403
static ULONG WINAPI WshShell3_AddRef(IWshShell3 *iface)
Definition: shell.c:1146
static HRESULT WINAPI WshShortcut_put_RelativePath(IWshShortcut *iface, BSTR rhs)
Definition: shell.c:968
static HRESULT WINAPI WshShortcut_put_TargetPath(IWshShortcut *iface, BSTR Path)
Definition: shell.c:982
static HRESULT WINAPI WshExec_GetTypeInfo(IWshExec *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: shell.c:151
static HRESULT WINAPI WshShortcut_get_Description(IWshShortcut *iface, BSTR *Description)
Definition: shell.c:885
static HRESULT WINAPI WshShell3_RegWrite(IWshShell3 *iface, BSTR name, VARIANT *value, VARIANT *type)
Definition: shell.c:1638
static HRESULT WshExec_create(BSTR command, IWshExec **ret)
Definition: shell.c:325
static const IWshShortcutVtbl WshShortcutVtbl
Definition: shell.c:1051
static HRESULT WINAPI WshCollection_GetTypeInfo(IWshCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: shell.c:594
static HRESULT WINAPI WshEnvironment_put_Item(IWshEnvironment *iface, BSTR name, BSTR value)
Definition: shell.c:473
static HRESULT WINAPI WshExec_get_StdIn(IWshExec *iface, ITextStream **stream)
Definition: shell.c:226
static const IWshShell3Vtbl WshShell3Vtbl
Definition: shell.c:1800
static HRESULT WINAPI WshShortcut_put_WindowStyle(IWshShortcut *iface, int ShowCmd)
Definition: shell.c:996
static HRESULT WINAPI WshShortcut_Load(IWshShortcut *iface, BSTR PathLink)
Definition: shell.c:1029
static HRESULT WINAPI WshExec_GetIDsOfNames(IWshExec *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: shell.c:158
static HRESULT WINAPI WshShell3_Run(IWshShell3 *iface, BSTR cmd, VARIANT *style, VARIANT *wait, DWORD *exit_code)
Definition: shell.c:1249
static HRESULT WINAPI WshEnvironment_get_length(IWshEnvironment *iface, LONG *len)
Definition: shell.c:487
static HRESULT WINAPI WshEnvironment_get_Item(IWshEnvironment *iface, BSTR name, BSTR *value)
Definition: shell.c:450
static BOOL CALLBACK enum_thread_wnd_proc(HWND hwnd, LPARAM lParam)
Definition: shell.c:275
static HRESULT WINAPI WshShortcut_GetIDsOfNames(IWshShortcut *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: shell.c:808
static HRESULT WINAPI WshShell3_get_SpecialFolders(IWshShell3 *iface, IWshCollection **folders)
Definition: shell.c:1209
static HRESULT WINAPI WshEnvironment_Invoke(IWshEnvironment *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: shell.c:429
static const IWshExecVtbl WshExecVtbl
Definition: shell.c:308
static const IWshEnvironmentVtbl WshEnvironmentVtbl
Definition: shell.c:508
static HRESULT WINAPI WshShortcut_get_TargetPath(IWshShortcut *iface, BSTR *Path)
Definition: shell.c:975
static HRESULT WINAPI WshExec_GetTypeInfoCount(IWshExec *iface, UINT *pctinfo)
Definition: shell.c:143
static HRESULT WINAPI WshShortcut_put_IconLocation(IWshShortcut *iface, BSTR IconPath)
Definition: shell.c:936
static HRESULT split_reg_path(const WCHAR *path, WCHAR **subkey, WCHAR **value)
Definition: shell.c:1467
static HRESULT WINAPI WshShortcut_get_IconLocation(IWshShortcut *iface, BSTR *IconPath)
Definition: shell.c:913
static HRESULT WINAPI WshEnvironment_Remove(IWshEnvironment *iface, BSTR name)
Definition: shell.c:501
static ULONG WINAPI WshCollection_Release(IWshCollection *iface)
Definition: shell.c:574
static HRESULT WINAPI WshShell3_SendKeys(IWshShell3 *iface, BSTR Keys, VARIANT *Wait)
Definition: shell.c:1744
static HKEY get_root_key(const WCHAR *path)
Definition: shell.c:1441
static ULONG WINAPI WshShortcut_AddRef(IWshShortcut *iface)
Definition: shell.c:769
static HRESULT WINAPI WshEnvironment_QueryInterface(IWshEnvironment *iface, REFIID riid, void **obj)
Definition: shell.c:349
static HRESULT WINAPI WshShell3_GetTypeInfo(IWshShell3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: shell.c:1165
static WshCollection * impl_from_IWshCollection(IWshCollection *iface)
Definition: shell.c:74
static HRESULT WINAPI WshShortcut_QueryInterface(IWshShortcut *iface, REFIID riid, void **ppv)
Definition: shell.c:743
static HRESULT WINAPI WshExec_get_ExitCode(IWshExec *iface, DWORD *code)
Definition: shell.c:266
static HRESULT WINAPI WshShell3_Invoke(IWshShell3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: shell.c:1189
static HRESULT WINAPI WshCollection_get_length(IWshCollection *iface, LONG *count)
Definition: shell.c:698
static HRESULT WINAPI WshShell3_QueryInterface(IWshShell3 *iface, REFIID riid, void **ppv)
Definition: shell.c:1114
static HRESULT WINAPI WshShell3_LogEvent(IWshShell3 *iface, VARIANT *Type, BSTR Message, BSTR Target, VARIANT_BOOL *out_Success)
Definition: shell.c:1732
static HRESULT WINAPI WshShell3_RegRead(IWshShell3 *iface, BSTR name, VARIANT *value)
Definition: shell.c:1501
static ULONG WINAPI WshShortcut_Release(IWshShortcut *iface)
Definition: shell.c:777
static HRESULT WINAPI WshShell3_GetIDsOfNames(IWshShell3 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: shell.c:1171
HRESULT WINAPI WshShellFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
Definition: shell.c:1825
static HRESULT WINAPI WshExec_get_StdErr(IWshExec *iface, ITextStream **stream)
Definition: shell.c:244
static ULONG WINAPI WshCollection_AddRef(IWshCollection *iface)
Definition: shell.c:566
static BOOL is_optional_argument(const VARIANT *arg)
Definition: shell.c:1221
static HRESULT WINAPI WshShell3_Exec(IWshShell3 *iface, BSTR command, IWshExec **ret)
Definition: shell.c:1750
static HRESULT WINAPI WshShortcut_get_FullName(IWshShortcut *iface, BSTR *name)
Definition: shell.c:848
static HRESULT WINAPI WshShortcut_GetTypeInfoCount(IWshShortcut *iface, UINT *pctinfo)
Definition: shell.c:793
static ULONG WINAPI WshEnvironment_Release(IWshEnvironment *iface)
Definition: shell.c:383
static ULONG WINAPI WshEnvironment_AddRef(IWshEnvironment *iface)
Definition: shell.c:375
static HRESULT WINAPI WshShortcut_GetTypeInfo(IWshShortcut *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: shell.c:801
static WCHAR * split_command(BSTR cmd, WCHAR **params)
Definition: shell.c:1226
static HRESULT WINAPI WshCollection__NewEnum(IWshCollection *iface, IUnknown **Enum)
Definition: shell.c:705
static HRESULT WshShortcut_Create(const WCHAR *path, IDispatch **shortcut)
Definition: shell.c:1079
static HRESULT WINAPI WshExec_Invoke(IWshExec *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: shell.c:177
static ULONG WINAPI WshExec_AddRef(IWshExec *iface)
Definition: shell.c:120
static HRESULT WINAPI WshShell3_CreateShortcut(IWshShell3 *iface, BSTR PathLink, IDispatch **Shortcut)
Definition: shell.c:1413
static HRESULT WINAPI WshCollection_GetIDsOfNames(IWshCollection *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: shell.c:601
static HRESULT WINAPI WshShell3_get_Environment(IWshShell3 *iface, VARIANT *type, IWshEnvironment **env)
Definition: shell.c:1215
static HRESULT WINAPI WshShortcut_put_Description(IWshShortcut *iface, BSTR Description)
Definition: shell.c:892
static HRESULT WINAPI WshCollection_Count(IWshCollection *iface, LONG *count)
Definition: shell.c:691
static HRESULT WINAPI WshShortcut_Save(IWshShortcut *iface)
Definition: shell.c:1036
static HRESULT WINAPI WshExec_get_Status(IWshExec *iface, WshExecStatus *status)
Definition: shell.c:198
static HRESULT WINAPI WshShell3_ExpandEnvironmentStrings(IWshShell3 *iface, BSTR Src, BSTR *Dst)
Definition: shell.c:1419
static HRESULT WINAPI WshShortcut_Invoke(IWshShortcut *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: shell.c:827
static HRESULT WINAPI WshExec_get_ProcessID(IWshExec *iface, DWORD *pid)
Definition: shell.c:253
static const IWshCollectionVtbl WshCollectionVtbl
Definition: shell.c:712
static HRESULT WINAPI WshEnvironment_GetIDsOfNames(IWshEnvironment *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: shell.c:410
static HRESULT WINAPI WshShell3_put_CurrentDirectory(IWshShell3 *iface, BSTR dir)
Definition: shell.c:1787
static WshShortcut * impl_from_IWshShortcut(IWshShortcut *iface)
Definition: shell.c:79
static HRESULT WshCollection_Create(IWshCollection **collection)
Definition: shell.c:726
static HRESULT WINAPI WshCollection_GetTypeInfoCount(IWshCollection *iface, UINT *pctinfo)
Definition: shell.c:586
static DWORD WINAPI popup_thread_proc(void *arg)
Definition: shell.c:1332
static HRESULT WINAPI WshShell3_Popup(IWshShell3 *iface, BSTR text, VARIANT *seconds_to_wait, VARIANT *title, VARIANT *type, int *button)
Definition: shell.c:1342
static HRESULT WINAPI WshExec_get_StdOut(IWshExec *iface, ITextStream **stream)
Definition: shell.c:235
static HRESULT WINAPI WshEnvironment_Count(IWshEnvironment *iface, LONG *count)
Definition: shell.c:480
static HRESULT WINAPI WshShortcut_get_Hotkey(IWshShortcut *iface, BSTR *Hotkey)
Definition: shell.c:899
#define INFINITE
Definition: serial.h:102
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
const GLdouble * v
Definition: gl.h:2040
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLdouble s
Definition: gl.h:2039
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLuint index
Definition: glext.h:6031
GLenum const GLfloat * params
Definition: glext.h:5645
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat param
Definition: glext.h:5796
GLenum GLsizei len
Definition: glext.h:6722
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
#define iswspace(_c)
Definition: ctype.h:669
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
int const JOCTET unsigned int datalen
Definition: jpeglib.h:1031
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
#define REG_SZ
Definition: layer.c:22
#define Dst
Definition: mesh.h:153
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PVOID ptr
Definition: dispmode.c:27
DWORD button
Definition: button.c:166
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46
static UINT exit_code
Definition: process.c:78
static TfClientId tid
static LPOLESTR
Definition: stg_prop.c:27
static ICollection collection
Definition: typelib.c:184
static VARIANTARG static DISPID
Definition: ordinal.c:52
unsigned int UINT
Definition: ndis.h:50
#define REG_BINARY
Definition: nt_native.h:1496
#define REG_MULTI_SZ
Definition: nt_native.h:1501
#define DWORD
Definition: nt_native.h:44
#define REG_NONE
Definition: nt_native.h:1492
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
UINT WINAPI SysStringByteLen(BSTR str)
Definition: oleaut.c:215
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
#define V_ERROR(A)
Definition: oleauto.h:241
#define V_UI1(A)
Definition: oleauto.h:266
#define V_ARRAY(A)
Definition: oleauto.h:222
#define V_VT(A)
Definition: oleauto.h:211
#define V_BSTR(A)
Definition: oleauto.h:226
#define V_I4(A)
Definition: oleauto.h:247
const GUID IID_IProvideClassInfo
const GUID IID_IDispatch
const GUID IID_IPersistFile
long LONG
Definition: pedump.c:60
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1353
static char title[]
Definition: ps.c:92
#define INFOTIPSIZE
Definition: commctrl.h:124
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
void init_classinfo(const GUID *guid, IUnknown *outer, struct provideclassinfo *classinfo)
Definition: scrrun.c:232
#define REG_DWORD
Definition: sdbapi.c:596
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
_Check_return_ _CRTIMP int __cdecl wcsncmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
DWORD LCID
Definition: nls.h:13
#define memset(x, y, z)
Definition: compat.h:39
#define SEE_MASK_NOCLOSEPROCESS
Definition: shellapi.h:31
#define SEE_MASK_NOASYNC
Definition: shellapi.h:33
#define SEE_MASK_DEFAULT
Definition: shellapi.h:24
BOOL WINAPI DECLSPEC_HOTPATCH ShellExecuteExW(LPSHELLEXECUTEINFOW sei)
Definition: shlexec.cpp:2391
HRESULT hr
Definition: shlfolder.c:183
#define CSIDL_COMMON_DESKTOPDIRECTORY
Definition: shlobj.h:2182
#define CSIDL_COMMON_PROGRAMS
Definition: shlobj.h:2180
#define CSIDL_DESKTOP
Definition: shlobj.h:2158
#define TRACE(s)
Definition: solgame.cpp:4
LONG ref
Definition: shell.c:46
IWshCollection IWshCollection_iface
Definition: shell.c:45
LONG ref
Definition: shell.c:63
IWshEnvironment IWshEnvironment_iface
Definition: shell.c:62
IWshExec IWshExec_iface
Definition: shell.c:69
PROCESS_INFORMATION info
Definition: shell.c:71
LONG ref
Definition: shell.c:70
IWshShell3 IWshShell3_iface
Definition: shell.c:38
struct provideclassinfo classinfo
Definition: shell.c:37
BSTR path_link
Definition: shell.c:56
IWshShortcut IWshShortcut_iface
Definition: shell.c:52
LONG ref
Definition: shell.c:53
IShellLinkW * link
Definition: shell.c:55
Definition: ftp_var.h:139
Definition: inflate.c:139
Definition: fci.c:127
Definition: fci.c:116
Definition: name.c:39
WCHAR * text
Definition: shell.c:1326
VARIANT title
Definition: shell.c:1327
VARIANT type
Definition: shell.c:1328
Definition: send.c:48
Definition: ps.c:97
Definition: parse.h:23
Definition: dhcpd.h:245
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
int32_t INT
Definition: typedefs.h:58
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
Definition: pdh_main.c:94
HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG *pvargDest, VARIANTARG *pvargSrc, USHORT wFlags, VARTYPE vt)
Definition: variant.c:962
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
int ret
_In_ WDFDPC _In_ BOOLEAN Wait
Definition: wdfdpc.h:170
_In_ WDFIOTARGET Target
Definition: wdfrequest.h:306
#define STILL_ACTIVE
Definition: winbase.h:233
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define WAIT_OBJECT_0
Definition: winbase.h:406
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
_In_ ULONG_PTR _In_ ULONG _Out_ ULONG_PTR * pid
Definition: winddi.h:3837
LONG_PTR LPARAM
Definition: windef.h:208
#define WINAPI
Definition: msvc.h:6
#define DISP_E_PARAMNOTFOUND
Definition: winerror.h:2513
#define E_NOINTERFACE
Definition: winerror.h:2364
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
#define DISP_E_EXCEPTION
Definition: winerror.h:2518
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define E_POINTER
Definition: winerror.h:2365
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_CONFIG
Definition: winreg.h:15
#define HKEY_CURRENT_USER
Definition: winreg.h:11
#define RRF_RT_ANY
Definition: winreg.h:64
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
#define HKEY_USERS
Definition: winreg.h:13
#define WM_CLOSE
Definition: winuser.h:1621
#define WM_QUIT
Definition: winuser.h:1623
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
DWORD WINAPI MsgWaitForMultipleObjects(_In_ DWORD nCount, _In_reads_opt_(nCount) CONST HANDLE *pHandles, _In_ BOOL fWaitAll, _In_ DWORD dwMilliseconds, _In_ DWORD dwWakeMask)
int WINAPI MessageBoxW(_In_opt_ HWND hWnd, _In_opt_ LPCWSTR lpText, _In_opt_ LPCWSTR lpCaption, _In_ UINT uType)
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define SW_SHOW
Definition: winuser.h:775
BOOL WINAPI EnumThreadWindows(_In_ DWORD, _In_ WNDENUMPROC, _In_ LPARAM)
@ IWshEnvironment_tid
Definition: wshom_private.h:34
@ IWshShortcut_tid
Definition: wshom_private.h:37
@ IWshExec_tid
Definition: wshom_private.h:35
@ IWshShell3_tid
Definition: wshom_private.h:36
@ IWshCollection_tid
Definition: wshom_private.h:33
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193