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