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