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