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