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