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