?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winealsa.drv: Remap mmdevapi channels to correct ALSA channels.
[wine.git] / dlls / shell32 / shelllink.c
blobe325e2e46d46581b8635535b1d38d0183aece941
1 /*
2 *
3 * Copyright 1997 Marcus Meissner
4 * Copyright 1998 Juergen Schmied
5 * Copyright 2005 Mike McCormack
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * NOTES
22 * Nearly complete information about the binary formats
23 * of .lnk files available at http://www.wotsit.org
24 *
25 * You can use winedump to examine the contents of a link file:
26 * winedump lnk sc.lnk
27 *
28 * MSI advertised shortcuts are totally undocumented. They provide an
29 * icon for a program that is not yet installed, and invoke MSI to
30 * install the program when the shortcut is clicked on. They are
31 * created by passing a special string to SetPath, and the information
32 * in that string is parsed an stored.
33 */
34
35 #define COBJMACROS
36 #define NONAMELESSUNION
37
38 #include "wine/debug.h"
39 #include "winerror.h"
40 #include "windef.h"
41 #include "winbase.h"
42 #include "winnls.h"
43 #include "winreg.h"
44
45 #include "winuser.h"
46 #include "wingdi.h"
47 #include "shlobj.h"
48 #include "undocshell.h"
49
50 #include "pidl.h"
51 #include "shell32_main.h"
52 #include "shlguid.h"
53 #include "shlwapi.h"
54 #include "msi.h"
55 #include "appmgmt.h"
56
57 #include "initguid.h"
58
59 WINE_DEFAULT_DEBUG_CHANNEL(shell);
60
61 DEFINE_GUID( SHELL32_AdvtShortcutProduct,
62 0x9db1186f,0x40df,0x11d1,0xaa,0x8c,0x00,0xc0,0x4f,0xb6,0x78,0x63);
63 DEFINE_GUID( SHELL32_AdvtShortcutComponent,
64 0x9db1186e,0x40df,0x11d1,0xaa,0x8c,0x00,0xc0,0x4f,0xb6,0x78,0x63);
65
66 /* link file formats */
67
68 #include "pshpack1.h"
69
70 typedef struct _LINK_HEADER
71 {
72 DWORD dwSize; /* 0x00 size of the header - 0x4c */
73 GUID MagicGuid; /* 0x04 is CLSID_ShellLink */
74 DWORD dwFlags; /* 0x14 describes elements following */
75 DWORD dwFileAttr; /* 0x18 attributes of the target file */
76 FILETIME Time1; /* 0x1c */
77 FILETIME Time2; /* 0x24 */
78 FILETIME Time3; /* 0x2c */
79 DWORD dwFileLength; /* 0x34 File length */
80 DWORD nIcon; /* 0x38 icon number */
81 DWORD fStartup; /* 0x3c startup type */
82 DWORD wHotKey; /* 0x40 hotkey */
83 DWORD Unknown5; /* 0x44 */
84 DWORD Unknown6; /* 0x48 */
85 } LINK_HEADER, * PLINK_HEADER;
86
87 #define SHLINK_LOCAL 0
88 #define SHLINK_REMOTE 1
89
90 typedef struct _LOCATION_INFO
91 {
92 DWORD dwTotalSize;
93 DWORD dwHeaderSize;
94 DWORD dwFlags;
95 DWORD dwVolTableOfs;
96 DWORD dwLocalPathOfs;
97 DWORD dwNetworkVolTableOfs;
98 DWORD dwFinalPathOfs;
99 } LOCATION_INFO;
100
101 typedef struct _LOCAL_VOLUME_INFO
102 {
103 DWORD dwSize;
104 DWORD dwType;
105 DWORD dwVolSerial;
106 DWORD dwVolLabelOfs;
107 } LOCAL_VOLUME_INFO;
108
109 typedef struct volume_info_t
110 {
111 DWORD type;
112 DWORD serial;
113 WCHAR label[12]; /* assume 8.3 */
114 } volume_info;
115
116 #include "poppack.h"
117
118 static const IShellLinkAVtbl slvt;
119 static const IShellLinkWVtbl slvtw;
120 static const IPersistFileVtbl pfvt;
121 static const IPersistStreamVtbl psvt;
122 static const IShellLinkDataListVtbl dlvt;
123 static const IShellExtInitVtbl eivt;
124 static const IContextMenuVtbl cmvt;
125 static const IObjectWithSiteVtbl owsvt;
126
127 /* IShellLink Implementation */
128
129 typedef struct
130 {
131 IShellLinkA IShellLinkA_iface;
132 IShellLinkW IShellLinkW_iface;
133 IPersistFile IPersistFile_iface;
134 IPersistStream IPersistStream_iface;
135 IShellLinkDataList IShellLinkDataList_iface;
136 IShellExtInit IShellExtInit_iface;
137 IContextMenu IContextMenu_iface;
138 IObjectWithSite IObjectWithSite_iface;
139
140 LONG ref;
141
142 /* data structures according to the information in the link */
143 LPITEMIDLIST pPidl;
144 WORD wHotKey;
145 SYSTEMTIME time1;
146 SYSTEMTIME time2;
147 SYSTEMTIME time3;
148
149 DWORD iShowCmd;
150 LPWSTR sIcoPath;
151 INT iIcoNdx;
152 LPWSTR sPath;
153 LPWSTR sArgs;
154 LPWSTR sWorkDir;
155 LPWSTR sDescription;
156 LPWSTR sPathRel;
157 LPWSTR sProduct;
158 LPWSTR sComponent;
159 volume_info volume;
160
161 BOOL bDirty;
162 INT iIdOpen; /* id of the "Open" entry in the context menu */
163 IUnknown *site;
164
165 LPOLESTR filepath; /* file path returned by IPersistFile::GetCurFile */
166 } IShellLinkImpl;
167
168 static inline IShellLinkImpl *impl_from_IShellLinkA(IShellLinkA *iface)
169 {
170 return CONTAINING_RECORD(iface, IShellLinkImpl, IShellLinkA_iface);
171 }
172
173 static inline IShellLinkImpl *impl_from_IShellLinkW(IShellLinkW *iface)
174 {
175 return CONTAINING_RECORD(iface, IShellLinkImpl, IShellLinkW_iface);
176 }
177
178 static inline IShellLinkImpl *impl_from_IPersistFile(IPersistFile *iface)
179 {
180 return CONTAINING_RECORD(iface, IShellLinkImpl, IPersistFile_iface);
181 }
182
183 static inline IShellLinkImpl *impl_from_IPersistStream(IPersistStream *iface)
184 {
185 return CONTAINING_RECORD(iface, IShellLinkImpl, IPersistStream_iface);
186 }
187
188 static inline IShellLinkImpl *impl_from_IShellLinkDataList(IShellLinkDataList *iface)
189 {
190 return CONTAINING_RECORD(iface, IShellLinkImpl, IShellLinkDataList_iface);
191 }
192
193 static inline IShellLinkImpl *impl_from_IShellExtInit(IShellExtInit *iface)
194 {
195 return CONTAINING_RECORD(iface, IShellLinkImpl, IShellExtInit_iface);
196 }
197
198 static inline IShellLinkImpl *impl_from_IContextMenu(IContextMenu *iface)
199 {
200 return CONTAINING_RECORD(iface, IShellLinkImpl, IContextMenu_iface);
201 }
202
203 static inline IShellLinkImpl *impl_from_IObjectWithSite(IObjectWithSite *iface)
204 {
205 return CONTAINING_RECORD(iface, IShellLinkImpl, IObjectWithSite_iface);
206 }
207
208 static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath);
209
210 /* strdup on the process heap */
211 static inline LPWSTR HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str)
212 {
213 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
214 LPWSTR p = HeapAlloc( heap, flags, len*sizeof (WCHAR) );
215 if( !p )
216 return p;
217 MultiByteToWideChar( CP_ACP, 0, str, -1, p, len );
218 return p;
219 }
220
221 static inline LPWSTR strdupW( LPCWSTR src )
222 {
223 LPWSTR dest;
224 if (!src) return NULL;
225 dest = HeapAlloc( GetProcessHeap(), 0, (lstrlenW(src)+1)*sizeof(WCHAR) );
226 if (dest)
227 lstrcpyW(dest, src);
228 return dest;
229 }
230
231 /**************************************************************************
232 * ShellLink::QueryInterface implementation
233 */
234 static HRESULT ShellLink_QueryInterface( IShellLinkImpl *This, REFIID riid, LPVOID *ppvObj)
235 {
236 TRACE("(%p)->(\n\tIID:\t%s)\n",This,debugstr_guid(riid));
237
238 *ppvObj = NULL;
239
240 if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IShellLinkA))
241 {
242 *ppvObj = This;
243 }
244 else if(IsEqualIID(riid, &IID_IShellLinkW))
245 {
246 *ppvObj = &This->IShellLinkW_iface;
247 }
248 else if(IsEqualIID(riid, &IID_IPersistFile))
249 {
250 *ppvObj = &This->IPersistFile_iface;
251 }
252 else if(IsEqualIID(riid, &IID_IPersistStream))
253 {
254 *ppvObj = &This->IPersistStream_iface;
255 }
256 else if(IsEqualIID(riid, &IID_IShellLinkDataList))
257 {
258 *ppvObj = &This->IShellLinkDataList_iface;
259 }
260 else if(IsEqualIID(riid, &IID_IShellExtInit))
261 {
262 *ppvObj = &This->IShellExtInit_iface;
263 }
264 else if(IsEqualIID(riid, &IID_IContextMenu))
265 {
266 *ppvObj = &This->IContextMenu_iface;
267 }
268 else if(IsEqualIID(riid, &IID_IObjectWithSite))
269 {
270 *ppvObj = &This->IObjectWithSite_iface;
271 }
272
273 if(*ppvObj)
274 {
275 IUnknown_AddRef((IUnknown*)(*ppvObj));
276 TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
277 return S_OK;
278 }
279 ERR("-- Interface: E_NOINTERFACE\n");
280 return E_NOINTERFACE;
281 }
282
283 /**************************************************************************
284 * ShellLink::AddRef implementation
285 */
286 static ULONG ShellLink_AddRef( IShellLinkImpl *This )
287 {
288 ULONG refCount = InterlockedIncrement(&This->ref);
289
290 TRACE("(%p)->(count=%u)\n", This, refCount - 1);
291
292 return refCount;
293 }
294
295 /**************************************************************************
296 * ShellLink::Release implementation
297 */
298 static ULONG ShellLink_Release( IShellLinkImpl *This )
299 {
300 ULONG refCount = InterlockedDecrement(&This->ref);
301
302 TRACE("(%p)->(count=%u)\n", This, refCount + 1);
303
304 if (refCount)
305 return refCount;
306
307 TRACE("-- destroying IShellLink(%p)\n",This);
308
309 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
310 HeapFree(GetProcessHeap(), 0, This->sArgs);
311 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
312 HeapFree(GetProcessHeap(), 0, This->sDescription);
313 HeapFree(GetProcessHeap(), 0, This->sPath);
314 HeapFree(GetProcessHeap(), 0, This->sPathRel);
315 HeapFree(GetProcessHeap(), 0, This->sProduct);
316 HeapFree(GetProcessHeap(), 0, This->sComponent);
317 HeapFree(GetProcessHeap(), 0, This->filepath);
318
319 if (This->site)
320 IUnknown_Release( This->site );
321
322 if (This->pPidl)
323 ILFree(This->pPidl);
324
325 LocalFree(This);
326
327 return 0;
328 }
329
330 static HRESULT ShellLink_GetClassID( IShellLinkImpl *This, CLSID *pclsid )
331 {
332 TRACE("%p %p\n", This, pclsid);
333
334 *pclsid = CLSID_ShellLink;
335 return S_OK;
336 }
337
338 /**************************************************************************
339 * IPersistFile_QueryInterface
340 */
341 static HRESULT WINAPI IPersistFile_fnQueryInterface(
342 IPersistFile* iface,
343 REFIID riid,
344 LPVOID *ppvObj)
345 {
346 IShellLinkImpl *This = impl_from_IPersistFile(iface);
347 return ShellLink_QueryInterface( This, riid, ppvObj );
348 }
349
350 /******************************************************************************
351 * IPersistFile_AddRef
352 */
353 static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile* iface)
354 {
355 IShellLinkImpl *This = impl_from_IPersistFile(iface);
356 return ShellLink_AddRef( This );
357 }
358
359 /******************************************************************************
360 * IPersistFile_Release
361 */
362 static ULONG WINAPI IPersistFile_fnRelease(IPersistFile* iface)
363 {
364 IShellLinkImpl *This = impl_from_IPersistFile(iface);
365 return IShellLinkA_Release(&This->IShellLinkA_iface);
366 }
367
368 static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile* iface, CLSID *pClassID)
369 {
370 IShellLinkImpl *This = impl_from_IPersistFile(iface);
371 return ShellLink_GetClassID( This, pClassID );
372 }
373
374 static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile* iface)
375 {
376 IShellLinkImpl *This = impl_from_IPersistFile(iface);
377
378 TRACE("(%p)\n",This);
379
380 if (This->bDirty)
381 return S_OK;
382
383 return S_FALSE;
384 }
385
386 static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile* iface, LPCOLESTR pszFileName, DWORD dwMode)
387 {
388 IShellLinkImpl *This = impl_from_IPersistFile(iface);
389 IPersistStream *StreamThis = &This->IPersistStream_iface;
390 HRESULT r;
391 IStream *stm;
392
393 TRACE("(%p, %s, %x)\n",This, debugstr_w(pszFileName), dwMode);
394
395 if( dwMode == 0 )
396 dwMode = STGM_READ | STGM_SHARE_DENY_WRITE;
397 r = SHCreateStreamOnFileW(pszFileName, dwMode, &stm);
398 if( SUCCEEDED( r ) )
399 {
400 r = IPersistStream_Load(StreamThis, stm);
401 ShellLink_UpdatePath(This->sPathRel, pszFileName, This->sWorkDir, &This->sPath);
402 IStream_Release( stm );
403
404 /* update file path */
405 HeapFree(GetProcessHeap(), 0, This->filepath);
406 This->filepath = strdupW(pszFileName);
407
408 This->bDirty = FALSE;
409 }
410 TRACE("-- returning hr %08x\n", r);
411 return r;
412 }
413
414 BOOL run_winemenubuilder( const WCHAR *args )
415 {
416 static const WCHAR menubuilder[] = {'\\','w','i','n','e','m','e','n','u','b','u','i','l','d','e','r','.','e','x','e',0};
417 LONG len;
418 LPWSTR buffer;
419 STARTUPINFOW si;
420 PROCESS_INFORMATION pi;
421 BOOL ret;
422 WCHAR app[MAX_PATH];
423 void *redir;
424
425 GetSystemDirectoryW( app, MAX_PATH - sizeof(menubuilder)/sizeof(WCHAR) );
426 strcatW( app, menubuilder );
427
428 len = (strlenW( app ) + strlenW( args ) + 1) * sizeof(WCHAR);
429 buffer = HeapAlloc( GetProcessHeap(), 0, len );
430 if( !buffer )
431 return FALSE;
432
433 strcpyW( buffer, app );
434 strcatW( buffer, args );
435
436 TRACE("starting %s\n",debugstr_w(buffer));
437
438 memset(&si, 0, sizeof(si));
439 si.cb = sizeof(si);
440
441 Wow64DisableWow64FsRedirection( &redir );
442 ret = CreateProcessW( app, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi );
443 Wow64RevertWow64FsRedirection( redir );
444
445 HeapFree( GetProcessHeap(), 0, buffer );
446
447 if (ret)
448 {
449 CloseHandle( pi.hProcess );
450 CloseHandle( pi.hThread );
451 }
452
453 return ret;
454 }
455
456 static BOOL StartLinkProcessor( LPCOLESTR szLink )
457 {
458 static const WCHAR szFormat[] = {' ','-','w',' ','"','%','s','"',0 };
459 LONG len;
460 LPWSTR buffer;
461 BOOL ret;
462
463 len = sizeof(szFormat) + lstrlenW( szLink ) * sizeof(WCHAR);
464 buffer = HeapAlloc( GetProcessHeap(), 0, len );
465 if( !buffer )
466 return FALSE;
467
468 wsprintfW( buffer, szFormat, szLink );
469 ret = run_winemenubuilder( buffer );
470 HeapFree( GetProcessHeap(), 0, buffer );
471 return ret;
472 }
473
474 static HRESULT WINAPI IPersistFile_fnSave(IPersistFile* iface, LPCOLESTR pszFileName, BOOL fRemember)
475 {
476 IShellLinkImpl *This = impl_from_IPersistFile(iface);
477 IPersistStream *StreamThis = &This->IPersistStream_iface;
478 HRESULT r;
479 IStream *stm;
480
481 TRACE("(%p)->(%s)\n",This,debugstr_w(pszFileName));
482
483 if (!pszFileName)
484 return E_FAIL;
485
486 r = SHCreateStreamOnFileW( pszFileName, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &stm );
487 if( SUCCEEDED( r ) )
488 {
489 r = IPersistStream_Save(StreamThis, stm, FALSE);
490 IStream_Release( stm );
491
492 if( SUCCEEDED( r ) )
493 {
494 StartLinkProcessor( pszFileName );
495
496 /* update file path */
497 HeapFree(GetProcessHeap(), 0, This->filepath);
498 This->filepath = strdupW(pszFileName);
499
500 This->bDirty = FALSE;
501 }
502 else
503 {
504 DeleteFileW( pszFileName );
505 WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName) );
506 }
507 }
508
509 return r;
510 }
511
512 static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile* iface, LPCOLESTR filename)
513 {
514 IShellLinkImpl *This = impl_from_IPersistFile(iface);
515 FIXME("(%p)->(%s): stub\n", This, debugstr_w(filename));
516 return S_OK;
517 }
518
519 static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile* iface, LPOLESTR *filename)
520 {
521 IShellLinkImpl *This = impl_from_IPersistFile(iface);
522 IMalloc *pMalloc;
523
524 TRACE("(%p)->(%p)\n", This, filename);
525
526 if (!This->filepath)
527 {
528 *filename = NULL;
529 return S_FALSE;
530 }
531
532 SHGetMalloc(&pMalloc);
533 *filename = IMalloc_Alloc(pMalloc, (strlenW(This->filepath)+1)*sizeof(WCHAR));
534 if (!*filename) return E_OUTOFMEMORY;
535
536 strcpyW(*filename, This->filepath);
537
538 return S_OK;
539 }
540
541 static const IPersistFileVtbl pfvt =
542 {
543 IPersistFile_fnQueryInterface,
544 IPersistFile_fnAddRef,
545 IPersistFile_fnRelease,
546 IPersistFile_fnGetClassID,
547 IPersistFile_fnIsDirty,
548 IPersistFile_fnLoad,
549 IPersistFile_fnSave,
550 IPersistFile_fnSaveCompleted,
551 IPersistFile_fnGetCurFile
552 };
553
554 /************************************************************************
555 * IPersistStream_QueryInterface
556 */
557 static HRESULT WINAPI IPersistStream_fnQueryInterface(
558 IPersistStream* iface,
559 REFIID riid,
560 VOID** ppvObj)
561 {
562 IShellLinkImpl *This = impl_from_IPersistStream(iface);
563 return ShellLink_QueryInterface( This, riid, ppvObj );
564 }
565
566 /************************************************************************
567 * IPersistStream_Release
568 */
569 static ULONG WINAPI IPersistStream_fnRelease(
570 IPersistStream* iface)
571 {
572 IShellLinkImpl *This = impl_from_IPersistStream(iface);
573 return IShellLinkA_Release(&This->IShellLinkA_iface);
574 }
575
576 /************************************************************************
577 * IPersistStream_AddRef
578 */
579 static ULONG WINAPI IPersistStream_fnAddRef(
580 IPersistStream* iface)
581 {
582 IShellLinkImpl *This = impl_from_IPersistStream(iface);
583 return ShellLink_AddRef( This );
584 }
585
586 /************************************************************************
587 * IPersistStream_GetClassID
588 *
589 */
590 static HRESULT WINAPI IPersistStream_fnGetClassID(
591 IPersistStream* iface,
592 CLSID* pClassID)
593 {
594 IShellLinkImpl *This = impl_from_IPersistStream(iface);
595 return ShellLink_GetClassID( This, pClassID );
596 }
597
598 /************************************************************************
599 * IPersistStream_IsDirty (IPersistStream)
600 */
601 static HRESULT WINAPI IPersistStream_fnIsDirty(
602 IPersistStream* iface)
603 {
604 IShellLinkImpl *This = impl_from_IPersistStream(iface);
605
606 TRACE("(%p)\n", This);
607
608 return S_OK;
609 }
610
611
612 static HRESULT Stream_LoadString( IStream* stm, BOOL unicode, LPWSTR *pstr )
613 {
614 DWORD count;
615 USHORT len;
616 LPVOID temp;
617 LPWSTR str;
618 HRESULT r;
619
620 TRACE("%p\n", stm);
621
622 count = 0;
623 r = IStream_Read(stm, &len, sizeof(len), &count);
624 if ( FAILED (r) || ( count != sizeof(len) ) )
625 return E_FAIL;
626
627 if( unicode )
628 len *= sizeof (WCHAR);
629
630 TRACE("reading %d\n", len);
631 temp = HeapAlloc(GetProcessHeap(), 0, len+sizeof(WCHAR));
632 if( !temp )
633 return E_OUTOFMEMORY;
634 count = 0;
635 r = IStream_Read(stm, temp, len, &count);
636 if( FAILED (r) || ( count != len ) )
637 {
638 HeapFree( GetProcessHeap(), 0, temp );
639 return E_FAIL;
640 }
641
642 TRACE("read %s\n", debugstr_an(temp,len));
643
644 /* convert to unicode if necessary */
645 if( !unicode )
646 {
647 count = MultiByteToWideChar( CP_ACP, 0, temp, len, NULL, 0 );
648 str = HeapAlloc( GetProcessHeap(), 0, (count+1)*sizeof (WCHAR) );
649 if( !str )
650 {
651 HeapFree( GetProcessHeap(), 0, temp );
652 return E_OUTOFMEMORY;
653 }
654 MultiByteToWideChar( CP_ACP, 0, temp, len, str, count );
655 HeapFree( GetProcessHeap(), 0, temp );
656 }
657 else
658 {
659 count /= 2;
660 str = temp;
661 }
662 str[count] = 0;
663
664 *pstr = str;
665
666 return S_OK;
667 }
668
669 static HRESULT Stream_ReadChunk( IStream* stm, LPVOID *data )
670 {
671 DWORD size;
672 ULONG count;
673 HRESULT r;
674 struct sized_chunk {
675 DWORD size;
676 unsigned char data[1];
677 } *chunk;
678
679 TRACE("%p\n",stm);
680
681 r = IStream_Read( stm, &size, sizeof(size), &count );
682 if( FAILED( r ) || count != sizeof(size) )
683 return E_FAIL;
684
685 chunk = HeapAlloc( GetProcessHeap(), 0, size );
686 if( !chunk )
687 return E_OUTOFMEMORY;
688
689 chunk->size = size;
690 r = IStream_Read( stm, chunk->data, size - sizeof(size), &count );
691 if( FAILED( r ) || count != (size - sizeof(size)) )
692 {
693 HeapFree( GetProcessHeap(), 0, chunk );
694 return E_FAIL;
695 }
696
697 TRACE("Read %d bytes\n",chunk->size);
698
699 *data = chunk;
700
701 return S_OK;
702 }
703
704 static BOOL Stream_LoadVolume( LOCAL_VOLUME_INFO *vol, volume_info *volume )
705 {
706 const int label_sz = sizeof volume->label/sizeof volume->label[0];
707 LPSTR label;
708 int len;
709
710 volume->serial = vol->dwVolSerial;
711 volume->type = vol->dwType;
712
713 if( !vol->dwVolLabelOfs )
714 return FALSE;
715 if( vol->dwSize <= vol->dwVolLabelOfs )
716 return FALSE;
717 len = vol->dwSize - vol->dwVolLabelOfs;
718
719 label = (LPSTR) vol;
720 label += vol->dwVolLabelOfs;
721 MultiByteToWideChar( CP_ACP, 0, label, len, volume->label, label_sz-1);
722
723 return TRUE;
724 }
725
726 static LPWSTR Stream_LoadPath( LPCSTR p, DWORD maxlen )
727 {
728 int len = 0, wlen;
729 LPWSTR path;
730
731 while( p[len] && (len < maxlen) )
732 len++;
733
734 wlen = MultiByteToWideChar(CP_ACP, 0, p, len, NULL, 0);
735 path = HeapAlloc(GetProcessHeap(), 0, (wlen+1)*sizeof(WCHAR));
736 MultiByteToWideChar(CP_ACP, 0, p, len, path, wlen);
737 path[wlen] = 0;
738
739 return path;
740 }
741
742 static HRESULT Stream_LoadLocation( IStream *stm,
743 volume_info *volume, LPWSTR *path )
744 {
745 char *p = NULL;
746 LOCATION_INFO *loc;
747 HRESULT r;
748 DWORD n;
749
750 r = Stream_ReadChunk( stm, (LPVOID*) &p );
751 if( FAILED(r) )
752 return r;
753
754 loc = (LOCATION_INFO*) p;
755 if (loc->dwTotalSize < sizeof(LOCATION_INFO))
756 {
757 HeapFree( GetProcessHeap(), 0, p );
758 return E_FAIL;
759 }
760
761 /* if there's valid local volume information, load it */
762 if( loc->dwVolTableOfs &&
763 ((loc->dwVolTableOfs + sizeof(LOCAL_VOLUME_INFO)) <= loc->dwTotalSize) )
764 {
765 LOCAL_VOLUME_INFO *volume_info;
766
767 volume_info = (LOCAL_VOLUME_INFO*) &p[loc->dwVolTableOfs];
768 Stream_LoadVolume( volume_info, volume );
769 }
770
771 /* if there's a local path, load it */
772 n = loc->dwLocalPathOfs;
773 if( n && (n < loc->dwTotalSize) )
774 *path = Stream_LoadPath( &p[n], loc->dwTotalSize - n );
775
776 TRACE("type %d serial %08x name %s path %s\n", volume->type,
777 volume->serial, debugstr_w(volume->label), debugstr_w(*path));
778
779 HeapFree( GetProcessHeap(), 0, p );
780 return S_OK;
781 }
782
783 /*
784 * The format of the advertised shortcut info seems to be:
785 *
786 * Offset Description
787 * ------ -----------
788 *
789 * 0 Length of the block (4 bytes, usually 0x314)
790 * 4 tag (dword)
791 * 8 string data in ASCII
792 * 8+0x104 string data in UNICODE
793 *
794 * In the original Win32 implementation the buffers are not initialized
795 * to zero, so data trailing the string is random garbage.
796 */
797 static HRESULT Stream_LoadAdvertiseInfo( IStream* stm, LPWSTR *str )
798 {
799 DWORD size;
800 ULONG count;
801 HRESULT r;
802 EXP_DARWIN_LINK buffer;
803
804 TRACE("%p\n",stm);
805
806 r = IStream_Read( stm, &buffer.dbh.cbSize, sizeof (DWORD), &count );
807 if( FAILED( r ) )
808 return r;
809
810 /* make sure that we read the size of the structure even on error */
811 size = sizeof buffer - sizeof (DWORD);
812 if( buffer.dbh.cbSize != sizeof buffer )
813 {
814 ERR("Ooops. This structure is not as expected...\n");
815 return E_FAIL;
816 }
817
818 r = IStream_Read( stm, &buffer.dbh.dwSignature, size, &count );
819 if( FAILED( r ) )
820 return r;
821
822 if( count != size )
823 return E_FAIL;
824
825 TRACE("magic %08x string = %s\n", buffer.dbh.dwSignature, debugstr_w(buffer.szwDarwinID));
826
827 if( (buffer.dbh.dwSignature&0xffff0000) != 0xa0000000 )
828 {
829 ERR("Unknown magic number %08x in advertised shortcut\n", buffer.dbh.dwSignature);
830 return E_FAIL;
831 }
832
833 *str = HeapAlloc( GetProcessHeap(), 0,
834 (lstrlenW(buffer.szwDarwinID)+1) * sizeof(WCHAR) );
835 lstrcpyW( *str, buffer.szwDarwinID );
836
837 return S_OK;
838 }
839
840 /************************************************************************
841 * IPersistStream_Load (IPersistStream)
842 */
843 static HRESULT WINAPI IPersistStream_fnLoad(
844 IPersistStream* iface,
845 IStream* stm)
846 {
847 LINK_HEADER hdr;
848 ULONG dwBytesRead;
849 BOOL unicode;
850 HRESULT r;
851 DWORD zero;
852
853 IShellLinkImpl *This = impl_from_IPersistStream(iface);
854
855 TRACE("%p %p\n", This, stm);
856
857 if( !stm )
858 return STG_E_INVALIDPOINTER;
859
860 dwBytesRead = 0;
861 r = IStream_Read(stm, &hdr, sizeof(hdr), &dwBytesRead);
862 if( FAILED( r ) )
863 return r;
864
865 if( dwBytesRead != sizeof(hdr))
866 return E_FAIL;
867 if( hdr.dwSize != sizeof(hdr))
868 return E_FAIL;
869 if( !IsEqualIID(&hdr.MagicGuid, &CLSID_ShellLink) )
870 return E_FAIL;
871
872 /* free all the old stuff */
873 ILFree(This->pPidl);
874 This->pPidl = NULL;
875 memset( &This->volume, 0, sizeof This->volume );
876 HeapFree(GetProcessHeap(), 0, This->sPath);
877 This->sPath = NULL;
878 HeapFree(GetProcessHeap(), 0, This->sDescription);
879 This->sDescription = NULL;
880 HeapFree(GetProcessHeap(), 0, This->sPathRel);
881 This->sPathRel = NULL;
882 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
883 This->sWorkDir = NULL;
884 HeapFree(GetProcessHeap(), 0, This->sArgs);
885 This->sArgs = NULL;
886 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
887 This->sIcoPath = NULL;
888 HeapFree(GetProcessHeap(), 0, This->sProduct);
889 This->sProduct = NULL;
890 HeapFree(GetProcessHeap(), 0, This->sComponent);
891 This->sComponent = NULL;
892
893 This->wHotKey = (WORD)hdr.wHotKey;
894 This->iIcoNdx = hdr.nIcon;
895 FileTimeToSystemTime (&hdr.Time1, &This->time1);
896 FileTimeToSystemTime (&hdr.Time2, &This->time2);
897 FileTimeToSystemTime (&hdr.Time3, &This->time3);
898 if (TRACE_ON(shell))
899 {
900 WCHAR sTemp[MAX_PATH];
901 GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time1,
902 NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
903 TRACE("-- time1: %s\n", debugstr_w(sTemp) );
904 GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time2,
905 NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
906 TRACE("-- time2: %s\n", debugstr_w(sTemp) );
907 GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time3,
908 NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
909 TRACE("-- time3: %s\n", debugstr_w(sTemp) );
910 }
911
912 /* load all the new stuff */
913 if( hdr.dwFlags & SLDF_HAS_ID_LIST )
914 {
915 r = ILLoadFromStream( stm, &This->pPidl );
916 if( FAILED( r ) )
917 return r;
918 }
919 pdump(This->pPidl);
920
921 /* load the location information */
922 if( hdr.dwFlags & SLDF_HAS_LINK_INFO )
923 r = Stream_LoadLocation( stm, &This->volume, &This->sPath );
924 if( FAILED( r ) )
925 goto end;
926
927 unicode = hdr.dwFlags & SLDF_UNICODE;
928 if( hdr.dwFlags & SLDF_HAS_NAME )
929 {
930 r = Stream_LoadString( stm, unicode, &This->sDescription );
931 TRACE("Description -> %s\n",debugstr_w(This->sDescription));
932 }
933 if( FAILED( r ) )
934 goto end;
935
936 if( hdr.dwFlags & SLDF_HAS_RELPATH )
937 {
938 r = Stream_LoadString( stm, unicode, &This->sPathRel );
939 TRACE("Relative Path-> %s\n",debugstr_w(This->sPathRel));
940 }
941 if( FAILED( r ) )
942 goto end;
943
944 if( hdr.dwFlags & SLDF_HAS_WORKINGDIR )
945 {
946 r = Stream_LoadString( stm, unicode, &This->sWorkDir );
947 TRACE("Working Dir -> %s\n",debugstr_w(This->sWorkDir));
948 }
949 if( FAILED( r ) )
950 goto end;
951
952 if( hdr.dwFlags & SLDF_HAS_ARGS )
953 {
954 r = Stream_LoadString( stm, unicode, &This->sArgs );
955 TRACE("Working Dir -> %s\n",debugstr_w(This->sArgs));
956 }
957 if( FAILED( r ) )
958 goto end;
959
960 if( hdr.dwFlags & SLDF_HAS_ICONLOCATION )
961 {
962 r = Stream_LoadString( stm, unicode, &This->sIcoPath );
963 TRACE("Icon file -> %s\n",debugstr_w(This->sIcoPath));
964 }
965 if( FAILED( r ) )
966 goto end;
967
968 if( hdr.dwFlags & SLDF_HAS_LOGO3ID )
969 {
970 r = Stream_LoadAdvertiseInfo( stm, &This->sProduct );
971 TRACE("Product -> %s\n",debugstr_w(This->sProduct));
972 }
973 if( FAILED( r ) )
974 goto end;
975
976 if( hdr.dwFlags & SLDF_HAS_DARWINID )
977 {
978 r = Stream_LoadAdvertiseInfo( stm, &This->sComponent );
979 TRACE("Component -> %s\n",debugstr_w(This->sComponent));
980 }
981 if( FAILED( r ) )
982 goto end;
983
984 r = IStream_Read(stm, &zero, sizeof zero, &dwBytesRead);
985 if( FAILED( r ) || zero || dwBytesRead != sizeof zero )
986 {
987 /* Some lnk files have extra data blocks starting with a
988 * DATABLOCK_HEADER. For instance EXP_SPECIAL_FOLDER and an unknown
989 * one with a 0xa0000003 signature. However these don't seem to matter
990 * too much.
991 */
992 WARN("Last word was not zero\n");
993 }
994
995 TRACE("OK\n");
996
997 pdump (This->pPidl);
998
999 return S_OK;
1000 end:
1001 return r;
1002 }
1003
1004 /************************************************************************
1005 * Stream_WriteString
1006 *
1007 * Helper function for IPersistStream_Save. Writes a unicode string
1008 * with terminating nul byte to a stream, preceded by the its length.
1009 */
1010 static HRESULT Stream_WriteString( IStream* stm, LPCWSTR str )
1011 {
1012 USHORT len = lstrlenW( str ) + 1;
1013 DWORD count;
1014 HRESULT r;
1015
1016 r = IStream_Write( stm, &len, sizeof(len), &count );
1017 if( FAILED( r ) )
1018 return r;
1019
1020 len *= sizeof(WCHAR);
1021
1022 r = IStream_Write( stm, str, len, &count );
1023 if( FAILED( r ) )
1024 return r;
1025
1026 return S_OK;
1027 }
1028
1029 /************************************************************************
1030 * Stream_WriteLocationInfo
1031 *
1032 * Writes the location info to a stream
1033 *
1034 * FIXME: One day we might want to write the network volume information
1035 * and the final path.
1036 * Figure out how Windows deals with unicode paths here.
1037 */
1038 static HRESULT Stream_WriteLocationInfo( IStream* stm, LPCWSTR path,
1039 volume_info *volume )
1040 {
1041 DWORD total_size, path_size, volume_info_size, label_size, final_path_size;
1042 LOCAL_VOLUME_INFO *vol;
1043 LOCATION_INFO *loc;
1044 LPSTR szLabel, szPath, szFinalPath;
1045 ULONG count = 0;
1046 HRESULT hr;
1047
1048 TRACE("%p %s %p\n", stm, debugstr_w(path), volume);
1049
1050 /* figure out the size of everything */
1051 label_size = WideCharToMultiByte( CP_ACP, 0, volume->label, -1,
1052 NULL, 0, NULL, NULL );
1053 path_size = WideCharToMultiByte( CP_ACP, 0, path, -1,
1054 NULL, 0, NULL, NULL );
1055 volume_info_size = sizeof *vol + label_size;
1056 final_path_size = 1;
1057 total_size = sizeof *loc + volume_info_size + path_size + final_path_size;
1058
1059 /* create pointers to everything */
1060 loc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, total_size);
1061 vol = (LOCAL_VOLUME_INFO*) &loc[1];
1062 szLabel = (LPSTR) &vol[1];
1063 szPath = &szLabel[label_size];
1064 szFinalPath = &szPath[path_size];
1065
1066 /* fill in the location information header */
1067 loc->dwTotalSize = total_size;
1068 loc->dwHeaderSize = sizeof (*loc);
1069 loc->dwFlags = 1;
1070 loc->dwVolTableOfs = sizeof (*loc);
1071 loc->dwLocalPathOfs = sizeof (*loc) + volume_info_size;
1072 loc->dwNetworkVolTableOfs = 0;
1073 loc->dwFinalPathOfs = sizeof (*loc) + volume_info_size + path_size;
1074
1075 /* fill in the volume information */
1076 vol->dwSize = volume_info_size;
1077 vol->dwType = volume->type;
1078 vol->dwVolSerial = volume->serial;
1079 vol->dwVolLabelOfs = sizeof (*vol);
1080
1081 /* copy in the strings */
1082 WideCharToMultiByte( CP_ACP, 0, volume->label, -1,
1083 szLabel, label_size, NULL, NULL );
1084 WideCharToMultiByte( CP_ACP, 0, path, -1,
1085 szPath, path_size, NULL, NULL );
1086 szFinalPath[0] = 0;
1087
1088 hr = IStream_Write( stm, loc, total_size, &count );
1089 HeapFree(GetProcessHeap(), 0, loc);
1090
1091 return hr;
1092 }
1093
1094 static EXP_DARWIN_LINK* shelllink_build_darwinid( LPCWSTR string, DWORD magic )
1095 {
1096 EXP_DARWIN_LINK *buffer;
1097
1098 buffer = LocalAlloc( LMEM_ZEROINIT, sizeof *buffer );
1099 buffer->dbh.cbSize = sizeof *buffer;
1100 buffer->dbh.dwSignature = magic;
1101 lstrcpynW( buffer->szwDarwinID, string, MAX_PATH );
1102 WideCharToMultiByte(CP_ACP, 0, string, -1, buffer->szDarwinID, MAX_PATH, NULL, NULL );
1103
1104 return buffer;
1105 }
1106
1107 static HRESULT Stream_WriteAdvertiseInfo( IStream* stm, LPCWSTR string, DWORD magic )
1108 {
1109 EXP_DARWIN_LINK *buffer;
1110 ULONG count;
1111
1112 TRACE("%p\n",stm);
1113
1114 buffer = shelllink_build_darwinid( string, magic );
1115
1116 return IStream_Write( stm, buffer, buffer->dbh.cbSize, &count );
1117 }
1118
1119 /************************************************************************
1120 * IPersistStream_Save (IPersistStream)
1121 *
1122 * FIXME: makes assumptions about byte order
1123 */
1124 static HRESULT WINAPI IPersistStream_fnSave(
1125 IPersistStream* iface,
1126 IStream* stm,
1127 BOOL fClearDirty)
1128 {
1129 LINK_HEADER header;
1130 ULONG count;
1131 DWORD zero;
1132 HRESULT r;
1133
1134 IShellLinkImpl *This = impl_from_IPersistStream(iface);
1135
1136 TRACE("%p %p %x\n", This, stm, fClearDirty);
1137
1138 memset(&header, 0, sizeof(header));
1139 header.dwSize = sizeof(header);
1140 header.fStartup = This->iShowCmd;
1141 header.MagicGuid = CLSID_ShellLink;
1142
1143 header.wHotKey = This->wHotKey;
1144 header.nIcon = This->iIcoNdx;
1145 header.dwFlags = SLDF_UNICODE; /* strings are in unicode */
1146 if( This->pPidl )
1147 header.dwFlags |= SLDF_HAS_ID_LIST;
1148 if( This->sPath )
1149 header.dwFlags |= SLDF_HAS_LINK_INFO;
1150 if( This->sDescription )
1151 header.dwFlags |= SLDF_HAS_NAME;
1152 if( This->sWorkDir )
1153 header.dwFlags |= SLDF_HAS_WORKINGDIR;
1154 if( This->sArgs )
1155 header.dwFlags |= SLDF_HAS_ARGS;
1156 if( This->sIcoPath )
1157 header.dwFlags |= SLDF_HAS_ICONLOCATION;
1158 if( This->sProduct )
1159 header.dwFlags |= SLDF_HAS_LOGO3ID;
1160 if( This->sComponent )
1161 header.dwFlags |= SLDF_HAS_DARWINID;
1162
1163 SystemTimeToFileTime ( &This->time1, &header.Time1 );
1164 SystemTimeToFileTime ( &This->time2, &header.Time2 );
1165 SystemTimeToFileTime ( &This->time3, &header.Time3 );
1166
1167 /* write the Shortcut header */
1168 r = IStream_Write( stm, &header, sizeof(header), &count );
1169 if( FAILED( r ) )
1170 {
1171 ERR("Write failed at %d\n",__LINE__);
1172 return r;
1173 }
1174
1175 TRACE("Writing pidl\n");
1176
1177 /* write the PIDL to the shortcut */
1178 if( This->pPidl )
1179 {
1180 r = ILSaveToStream( stm, This->pPidl );
1181 if( FAILED( r ) )
1182 {
1183 ERR("Failed to write PIDL at %d\n",__LINE__);
1184 return r;
1185 }
1186 }
1187
1188 if( This->sPath )
1189 Stream_WriteLocationInfo( stm, This->sPath, &This->volume );
1190
1191 if( This->sDescription )
1192 r = Stream_WriteString( stm, This->sDescription );
1193
1194 if( This->sPathRel )
1195 r = Stream_WriteString( stm, This->sPathRel );
1196
1197 if( This->sWorkDir )
1198 r = Stream_WriteString( stm, This->sWorkDir );
1199
1200 if( This->sArgs )
1201 r = Stream_WriteString( stm, This->sArgs );
1202
1203 if( This->sIcoPath )
1204 r = Stream_WriteString( stm, This->sIcoPath );
1205
1206 if( This->sProduct )
1207 r = Stream_WriteAdvertiseInfo( stm, This->sProduct, EXP_SZ_ICON_SIG );
1208
1209 if( This->sComponent )
1210 r = Stream_WriteAdvertiseInfo( stm, This->sComponent, EXP_DARWIN_ID_SIG );
1211
1212 /* the last field is a single zero dword */
1213 zero = 0;
1214 r = IStream_Write( stm, &zero, sizeof zero, &count );
1215
1216 return S_OK;
1217 }
1218
1219 /************************************************************************
1220 * IPersistStream_GetSizeMax (IPersistStream)
1221 */
1222 static HRESULT WINAPI IPersistStream_fnGetSizeMax(
1223 IPersistStream* iface,
1224 ULARGE_INTEGER* pcbSize)
1225 {
1226 IShellLinkImpl *This = impl_from_IPersistStream(iface);
1227
1228 TRACE("(%p)\n", This);
1229
1230 return E_NOTIMPL;
1231 }
1232
1233 static const IPersistStreamVtbl psvt =
1234 {
1235 IPersistStream_fnQueryInterface,
1236 IPersistStream_fnAddRef,
1237 IPersistStream_fnRelease,
1238 IPersistStream_fnGetClassID,
1239 IPersistStream_fnIsDirty,
1240 IPersistStream_fnLoad,
1241 IPersistStream_fnSave,
1242 IPersistStream_fnGetSizeMax
1243 };
1244
1245 /**************************************************************************
1246 * IShellLink_Constructor
1247 */
1248 HRESULT WINAPI IShellLink_Constructor( IUnknown *pUnkOuter,
1249 REFIID riid, LPVOID *ppv )
1250 {
1251 IShellLinkImpl * sl;
1252 HRESULT r;
1253
1254 TRACE("unkOut=%p riid=%s\n",pUnkOuter, debugstr_guid(riid));
1255
1256 *ppv = NULL;
1257
1258 if (pUnkOuter)
1259 return CLASS_E_NOAGGREGATION;
1260 sl = LocalAlloc(LMEM_ZEROINIT,sizeof(IShellLinkImpl));
1261 if (!sl)
1262 return E_OUTOFMEMORY;
1263
1264 sl->ref = 1;
1265 sl->IShellLinkA_iface.lpVtbl = &slvt;
1266 sl->IShellLinkW_iface.lpVtbl = &slvtw;
1267 sl->IPersistFile_iface.lpVtbl = &pfvt;
1268 sl->IPersistStream_iface.lpVtbl = &psvt;
1269 sl->IShellLinkDataList_iface.lpVtbl = &dlvt;
1270 sl->IShellExtInit_iface.lpVtbl = &eivt;
1271 sl->IContextMenu_iface.lpVtbl = &cmvt;
1272 sl->IObjectWithSite_iface.lpVtbl = &owsvt;
1273 sl->iShowCmd = SW_SHOWNORMAL;
1274 sl->bDirty = FALSE;
1275 sl->iIdOpen = -1;
1276 sl->site = NULL;
1277 sl->filepath = NULL;
1278
1279 TRACE("(%p)->()\n",sl);
1280
1281 r = ShellLink_QueryInterface( sl, riid, ppv );
1282 ShellLink_Release( sl );
1283 return r;
1284 }
1285
1286
1287 static BOOL SHELL_ExistsFileW(LPCWSTR path)
1288 {
1289 if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(path))
1290 return FALSE;
1291 return TRUE;
1292 }
1293
1294 /**************************************************************************
1295 * ShellLink_UpdatePath
1296 * update absolute path in sPath using relative path in sPathRel
1297 */
1298 static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath)
1299 {
1300 if (!path || !psPath)
1301 return E_INVALIDARG;
1302
1303 if (!*psPath && sPathRel) {
1304 WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH];
1305 LPWSTR final = NULL;
1306
1307 /* first try if [directory of link file] + [relative path] finds an existing file */
1308
1309 GetFullPathNameW( path, MAX_PATH*2, buffer, &final );
1310 if( !final )
1311 final = buffer;
1312 lstrcpyW(final, sPathRel);
1313
1314 *abs_path = '\0';
1315
1316 if (SHELL_ExistsFileW(buffer)) {
1317 if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
1318 lstrcpyW(abs_path, buffer);
1319 } else {
1320 /* try if [working directory] + [relative path] finds an existing file */
1321 if (sWorkDir) {
1322 lstrcpyW(buffer, sWorkDir);
1323 lstrcpyW(PathAddBackslashW(buffer), sPathRel);
1324
1325 if (SHELL_ExistsFileW(buffer))
1326 if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
1327 lstrcpyW(abs_path, buffer);
1328 }
1329 }
1330
1331 /* FIXME: This is even not enough - not all shell links can be resolved using this algorithm. */
1332 if (!*abs_path)
1333 lstrcpyW(abs_path, sPathRel);
1334
1335 *psPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(abs_path)+1)*sizeof(WCHAR));
1336 if (!*psPath)
1337 return E_OUTOFMEMORY;
1338
1339 lstrcpyW(*psPath, abs_path);
1340 }
1341
1342 return S_OK;
1343 }
1344
1345 /**************************************************************************
1346 * IShellLink_ConstructFromFile
1347 */
1348 HRESULT WINAPI IShellLink_ConstructFromFile( IUnknown* pUnkOuter, REFIID riid,
1349 LPCITEMIDLIST pidl, LPVOID* ppv)
1350 {
1351 IShellLinkW* psl;
1352
1353 HRESULT hr = IShellLink_Constructor(NULL, riid, (LPVOID*)&psl);
1354
1355 if (SUCCEEDED(hr)) {
1356 IPersistFile* ppf;
1357
1358 *ppv = NULL;
1359
1360 hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID*)&ppf);
1361
1362 if (SUCCEEDED(hr)) {
1363 WCHAR path[MAX_PATH];
1364
1365 if (SHGetPathFromIDListW(pidl, path))
1366 hr = IPersistFile_Load(ppf, path, 0);
1367 else
1368 hr = E_FAIL;
1369
1370 if (SUCCEEDED(hr))
1371 *ppv = psl;
1372
1373 IPersistFile_Release(ppf);
1374 }
1375
1376 if (!*ppv)
1377 IShellLinkW_Release(psl);
1378 }
1379
1380 return hr;
1381 }
1382
1383 /**************************************************************************
1384 * IShellLinkA_QueryInterface
1385 */
1386 static HRESULT WINAPI IShellLinkA_fnQueryInterface(IShellLinkA *iface, REFIID riid, void **ppvObj)
1387 {
1388 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1389 return ShellLink_QueryInterface( This, riid, ppvObj );
1390 }
1391
1392 /******************************************************************************
1393 * IShellLinkA_AddRef
1394 */
1395 static ULONG WINAPI IShellLinkA_fnAddRef(IShellLinkA *iface)
1396 {
1397 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1398 return ShellLink_AddRef( This );
1399 }
1400
1401 /******************************************************************************
1402 * IShellLinkA_Release
1403 */
1404 static ULONG WINAPI IShellLinkA_fnRelease(IShellLinkA *iface)
1405 {
1406 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1407 return ShellLink_Release( This );
1408 }
1409
1410 static HRESULT WINAPI IShellLinkA_fnGetPath(IShellLinkA *iface, LPSTR pszFile, INT cchMaxPath,
1411 WIN32_FIND_DATAA *pfd, DWORD fFlags)
1412 {
1413 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1414
1415 TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n",
1416 This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1417
1418 if (This->sComponent || This->sProduct)
1419 return S_FALSE;
1420
1421 if (cchMaxPath)
1422 pszFile[0] = 0;
1423 if (This->sPath)
1424 WideCharToMultiByte( CP_ACP, 0, This->sPath, -1,
1425 pszFile, cchMaxPath, NULL, NULL);
1426
1427 if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", This);
1428
1429 return S_OK;
1430 }
1431
1432 static HRESULT WINAPI IShellLinkA_fnGetIDList(IShellLinkA *iface, LPITEMIDLIST *ppidl)
1433 {
1434 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1435
1436 TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1437
1438 return IShellLinkW_GetIDList(&This->IShellLinkW_iface, ppidl);
1439 }
1440
1441 static HRESULT WINAPI IShellLinkA_fnSetIDList(IShellLinkA *iface, LPCITEMIDLIST pidl)
1442 {
1443 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1444
1445 TRACE("(%p)->(pidl=%p)\n",This, pidl);
1446
1447 if (This->pPidl)
1448 ILFree(This->pPidl);
1449 This->pPidl = ILClone (pidl);
1450 This->bDirty = TRUE;
1451
1452 return S_OK;
1453 }
1454
1455 static HRESULT WINAPI IShellLinkA_fnGetDescription(IShellLinkA *iface, LPSTR pszName,
1456 INT cchMaxName)
1457 {
1458 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1459
1460 TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);
1461
1462 if( cchMaxName )
1463 pszName[0] = 0;
1464 if( This->sDescription )
1465 WideCharToMultiByte( CP_ACP, 0, This->sDescription, -1,
1466 pszName, cchMaxName, NULL, NULL);
1467
1468 return S_OK;
1469 }
1470
1471 static HRESULT WINAPI IShellLinkA_fnSetDescription(IShellLinkA *iface, LPCSTR pszName)
1472 {
1473 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1474
1475 TRACE("(%p)->(pName=%s)\n", This, debugstr_a(pszName));
1476
1477 HeapFree(GetProcessHeap(), 0, This->sDescription);
1478 if (pszName)
1479 {
1480 This->sDescription = HEAP_strdupAtoW( GetProcessHeap(), 0, pszName);
1481 if ( !This->sDescription )
1482 return E_OUTOFMEMORY;
1483 }
1484 else
1485 This->sDescription = NULL;
1486
1487 This->bDirty = TRUE;
1488
1489 return S_OK;
1490 }
1491
1492 static HRESULT WINAPI IShellLinkA_fnGetWorkingDirectory(IShellLinkA *iface, LPSTR pszDir,
1493 INT cchMaxPath)
1494 {
1495 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1496
1497 TRACE("(%p)->(%p len=%u)\n", This, pszDir, cchMaxPath);
1498
1499 if( cchMaxPath )
1500 pszDir[0] = 0;
1501 if( This->sWorkDir )
1502 WideCharToMultiByte( CP_ACP, 0, This->sWorkDir, -1,
1503 pszDir, cchMaxPath, NULL, NULL);
1504
1505 return S_OK;
1506 }
1507
1508 static HRESULT WINAPI IShellLinkA_fnSetWorkingDirectory(IShellLinkA *iface, LPCSTR pszDir)
1509 {
1510 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1511
1512 TRACE("(%p)->(dir=%s)\n",This, pszDir);
1513
1514 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1515 This->sWorkDir = HEAP_strdupAtoW( GetProcessHeap(), 0, pszDir);
1516 if ( !This->sWorkDir )
1517 return E_OUTOFMEMORY;
1518
1519 This->bDirty = TRUE;
1520
1521 return S_OK;
1522 }
1523
1524 static HRESULT WINAPI IShellLinkA_fnGetArguments(IShellLinkA *iface, LPSTR pszArgs, INT cchMaxPath)
1525 {
1526 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1527
1528 TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1529
1530 if( cchMaxPath )
1531 pszArgs[0] = 0;
1532 if( This->sArgs )
1533 WideCharToMultiByte( CP_ACP, 0, This->sArgs, -1,
1534 pszArgs, cchMaxPath, NULL, NULL);
1535
1536 return S_OK;
1537 }
1538
1539 static HRESULT WINAPI IShellLinkA_fnSetArguments(IShellLinkA *iface, LPCSTR pszArgs)
1540 {
1541 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1542
1543 TRACE("(%p)->(args=%s)\n",This, debugstr_a(pszArgs));
1544
1545 HeapFree(GetProcessHeap(), 0, This->sArgs);
1546 if (pszArgs)
1547 {
1548 This->sArgs = HEAP_strdupAtoW( GetProcessHeap(), 0, pszArgs);
1549 if( !This->sArgs )
1550 return E_OUTOFMEMORY;
1551 }
1552 else This->sArgs = NULL;
1553
1554 This->bDirty = TRUE;
1555
1556 return S_OK;
1557 }
1558
1559 static HRESULT WINAPI IShellLinkA_fnGetHotkey(IShellLinkA *iface, WORD *pwHotkey)
1560 {
1561 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1562
1563 TRACE("(%p)->(%p)(0x%08x)\n",This, pwHotkey, This->wHotKey);
1564
1565 *pwHotkey = This->wHotKey;
1566
1567 return S_OK;
1568 }
1569
1570 static HRESULT WINAPI IShellLinkA_fnSetHotkey(IShellLinkA *iface, WORD wHotkey)
1571 {
1572 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1573
1574 TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1575
1576 This->wHotKey = wHotkey;
1577 This->bDirty = TRUE;
1578
1579 return S_OK;
1580 }
1581
1582 static HRESULT WINAPI IShellLinkA_fnGetShowCmd(IShellLinkA *iface, INT *piShowCmd)
1583 {
1584 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1585
1586 TRACE("(%p)->(%p)\n",This, piShowCmd);
1587 *piShowCmd = This->iShowCmd;
1588 return S_OK;
1589 }
1590
1591 static HRESULT WINAPI IShellLinkA_fnSetShowCmd(IShellLinkA *iface, INT iShowCmd)
1592 {
1593 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1594
1595 TRACE("(%p) %d\n",This, iShowCmd);
1596
1597 This->iShowCmd = iShowCmd;
1598 This->bDirty = TRUE;
1599
1600 return S_OK;
1601 }
1602
1603 static HRESULT WINAPI IShellLinkA_fnGetIconLocation(IShellLinkA *iface, LPSTR pszIconPath,
1604 INT cchIconPath, INT *piIcon)
1605 {
1606 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1607
1608 TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1609
1610 *piIcon = This->iIcoNdx;
1611
1612 if (This->sIcoPath)
1613 WideCharToMultiByte(CP_ACP, 0, This->sIcoPath, -1, pszIconPath, cchIconPath, NULL, NULL);
1614 else
1615 pszIconPath[0] = 0;
1616
1617 return S_OK;
1618 }
1619
1620 static HRESULT WINAPI IShellLinkA_fnSetIconLocation(IShellLinkA *iface, LPCSTR pszIconPath,
1621 INT iIcon)
1622 {
1623 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1624
1625 TRACE("(%p)->(path=%s iicon=%u)\n",This, pszIconPath, iIcon);
1626
1627 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1628 This->sIcoPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath);
1629 if ( !This->sIcoPath )
1630 return E_OUTOFMEMORY;
1631
1632 This->iIcoNdx = iIcon;
1633 This->bDirty = TRUE;
1634
1635 return S_OK;
1636 }
1637
1638 static HRESULT WINAPI IShellLinkA_fnSetRelativePath(IShellLinkA *iface, LPCSTR pszPathRel,
1639 DWORD dwReserved)
1640 {
1641 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1642
1643 TRACE("(%p)->(path=%s %x)\n",This, pszPathRel, dwReserved);
1644
1645 HeapFree(GetProcessHeap(), 0, This->sPathRel);
1646 This->sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel);
1647 This->bDirty = TRUE;
1648
1649 return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1650 }
1651
1652 static HRESULT WINAPI IShellLinkA_fnResolve(IShellLinkA *iface, HWND hwnd, DWORD fFlags)
1653 {
1654 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1655
1656 TRACE("(%p)->(hwnd=%p flags=%x)\n",This, hwnd, fFlags);
1657
1658 return IShellLinkW_Resolve(&This->IShellLinkW_iface, hwnd, fFlags);
1659 }
1660
1661 static HRESULT WINAPI IShellLinkA_fnSetPath(IShellLinkA *iface, LPCSTR pszFile)
1662 {
1663 IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1664 HRESULT r;
1665 LPWSTR str;
1666
1667 TRACE("(%p)->(path=%s)\n",This, debugstr_a(pszFile));
1668
1669 if (!pszFile) return E_INVALIDARG;
1670
1671 str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
1672 if( !str )
1673 return E_OUTOFMEMORY;
1674
1675 r = IShellLinkW_SetPath(&This->IShellLinkW_iface, str);
1676 HeapFree( GetProcessHeap(), 0, str );
1677
1678 return r;
1679 }
1680
1681 /**************************************************************************
1682 * IShellLink Implementation
1683 */
1684
1685 static const IShellLinkAVtbl slvt =
1686 {
1687 IShellLinkA_fnQueryInterface,
1688 IShellLinkA_fnAddRef,
1689 IShellLinkA_fnRelease,
1690 IShellLinkA_fnGetPath,
1691 IShellLinkA_fnGetIDList,
1692 IShellLinkA_fnSetIDList,
1693 IShellLinkA_fnGetDescription,
1694 IShellLinkA_fnSetDescription,
1695 IShellLinkA_fnGetWorkingDirectory,
1696 IShellLinkA_fnSetWorkingDirectory,
1697 IShellLinkA_fnGetArguments,
1698 IShellLinkA_fnSetArguments,
1699 IShellLinkA_fnGetHotkey,
1700 IShellLinkA_fnSetHotkey,
1701 IShellLinkA_fnGetShowCmd,
1702 IShellLinkA_fnSetShowCmd,
1703 IShellLinkA_fnGetIconLocation,
1704 IShellLinkA_fnSetIconLocation,
1705 IShellLinkA_fnSetRelativePath,
1706 IShellLinkA_fnResolve,
1707 IShellLinkA_fnSetPath
1708 };
1709
1710
1711 /**************************************************************************
1712 * IShellLinkW_fnQueryInterface
1713 */
1714 static HRESULT WINAPI IShellLinkW_fnQueryInterface(
1715 IShellLinkW * iface, REFIID riid, LPVOID *ppvObj)
1716 {
1717 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1718 return ShellLink_QueryInterface( This, riid, ppvObj );
1719 }
1720
1721 /******************************************************************************
1722 * IShellLinkW_fnAddRef
1723 */
1724 static ULONG WINAPI IShellLinkW_fnAddRef(IShellLinkW * iface)
1725 {
1726 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1727 return ShellLink_AddRef( This );
1728 }
1729
1730 /******************************************************************************
1731 * IShellLinkW_fnRelease
1732 */
1733 static ULONG WINAPI IShellLinkW_fnRelease(IShellLinkW * iface)
1734 {
1735 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1736 return ShellLink_Release( This );
1737 }
1738
1739 static HRESULT WINAPI IShellLinkW_fnGetPath(IShellLinkW * iface, LPWSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAW *pfd, DWORD fFlags)
1740 {
1741 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1742
1743 TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n",
1744 This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1745
1746 if (This->sComponent || This->sProduct)
1747 return S_FALSE;
1748
1749 if (cchMaxPath)
1750 pszFile[0] = 0;
1751 if (This->sPath)
1752 lstrcpynW( pszFile, This->sPath, cchMaxPath );
1753
1754 if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", This);
1755
1756 return S_OK;
1757 }
1758
1759 static HRESULT WINAPI IShellLinkW_fnGetIDList(IShellLinkW * iface, LPITEMIDLIST * ppidl)
1760 {
1761 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1762
1763 TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1764
1765 if (!This->pPidl)
1766 {
1767 *ppidl = NULL;
1768 return S_FALSE;
1769 }
1770 *ppidl = ILClone(This->pPidl);
1771 return S_OK;
1772 }
1773
1774 static HRESULT WINAPI IShellLinkW_fnSetIDList(IShellLinkW * iface, LPCITEMIDLIST pidl)
1775 {
1776 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1777
1778 TRACE("(%p)->(pidl=%p)\n",This, pidl);
1779
1780 if( This->pPidl )
1781 ILFree( This->pPidl );
1782 This->pPidl = ILClone( pidl );
1783 if( !This->pPidl )
1784 return E_FAIL;
1785
1786 This->bDirty = TRUE;
1787
1788 return S_OK;
1789 }
1790
1791 static HRESULT WINAPI IShellLinkW_fnGetDescription(IShellLinkW * iface, LPWSTR pszName,INT cchMaxName)
1792 {
1793 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1794
1795 TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);
1796
1797 pszName[0] = 0;
1798 if( This->sDescription )
1799 lstrcpynW( pszName, This->sDescription, cchMaxName );
1800
1801 return S_OK;
1802 }
1803
1804 static HRESULT WINAPI IShellLinkW_fnSetDescription(IShellLinkW * iface, LPCWSTR pszName)
1805 {
1806 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1807
1808 TRACE("(%p)->(desc=%s)\n",This, debugstr_w(pszName));
1809
1810 HeapFree(GetProcessHeap(), 0, This->sDescription);
1811 if (pszName)
1812 {
1813 This->sDescription = HeapAlloc( GetProcessHeap(), 0,
1814 (lstrlenW( pszName )+1)*sizeof(WCHAR) );
1815 if ( !This->sDescription )
1816 return E_OUTOFMEMORY;
1817
1818 lstrcpyW( This->sDescription, pszName );
1819 }
1820 else
1821 This->sDescription = NULL;
1822 This->bDirty = TRUE;
1823
1824 return S_OK;
1825 }
1826
1827 static HRESULT WINAPI IShellLinkW_fnGetWorkingDirectory(IShellLinkW * iface, LPWSTR pszDir,INT cchMaxPath)
1828 {
1829 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1830
1831 TRACE("(%p)->(%p len %u)\n", This, pszDir, cchMaxPath);
1832
1833 if( cchMaxPath )
1834 pszDir[0] = 0;
1835 if( This->sWorkDir )
1836 lstrcpynW( pszDir, This->sWorkDir, cchMaxPath );
1837
1838 return S_OK;
1839 }
1840
1841 static HRESULT WINAPI IShellLinkW_fnSetWorkingDirectory(IShellLinkW * iface, LPCWSTR pszDir)
1842 {
1843 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1844
1845 TRACE("(%p)->(dir=%s)\n",This, debugstr_w(pszDir));
1846
1847 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1848 This->sWorkDir = HeapAlloc( GetProcessHeap(), 0,
1849 (lstrlenW( pszDir )+1)*sizeof (WCHAR) );
1850 if ( !This->sWorkDir )
1851 return E_OUTOFMEMORY;
1852 lstrcpyW( This->sWorkDir, pszDir );
1853 This->bDirty = TRUE;
1854
1855 return S_OK;
1856 }
1857
1858 static HRESULT WINAPI IShellLinkW_fnGetArguments(IShellLinkW * iface, LPWSTR pszArgs,INT cchMaxPath)
1859 {
1860 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1861
1862 TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1863
1864 if( cchMaxPath )
1865 pszArgs[0] = 0;
1866 if( This->sArgs )
1867 lstrcpynW( pszArgs, This->sArgs, cchMaxPath );
1868
1869 return S_OK;
1870 }
1871
1872 static HRESULT WINAPI IShellLinkW_fnSetArguments(IShellLinkW * iface, LPCWSTR pszArgs)
1873 {
1874 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1875
1876 TRACE("(%p)->(args=%s)\n",This, debugstr_w(pszArgs));
1877
1878 HeapFree(GetProcessHeap(), 0, This->sArgs);
1879 if (pszArgs)
1880 {
1881 This->sArgs = HeapAlloc( GetProcessHeap(), 0,
1882 (lstrlenW( pszArgs )+1)*sizeof (WCHAR) );
1883 if ( !This->sArgs )
1884 return E_OUTOFMEMORY;
1885 lstrcpyW( This->sArgs, pszArgs );
1886 }
1887 else This->sArgs = NULL;
1888
1889 This->bDirty = TRUE;
1890
1891 return S_OK;
1892 }
1893
1894 static HRESULT WINAPI IShellLinkW_fnGetHotkey(IShellLinkW * iface, WORD *pwHotkey)
1895 {
1896 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1897
1898 TRACE("(%p)->(%p)\n",This, pwHotkey);
1899
1900 *pwHotkey=This->wHotKey;
1901
1902 return S_OK;
1903 }
1904
1905 static HRESULT WINAPI IShellLinkW_fnSetHotkey(IShellLinkW * iface, WORD wHotkey)
1906 {
1907 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1908
1909 TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1910
1911 This->wHotKey = wHotkey;
1912 This->bDirty = TRUE;
1913
1914 return S_OK;
1915 }
1916
1917 static HRESULT WINAPI IShellLinkW_fnGetShowCmd(IShellLinkW * iface, INT *piShowCmd)
1918 {
1919 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1920
1921 TRACE("(%p)->(%p)\n",This, piShowCmd);
1922
1923 *piShowCmd = This->iShowCmd;
1924
1925 return S_OK;
1926 }
1927
1928 static HRESULT WINAPI IShellLinkW_fnSetShowCmd(IShellLinkW * iface, INT iShowCmd)
1929 {
1930 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1931
1932 This->iShowCmd = iShowCmd;
1933 This->bDirty = TRUE;
1934
1935 return S_OK;
1936 }
1937
1938 static HRESULT WINAPI IShellLinkW_fnGetIconLocation(IShellLinkW * iface, LPWSTR pszIconPath,INT cchIconPath,INT *piIcon)
1939 {
1940 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1941
1942 TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1943
1944 *piIcon = This->iIcoNdx;
1945
1946 if (This->sIcoPath)
1947 lstrcpynW(pszIconPath, This->sIcoPath, cchIconPath);
1948 else
1949 pszIconPath[0] = 0;
1950
1951 return S_OK;
1952 }
1953
1954 static HRESULT WINAPI IShellLinkW_fnSetIconLocation(IShellLinkW * iface, LPCWSTR pszIconPath,INT iIcon)
1955 {
1956 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1957
1958 TRACE("(%p)->(path=%s iicon=%u)\n",This, debugstr_w(pszIconPath), iIcon);
1959
1960 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1961 This->sIcoPath = HeapAlloc( GetProcessHeap(), 0,
1962 (lstrlenW( pszIconPath )+1)*sizeof (WCHAR) );
1963 if ( !This->sIcoPath )
1964 return E_OUTOFMEMORY;
1965 lstrcpyW( This->sIcoPath, pszIconPath );
1966
1967 This->iIcoNdx = iIcon;
1968 This->bDirty = TRUE;
1969
1970 return S_OK;
1971 }
1972
1973 static HRESULT WINAPI IShellLinkW_fnSetRelativePath(IShellLinkW * iface, LPCWSTR pszPathRel, DWORD dwReserved)
1974 {
1975 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1976
1977 TRACE("(%p)->(path=%s %x)\n",This, debugstr_w(pszPathRel), dwReserved);
1978
1979 HeapFree(GetProcessHeap(), 0, This->sPathRel);
1980 This->sPathRel = HeapAlloc( GetProcessHeap(), 0,
1981 (lstrlenW( pszPathRel )+1) * sizeof (WCHAR) );
1982 if ( !This->sPathRel )
1983 return E_OUTOFMEMORY;
1984 lstrcpyW( This->sPathRel, pszPathRel );
1985 This->bDirty = TRUE;
1986
1987 return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1988 }
1989
1990 static HRESULT WINAPI IShellLinkW_fnResolve(IShellLinkW * iface, HWND hwnd, DWORD fFlags)
1991 {
1992 HRESULT hr = S_OK;
1993 BOOL bSuccess;
1994
1995 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1996
1997 TRACE("(%p)->(hwnd=%p flags=%x)\n",This, hwnd, fFlags);
1998
1999 /*FIXME: use IResolveShellLink interface */
2000
2001 if (!This->sPath && This->pPidl) {
2002 WCHAR buffer[MAX_PATH];
2003
2004 bSuccess = SHGetPathFromIDListW(This->pPidl, buffer);
2005
2006 if (bSuccess && *buffer) {
2007 This->sPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(buffer)+1)*sizeof(WCHAR));
2008 if (!This->sPath)
2009 return E_OUTOFMEMORY;
2010
2011 lstrcpyW(This->sPath, buffer);
2012
2013 This->bDirty = TRUE;
2014 } else
2015 hr = S_OK; /* don't report an error occurred while just caching information */
2016 }
2017
2018 if (!This->sIcoPath && This->sPath) {
2019 This->sIcoPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(This->sPath)+1)*sizeof(WCHAR));
2020 if (!This->sIcoPath)
2021 return E_OUTOFMEMORY;
2022
2023 lstrcpyW(This->sIcoPath, This->sPath);
2024 This->iIcoNdx = 0;
2025
2026 This->bDirty = TRUE;
2027 }
2028
2029 return hr;
2030 }
2031
2032 static LPWSTR ShellLink_GetAdvertisedArg(LPCWSTR str)
2033 {
2034 LPWSTR ret;
2035 LPCWSTR p;
2036 DWORD len;
2037
2038 if( !str )
2039 return NULL;
2040
2041 p = strchrW( str, ':' );
2042 if( !p )
2043 return NULL;
2044 len = p - str;
2045 ret = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR)*(len+1));
2046 if( !ret )
2047 return ret;
2048 memcpy( ret, str, sizeof(WCHAR)*len );
2049 ret[len] = 0;
2050 return ret;
2051 }
2052
2053 static HRESULT ShellLink_SetAdvertiseInfo(IShellLinkImpl *This, LPCWSTR str)
2054 {
2055 LPCWSTR szComponent = NULL, szProduct = NULL, p;
2056 WCHAR szGuid[39];
2057 HRESULT r;
2058 GUID guid;
2059 int len;
2060
2061 while( str[0] )
2062 {
2063 /* each segment must start with two colons */
2064 if( str[0] != ':' || str[1] != ':' )
2065 return E_FAIL;
2066
2067 /* the last segment is just two colons */
2068 if( !str[2] )
2069 break;
2070 str += 2;
2071
2072 /* there must be a colon straight after a guid */
2073 p = strchrW( str, ':' );
2074 if( !p )
2075 return E_FAIL;
2076 len = p - str;
2077 if( len != 38 )
2078 return E_FAIL;
2079
2080 /* get the guid, and check it's validly formatted */
2081 memcpy( szGuid, str, sizeof(WCHAR)*len );
2082 szGuid[len] = 0;
2083 r = CLSIDFromString( szGuid, &guid );
2084 if( r != S_OK )
2085 return r;
2086 str = p + 1;
2087
2088 /* match it up to a guid that we care about */
2089 if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutComponent ) && !szComponent )
2090 szComponent = str;
2091 else if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutProduct ) && !szProduct )
2092 szProduct = str;
2093 else
2094 return E_FAIL;
2095
2096 /* skip to the next field */
2097 str = strchrW( str, ':' );
2098 if( !str )
2099 return E_FAIL;
2100 }
2101
2102 /* we have to have a component for an advertised shortcut */
2103 if( !szComponent )
2104 return E_FAIL;
2105
2106 This->sComponent = ShellLink_GetAdvertisedArg( szComponent );
2107 This->sProduct = ShellLink_GetAdvertisedArg( szProduct );
2108
2109 TRACE("Component = %s\n", debugstr_w(This->sComponent));
2110 TRACE("Product = %s\n", debugstr_w(This->sProduct));
2111
2112 return S_OK;
2113 }
2114
2115 static BOOL ShellLink_GetVolumeInfo(LPCWSTR path, volume_info *volume)
2116 {
2117 const int label_sz = sizeof volume->label/sizeof volume->label[0];
2118 WCHAR drive[] = { path[0], ':', '\\', 0 };
2119 BOOL r;
2120
2121 volume->type = GetDriveTypeW(drive);
2122 r = GetVolumeInformationW(drive, volume->label, label_sz,
2123 &volume->serial, NULL, NULL, NULL, 0);
2124 TRACE("r = %d type %d serial %08x name %s\n", r,
2125 volume->type, volume->serial, debugstr_w(volume->label));
2126 return r;
2127 }
2128
2129 static HRESULT WINAPI IShellLinkW_fnSetPath(IShellLinkW * iface, LPCWSTR pszFile)
2130 {
2131 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
2132 WCHAR buffer[MAX_PATH];
2133 LPWSTR fname, unquoted = NULL;
2134 HRESULT hr = S_OK;
2135 UINT len;
2136
2137 TRACE("(%p)->(path=%s)\n",This, debugstr_w(pszFile));
2138
2139 if (!pszFile) return E_INVALIDARG;
2140
2141 /* quotes at the ends of the string are stripped */
2142 len = lstrlenW(pszFile);
2143 if (pszFile[0] == '"' && pszFile[len-1] == '"')
2144 {
2145 unquoted = strdupW(pszFile);
2146 PathUnquoteSpacesW(unquoted);
2147 pszFile = unquoted;
2148 }
2149
2150 /* any other quote marks are invalid */
2151 if (strchrW(pszFile, '"'))
2152 {
2153 HeapFree(GetProcessHeap(), 0, unquoted);
2154 return S_FALSE;
2155 }
2156
2157 HeapFree(GetProcessHeap(), 0, This->sPath);
2158 This->sPath = NULL;
2159
2160 HeapFree(GetProcessHeap(), 0, This->sComponent);
2161 This->sComponent = NULL;
2162
2163 if (This->pPidl)
2164 ILFree(This->pPidl);
2165 This->pPidl = NULL;
2166
2167 if (S_OK != ShellLink_SetAdvertiseInfo( This, pszFile ))
2168 {
2169 if (*pszFile == '\0')
2170 *buffer = '\0';
2171 else if (!GetFullPathNameW(pszFile, MAX_PATH, buffer, &fname))
2172 return E_FAIL;
2173 else if(!PathFileExistsW(buffer) &&
2174 !SearchPathW(NULL, pszFile, NULL, MAX_PATH, buffer, NULL))
2175 hr = S_FALSE;
2176
2177 This->pPidl = SHSimpleIDListFromPathW(pszFile);
2178 ShellLink_GetVolumeInfo(buffer, &This->volume);
2179
2180 This->sPath = HeapAlloc( GetProcessHeap(), 0,
2181 (lstrlenW( buffer )+1) * sizeof (WCHAR) );
2182 if (!This->sPath)
2183 {
2184 HeapFree(GetProcessHeap(), 0, unquoted);
2185 return E_OUTOFMEMORY;
2186 }
2187
2188 lstrcpyW(This->sPath, buffer);
2189 }
2190 This->bDirty = TRUE;
2191 HeapFree(GetProcessHeap(), 0, unquoted);
2192
2193 return hr;
2194 }
2195
2196 /**************************************************************************
2197 * IShellLinkW Implementation
2198 */
2199
2200 static const IShellLinkWVtbl slvtw =
2201 {
2202 IShellLinkW_fnQueryInterface,
2203 IShellLinkW_fnAddRef,
2204 IShellLinkW_fnRelease,
2205 IShellLinkW_fnGetPath,
2206 IShellLinkW_fnGetIDList,
2207 IShellLinkW_fnSetIDList,
2208 IShellLinkW_fnGetDescription,
2209 IShellLinkW_fnSetDescription,
2210 IShellLinkW_fnGetWorkingDirectory,
2211 IShellLinkW_fnSetWorkingDirectory,
2212 IShellLinkW_fnGetArguments,
2213 IShellLinkW_fnSetArguments,
2214 IShellLinkW_fnGetHotkey,
2215 IShellLinkW_fnSetHotkey,
2216 IShellLinkW_fnGetShowCmd,
2217 IShellLinkW_fnSetShowCmd,
2218 IShellLinkW_fnGetIconLocation,
2219 IShellLinkW_fnSetIconLocation,
2220 IShellLinkW_fnSetRelativePath,
2221 IShellLinkW_fnResolve,
2222 IShellLinkW_fnSetPath
2223 };
2224
2225 static HRESULT WINAPI
2226 ShellLink_DataList_QueryInterface( IShellLinkDataList* iface, REFIID riid, void** ppvObject)
2227 {
2228 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2229 return IShellLinkA_QueryInterface(&This->IShellLinkA_iface, riid, ppvObject);
2230 }
2231
2232 static ULONG WINAPI
2233 ShellLink_DataList_AddRef( IShellLinkDataList* iface )
2234 {
2235 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2236 return IShellLinkA_AddRef(&This->IShellLinkA_iface);
2237 }
2238
2239 static ULONG WINAPI
2240 ShellLink_DataList_Release( IShellLinkDataList* iface )
2241 {
2242 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2243 return ShellLink_Release( This );
2244 }
2245
2246 static HRESULT WINAPI
2247 ShellLink_AddDataBlock( IShellLinkDataList* iface, void* pDataBlock )
2248 {
2249 FIXME("(%p)->(%p): stub\n", iface, pDataBlock);
2250 return E_NOTIMPL;
2251 }
2252
2253 static HRESULT WINAPI
2254 ShellLink_CopyDataBlock( IShellLinkDataList* iface, DWORD dwSig, void** ppDataBlock )
2255 {
2256 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2257 LPVOID block = NULL;
2258 HRESULT r = E_FAIL;
2259
2260 TRACE("%p %08x %p\n", iface, dwSig, ppDataBlock );
2261
2262 switch (dwSig)
2263 {
2264 case EXP_DARWIN_ID_SIG:
2265 if (!This->sComponent)
2266 break;
2267 block = shelllink_build_darwinid( This->sComponent, dwSig );
2268 r = S_OK;
2269 break;
2270 case EXP_SZ_LINK_SIG:
2271 case NT_CONSOLE_PROPS_SIG:
2272 case NT_FE_CONSOLE_PROPS_SIG:
2273 case EXP_SPECIAL_FOLDER_SIG:
2274 case EXP_SZ_ICON_SIG:
2275 FIXME("valid but unhandled datablock %08x\n", dwSig);
2276 break;
2277 default:
2278 ERR("unknown datablock %08x\n", dwSig);
2279 }
2280 *ppDataBlock = block;
2281 return r;
2282 }
2283
2284 static HRESULT WINAPI
2285 ShellLink_RemoveDataBlock( IShellLinkDataList* iface, DWORD dwSig )
2286 {
2287 FIXME("(%p)->(%u): stub\n", iface, dwSig);
2288 return E_NOTIMPL;
2289 }
2290
2291 static HRESULT WINAPI
2292 ShellLink_GetFlags( IShellLinkDataList* iface, DWORD* pdwFlags )
2293 {
2294 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2295 DWORD flags = 0;
2296
2297 FIXME("(%p)->(%p): partially implemented\n", This, pdwFlags);
2298
2299 /* FIXME: add more */
2300 if (This->sArgs)
2301 flags |= SLDF_HAS_ARGS;
2302 if (This->sComponent)
2303 flags |= SLDF_HAS_DARWINID;
2304 if (This->sIcoPath)
2305 flags |= SLDF_HAS_ICONLOCATION;
2306 if (This->sProduct)
2307 flags |= SLDF_HAS_LOGO3ID;
2308 if (This->pPidl)
2309 flags |= SLDF_HAS_ID_LIST;
2310
2311 *pdwFlags = flags;
2312
2313 return S_OK;
2314 }
2315
2316 static HRESULT WINAPI
2317 ShellLink_SetFlags( IShellLinkDataList* iface, DWORD dwFlags )
2318 {
2319 FIXME("(%p)->(%u): stub\n", iface, dwFlags);
2320 return E_NOTIMPL;
2321 }
2322
2323 static const IShellLinkDataListVtbl dlvt =
2324 {
2325 ShellLink_DataList_QueryInterface,
2326 ShellLink_DataList_AddRef,
2327 ShellLink_DataList_Release,
2328 ShellLink_AddDataBlock,
2329 ShellLink_CopyDataBlock,
2330 ShellLink_RemoveDataBlock,
2331 ShellLink_GetFlags,
2332 ShellLink_SetFlags
2333 };
2334
2335 static HRESULT WINAPI
2336 ShellLink_ExtInit_QueryInterface( IShellExtInit* iface, REFIID riid, void** ppvObject )
2337 {
2338 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2339 return IShellLinkA_QueryInterface(&This->IShellLinkA_iface, riid, ppvObject);
2340 }
2341
2342 static ULONG WINAPI
2343 ShellLink_ExtInit_AddRef( IShellExtInit* iface )
2344 {
2345 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2346 return IShellLinkA_AddRef(&This->IShellLinkA_iface);
2347 }
2348
2349 static ULONG WINAPI
2350 ShellLink_ExtInit_Release( IShellExtInit* iface )
2351 {
2352 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2353 return ShellLink_Release( This );
2354 }
2355
2356 /**************************************************************************
2357 * ShellLink implementation of IShellExtInit::Initialize()
2358 *
2359 * Loads the shelllink from the dataobject the shell is pointing to.
2360 */
2361 static HRESULT WINAPI
2362 ShellLink_ExtInit_Initialize( IShellExtInit* iface, LPCITEMIDLIST pidlFolder,
2363 IDataObject *pdtobj, HKEY hkeyProgID )
2364 {
2365 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2366 FORMATETC format;
2367 STGMEDIUM stgm;
2368 UINT count;
2369 HRESULT r = E_FAIL;
2370
2371 TRACE("%p %p %p %p\n", This, pidlFolder, pdtobj, hkeyProgID );
2372
2373 if( !pdtobj )
2374 return r;
2375
2376 format.cfFormat = CF_HDROP;
2377 format.ptd = NULL;
2378 format.dwAspect = DVASPECT_CONTENT;
2379 format.lindex = -1;
2380 format.tymed = TYMED_HGLOBAL;
2381
2382 if( FAILED( IDataObject_GetData( pdtobj, &format, &stgm ) ) )
2383 return r;
2384
2385 count = DragQueryFileW( stgm.u.hGlobal, -1, NULL, 0 );
2386 if( count == 1 )
2387 {
2388 LPWSTR path;
2389
2390 count = DragQueryFileW( stgm.u.hGlobal, 0, NULL, 0 );
2391 count++;
2392 path = HeapAlloc( GetProcessHeap(), 0, count*sizeof(WCHAR) );
2393 if( path )
2394 {
2395 IPersistFile *pf = &This->IPersistFile_iface;
2396
2397 count = DragQueryFileW( stgm.u.hGlobal, 0, path, count );
2398 r = IPersistFile_Load( pf, path, 0 );
2399 HeapFree( GetProcessHeap(), 0, path );
2400 }
2401 }
2402 ReleaseStgMedium( &stgm );
2403
2404 return r;
2405 }
2406
2407 static const IShellExtInitVtbl eivt =
2408 {
2409 ShellLink_ExtInit_QueryInterface,
2410 ShellLink_ExtInit_AddRef,
2411 ShellLink_ExtInit_Release,
2412 ShellLink_ExtInit_Initialize
2413 };
2414
2415 static HRESULT WINAPI
2416 ShellLink_ContextMenu_QueryInterface( IContextMenu* iface, REFIID riid, void** ppvObject )
2417 {
2418 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2419 return IShellLinkA_QueryInterface(&This->IShellLinkA_iface, riid, ppvObject);
2420 }
2421
2422 static ULONG WINAPI
2423 ShellLink_ContextMenu_AddRef( IContextMenu* iface )
2424 {
2425 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2426 return IShellLinkA_AddRef(&This->IShellLinkA_iface);
2427 }
2428
2429 static ULONG WINAPI
2430 ShellLink_ContextMenu_Release( IContextMenu* iface )
2431 {
2432 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2433 return ShellLink_Release( This );
2434 }
2435
2436 static HRESULT WINAPI
2437 ShellLink_QueryContextMenu( IContextMenu* iface, HMENU hmenu, UINT indexMenu,
2438 UINT idCmdFirst, UINT idCmdLast, UINT uFlags )
2439 {
2440 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2441 static WCHAR szOpen[] = { 'O','p','e','n',0 };
2442 MENUITEMINFOW mii;
2443 int id = 1;
2444
2445 TRACE("%p %p %u %u %u %u\n", This,
2446 hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
2447
2448 if ( !hmenu )
2449 return E_INVALIDARG;
2450
2451 memset( &mii, 0, sizeof mii );
2452 mii.cbSize = sizeof mii;
2453 mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
2454 mii.dwTypeData = szOpen;
2455 mii.cch = strlenW( mii.dwTypeData );
2456 mii.wID = idCmdFirst + id++;
2457 mii.fState = MFS_DEFAULT | MFS_ENABLED;
2458 mii.fType = MFT_STRING;
2459 if (!InsertMenuItemW( hmenu, indexMenu, TRUE, &mii ))
2460 return E_FAIL;
2461 This->iIdOpen = 0;
2462
2463 return MAKE_HRESULT( SEVERITY_SUCCESS, 0, id );
2464 }
2465
2466 static LPWSTR
2467 shelllink_get_msi_component_path( LPWSTR component )
2468 {
2469 LPWSTR path;
2470 DWORD r, sz = 0;
2471
2472 r = CommandLineFromMsiDescriptor( component, NULL, &sz );
2473 if (r != ERROR_SUCCESS)
2474 return NULL;
2475
2476 sz++;
2477 path = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
2478 r = CommandLineFromMsiDescriptor( component, path, &sz );
2479 if (r != ERROR_SUCCESS)
2480 {
2481 HeapFree( GetProcessHeap(), 0, path );
2482 path = NULL;
2483 }
2484
2485 TRACE("returning %s\n", debugstr_w( path ) );
2486
2487 return path;
2488 }
2489
2490 static HRESULT WINAPI
2491 ShellLink_InvokeCommand( IContextMenu* iface, LPCMINVOKECOMMANDINFO lpici )
2492 {
2493 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2494 static const WCHAR szOpen[] = { 'O','p','e','n',0 };
2495 SHELLEXECUTEINFOW sei;
2496 HWND hwnd = NULL; /* FIXME: get using interface set from IObjectWithSite */
2497 LPWSTR args = NULL;
2498 LPWSTR path = NULL;
2499 HRESULT r;
2500
2501 TRACE("%p %p\n", This, lpici );
2502
2503 if ( lpici->cbSize < sizeof (CMINVOKECOMMANDINFO) )
2504 return E_INVALIDARG;
2505
2506 if ( lpici->lpVerb != MAKEINTRESOURCEA(This->iIdOpen) )
2507 {
2508 ERR("Unknown id %p != %d\n", lpici->lpVerb, This->iIdOpen );
2509 return E_INVALIDARG;
2510 }
2511
2512 r = IShellLinkW_Resolve(&This->IShellLinkW_iface, hwnd, 0);
2513 if ( FAILED( r ) )
2514 return r;
2515
2516 if ( This->sComponent )
2517 {
2518 path = shelllink_get_msi_component_path( This->sComponent );
2519 if (!path)
2520 return E_FAIL;
2521 }
2522 else
2523 path = strdupW( This->sPath );
2524
2525 if ( lpici->cbSize == sizeof (CMINVOKECOMMANDINFOEX) &&
2526 ( lpici->fMask & CMIC_MASK_UNICODE ) )
2527 {
2528 LPCMINVOKECOMMANDINFOEX iciex = (LPCMINVOKECOMMANDINFOEX) lpici;
2529 DWORD len = 2;
2530
2531 if ( This->sArgs )
2532 len += lstrlenW( This->sArgs );
2533 if ( iciex->lpParametersW )
2534 len += lstrlenW( iciex->lpParametersW );
2535
2536 args = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
2537 args[0] = 0;
2538 if ( This->sArgs )
2539 lstrcatW( args, This->sArgs );
2540 if ( iciex->lpParametersW )
2541 {
2542 static const WCHAR space[] = { ' ', 0 };
2543 lstrcatW( args, space );
2544 lstrcatW( args, iciex->lpParametersW );
2545 }
2546 }
2547
2548 memset( &sei, 0, sizeof sei );
2549 sei.cbSize = sizeof sei;
2550 sei.fMask = SEE_MASK_UNICODE | (lpici->fMask & (SEE_MASK_NOASYNC|SEE_MASK_ASYNCOK|SEE_MASK_FLAG_NO_UI));
2551 sei.lpFile = path;
2552 sei.nShow = This->iShowCmd;
2553 sei.lpIDList = This->pPidl;
2554 sei.lpDirectory = This->sWorkDir;
2555 sei.lpParameters = args;
2556 sei.lpVerb = szOpen;
2557
2558 if( ShellExecuteExW( &sei ) )
2559 r = S_OK;
2560 else
2561 r = E_FAIL;
2562
2563 HeapFree( GetProcessHeap(), 0, args );
2564 HeapFree( GetProcessHeap(), 0, path );
2565
2566 return r;
2567 }
2568
2569 static HRESULT WINAPI
2570 ShellLink_GetCommandString( IContextMenu* iface, UINT_PTR idCmd, UINT uType,
2571 UINT* pwReserved, LPSTR pszName, UINT cchMax )
2572 {
2573 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2574
2575 FIXME("(%p)->(%lu %u %p %p %u): stub\n", This,
2576 idCmd, uType, pwReserved, pszName, cchMax );
2577
2578 return E_NOTIMPL;
2579 }
2580
2581 static const IContextMenuVtbl cmvt =
2582 {
2583 ShellLink_ContextMenu_QueryInterface,
2584 ShellLink_ContextMenu_AddRef,
2585 ShellLink_ContextMenu_Release,
2586 ShellLink_QueryContextMenu,
2587 ShellLink_InvokeCommand,
2588 ShellLink_GetCommandString
2589 };
2590
2591 static HRESULT WINAPI
2592 ShellLink_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
2593 {
2594 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2595 return ShellLink_QueryInterface( This, riid, ppvObject );
2596 }
2597
2598 static ULONG WINAPI
2599 ShellLink_ObjectWithSite_AddRef( IObjectWithSite* iface )
2600 {
2601 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2602 return ShellLink_AddRef( This );
2603 }
2604
2605 static ULONG WINAPI
2606 ShellLink_ObjectWithSite_Release( IObjectWithSite* iface )
2607 {
2608 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2609 return ShellLink_Release( This );
2610 }
2611
2612 static HRESULT WINAPI
2613 ShellLink_GetSite( IObjectWithSite *iface, REFIID iid, void ** ppvSite )
2614 {
2615 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2616
2617 TRACE("%p %s %p\n", This, debugstr_guid( iid ), ppvSite );
2618
2619 if ( !This->site )
2620 return E_FAIL;
2621 return IUnknown_QueryInterface( This->site, iid, ppvSite );
2622 }
2623
2624 static HRESULT WINAPI
2625 ShellLink_SetSite( IObjectWithSite *iface, IUnknown *punk )
2626 {
2627 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2628
2629 TRACE("%p %p\n", iface, punk);
2630
2631 if ( punk )
2632 IUnknown_AddRef( punk );
2633
2634 if( This->site )
2635 IUnknown_Release( This->site );
2636
2637 This->site = punk;
2638
2639 return S_OK;
2640 }
2641
2642 static const IObjectWithSiteVtbl owsvt =
2643 {
2644 ShellLink_ObjectWithSite_QueryInterface,
2645 ShellLink_ObjectWithSite_AddRef,
2646 ShellLink_ObjectWithSite_Release,
2647 ShellLink_SetSite,
2648 ShellLink_GetSite,
2649 };
Windows API implementation