ReactOS 0.4.15-dev-7889-g76290a6
desktopipc.cpp
Go to the documentation of this file.
1#include "precomp.h"
2#include <shlwapi.h>
3#include <shlwapi_undoc.h>
4
5#define PROXY_DESKTOP_CLASS L"Proxy Desktop"
6
9
10// fields indented more are unknown ;P
12{
30};
31
33 public CComObjectRootEx<CComMultiThreadModelNoCS>,
34 public CWindowImpl < CProxyDesktop, CWindow, CFrameWinTraits >
35{
36
37public:
39 {
40 }
41
43 {
44 }
45
47 {
48 TRACE("Proxy Desktop message 1037.\n");
49 bHandled = TRUE;
50 return TRUE;
51 }
52
54 {
55 TRACE("Proxy Desktop message 1035 received.\n");
56 bHandled = TRUE;
58 return 0;
59 }
60
62
67};
68
70{
71 /* If there is a proxy desktop in the current process use it */
73 return g_hwndProxyDesktop;
74
75 /* Try to find the desktop of the main explorer process */
77 {
79
80 if (shell)
81 {
82 TRACE("Found main desktop.\n");
83 return shell;
84 }
85 }
86 else
87 {
88 TRACE("Separate folders setting enabled. Ignoring main desktop.\n");
89 }
90
91 /* The main desktop can't be find so try to see if another process has a proxy desktop */
93 if (proxy)
94 {
95 TRACE("Found proxy desktop.\n");
96 return proxy;
97 }
98
99 return NULL;
100}
101
102HANDLE MakeSharedPacket(IEThreadParamBlock * threadParams, LPCWSTR strPath, int dwProcessId)
103{
104 HNFBlock* hnfData;
105 UINT sharedBlockSize = sizeof(*hnfData);
106 UINT directoryPidlLength = 0;
107 UINT pidlSize7C = 0;
108 UINT pidlSize80 = 0;
109 UINT pathLength = 0;
110 LPITEMIDLIST pidl80 = threadParams->offset80;
111
112 // Count the total length of the message packet
113
114 // directory PIDL
115 if (threadParams->directoryPIDL)
116 {
117 directoryPidlLength = ILGetSize(threadParams->directoryPIDL);
118 sharedBlockSize += directoryPidlLength;
119 TRACE("directoryPidlLength=%d\n", directoryPidlLength);
120 }
121
122 // another PIDL
123 if (threadParams->offset7C)
124 {
125 pidlSize7C = ILGetSize(threadParams->offset7C);
126 sharedBlockSize += pidlSize7C;
127 TRACE("pidlSize7C=%d\n", pidlSize7C);
128 }
129
130 // This flag indicates the presence of another pidl?
131 if (!(threadParams->offset84 & 0x8000))
132 {
133 if (pidl80)
134 {
135 pidlSize80 = ILGetSize(pidl80);
136 sharedBlockSize += pidlSize80;
137 TRACE("pidlSize80=%d\n", pidlSize7C);
138 }
139 }
140 else
141 {
142 TRACE("pidl80 sent by value = %p\n", pidl80);
143 pidlSize80 = 4;
144 sharedBlockSize += pidlSize80;
145 }
146
147 // The path string
148 if (strPath)
149 {
150 pathLength = 2 * lstrlenW(strPath) + 2;
151 sharedBlockSize += pathLength;
152 TRACE("pathLength=%d\n", pidlSize7C);
153 }
154
155 TRACE("sharedBlockSize=%d\n", sharedBlockSize);
156
157 // Allocate and fill the shared section
158 HANDLE hShared = SHAllocShared(0, sharedBlockSize, dwProcessId);
159 if (!hShared)
160 {
161 ERR("Shared section alloc error.\n");
162 return 0;
163 }
164
165 PBYTE target = (PBYTE) SHLockShared(hShared, dwProcessId);
166 if (!target)
167 {
168 ERR("Shared section lock error. %d\n", GetLastError());
169 SHFreeShared(hShared, dwProcessId);
170 return 0;
171 }
172
173 // Basic information
174 hnfData = (HNFBlock*) target;
175 hnfData->cbSize = sharedBlockSize;
176 hnfData->offset4 = (DWORD) (threadParams->dwFlags);
177 hnfData->offset8 = (DWORD) (threadParams->offset8);
178 hnfData->offsetC = (DWORD) (threadParams->offset74);
179 hnfData->offset10 = (DWORD) (threadParams->offsetD8);
180 hnfData->offset14 = (DWORD) (threadParams->offset84);
181 hnfData->offset18 = (DWORD) (threadParams->offset88);
182 hnfData->offset1C = (DWORD) (threadParams->offset8C);
183 hnfData->offset20 = (DWORD) (threadParams->offset90);
184 hnfData->offset24 = (DWORD) (threadParams->offset94);
185 hnfData->offset28 = (DWORD) (threadParams->offset98);
186 hnfData->offset2C = (DWORD) (threadParams->offset9C);
187 hnfData->offset30 = (DWORD) (threadParams->offsetA0);
188 hnfData->directoryPidlLength = 0;
189 hnfData->pidlSize7C = 0;
190 hnfData->pidlSize80 = 0;
191 hnfData->pathLength = 0;
192 target += sizeof(*hnfData);
193
194 // Copy the directory pidl contents
195 if (threadParams->directoryPIDL)
196 {
197 memcpy(target, threadParams->directoryPIDL, directoryPidlLength);
198 target += directoryPidlLength;
199 hnfData->directoryPidlLength = directoryPidlLength;
200 }
201
202 // Copy the other pidl contents
203 if (threadParams->offset7C)
204 {
205 memcpy(target, threadParams->offset7C, pidlSize7C);
206 target += pidlSize7C;
207 hnfData->pidlSize7C = pidlSize7C;
208 }
209
210 // copy the third pidl
211 if (threadParams->offset84 & 0x8000)
212 {
213 *(LPITEMIDLIST*) target = pidl80;
214 target += pidlSize80;
215 hnfData->pidlSize80 = pidlSize80;
216 }
217 else if (pidl80)
218 {
219 memcpy(target, pidl80, pidlSize80);
220 target += pidlSize80;
221 hnfData->pidlSize80 = pidlSize80;
222 }
223
224 // and finally the path string
225 if (strPath)
226 {
227 memcpy(target, strPath, pathLength);
228 hnfData->pathLength = pathLength;
229 }
230
231 SHUnlockShared(hnfData);
232
233 return hShared;
234}
235
237{
238 HNFBlock * hnfData;
239 PBYTE block;
240 int pid;
242
243 if (!hData)
244 goto cleanup0;
245
247 block = (PBYTE) SHLockShared(hData, pid);
248
249 hnfData = (HNFBlock *) block;
250 if (!block)
251 goto cleanup2;
252
253 if (hnfData->cbSize < sizeof(HNFBlock))
254 goto cleanup2;
255
256 params = SHCreateIETHREADPARAM(0, hnfData->offset8, 0, 0);
257 if (!params)
258 goto cleanup2;
259
260 params->dwFlags = hnfData->offset4;
261 params->offset8 = hnfData->offset8;
262 params->offset74 = hnfData->offsetC;
263 params->offsetD8 = hnfData->offset10;
264 params->offset84 = hnfData->offset14;
265 params->offset88 = hnfData->offset18;
266 params->offset8C = hnfData->offset1C;
267 params->offset90 = hnfData->offset20;
268 params->offset94 = hnfData->offset24;
269 params->offset98 = hnfData->offset28;
270 params->offset9C = hnfData->offset2C;
271 params->offsetA0 = hnfData->offset30;
272
273 block += sizeof(*hnfData);
274 if (hnfData->directoryPidlLength)
275 {
276 LPITEMIDLIST pidl = NULL;
277 if (*block)
278 pidl = ILClone((LPITEMIDLIST) block);
279 params->directoryPIDL = pidl;
280
281 block += hnfData->directoryPidlLength;
282 }
283
284 if (hnfData->pidlSize7C)
285 {
286 LPITEMIDLIST pidl = NULL;
287 if (*block)
288 pidl = ILClone((LPITEMIDLIST) block);
289 params->offset7C = pidl;
290
291 block += hnfData->pidlSize80;
292 }
293
294 if (hnfData->pidlSize80)
295 {
296 if (!(params->offset84 & 0x8000))
297 {
298 params->offset80 = *(LPITEMIDLIST *) block;
299 }
300 else
301 {
302 LPITEMIDLIST pidl = NULL;
303 if (*block)
304 pidl = ILClone((LPITEMIDLIST) block);
305 params->offset80 = pidl;
306 }
307
308 block += hnfData->pidlSize80;
309 }
310
311 if (hnfData->pathLength)
312 {
313 CComPtr<IShellFolder> psfDesktop;
314 PWSTR strPath = (PWSTR) block;
315
316 if (FAILED(SHGetDesktopFolder(&psfDesktop)))
317 {
318 params->directoryPIDL = NULL;
319 goto cleanup0;
320 }
321
322 if (FAILED(psfDesktop->ParseDisplayName(NULL, NULL, strPath, NULL, &params->directoryPIDL, NULL)))
323 {
324 params->directoryPIDL = NULL;
325 goto cleanup0;
326 }
327 }
328
329cleanup2:
330 SHUnlockShared(hnfData);
331 SHFreeShared(hData, pid);
332
333cleanup0:
334 if (!params->directoryPIDL)
335 {
337 return NULL;
338 }
339
340 return params;
341}
342
343
345{
346 HRESULT hResult;
347 MSG Msg;
348 BOOL Ret;
349
350 // Tell the thread ref we are using it.
351 if (parameters && parameters->pExplorerInstance)
352 parameters->pExplorerInstance->AddRef();
353
354 /* Handle /e parameter */
355 UINT wFlags = 0;
356 if (parameters->dwFlags & SH_EXPLORER_CMDLINE_FLAG_E)
357 wFlags |= SBSP_EXPLOREMODE;
358
359 /* Handle /select parameter */
360 PUITEMID_CHILD pidlSelect = NULL;
361 if ((parameters->dwFlags & SH_EXPLORER_CMDLINE_FLAG_SELECT) &&
362 (ILGetNext(parameters->directoryPIDL) != NULL))
363 {
364 pidlSelect = ILClone(ILFindLastID(parameters->directoryPIDL));
365 ILRemoveLastID(parameters->directoryPIDL);
366 }
367
370 if (FAILED_UNEXPECTEDLY(hResult))
371 return hResult;
372
373 hResult = psb->BrowseObject(parameters->directoryPIDL, wFlags);
374 if (FAILED_UNEXPECTEDLY(hResult))
375 return hResult;
376
377 if (pidlSelect != NULL)
378 {
379 CComPtr<IShellView> shellView;
380 hResult = psb->QueryActiveShellView(&shellView);
381 if (SUCCEEDED(hResult))
382 {
383 shellView->SelectItem(pidlSelect, SVSI_SELECT | SVSI_FOCUSED | SVSI_ENSUREVISIBLE);
384 }
385 ILFree(pidlSelect);
386 }
387
389 hResult = psb->QueryInterface(IID_PPV_ARG(IBrowserService2, &browser));
390 if (FAILED_UNEXPECTEDLY(hResult))
391 return hResult;
392
393 psb.Release();
394
395 while ((Ret = GetMessage(&Msg, NULL, 0, 0)) != 0)
396 {
397 if (Ret == -1)
398 {
399 // Error: continue or exit?
400 break;
401 }
402
403 if (Msg.message == WM_QUIT)
404 break;
405
406 if (browser->v_MayTranslateAccelerator(&Msg) != S_OK)
407 {
410 }
411 }
412
413 ReleaseCComPtrExpectZero(browser);
414
415 // Tell the thread ref we are not using it anymore.
416 if (parameters && parameters->pExplorerInstance)
417 parameters->pExplorerInstance->Release();
418
419 return hResult;
420}
421
422static DWORD WINAPI BrowserThreadProc(LPVOID lpThreadParameter)
423{
424 IEThreadParamBlock * parameters = (IEThreadParamBlock *) lpThreadParameter;
425
427 ExplorerMessageLoop(parameters);
428
429 /* Destroying the parameters releases the thread reference */
430 SHDestroyIETHREADPARAM(parameters);
431
432 /* Wake up the proxy desktop thread so it can check whether the last browser thread exited */
433 /* Use PostMessage in order to force GetMessage to return and check if all browser windows have exited */
435
437
438 return 0;
439}
440
441/*************************************************************************
442* SHCreateIETHREADPARAM [BROWSEUI.123]
443*/
445 long param8, long paramC, IUnknown *param10, IUnknown *param14)
446{
448
449 TRACE("SHCreateIETHREADPARAM\n");
450
452 if (result == NULL)
453 return NULL;
454 result->offset0 = param8;
455 result->offset8 = paramC;
456 result->offsetC = param10;
457 if (param10 != NULL)
458 param10->AddRef();
459 result->offset14 = param14;
460 if (param14 != NULL)
461 param14->AddRef();
462 return result;
463}
464
465/*************************************************************************
466* SHCloneIETHREADPARAM [BROWSEUI.124]
467*/
469{
471
472 TRACE("SHCloneIETHREADPARAM\n");
473
475 if (result == NULL)
476 return NULL;
477 *result = *param;
478 if (result->directoryPIDL != NULL)
479 result->directoryPIDL = ILClone(result->directoryPIDL);
480 if (result->offset7C != NULL)
481 result->offset7C = ILClone(result->offset7C);
482 if (result->offset80 != NULL)
483 result->offset80 = ILClone(result->offset80);
484 if (result->offset70 != NULL)
485 result->offset70->AddRef();
486#if 0
487 if (result->offsetC != NULL)
488 result->offsetC->Method2C();
489#endif
490 return result;
491}
492
493/*************************************************************************
494* SHDestroyIETHREADPARAM [BROWSEUI.126]
495*/
497{
498 TRACE("SHDestroyIETHREADPARAM\n");
499
500 if (param == NULL)
501 return;
502 if (param->directoryPIDL != NULL)
503 ILFree(param->directoryPIDL);
504 if (param->offset7C != NULL)
505 ILFree(param->offset7C);
506 if ((param->dwFlags & 0x80000) == 0 && param->offset80 != NULL)
507 ILFree(param->offset80);
508 if (param->offset14 != NULL)
509 param->offset14->Release();
510 if (param->offset70 != NULL)
511 param->offset70->Release();
512 if (param->offset78 != NULL)
513 param->offset78->Release();
514 if (param->offsetC != NULL)
515 param->offsetC->Release();
516 if (param->pExplorerInstance != NULL)
517 param->pExplorerInstance->Release();
519}
520
521/*************************************************************************
522* SHOnCWMCommandLine [BROWSEUI.127]
523*/
524extern "C" BOOL WINAPI SHOnCWMCommandLine(HANDLE hSharedInfo)
525{
526 TRACE("SHOnCWMCommandLine\n");
527
529
530 if (params)
532
534
535 return FALSE;
536}
537
538/*************************************************************************
539* SHOpenFolderWindow [BROWSEUI.102]
540* see SHOpenNewFrame below for remarks
541*/
543{
544 HANDLE threadHandle;
545 DWORD threadID;
546
547 // Only try to convert the pidl when it is going to be printed
548 if (TRACE_ON(browseui))
549 {
550 WCHAR debugStr[MAX_PATH + 2] = { 0 };
551 if (!ILGetDisplayName(parameters->directoryPIDL, debugStr))
552 {
553 debugStr[0] = UNICODE_NULL;
554 }
555 TRACE("SHOpenFolderWindow %p(%S)\n", parameters->directoryPIDL, debugStr);
556 }
557
558 PIE_THREAD_PARAM_BLOCK paramsCopy = SHCloneIETHREADPARAM(parameters);
559
561 threadHandle = CreateThread(NULL, 0x10000, BrowserThreadProc, paramsCopy, 0, &threadID);
562 if (threadHandle != NULL)
563 {
564 CloseHandle(threadHandle);
565 return S_OK;
566 }
567 SHDestroyIETHREADPARAM(paramsCopy);
568 return E_FAIL;
569}
570
571// 75FA56C1h
572// (pidl, 0, -1, 1)
573// this function should handle creating a new process if needed, but I'm leaving that out for now
574// this function always opens a new window - it does NOT check for duplicates
575/*************************************************************************
576* SHOpenNewFrame [BROWSEUI.103]
577*/
578extern "C" HRESULT WINAPI SHOpenNewFrame(LPITEMIDLIST pidl, IUnknown *paramC, long param10, DWORD dwFlags)
579{
580 IEThreadParamBlock *parameters;
581
582 TRACE("SHOpenNewFrame\n");
583
584 parameters = SHCreateIETHREADPARAM(0, 1, paramC, NULL);
585 if (parameters == NULL)
586 {
587 ILFree(pidl);
588 return E_OUTOFMEMORY;
589 }
590 if (paramC != NULL)
591 parameters->offset10 = param10;
592 parameters->directoryPIDL = pidl;
593 parameters->dwFlags = dwFlags;
594
595 HRESULT hr = SHOpenFolderWindow(parameters);
596
597 SHDestroyIETHREADPARAM(parameters);
598
599 return hr;
600}
601
602/*************************************************************************
603* SHCreateFromDesktop [BROWSEUI.106]
604* parameter is a FolderInfo
605*/
607{
608 TRACE("SHCreateFromDesktop\n");
609
610 IEThreadParamBlock * parameters = SHCreateIETHREADPARAM(0, 0, 0, 0);
611 if (!parameters)
612 return FALSE;
613
614 PCWSTR strPath = NULL;
615 if (parseResults->dwFlags & SH_EXPLORER_CMDLINE_FLAG_STRING)
616 {
617 if (parseResults->pidlPath)
618 {
619 WARN("strPath and pidlPath are both assigned. This shouldn't happen.\n");
620 }
621
622 strPath = parseResults->strPath;
623 }
624
625 parameters->dwFlags = parseResults->dwFlags;
626 parameters->offset8 = parseResults->nCmdShow;
627
628 LPITEMIDLIST pidl = parseResults->pidlPath ? ILClone(parseResults->pidlPath) : NULL;
629 if (!pidl && parseResults->dwFlags & SH_EXPLORER_CMDLINE_FLAG_STRING)
630 {
631 if (parseResults->strPath && parseResults->strPath[0])
632 {
633 pidl = ILCreateFromPathW(parseResults->strPath);
634 }
635 }
636
637 // HACK! This shouldn't happen! SHExplorerParseCmdLine needs fixing.
638 if (!pidl)
639 {
641 }
642
643 parameters->directoryPIDL = pidl;
644
645 // Try to find the owner of the idlist, if we aren't running /SEPARATE
646 HWND desktop = NULL;
647 if (!(parseResults->dwFlags & SH_EXPLORER_CMDLINE_FLAG_SEPARATE))
648 desktop = FindShellProxy(parameters->directoryPIDL);
649
650 // If found, ask it to open the new window
651 if (desktop)
652 {
653 TRACE("Found desktop hwnd=%p\n", desktop);
654
655 DWORD dwProcessId;
656
657 GetWindowThreadProcessId(desktop, &dwProcessId);
658 AllowSetForegroundWindow(dwProcessId);
659
660 HANDLE hShared = MakeSharedPacket(parameters, strPath, dwProcessId);
661 if (hShared)
662 {
663 TRACE("Sending open message...\n");
664
665 PostMessageW(desktop, WM_EXPLORER_OPEN_NEW_WINDOW, 0, (LPARAM) hShared);
666 }
667
668 SHDestroyIETHREADPARAM(parameters);
669 return TRUE;
670 }
671
672 TRACE("Desktop not found or separate flag requested.\n");
673
674 // Else, start our own message loop!
676 CProxyDesktop * proxy = new CProxyDesktop(parameters);
677 if (proxy)
678 {
679 g_hwndProxyDesktop = proxy->Create(0);
680
681 LONG refCount;
683 if (SHCreateThreadRef(&refCount, &thread) >= 0)
684 {
686 if (strPath)
687 parameters->directoryPIDL = ILCreateFromPath(strPath);
688 SHOpenFolderWindow(parameters);
689 parameters = NULL;
690 thread.Release();
691 }
692
693 MSG Msg;
694 while (GetMessageW(&Msg, 0, 0, 0) && refCount)
695 {
698 }
699
701
702 delete proxy;
703 }
704
705 if (SUCCEEDED(hr))
707
708 SHDestroyIETHREADPARAM(parameters);
709
710 return TRUE;
711}
HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
static HANDLE thread
Definition: service.c:33
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
HRESULT CShellBrowser_CreateInstance(REFIID riid, void **ppv)
#define WM_EXPLORER_OPEN_NEW_WINDOW
#define SH_EXPLORER_CMDLINE_FLAG_STRING
#define SH_EXPLORER_CMDLINE_FLAG_SEPARATE
#define SH_EXPLORER_CMDLINE_FLAG_E
#define WM_EXPLORER_1037
#define SH_EXPLORER_CMDLINE_FLAG_SELECT
void Release()
Definition: atlcomcli.h:170
LRESULT OnMessage1037(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: desktopipc.cpp:46
CProxyDesktop(IEThreadParamBlock *parameters)
Definition: desktopipc.cpp:38
LRESULT OnOpenNewWindow(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: desktopipc.cpp:53
virtual ~CProxyDesktop()
Definition: desktopipc.cpp:42
struct @1632 Msg[]
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_FAIL
Definition: ddrawi.h:102
PIE_THREAD_PARAM_BLOCK ParseSharedPacket(HANDLE hData)
Definition: desktopipc.cpp:236
HWND g_hwndProxyDesktop
Definition: desktopipc.cpp:8
static DWORD WINAPI BrowserThreadProc(LPVOID lpThreadParameter)
Definition: desktopipc.cpp:422
HRESULT WINAPI SHOpenNewFrame(LPITEMIDLIST pidl, IUnknown *paramC, long param10, DWORD dwFlags)
Definition: desktopipc.cpp:578
HWND FindShellProxy(LPITEMIDLIST pidl)
Definition: desktopipc.cpp:69
BOOL WINAPI SHCreateFromDesktop(_In_ PEXPLORER_CMDLINE_PARSE_RESULTS parseResults)
Definition: desktopipc.cpp:606
HRESULT WINAPI SHOpenFolderWindow(PIE_THREAD_PARAM_BLOCK parameters)
Definition: desktopipc.cpp:542
BOOL g_SeparateFolders
Definition: desktopipc.cpp:7
#define PROXY_DESKTOP_CLASS
Definition: desktopipc.cpp:5
IEThreadParamBlock *WINAPI SHCreateIETHREADPARAM(long param8, long paramC, IUnknown *param10, IUnknown *param14)
Definition: desktopipc.cpp:444
BOOL WINAPI SHOnCWMCommandLine(HANDLE hSharedInfo)
Definition: desktopipc.cpp:524
IEThreadParamBlock *WINAPI SHCloneIETHREADPARAM(IEThreadParamBlock *param)
Definition: desktopipc.cpp:468
static HRESULT ExplorerMessageLoop(IEThreadParamBlock *parameters)
Definition: desktopipc.cpp:344
void WINAPI SHDestroyIETHREADPARAM(IEThreadParamBlock *param)
Definition: desktopipc.cpp:496
HANDLE MakeSharedPacket(IEThreadParamBlock *threadParams, LPCWSTR strPath, int dwProcessId)
Definition: desktopipc.cpp:102
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CloseHandle
Definition: compat.h:739
#define TRACE_ON(x)
Definition: compat.h:75
#define MAX_PATH
Definition: compat.h:34
#define lstrlenW
Definition: compat.h:750
#define FAILED_UNEXPECTEDLY(hr)
Definition: precomp.h:121
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
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
HRESULT WINAPI DECLSPEC_HOTPATCH OleInitialize(LPVOID reserved)
Definition: ole2.c:169
void WINAPI DECLSPEC_HOTPATCH OleUninitialize(void)
Definition: ole2.c:230
HRESULT WINAPI SHGetFolderLocation(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)
Definition: shellpath.c:3124
HANDLE WINAPI SHAllocShared(LPCVOID lpvData, DWORD dwSize, DWORD dwProcId)
Definition: ordinal.c:165
PVOID WINAPI SHLockShared(HANDLE hShared, DWORD dwProcId)
Definition: ordinal.c:255
BOOL WINAPI SHFreeShared(HANDLE hShared, DWORD dwProcId)
Definition: ordinal.c:311
BOOL WINAPI SHUnlockShared(LPVOID lpView)
Definition: ordinal.c:291
HRESULT WINAPI SHCreateThreadRef(LONG *lprefcount, IUnknown **lppUnknown)
Definition: thread.c:198
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
int proxy
Definition: main.c:67
GLenum const GLfloat * params
Definition: glext.h:5645
GLfloat param
Definition: glext.h:5796
GLuint64EXT * result
Definition: glext.h:11304
GLenum target
Definition: glext.h:7315
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
ULONG AddRef()
ULONG Release()
nsrefcnt Release()
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define MESSAGE_HANDLER(msg, func)
Definition: atlwin.h:1926
#define BEGIN_MSG_MAP(theClass)
Definition: atlwin.h:1898
#define END_MSG_MAP()
Definition: atlwin.h:1917
#define DECLARE_WND_CLASS_EX(WndClassName, style, bkgnd)
Definition: atlwin.h:2004
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define _In_
Definition: ms_sal.h:308
unsigned int UINT
Definition: ndis.h:50
#define DWORD
Definition: nt_native.h:44
#define UNICODE_NULL
BYTE * PBYTE
Definition: pedump.c:66
long LONG
Definition: pedump.c:60
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:237
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:938
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:198
BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
Definition: pidl.c:221
BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl, LPVOID path)
Definition: pidl.c:183
LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
Definition: pidl.c:864
LPITEMIDLIST WINAPI ILCreateFromPathW(LPCWSTR path)
Definition: pidl.c:995
#define ILGetSize
Definition: shellclasses.h:638
HRESULT WINAPI SHGetInstanceExplorer(IUnknown **lpUnknown)
Definition: shellord.c:1506
VOID WINAPI SHSetInstanceExplorer(LPUNKNOWN lpUnknown)
Definition: shellord.c:1496
HRESULT hr
Definition: shlfolder.c:183
#define ILCreateFromPath
Definition: shlobj.h:2491
#define CSIDL_PERSONAL
Definition: shlobj.h:2163
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
ITEMID_CHILD UNALIGNED * PUITEMID_CHILD
Definition: shtypes.idl:68
#define TRACE(s)
Definition: solgame.cpp:4
DWORD offset10
Definition: desktopipc.cpp:17
DWORD offset20
Definition: desktopipc.cpp:21
DWORD offset30
Definition: desktopipc.cpp:25
DWORD offsetC
Definition: desktopipc.cpp:16
DWORD offset18
Definition: desktopipc.cpp:19
DWORD offset8
Definition: desktopipc.cpp:15
UINT pidlSize7C
Definition: desktopipc.cpp:27
UINT cbSize
Definition: desktopipc.cpp:13
UINT directoryPidlLength
Definition: desktopipc.cpp:26
DWORD offset1C
Definition: desktopipc.cpp:20
UINT pidlSize80
Definition: desktopipc.cpp:28
UINT pathLength
Definition: desktopipc.cpp:29
DWORD offset24
Definition: desktopipc.cpp:22
DWORD offset14
Definition: desktopipc.cpp:18
DWORD offset28
Definition: desktopipc.cpp:23
DWORD offset4
Definition: desktopipc.cpp:14
DWORD offset2C
Definition: desktopipc.cpp:24
LPITEMIDLIST offset80
IUnknown * pExplorerInstance
LPITEMIDLIST directoryPIDL
LPITEMIDLIST offset7C
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
uint16_t * PWSTR
Definition: typedefs.h:56
const uint16_t * PCWSTR
Definition: typedefs.h:57
HWND WINAPI GetShellWindow(VOID)
Definition: desktop.c:651
BOOL WINAPI AllowSetForegroundWindow(DWORD dwProcessId)
Definition: window.c:49
#define LMEM_ZEROINIT
Definition: winbase.h:375
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
DWORD WINAPI GetCurrentProcessId(void)
Definition: proc.c:1158
DWORD WINAPI GetWindowThreadProcessId(HWND hWnd, PDWORD lpdwProcessId)
#define LMEM_FIXED
Definition: winbase.h:368
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ ULONG_PTR _In_ ULONG _Out_ ULONG_PTR * pid
Definition: winddi.h:3837
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
UINT_PTR WPARAM
Definition: windef.h:207
#define WINAPI
Definition: msvc.h:6
#define CS_DROPSHADOW
Definition: winuser.h:660
#define WM_QUIT
Definition: winuser.h:1623
BOOL WINAPI TranslateMessage(_In_ const MSG *)
BOOL WINAPI GetMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define FindWindow
Definition: winuser.h:5777
#define GetMessage
Definition: winuser.h:5790
LRESULT WINAPI DispatchMessageW(_In_ const MSG *)
#define CS_SAVEBITS
Definition: winuser.h:657
#define DispatchMessage
Definition: winuser.h:5765
BOOL WINAPI DestroyWindow(_In_ HWND)
#define COLOR_3DFACE
Definition: winuser.h:929
#define IID_PPV_ARG(Itype, ppType)
static unsigned int block
Definition: xmlmemory.c:101
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185