?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 1.3.7.
[wine/gsoc-2012-control.git] / dlls / shell32 / shelllink.c
blobb4a977a2769ab5141695e60bcc32fcd36c7b3284
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 WINAPI IShellLinkA_fnGetIconLocation(IShellLinkA * iface, LPSTR pszIconPath,INT cchIconPath,INT *piIcon)
1597 {
1598 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1599
1600 TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1601
1602 *piIcon = This->iIcoNdx;
1603
1604 if (This->sIcoPath)
1605 WideCharToMultiByte(CP_ACP, 0, This->sIcoPath, -1, pszIconPath, cchIconPath, NULL, NULL);
1606 else
1607 pszIconPath[0] = 0;
1608
1609 return S_OK;
1610 }
1611
1612 static HRESULT WINAPI IShellLinkA_fnSetIconLocation(IShellLinkA * iface, LPCSTR pszIconPath,INT iIcon)
1613 {
1614 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1615
1616 TRACE("(%p)->(path=%s iicon=%u)\n",This, pszIconPath, iIcon);
1617
1618 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1619 This->sIcoPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath);
1620 if ( !This->sIcoPath )
1621 return E_OUTOFMEMORY;
1622
1623 This->iIcoNdx = iIcon;
1624 This->bDirty = TRUE;
1625
1626 return S_OK;
1627 }
1628
1629 static HRESULT WINAPI IShellLinkA_fnSetRelativePath(IShellLinkA * iface, LPCSTR pszPathRel, DWORD dwReserved)
1630 {
1631 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1632
1633 TRACE("(%p)->(path=%s %x)\n",This, pszPathRel, dwReserved);
1634
1635 HeapFree(GetProcessHeap(), 0, This->sPathRel);
1636 This->sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel);
1637 This->bDirty = TRUE;
1638
1639 return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1640 }
1641
1642 static HRESULT WINAPI IShellLinkA_fnResolve(IShellLinkA * iface, HWND hwnd, DWORD fFlags)
1643 {
1644 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1645
1646 TRACE("(%p)->(hwnd=%p flags=%x)\n",This, hwnd, fFlags);
1647
1648 return IShellLinkW_Resolve( (IShellLinkW*)&(This->lpvtblw), hwnd, fFlags );
1649 }
1650
1651 static HRESULT WINAPI IShellLinkA_fnSetPath(IShellLinkA * iface, LPCSTR pszFile)
1652 {
1653 HRESULT r;
1654 LPWSTR str;
1655 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1656
1657 TRACE("(%p)->(path=%s)\n",This, pszFile);
1658
1659 if (!pszFile) return E_INVALIDARG;
1660
1661 str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
1662 if( !str )
1663 return E_OUTOFMEMORY;
1664
1665 r = IShellLinkW_SetPath((IShellLinkW*)&(This->lpvtblw), str);
1666 HeapFree( GetProcessHeap(), 0, str );
1667
1668 return r;
1669 }
1670
1671 /**************************************************************************
1672 * IShellLink Implementation
1673 */
1674
1675 static const IShellLinkAVtbl slvt =
1676 {
1677 IShellLinkA_fnQueryInterface,
1678 IShellLinkA_fnAddRef,
1679 IShellLinkA_fnRelease,
1680 IShellLinkA_fnGetPath,
1681 IShellLinkA_fnGetIDList,
1682 IShellLinkA_fnSetIDList,
1683 IShellLinkA_fnGetDescription,
1684 IShellLinkA_fnSetDescription,
1685 IShellLinkA_fnGetWorkingDirectory,
1686 IShellLinkA_fnSetWorkingDirectory,
1687 IShellLinkA_fnGetArguments,
1688 IShellLinkA_fnSetArguments,
1689 IShellLinkA_fnGetHotkey,
1690 IShellLinkA_fnSetHotkey,
1691 IShellLinkA_fnGetShowCmd,
1692 IShellLinkA_fnSetShowCmd,
1693 IShellLinkA_fnGetIconLocation,
1694 IShellLinkA_fnSetIconLocation,
1695 IShellLinkA_fnSetRelativePath,
1696 IShellLinkA_fnResolve,
1697 IShellLinkA_fnSetPath
1698 };
1699
1700
1701 /**************************************************************************
1702 * IShellLinkW_fnQueryInterface
1703 */
1704 static HRESULT WINAPI IShellLinkW_fnQueryInterface(
1705 IShellLinkW * iface, REFIID riid, LPVOID *ppvObj)
1706 {
1707 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1708 return ShellLink_QueryInterface( This, riid, ppvObj );
1709 }
1710
1711 /******************************************************************************
1712 * IShellLinkW_fnAddRef
1713 */
1714 static ULONG WINAPI IShellLinkW_fnAddRef(IShellLinkW * iface)
1715 {
1716 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1717 return ShellLink_AddRef( This );
1718 }
1719
1720 /******************************************************************************
1721 * IShellLinkW_fnRelease
1722 */
1723 static ULONG WINAPI IShellLinkW_fnRelease(IShellLinkW * iface)
1724 {
1725 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1726 return ShellLink_Release( This );
1727 }
1728
1729 static HRESULT WINAPI IShellLinkW_fnGetPath(IShellLinkW * iface, LPWSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAW *pfd, DWORD fFlags)
1730 {
1731 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1732
1733 TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n",
1734 This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1735
1736 if (This->sComponent || This->sProduct)
1737 return S_FALSE;
1738
1739 if (cchMaxPath)
1740 pszFile[0] = 0;
1741 if (This->sPath)
1742 lstrcpynW( pszFile, This->sPath, cchMaxPath );
1743
1744 if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", This);
1745
1746 return S_OK;
1747 }
1748
1749 static HRESULT WINAPI IShellLinkW_fnGetIDList(IShellLinkW * iface, LPITEMIDLIST * ppidl)
1750 {
1751 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1752
1753 TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1754
1755 if (!This->pPidl)
1756 {
1757 *ppidl = NULL;
1758 return S_FALSE;
1759 }
1760 *ppidl = ILClone(This->pPidl);
1761 return S_OK;
1762 }
1763
1764 static HRESULT WINAPI IShellLinkW_fnSetIDList(IShellLinkW * iface, LPCITEMIDLIST pidl)
1765 {
1766 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1767
1768 TRACE("(%p)->(pidl=%p)\n",This, pidl);
1769
1770 if( This->pPidl )
1771 ILFree( This->pPidl );
1772 This->pPidl = ILClone( pidl );
1773 if( !This->pPidl )
1774 return E_FAIL;
1775
1776 This->bDirty = TRUE;
1777
1778 return S_OK;
1779 }
1780
1781 static HRESULT WINAPI IShellLinkW_fnGetDescription(IShellLinkW * iface, LPWSTR pszName,INT cchMaxName)
1782 {
1783 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1784
1785 TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);
1786
1787 pszName[0] = 0;
1788 if( This->sDescription )
1789 lstrcpynW( pszName, This->sDescription, cchMaxName );
1790
1791 return S_OK;
1792 }
1793
1794 static HRESULT WINAPI IShellLinkW_fnSetDescription(IShellLinkW * iface, LPCWSTR pszName)
1795 {
1796 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1797
1798 TRACE("(%p)->(desc=%s)\n",This, debugstr_w(pszName));
1799
1800 HeapFree(GetProcessHeap(), 0, This->sDescription);
1801 if (pszName)
1802 {
1803 This->sDescription = HeapAlloc( GetProcessHeap(), 0,
1804 (lstrlenW( pszName )+1)*sizeof(WCHAR) );
1805 if ( !This->sDescription )
1806 return E_OUTOFMEMORY;
1807
1808 lstrcpyW( This->sDescription, pszName );
1809 }
1810 else
1811 This->sDescription = NULL;
1812 This->bDirty = TRUE;
1813
1814 return S_OK;
1815 }
1816
1817 static HRESULT WINAPI IShellLinkW_fnGetWorkingDirectory(IShellLinkW * iface, LPWSTR pszDir,INT cchMaxPath)
1818 {
1819 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1820
1821 TRACE("(%p)->(%p len %u)\n", This, pszDir, cchMaxPath);
1822
1823 if( cchMaxPath )
1824 pszDir[0] = 0;
1825 if( This->sWorkDir )
1826 lstrcpynW( pszDir, This->sWorkDir, cchMaxPath );
1827
1828 return S_OK;
1829 }
1830
1831 static HRESULT WINAPI IShellLinkW_fnSetWorkingDirectory(IShellLinkW * iface, LPCWSTR pszDir)
1832 {
1833 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1834
1835 TRACE("(%p)->(dir=%s)\n",This, debugstr_w(pszDir));
1836
1837 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1838 This->sWorkDir = HeapAlloc( GetProcessHeap(), 0,
1839 (lstrlenW( pszDir )+1)*sizeof (WCHAR) );
1840 if ( !This->sWorkDir )
1841 return E_OUTOFMEMORY;
1842 lstrcpyW( This->sWorkDir, pszDir );
1843 This->bDirty = TRUE;
1844
1845 return S_OK;
1846 }
1847
1848 static HRESULT WINAPI IShellLinkW_fnGetArguments(IShellLinkW * iface, LPWSTR pszArgs,INT cchMaxPath)
1849 {
1850 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1851
1852 TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1853
1854 if( cchMaxPath )
1855 pszArgs[0] = 0;
1856 if( This->sArgs )
1857 lstrcpynW( pszArgs, This->sArgs, cchMaxPath );
1858
1859 return NOERROR;
1860 }
1861
1862 static HRESULT WINAPI IShellLinkW_fnSetArguments(IShellLinkW * iface, LPCWSTR pszArgs)
1863 {
1864 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1865
1866 TRACE("(%p)->(args=%s)\n",This, debugstr_w(pszArgs));
1867
1868 HeapFree(GetProcessHeap(), 0, This->sArgs);
1869 if (pszArgs)
1870 {
1871 This->sArgs = HeapAlloc( GetProcessHeap(), 0,
1872 (lstrlenW( pszArgs )+1)*sizeof (WCHAR) );
1873 if ( !This->sArgs )
1874 return E_OUTOFMEMORY;
1875 lstrcpyW( This->sArgs, pszArgs );
1876 }
1877 else This->sArgs = NULL;
1878
1879 This->bDirty = TRUE;
1880
1881 return S_OK;
1882 }
1883
1884 static HRESULT WINAPI IShellLinkW_fnGetHotkey(IShellLinkW * iface, WORD *pwHotkey)
1885 {
1886 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1887
1888 TRACE("(%p)->(%p)\n",This, pwHotkey);
1889
1890 *pwHotkey=This->wHotKey;
1891
1892 return S_OK;
1893 }
1894
1895 static HRESULT WINAPI IShellLinkW_fnSetHotkey(IShellLinkW * iface, WORD wHotkey)
1896 {
1897 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1898
1899 TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1900
1901 This->wHotKey = wHotkey;
1902 This->bDirty = TRUE;
1903
1904 return S_OK;
1905 }
1906
1907 static HRESULT WINAPI IShellLinkW_fnGetShowCmd(IShellLinkW * iface, INT *piShowCmd)
1908 {
1909 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1910
1911 TRACE("(%p)->(%p)\n",This, piShowCmd);
1912
1913 *piShowCmd = This->iShowCmd;
1914
1915 return S_OK;
1916 }
1917
1918 static HRESULT WINAPI IShellLinkW_fnSetShowCmd(IShellLinkW * iface, INT iShowCmd)
1919 {
1920 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1921
1922 This->iShowCmd = iShowCmd;
1923 This->bDirty = TRUE;
1924
1925 return S_OK;
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 *piIcon = This->iIcoNdx;
1935
1936 if (This->sIcoPath)
1937 lstrcpynW(pszIconPath, This->sIcoPath, cchIconPath);
1938 else
1939 pszIconPath[0] = 0;
1940
1941 return S_OK;
1942 }
1943
1944 static HRESULT WINAPI IShellLinkW_fnSetIconLocation(IShellLinkW * iface, LPCWSTR pszIconPath,INT iIcon)
1945 {
1946 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1947
1948 TRACE("(%p)->(path=%s iicon=%u)\n",This, debugstr_w(pszIconPath), iIcon);
1949
1950 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1951 This->sIcoPath = HeapAlloc( GetProcessHeap(), 0,
1952 (lstrlenW( pszIconPath )+1)*sizeof (WCHAR) );
1953 if ( !This->sIcoPath )
1954 return E_OUTOFMEMORY;
1955 lstrcpyW( This->sIcoPath, pszIconPath );
1956
1957 This->iIcoNdx = iIcon;
1958 This->bDirty = TRUE;
1959
1960 return S_OK;
1961 }
1962
1963 static HRESULT WINAPI IShellLinkW_fnSetRelativePath(IShellLinkW * iface, LPCWSTR pszPathRel, DWORD dwReserved)
1964 {
1965 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1966
1967 TRACE("(%p)->(path=%s %x)\n",This, debugstr_w(pszPathRel), dwReserved);
1968
1969 HeapFree(GetProcessHeap(), 0, This->sPathRel);
1970 This->sPathRel = HeapAlloc( GetProcessHeap(), 0,
1971 (lstrlenW( pszPathRel )+1) * sizeof (WCHAR) );
1972 if ( !This->sPathRel )
1973 return E_OUTOFMEMORY;
1974 lstrcpyW( This->sPathRel, pszPathRel );
1975 This->bDirty = TRUE;
1976
1977 return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1978 }
1979
1980 static HRESULT WINAPI IShellLinkW_fnResolve(IShellLinkW * iface, HWND hwnd, DWORD fFlags)
1981 {
1982 HRESULT hr = S_OK;
1983 BOOL bSuccess;
1984
1985 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1986
1987 TRACE("(%p)->(hwnd=%p flags=%x)\n",This, hwnd, fFlags);
1988
1989 /*FIXME: use IResolveShellLink interface */
1990
1991 if (!This->sPath && This->pPidl) {
1992 WCHAR buffer[MAX_PATH];
1993
1994 bSuccess = SHGetPathFromIDListW(This->pPidl, buffer);
1995
1996 if (bSuccess && *buffer) {
1997 This->sPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(buffer)+1)*sizeof(WCHAR));
1998 if (!This->sPath)
1999 return E_OUTOFMEMORY;
2000
2001 lstrcpyW(This->sPath, buffer);
2002
2003 This->bDirty = TRUE;
2004 } else
2005 hr = S_OK; /* don't report an error occurred while just caching information */
2006 }
2007
2008 if (!This->sIcoPath && This->sPath) {
2009 This->sIcoPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(This->sPath)+1)*sizeof(WCHAR));
2010 if (!This->sIcoPath)
2011 return E_OUTOFMEMORY;
2012
2013 lstrcpyW(This->sIcoPath, This->sPath);
2014 This->iIcoNdx = 0;
2015
2016 This->bDirty = TRUE;
2017 }
2018
2019 return hr;
2020 }
2021
2022 static LPWSTR ShellLink_GetAdvertisedArg(LPCWSTR str)
2023 {
2024 LPWSTR ret;
2025 LPCWSTR p;
2026 DWORD len;
2027
2028 if( !str )
2029 return NULL;
2030
2031 p = strchrW( str, ':' );
2032 if( !p )
2033 return NULL;
2034 len = p - str;
2035 ret = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR)*(len+1));
2036 if( !ret )
2037 return ret;
2038 memcpy( ret, str, sizeof(WCHAR)*len );
2039 ret[len] = 0;
2040 return ret;
2041 }
2042
2043 static HRESULT ShellLink_SetAdvertiseInfo(IShellLinkImpl *This, LPCWSTR str)
2044 {
2045 LPCWSTR szComponent = NULL, szProduct = NULL, p;
2046 WCHAR szGuid[39];
2047 HRESULT r;
2048 GUID guid;
2049 int len;
2050
2051 while( str[0] )
2052 {
2053 /* each segment must start with two colons */
2054 if( str[0] != ':' || str[1] != ':' )
2055 return E_FAIL;
2056
2057 /* the last segment is just two colons */
2058 if( !str[2] )
2059 break;
2060 str += 2;
2061
2062 /* there must be a colon straight after a guid */
2063 p = strchrW( str, ':' );
2064 if( !p )
2065 return E_FAIL;
2066 len = p - str;
2067 if( len != 38 )
2068 return E_FAIL;
2069
2070 /* get the guid, and check it's validly formatted */
2071 memcpy( szGuid, str, sizeof(WCHAR)*len );
2072 szGuid[len] = 0;
2073 r = CLSIDFromString( szGuid, &guid );
2074 if( r != S_OK )
2075 return r;
2076 str = p + 1;
2077
2078 /* match it up to a guid that we care about */
2079 if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutComponent ) && !szComponent )
2080 szComponent = str;
2081 else if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutProduct ) && !szProduct )
2082 szProduct = str;
2083 else
2084 return E_FAIL;
2085
2086 /* skip to the next field */
2087 str = strchrW( str, ':' );
2088 if( !str )
2089 return E_FAIL;
2090 }
2091
2092 /* we have to have a component for an advertised shortcut */
2093 if( !szComponent )
2094 return E_FAIL;
2095
2096 This->sComponent = ShellLink_GetAdvertisedArg( szComponent );
2097 This->sProduct = ShellLink_GetAdvertisedArg( szProduct );
2098
2099 TRACE("Component = %s\n", debugstr_w(This->sComponent));
2100 TRACE("Product = %s\n", debugstr_w(This->sProduct));
2101
2102 return S_OK;
2103 }
2104
2105 static BOOL ShellLink_GetVolumeInfo(LPCWSTR path, volume_info *volume)
2106 {
2107 const int label_sz = sizeof volume->label/sizeof volume->label[0];
2108 WCHAR drive[4] = { path[0], ':', '\\', 0 };
2109 BOOL r;
2110
2111 volume->type = GetDriveTypeW(drive);
2112 r = GetVolumeInformationW(drive, volume->label, label_sz,
2113 &volume->serial, NULL, NULL, NULL, 0);
2114 TRACE("r = %d type %d serial %08x name %s\n", r,
2115 volume->type, volume->serial, debugstr_w(volume->label));
2116 return r;
2117 }
2118
2119 static HRESULT WINAPI IShellLinkW_fnSetPath(IShellLinkW * iface, LPCWSTR pszFile)
2120 {
2121 IShellLinkImpl *This = impl_from_IShellLinkW(iface);
2122 WCHAR buffer[MAX_PATH];
2123 LPWSTR fname, unquoted = NULL;
2124 HRESULT hr = S_OK;
2125 UINT len;
2126
2127 TRACE("(%p)->(path=%s)\n",This, debugstr_w(pszFile));
2128
2129 if (!pszFile) return E_INVALIDARG;
2130
2131 /* quotes at the ends of the string are stripped */
2132 len = lstrlenW(pszFile);
2133 if (pszFile[0] == '"' && pszFile[len-1] == '"')
2134 {
2135 unquoted = strdupW(pszFile);
2136 PathUnquoteSpacesW(unquoted);
2137 pszFile = unquoted;
2138 }
2139
2140 /* any other quote marks are invalid */
2141 if (strchrW(pszFile, '"'))
2142 {
2143 HeapFree(GetProcessHeap(), 0, unquoted);
2144 return S_FALSE;
2145 }
2146
2147 HeapFree(GetProcessHeap(), 0, This->sPath);
2148 This->sPath = NULL;
2149
2150 HeapFree(GetProcessHeap(), 0, This->sComponent);
2151 This->sComponent = NULL;
2152
2153 if (This->pPidl)
2154 ILFree(This->pPidl);
2155 This->pPidl = NULL;
2156
2157 if (S_OK != ShellLink_SetAdvertiseInfo( This, pszFile ))
2158 {
2159 if (*pszFile == '\0')
2160 *buffer = '\0';
2161 else if (!GetFullPathNameW(pszFile, MAX_PATH, buffer, &fname))
2162 return E_FAIL;
2163 else if(!PathFileExistsW(buffer) &&
2164 !SearchPathW(NULL, pszFile, NULL, MAX_PATH, buffer, NULL))
2165 hr = S_FALSE;
2166
2167 This->pPidl = SHSimpleIDListFromPathW(pszFile);
2168 ShellLink_GetVolumeInfo(buffer, &This->volume);
2169
2170 This->sPath = HeapAlloc( GetProcessHeap(), 0,
2171 (lstrlenW( buffer )+1) * sizeof (WCHAR) );
2172 if (!This->sPath)
2173 {
2174 HeapFree(GetProcessHeap(), 0, unquoted);
2175 return E_OUTOFMEMORY;
2176 }
2177
2178 lstrcpyW(This->sPath, buffer);
2179 }
2180 This->bDirty = TRUE;
2181 HeapFree(GetProcessHeap(), 0, unquoted);
2182
2183 return hr;
2184 }
2185
2186 /**************************************************************************
2187 * IShellLinkW Implementation
2188 */
2189
2190 static const IShellLinkWVtbl slvtw =
2191 {
2192 IShellLinkW_fnQueryInterface,
2193 IShellLinkW_fnAddRef,
2194 IShellLinkW_fnRelease,
2195 IShellLinkW_fnGetPath,
2196 IShellLinkW_fnGetIDList,
2197 IShellLinkW_fnSetIDList,
2198 IShellLinkW_fnGetDescription,
2199 IShellLinkW_fnSetDescription,
2200 IShellLinkW_fnGetWorkingDirectory,
2201 IShellLinkW_fnSetWorkingDirectory,
2202 IShellLinkW_fnGetArguments,
2203 IShellLinkW_fnSetArguments,
2204 IShellLinkW_fnGetHotkey,
2205 IShellLinkW_fnSetHotkey,
2206 IShellLinkW_fnGetShowCmd,
2207 IShellLinkW_fnSetShowCmd,
2208 IShellLinkW_fnGetIconLocation,
2209 IShellLinkW_fnSetIconLocation,
2210 IShellLinkW_fnSetRelativePath,
2211 IShellLinkW_fnResolve,
2212 IShellLinkW_fnSetPath
2213 };
2214
2215 static HRESULT WINAPI
2216 ShellLink_DataList_QueryInterface( IShellLinkDataList* iface, REFIID riid, void** ppvObject)
2217 {
2218 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2219 return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
2220 }
2221
2222 static ULONG WINAPI
2223 ShellLink_DataList_AddRef( IShellLinkDataList* iface )
2224 {
2225 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2226 return IShellLinkA_AddRef((IShellLinkA*)This);
2227 }
2228
2229 static ULONG WINAPI
2230 ShellLink_DataList_Release( IShellLinkDataList* iface )
2231 {
2232 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2233 return ShellLink_Release( This );
2234 }
2235
2236 static HRESULT WINAPI
2237 ShellLink_AddDataBlock( IShellLinkDataList* iface, void* pDataBlock )
2238 {
2239 FIXME("(%p)->(%p): stub\n", iface, pDataBlock);
2240 return E_NOTIMPL;
2241 }
2242
2243 static HRESULT WINAPI
2244 ShellLink_CopyDataBlock( IShellLinkDataList* iface, DWORD dwSig, void** ppDataBlock )
2245 {
2246 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2247 LPVOID block = NULL;
2248 HRESULT r = E_FAIL;
2249
2250 TRACE("%p %08x %p\n", iface, dwSig, ppDataBlock );
2251
2252 switch (dwSig)
2253 {
2254 case EXP_DARWIN_ID_SIG:
2255 if (!This->sComponent)
2256 break;
2257 block = shelllink_build_darwinid( This->sComponent, dwSig );
2258 r = S_OK;
2259 break;
2260 case EXP_SZ_LINK_SIG:
2261 case NT_CONSOLE_PROPS_SIG:
2262 case NT_FE_CONSOLE_PROPS_SIG:
2263 case EXP_SPECIAL_FOLDER_SIG:
2264 case EXP_SZ_ICON_SIG:
2265 FIXME("valid but unhandled datablock %08x\n", dwSig);
2266 break;
2267 default:
2268 ERR("unknown datablock %08x\n", dwSig);
2269 }
2270 *ppDataBlock = block;
2271 return r;
2272 }
2273
2274 static HRESULT WINAPI
2275 ShellLink_RemoveDataBlock( IShellLinkDataList* iface, DWORD dwSig )
2276 {
2277 FIXME("(%p)->(%u): stub\n", iface, dwSig);
2278 return E_NOTIMPL;
2279 }
2280
2281 static HRESULT WINAPI
2282 ShellLink_GetFlags( IShellLinkDataList* iface, DWORD* pdwFlags )
2283 {
2284 IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2285 DWORD flags = 0;
2286
2287 FIXME("(%p)->(%p): partially implemented\n", This, pdwFlags);
2288
2289 /* FIXME: add more */
2290 if (This->sArgs)
2291 flags |= SLDF_HAS_ARGS;
2292 if (This->sComponent)
2293 flags |= SLDF_HAS_DARWINID;
2294 if (This->sIcoPath)
2295 flags |= SLDF_HAS_ICONLOCATION;
2296 if (This->sProduct)
2297 flags |= SLDF_HAS_LOGO3ID;
2298 if (This->pPidl)
2299 flags |= SLDF_HAS_ID_LIST;
2300
2301 *pdwFlags = flags;
2302
2303 return S_OK;
2304 }
2305
2306 static HRESULT WINAPI
2307 ShellLink_SetFlags( IShellLinkDataList* iface, DWORD dwFlags )
2308 {
2309 FIXME("(%p)->(%u): stub\n", iface, dwFlags);
2310 return E_NOTIMPL;
2311 }
2312
2313 static const IShellLinkDataListVtbl dlvt =
2314 {
2315 ShellLink_DataList_QueryInterface,
2316 ShellLink_DataList_AddRef,
2317 ShellLink_DataList_Release,
2318 ShellLink_AddDataBlock,
2319 ShellLink_CopyDataBlock,
2320 ShellLink_RemoveDataBlock,
2321 ShellLink_GetFlags,
2322 ShellLink_SetFlags
2323 };
2324
2325 static HRESULT WINAPI
2326 ShellLink_ExtInit_QueryInterface( IShellExtInit* iface, REFIID riid, void** ppvObject )
2327 {
2328 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2329 return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
2330 }
2331
2332 static ULONG WINAPI
2333 ShellLink_ExtInit_AddRef( IShellExtInit* iface )
2334 {
2335 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2336 return IShellLinkA_AddRef((IShellLinkA*)This);
2337 }
2338
2339 static ULONG WINAPI
2340 ShellLink_ExtInit_Release( IShellExtInit* iface )
2341 {
2342 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2343 return ShellLink_Release( This );
2344 }
2345
2346 /**************************************************************************
2347 * ShellLink implementation of IShellExtInit::Initialize()
2348 *
2349 * Loads the shelllink from the dataobject the shell is pointing to.
2350 */
2351 static HRESULT WINAPI
2352 ShellLink_ExtInit_Initialize( IShellExtInit* iface, LPCITEMIDLIST pidlFolder,
2353 IDataObject *pdtobj, HKEY hkeyProgID )
2354 {
2355 IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2356 FORMATETC format;
2357 STGMEDIUM stgm;
2358 UINT count;
2359 HRESULT r = E_FAIL;
2360
2361 TRACE("%p %p %p %p\n", This, pidlFolder, pdtobj, hkeyProgID );
2362
2363 if( !pdtobj )
2364 return r;
2365
2366 format.cfFormat = CF_HDROP;
2367 format.ptd = NULL;
2368 format.dwAspect = DVASPECT_CONTENT;
2369 format.lindex = -1;
2370 format.tymed = TYMED_HGLOBAL;
2371
2372 if( FAILED( IDataObject_GetData( pdtobj, &format, &stgm ) ) )
2373 return r;
2374
2375 count = DragQueryFileW( stgm.u.hGlobal, -1, NULL, 0 );
2376 if( count == 1 )
2377 {
2378 LPWSTR path;
2379
2380 count = DragQueryFileW( stgm.u.hGlobal, 0, NULL, 0 );
2381 count++;
2382 path = HeapAlloc( GetProcessHeap(), 0, count*sizeof(WCHAR) );
2383 if( path )
2384 {
2385 IPersistFile *pf = (IPersistFile*) &This->lpvtblPersistFile;
2386
2387 count = DragQueryFileW( stgm.u.hGlobal, 0, path, count );
2388 r = IPersistFile_Load( pf, path, 0 );
2389 HeapFree( GetProcessHeap(), 0, path );
2390 }
2391 }
2392 ReleaseStgMedium( &stgm );
2393
2394 return r;
2395 }
2396
2397 static const IShellExtInitVtbl eivt =
2398 {
2399 ShellLink_ExtInit_QueryInterface,
2400 ShellLink_ExtInit_AddRef,
2401 ShellLink_ExtInit_Release,
2402 ShellLink_ExtInit_Initialize
2403 };
2404
2405 static HRESULT WINAPI
2406 ShellLink_ContextMenu_QueryInterface( IContextMenu* iface, REFIID riid, void** ppvObject )
2407 {
2408 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2409 return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
2410 }
2411
2412 static ULONG WINAPI
2413 ShellLink_ContextMenu_AddRef( IContextMenu* iface )
2414 {
2415 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2416 return IShellLinkA_AddRef((IShellLinkA*)This);
2417 }
2418
2419 static ULONG WINAPI
2420 ShellLink_ContextMenu_Release( IContextMenu* iface )
2421 {
2422 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2423 return ShellLink_Release( This );
2424 }
2425
2426 static HRESULT WINAPI
2427 ShellLink_QueryContextMenu( IContextMenu* iface, HMENU hmenu, UINT indexMenu,
2428 UINT idCmdFirst, UINT idCmdLast, UINT uFlags )
2429 {
2430 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2431 static WCHAR szOpen[] = { 'O','p','e','n',0 };
2432 MENUITEMINFOW mii;
2433 int id = 1;
2434
2435 TRACE("%p %p %u %u %u %u\n", This,
2436 hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
2437
2438 if ( !hmenu )
2439 return E_INVALIDARG;
2440
2441 memset( &mii, 0, sizeof mii );
2442 mii.cbSize = sizeof mii;
2443 mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
2444 mii.dwTypeData = szOpen;
2445 mii.cch = strlenW( mii.dwTypeData );
2446 mii.wID = idCmdFirst + id++;
2447 mii.fState = MFS_DEFAULT | MFS_ENABLED;
2448 mii.fType = MFT_STRING;
2449 if (!InsertMenuItemW( hmenu, indexMenu, TRUE, &mii ))
2450 return E_FAIL;
2451 This->iIdOpen = 0;
2452
2453 return MAKE_HRESULT( SEVERITY_SUCCESS, 0, id );
2454 }
2455
2456 static LPWSTR
2457 shelllink_get_msi_component_path( LPWSTR component )
2458 {
2459 LPWSTR path;
2460 DWORD r, sz = 0;
2461
2462 r = CommandLineFromMsiDescriptor( component, NULL, &sz );
2463 if (r != ERROR_SUCCESS)
2464 return NULL;
2465
2466 sz++;
2467 path = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
2468 r = CommandLineFromMsiDescriptor( component, path, &sz );
2469 if (r != ERROR_SUCCESS)
2470 {
2471 HeapFree( GetProcessHeap(), 0, path );
2472 path = NULL;
2473 }
2474
2475 TRACE("returning %s\n", debugstr_w( path ) );
2476
2477 return path;
2478 }
2479
2480 static HRESULT WINAPI
2481 ShellLink_InvokeCommand( IContextMenu* iface, LPCMINVOKECOMMANDINFO lpici )
2482 {
2483 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2484 static const WCHAR szOpen[] = { 'O','p','e','n',0 };
2485 SHELLEXECUTEINFOW sei;
2486 HWND hwnd = NULL; /* FIXME: get using interface set from IObjectWithSite */
2487 LPWSTR args = NULL;
2488 LPWSTR path = NULL;
2489 HRESULT r;
2490
2491 TRACE("%p %p\n", This, lpici );
2492
2493 if ( lpici->cbSize < sizeof (CMINVOKECOMMANDINFO) )
2494 return E_INVALIDARG;
2495
2496 if ( lpici->lpVerb != MAKEINTRESOURCEA(This->iIdOpen) )
2497 {
2498 ERR("Unknown id %p != %d\n", lpici->lpVerb, This->iIdOpen );
2499 return E_INVALIDARG;
2500 }
2501
2502 r = IShellLinkW_Resolve( (IShellLinkW*)&(This->lpvtblw), hwnd, 0 );
2503 if ( FAILED( r ) )
2504 return r;
2505
2506 if ( This->sComponent )
2507 {
2508 path = shelllink_get_msi_component_path( This->sComponent );
2509 if (!path)
2510 return E_FAIL;
2511 }
2512 else
2513 path = strdupW( This->sPath );
2514
2515 if ( lpici->cbSize == sizeof (CMINVOKECOMMANDINFOEX) &&
2516 ( lpici->fMask & CMIC_MASK_UNICODE ) )
2517 {
2518 LPCMINVOKECOMMANDINFOEX iciex = (LPCMINVOKECOMMANDINFOEX) lpici;
2519 DWORD len = 2;
2520
2521 if ( This->sArgs )
2522 len += lstrlenW( This->sArgs );
2523 if ( iciex->lpParametersW )
2524 len += lstrlenW( iciex->lpParametersW );
2525
2526 args = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
2527 args[0] = 0;
2528 if ( This->sArgs )
2529 lstrcatW( args, This->sArgs );
2530 if ( iciex->lpParametersW )
2531 {
2532 static const WCHAR space[] = { ' ', 0 };
2533 lstrcatW( args, space );
2534 lstrcatW( args, iciex->lpParametersW );
2535 }
2536 }
2537
2538 memset( &sei, 0, sizeof sei );
2539 sei.cbSize = sizeof sei;
2540 sei.fMask = SEE_MASK_UNICODE | (lpici->fMask & (SEE_MASK_NOASYNC|SEE_MASK_ASYNCOK|SEE_MASK_FLAG_NO_UI));
2541 sei.lpFile = path;
2542 sei.nShow = This->iShowCmd;
2543 sei.lpIDList = This->pPidl;
2544 sei.lpDirectory = This->sWorkDir;
2545 sei.lpParameters = args;
2546 sei.lpVerb = szOpen;
2547
2548 if( ShellExecuteExW( &sei ) )
2549 r = S_OK;
2550 else
2551 r = E_FAIL;
2552
2553 HeapFree( GetProcessHeap(), 0, args );
2554 HeapFree( GetProcessHeap(), 0, path );
2555
2556 return r;
2557 }
2558
2559 static HRESULT WINAPI
2560 ShellLink_GetCommandString( IContextMenu* iface, UINT_PTR idCmd, UINT uType,
2561 UINT* pwReserved, LPSTR pszName, UINT cchMax )
2562 {
2563 IShellLinkImpl *This = impl_from_IContextMenu(iface);
2564
2565 FIXME("(%p)->(%lu %u %p %p %u): stub\n", This,
2566 idCmd, uType, pwReserved, pszName, cchMax );
2567
2568 return E_NOTIMPL;
2569 }
2570
2571 static const IContextMenuVtbl cmvt =
2572 {
2573 ShellLink_ContextMenu_QueryInterface,
2574 ShellLink_ContextMenu_AddRef,
2575 ShellLink_ContextMenu_Release,
2576 ShellLink_QueryContextMenu,
2577 ShellLink_InvokeCommand,
2578 ShellLink_GetCommandString
2579 };
2580
2581 static HRESULT WINAPI
2582 ShellLink_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
2583 {
2584 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2585 return ShellLink_QueryInterface( This, riid, ppvObject );
2586 }
2587
2588 static ULONG WINAPI
2589 ShellLink_ObjectWithSite_AddRef( IObjectWithSite* iface )
2590 {
2591 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2592 return ShellLink_AddRef( This );
2593 }
2594
2595 static ULONG WINAPI
2596 ShellLink_ObjectWithSite_Release( IObjectWithSite* iface )
2597 {
2598 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2599 return ShellLink_Release( This );
2600 }
2601
2602 static HRESULT WINAPI
2603 ShellLink_GetSite( IObjectWithSite *iface, REFIID iid, void ** ppvSite )
2604 {
2605 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2606
2607 TRACE("%p %s %p\n", This, debugstr_guid( iid ), ppvSite );
2608
2609 if ( !This->site )
2610 return E_FAIL;
2611 return IUnknown_QueryInterface( This->site, iid, ppvSite );
2612 }
2613
2614 static HRESULT WINAPI
2615 ShellLink_SetSite( IObjectWithSite *iface, IUnknown *punk )
2616 {
2617 IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
2618
2619 TRACE("%p %p\n", iface, punk);
2620
2621 if ( punk )
2622 IUnknown_AddRef( punk );
2623 This->site = punk;
2624
2625 return S_OK;
2626 }
2627
2628 static const IObjectWithSiteVtbl owsvt =
2629 {
2630 ShellLink_ObjectWithSite_QueryInterface,
2631 ShellLink_ObjectWithSite_AddRef,
2632 ShellLink_ObjectWithSite_Release,
2633 ShellLink_SetSite,
2634 ShellLink_GetSite,
2635 };
GSOC 2012 project to enhance the control panel