d3d9/tests: Add r500 fp_special results.
[wine] / dlls / hlink / link.c
1 /*
2  * Implementation of hyperlinking (hlink.dll)
3  *
4  * Copyright 2005 Aric Stewart for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "hlink_private.h"
22
23 #include "shellapi.h"
24 #include "hlguids.h"
25
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(hlink);
29
30 #define HLINK_SAVE_MAGIC    0x00000002
31 #define HLINK_SAVE_MONIKER_PRESENT      0x01
32 #define HLINK_SAVE_MONIKER_IS_ABSOLUTE  0x02
33 #define HLINK_SAVE_LOCATION_PRESENT     0x08
34 #define HLINK_SAVE_FRIENDLY_PRESENT     0x10
35 /* 0x20, 0x40 unknown */
36 #define HLINK_SAVE_TARGET_FRAME_PRESENT 0x80
37 /* known flags */
38 #define HLINK_SAVE_ALL (HLINK_SAVE_TARGET_FRAME_PRESENT|HLINK_SAVE_FRIENDLY_PRESENT|HLINK_SAVE_LOCATION_PRESENT|0x04|HLINK_SAVE_MONIKER_IS_ABSOLUTE|HLINK_SAVE_MONIKER_PRESENT)
39
40 typedef struct
41 {
42     IHlink              IHlink_iface;
43     LONG                ref;
44
45     IPersistStream      IPersistStream_iface;
46     IDataObject         IDataObject_iface;
47
48     LPWSTR              FriendlyName;
49     LPWSTR              Location;
50     LPWSTR              TargetFrameName;
51     IMoniker            *Moniker;
52     IHlinkSite          *Site;
53     DWORD               SiteData;
54     BOOL                absolute;
55 } HlinkImpl;
56
57 static inline HlinkImpl *impl_from_IHlink(IHlink *iface)
58 {
59     return CONTAINING_RECORD(iface, HlinkImpl, IHlink_iface);
60 }
61
62
63 static inline HlinkImpl* impl_from_IPersistStream( IPersistStream* iface)
64 {
65     return CONTAINING_RECORD(iface, HlinkImpl, IPersistStream_iface);
66 }
67
68 static inline HlinkImpl* impl_from_IDataObject( IDataObject* iface)
69 {
70     return CONTAINING_RECORD(iface, HlinkImpl, IDataObject_iface);
71 }
72
73 static HRESULT __GetMoniker(HlinkImpl* This, IMoniker** moniker,
74         DWORD ref_type)
75 {
76     HRESULT hres;
77
78     if (ref_type == HLINKGETREF_DEFAULT)
79         ref_type = HLINKGETREF_RELATIVE;
80
81     if (This->Moniker)
82     {
83         DWORD mktype = MKSYS_NONE;
84
85         hres = IMoniker_IsSystemMoniker(This->Moniker, &mktype);
86         if (hres == S_OK && mktype != MKSYS_NONE)
87         {
88             *moniker = This->Moniker;
89             IMoniker_AddRef(*moniker);
90             return S_OK;
91         }
92     }
93
94     if (ref_type == HLINKGETREF_ABSOLUTE && This->Site)
95     {
96         IMoniker *hls_moniker;
97
98         hres = IHlinkSite_GetMoniker(This->Site, This->SiteData,
99                 OLEGETMONIKER_FORCEASSIGN, OLEWHICHMK_CONTAINER, &hls_moniker);
100         if (FAILED(hres))
101             return hres;
102
103         if (This->Moniker)
104         {
105             hres = IMoniker_ComposeWith(hls_moniker, This->Moniker, FALSE,
106                     moniker);
107             IMoniker_Release(hls_moniker);
108             return hres;
109         }
110
111         *moniker = hls_moniker;
112         return S_OK;
113     }
114
115     *moniker = This->Moniker;
116     if (*moniker)
117         IMoniker_AddRef(*moniker);
118
119     return S_OK;
120 }
121
122 static HRESULT WINAPI IHlink_fnQueryInterface(IHlink* iface, REFIID riid,
123         LPVOID *ppvObj)
124 {
125     HlinkImpl  *This = impl_from_IHlink(iface);
126
127     TRACE ("(%p)->(%s,%p)\n", This, debugstr_guid (riid), ppvObj);
128
129     *ppvObj = NULL;
130
131     if (IsEqualIID(riid, &IID_IUnknown) || (IsEqualIID(riid, &IID_IHlink)))
132         *ppvObj = This;
133     else if (IsEqualIID(riid, &IID_IPersistStream))
134         *ppvObj = &This->IPersistStream_iface;
135     else if (IsEqualIID(riid, &IID_IDataObject))
136         *ppvObj = &This->IDataObject_iface;
137
138     if (*ppvObj)
139     {
140         IUnknown_AddRef((IUnknown*)(*ppvObj));
141         return S_OK;
142     }
143     return E_NOINTERFACE;
144 }
145
146 static ULONG WINAPI IHlink_fnAddRef (IHlink* iface)
147 {
148     HlinkImpl  *This = impl_from_IHlink(iface);
149     ULONG refCount = InterlockedIncrement(&This->ref);
150
151     TRACE("(%p)->(count=%u)\n", This, refCount - 1);
152
153     return refCount;
154 }
155
156 static ULONG WINAPI IHlink_fnRelease (IHlink* iface)
157 {
158     HlinkImpl  *This = impl_from_IHlink(iface);
159     ULONG refCount = InterlockedDecrement(&This->ref);
160
161     TRACE("(%p)->(count=%u)\n", This, refCount + 1);
162     if (refCount)
163         return refCount;
164
165     TRACE("-- destroying IHlink (%p)\n", This);
166     heap_free(This->FriendlyName);
167     heap_free(This->TargetFrameName);
168     heap_free(This->Location);
169     if (This->Moniker)
170         IMoniker_Release(This->Moniker);
171     if (This->Site)
172         IHlinkSite_Release(This->Site);
173     heap_free(This);
174     return 0;
175 }
176
177 static HRESULT WINAPI IHlink_fnSetHlinkSite( IHlink* iface,
178         IHlinkSite* pihlSite, DWORD dwSiteData)
179 {
180     HlinkImpl  *This = impl_from_IHlink(iface);
181
182     TRACE("(%p)->(%p %i)\n", This, pihlSite, dwSiteData);
183
184     if (This->Site)
185         IHlinkSite_Release(This->Site);
186
187     This->Site = pihlSite;
188     if (This->Site)
189         IHlinkSite_AddRef(This->Site);
190
191     This->SiteData = dwSiteData;
192
193     return S_OK;
194 }
195
196 static HRESULT WINAPI IHlink_fnGetHlinkSite( IHlink* iface,
197         IHlinkSite** ppihlSite, DWORD *pdwSiteData)
198 {
199     HlinkImpl  *This = impl_from_IHlink(iface);
200
201     TRACE("(%p)->(%p %p)\n", This, ppihlSite, pdwSiteData);
202
203     *ppihlSite = This->Site;
204
205     if (This->Site) {
206         IHlinkSite_AddRef(This->Site);
207         *pdwSiteData = This->SiteData;
208     }
209
210     return S_OK;
211 }
212
213 static HRESULT WINAPI IHlink_fnSetMonikerReference( IHlink* iface,
214         DWORD rfHLSETF, IMoniker *pmkTarget, LPCWSTR pwzLocation)
215 {
216     HlinkImpl  *This = impl_from_IHlink(iface);
217
218     TRACE("(%p)->(%i %p %s)\n", This, rfHLSETF, pmkTarget,
219             debugstr_w(pwzLocation));
220
221     if(rfHLSETF == 0)
222         return E_INVALIDARG;
223     if(!(rfHLSETF & (HLINKSETF_TARGET | HLINKSETF_LOCATION)))
224         return rfHLSETF;
225
226     if(rfHLSETF & HLINKSETF_TARGET){
227         if (This->Moniker)
228             IMoniker_Release(This->Moniker);
229
230         This->Moniker = pmkTarget;
231         if (This->Moniker)
232         {
233             IBindCtx *pbc;
234             LPOLESTR display_name;
235             IMoniker_AddRef(This->Moniker);
236             CreateBindCtx( 0, &pbc);
237             IMoniker_GetDisplayName(This->Moniker, pbc, NULL, &display_name);
238             IBindCtx_Release(pbc);
239             This->absolute = display_name && strchrW(display_name, ':');
240             CoTaskMemFree(display_name);
241         }
242     }
243
244     if(rfHLSETF & HLINKSETF_LOCATION){
245         heap_free(This->Location);
246         This->Location = hlink_strdupW( pwzLocation );
247     }
248
249     return S_OK;
250 }
251
252 static HRESULT WINAPI IHlink_fnSetStringReference(IHlink* iface,
253         DWORD grfHLSETF, LPCWSTR pwzTarget, LPCWSTR pwzLocation)
254 {
255     HlinkImpl  *This = impl_from_IHlink(iface);
256
257     TRACE("(%p)->(%i %s %s)\n", This, grfHLSETF, debugstr_w(pwzTarget),
258             debugstr_w(pwzLocation));
259
260     if(grfHLSETF > (HLINKSETF_TARGET | HLINKSETF_LOCATION) &&
261             grfHLSETF < -(HLINKSETF_TARGET | HLINKSETF_LOCATION))
262         return grfHLSETF;
263
264     if (grfHLSETF & HLINKSETF_TARGET)
265     {
266         if (This->Moniker)
267         {
268             IMoniker_Release(This->Moniker);
269             This->Moniker = NULL;
270         }
271         if (pwzTarget && *pwzTarget)
272         {
273             IMoniker *pMon;
274             IBindCtx *pbc = NULL;
275             ULONG eaten;
276             HRESULT r;
277
278             r = CreateBindCtx(0, &pbc);
279             if (FAILED(r))
280                 return E_OUTOFMEMORY;
281
282             r = MkParseDisplayName(pbc, pwzTarget, &eaten, &pMon);
283             IBindCtx_Release(pbc);
284
285             if (FAILED(r))
286             {
287                 LPCWSTR p = strchrW(pwzTarget, ':');
288                 if (p && (p - pwzTarget > 1))
289                     r = CreateURLMoniker(NULL, pwzTarget, &pMon);
290                 else
291                     r = CreateFileMoniker(pwzTarget, &pMon);
292                 if (FAILED(r))
293                 {
294                     ERR("couldn't create moniker for %s, failed with error 0x%08x\n",
295                         debugstr_w(pwzTarget), r);
296                     return r;
297                 }
298             }
299
300             IHlink_SetMonikerReference(iface, HLINKSETF_TARGET, pMon, NULL);
301             IMoniker_Release(pMon);
302         }
303     }
304
305     if (grfHLSETF & HLINKSETF_LOCATION)
306     {
307         heap_free(This->Location);
308         This->Location = NULL;
309         if (pwzLocation && *pwzLocation)
310             This->Location = hlink_strdupW( pwzLocation );
311     }
312
313     return S_OK;
314 }
315
316 static HRESULT WINAPI IHlink_fnGetMonikerReference(IHlink* iface,
317         DWORD dwWhichRef, IMoniker **ppimkTarget, LPWSTR *ppwzLocation)
318 {
319     HlinkImpl  *This = impl_from_IHlink(iface);
320
321     TRACE("(%p) -> (%i %p %p)\n", This, dwWhichRef, ppimkTarget,
322             ppwzLocation);
323
324     if (ppimkTarget)
325     {
326         HRESULT hres = __GetMoniker(This, ppimkTarget, dwWhichRef);
327         if (FAILED(hres))
328         {
329             if (ppwzLocation)
330                 *ppwzLocation = NULL;
331             return hres;
332         }
333     }
334
335     if (ppwzLocation)
336         IHlink_GetStringReference(iface, dwWhichRef, NULL, ppwzLocation);
337
338     return S_OK;
339 }
340
341 static HRESULT WINAPI IHlink_fnGetStringReference (IHlink* iface,
342         DWORD dwWhichRef, LPWSTR *ppwzTarget, LPWSTR *ppwzLocation)
343 {
344     HlinkImpl  *This = impl_from_IHlink(iface);
345
346     TRACE("(%p) -> (%i %p %p)\n", This, dwWhichRef, ppwzTarget, ppwzLocation);
347
348     if(dwWhichRef != -1 && dwWhichRef & ~(HLINKGETREF_DEFAULT | HLINKGETREF_ABSOLUTE | HLINKGETREF_RELATIVE))
349     {
350         if(ppwzTarget)
351             *ppwzTarget = NULL;
352         if(ppwzLocation)
353             *ppwzLocation = NULL;
354         return E_INVALIDARG;
355     }
356
357     if (ppwzTarget)
358     {
359         IMoniker* mon;
360         HRESULT hres = __GetMoniker(This, &mon, dwWhichRef);
361         if (FAILED(hres))
362         {
363             if (ppwzLocation)
364                 *ppwzLocation = NULL;
365             return hres;
366         }
367         if (mon)
368         {
369             IBindCtx *pbc;
370
371             CreateBindCtx( 0, &pbc);
372             IMoniker_GetDisplayName(mon, pbc, NULL, ppwzTarget);
373             IBindCtx_Release(pbc);
374             IMoniker_Release(mon);
375         }
376         else
377             *ppwzTarget = NULL;
378     }
379     if (ppwzLocation)
380         *ppwzLocation = hlink_co_strdupW( This->Location );
381
382     TRACE("(Target: %s Location: %s)\n",
383             (ppwzTarget)?debugstr_w(*ppwzTarget):"<NULL>",
384             (ppwzLocation)?debugstr_w(*ppwzLocation):"<NULL>");
385
386     return S_OK;
387 }
388
389 static HRESULT WINAPI IHlink_fnSetFriendlyName (IHlink *iface,
390         LPCWSTR pwzFriendlyName)
391 {
392     HlinkImpl  *This = impl_from_IHlink(iface);
393
394     TRACE("(%p) -> (%s)\n", This, debugstr_w(pwzFriendlyName));
395
396     heap_free(This->FriendlyName);
397     This->FriendlyName = hlink_strdupW( pwzFriendlyName );
398
399     return S_OK;
400 }
401
402 static HRESULT WINAPI IHlink_fnGetFriendlyName (IHlink* iface,
403         DWORD grfHLFNAMEF, LPWSTR* ppwzFriendlyName)
404 {
405     HlinkImpl  *This = impl_from_IHlink(iface);
406
407     TRACE("(%p) -> (%i %p)\n", This, grfHLFNAMEF, ppwzFriendlyName);
408
409     /* FIXME: Only using explicitly set and cached friendly names */
410
411     if (This->FriendlyName)
412         *ppwzFriendlyName = hlink_co_strdupW( This->FriendlyName );
413     else
414     {
415         IMoniker *moniker;
416         HRESULT hres = __GetMoniker(This, &moniker, HLINKGETREF_DEFAULT);
417         if (FAILED(hres))
418         {
419             *ppwzFriendlyName = NULL;
420             return hres;
421         }
422         if (moniker)
423         {
424             IBindCtx *bcxt;
425             CreateBindCtx(0, &bcxt);
426
427             IMoniker_GetDisplayName(moniker, bcxt, NULL, ppwzFriendlyName);
428             IBindCtx_Release(bcxt);
429             IMoniker_Release(moniker);
430         }
431         else
432             *ppwzFriendlyName = NULL;
433     }
434
435     return S_OK;
436 }
437
438 static HRESULT WINAPI IHlink_fnSetTargetFrameName(IHlink* iface,
439         LPCWSTR pwzTargetFramename)
440 {
441     HlinkImpl  *This = impl_from_IHlink(iface);
442     TRACE("(%p)->(%s)\n", This, debugstr_w(pwzTargetFramename));
443
444     heap_free(This->TargetFrameName);
445     This->TargetFrameName = hlink_strdupW( pwzTargetFramename );
446
447     return S_OK;
448 }
449
450 static HRESULT WINAPI IHlink_fnGetTargetFrameName(IHlink* iface,
451         LPWSTR *ppwzTargetFrameName)
452 {
453     HlinkImpl  *This = impl_from_IHlink(iface);
454
455     TRACE("(%p)->(%p)\n", This, ppwzTargetFrameName);
456
457     if(!This->TargetFrameName) {
458         *ppwzTargetFrameName = NULL;
459         return S_FALSE;
460     }
461
462     *ppwzTargetFrameName = hlink_co_strdupW( This->TargetFrameName );
463     if(!*ppwzTargetFrameName)
464         return E_OUTOFMEMORY;
465
466     return S_OK;
467 }
468
469 static HRESULT WINAPI IHlink_fnGetMiscStatus(IHlink* iface, DWORD* pdwStatus)
470 {
471     FIXME("\n");
472     return E_NOTIMPL;
473 }
474
475 static HRESULT WINAPI IHlink_fnNavigate(IHlink* iface, DWORD grfHLNF, LPBC pbc,
476         IBindStatusCallback *pbsc, IHlinkBrowseContext *phbc)
477 {
478     HlinkImpl  *This = impl_from_IHlink(iface);
479     IMoniker *mon = NULL;
480     HRESULT r;
481
482     FIXME("Semi-Stub:(%p)->(%i %p %p %p)\n", This, grfHLNF, pbc, pbsc, phbc);
483
484     r = __GetMoniker(This, &mon, HLINKGETREF_ABSOLUTE);
485     TRACE("Moniker %p\n", mon);
486
487     if (SUCCEEDED(r))
488     {
489         IBindCtx *bcxt;
490         IUnknown *unk = NULL;
491         IHlinkTarget *target;
492
493         CreateBindCtx(0, &bcxt);
494
495         RegisterBindStatusCallback(bcxt, pbsc, NULL, 0);
496
497         r = IMoniker_BindToObject(mon, bcxt, NULL, &IID_IUnknown, (void**)&unk);
498         if (r == S_OK)
499         {
500             r = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&target);
501             IUnknown_Release(unk);
502         }
503         if (r == S_OK)
504         {
505             IHlinkTarget_SetBrowseContext(target, phbc);
506             r = IHlinkTarget_Navigate(target, grfHLNF, This->Location);
507             IHlinkTarget_Release(target);
508         }
509         else
510         {
511             static const WCHAR szOpen[] = {'o','p','e','n',0};
512             LPWSTR target = NULL;
513
514             r = IHlink_GetStringReference(iface, HLINKGETREF_DEFAULT, &target, NULL);
515             if (SUCCEEDED(r) && target)
516             {
517                 ShellExecuteW(NULL, szOpen, target, NULL, NULL, SW_SHOW);
518                 CoTaskMemFree(target);
519             }
520         }
521
522         RevokeBindStatusCallback(bcxt, pbsc);
523
524         IBindCtx_Release(bcxt);
525         IMoniker_Release(mon);
526     }
527
528     if (This->Site)
529         IHlinkSite_OnNavigationComplete(This->Site, This->SiteData, 0, r, NULL);
530
531     TRACE("Finished Navigation\n");
532     return r;
533 }
534
535 static HRESULT WINAPI IHlink_fnSetAdditionalParams(IHlink* iface,
536         LPCWSTR pwzAdditionalParams)
537 {
538     TRACE("Not implemented in native IHlink\n");
539     return E_NOTIMPL;
540 }
541
542 static HRESULT WINAPI IHlink_fnGetAdditionalParams(IHlink* iface,
543         LPWSTR* ppwzAdditionalParams)
544 {
545     TRACE("Not implemented in native IHlink\n");
546     return E_NOTIMPL;
547 }
548
549 static const IHlinkVtbl hlvt =
550 {
551     IHlink_fnQueryInterface,
552     IHlink_fnAddRef,
553     IHlink_fnRelease,
554     IHlink_fnSetHlinkSite,
555     IHlink_fnGetHlinkSite,
556     IHlink_fnSetMonikerReference,
557     IHlink_fnGetMonikerReference,
558     IHlink_fnSetStringReference,
559     IHlink_fnGetStringReference,
560     IHlink_fnSetFriendlyName,
561     IHlink_fnGetFriendlyName,
562     IHlink_fnSetTargetFrameName,
563     IHlink_fnGetTargetFrameName,
564     IHlink_fnGetMiscStatus,
565     IHlink_fnNavigate,
566     IHlink_fnSetAdditionalParams,
567     IHlink_fnGetAdditionalParams
568 };
569
570 static HRESULT WINAPI IDataObject_fnQueryInterface(IDataObject* iface,
571         REFIID riid, LPVOID *ppvObj)
572 {
573     HlinkImpl *This = impl_from_IDataObject(iface);
574     TRACE("%p\n", This);
575     return IHlink_QueryInterface(&This->IHlink_iface, riid, ppvObj);
576 }
577
578 static ULONG WINAPI IDataObject_fnAddRef (IDataObject* iface)
579 {
580     HlinkImpl *This = impl_from_IDataObject(iface);
581     TRACE("%p\n", This);
582     return IHlink_AddRef(&This->IHlink_iface);
583 }
584
585 static ULONG WINAPI IDataObject_fnRelease (IDataObject* iface)
586 {
587     HlinkImpl *This = impl_from_IDataObject(iface);
588     TRACE("%p\n", This);
589     return IHlink_Release(&This->IHlink_iface);
590 }
591
592 static HRESULT WINAPI IDataObject_fnGetData(IDataObject* iface,
593         FORMATETC* pformatetcIn, STGMEDIUM* pmedium)
594 {
595     FIXME("\n");
596     return E_NOTIMPL;
597 }
598
599 static HRESULT WINAPI IDataObject_fnGetDataHere(IDataObject* iface,
600         FORMATETC* pformatetc, STGMEDIUM* pmedium)
601 {
602     FIXME("\n");
603     return E_NOTIMPL;
604 }
605
606 static HRESULT WINAPI IDataObject_fnQueryGetData(IDataObject* iface,
607         FORMATETC* pformatetc)
608 {
609     FIXME("\n");
610     return E_NOTIMPL;
611 }
612
613 static HRESULT WINAPI IDataObject_fnGetConicalFormatEtc(IDataObject* iface,
614         FORMATETC* pformatetcIn, FORMATETC* pformatetcOut)
615 {
616     FIXME("\n");
617     return E_NOTIMPL;
618 }
619
620 static HRESULT WINAPI IDataObject_fnSetData(IDataObject* iface,
621         FORMATETC* pformatetc, STGMEDIUM* pmedium, BOOL fRelease)
622 {
623     FIXME("\n");
624     return E_NOTIMPL;
625 }
626
627 static HRESULT WINAPI IDataObject_fnEnumFormatEtc(IDataObject* iface,
628         DWORD dwDirection, IEnumFORMATETC** ppenumFormatEtc)
629 {
630     FIXME("\n");
631     return E_NOTIMPL;
632 }
633
634 static HRESULT WINAPI IDataObject_fnDAdvise(IDataObject* iface,
635         FORMATETC* pformatetc, DWORD advf, IAdviseSink* pAdvSink,
636         DWORD* pdwConnection)
637 {
638     FIXME("\n");
639     return E_NOTIMPL;
640 }
641
642 static HRESULT WINAPI IDataObject_fnDUnadvise(IDataObject* iface,
643         DWORD dwConnection)
644 {
645     FIXME("\n");
646     return E_NOTIMPL;
647 }
648
649 static HRESULT WINAPI IDataObject_fnEnumDAdvise(IDataObject* iface,
650         IEnumSTATDATA** ppenumAdvise)
651 {
652     FIXME("\n");
653     return E_NOTIMPL;
654 }
655
656 static const IDataObjectVtbl dovt =
657 {
658     IDataObject_fnQueryInterface,
659     IDataObject_fnAddRef,
660     IDataObject_fnRelease,
661     IDataObject_fnGetData,
662     IDataObject_fnGetDataHere,
663     IDataObject_fnQueryGetData,
664     IDataObject_fnGetConicalFormatEtc,
665     IDataObject_fnSetData,
666     IDataObject_fnEnumFormatEtc,
667     IDataObject_fnDAdvise,
668     IDataObject_fnDUnadvise,
669     IDataObject_fnEnumDAdvise
670 };
671
672 static HRESULT WINAPI IPersistStream_fnQueryInterface(IPersistStream* iface,
673         REFIID riid, LPVOID *ppvObj)
674 {
675     HlinkImpl *This = impl_from_IPersistStream(iface);
676     TRACE("(%p)\n", This);
677     return IHlink_QueryInterface(&This->IHlink_iface, riid, ppvObj);
678 }
679
680 static ULONG WINAPI IPersistStream_fnAddRef (IPersistStream* iface)
681 {
682     HlinkImpl *This = impl_from_IPersistStream(iface);
683     TRACE("(%p)\n", This);
684     return IHlink_AddRef(&This->IHlink_iface);
685 }
686
687 static ULONG WINAPI IPersistStream_fnRelease (IPersistStream* iface)
688 {
689     HlinkImpl *This = impl_from_IPersistStream(iface);
690     TRACE("(%p)\n", This);
691     return IHlink_Release(&This->IHlink_iface);
692 }
693
694 static HRESULT WINAPI IPersistStream_fnGetClassID(IPersistStream* iface,
695         CLSID* pClassID)
696 {
697     HlinkImpl *This = impl_from_IPersistStream(iface);
698     TRACE("(%p)\n", This);
699     *pClassID = CLSID_StdHlink;
700     return S_OK;
701 }
702
703 static HRESULT WINAPI IPersistStream_fnIsDirty(IPersistStream* iface)
704 {
705     FIXME("\n");
706     return E_NOTIMPL;
707 }
708
709 static HRESULT write_hlink_string(IStream *pStm, LPCWSTR str)
710 {
711     DWORD len;
712     HRESULT hr;
713
714     TRACE("(%p, %s)\n", pStm, debugstr_w(str));
715
716     len = strlenW(str) + 1;
717
718     hr = IStream_Write(pStm, &len, sizeof(len), NULL);
719     if (FAILED(hr)) return hr;
720
721     hr = IStream_Write(pStm, str, len * sizeof(WCHAR), NULL);
722     if (FAILED(hr)) return hr;
723
724     return S_OK;
725 }
726
727 static inline ULONG size_hlink_string(LPCWSTR str)
728 {
729     return sizeof(DWORD) + (strlenW(str) + 1) * sizeof(WCHAR);
730 }
731
732 static HRESULT read_hlink_string(IStream *pStm, LPWSTR *out_str)
733 {
734     LPWSTR str;
735     DWORD len;
736     ULONG read;
737     HRESULT hr;
738
739     hr = IStream_Read(pStm, &len, sizeof(len), &read);
740     if (FAILED(hr)) return hr;
741     if (read != sizeof(len)) return STG_E_READFAULT;
742
743     TRACE("read len %d\n", len);
744
745     str = heap_alloc(len * sizeof(WCHAR));
746     if (!str) return E_OUTOFMEMORY;
747
748     hr = IStream_Read(pStm, str, len * sizeof(WCHAR), &read);
749     if (FAILED(hr))
750     {
751         heap_free(str);
752         return hr;
753     }
754     if (read != len * sizeof(WCHAR))
755     {
756         heap_free(str);
757         return STG_E_READFAULT;
758     }
759     TRACE("read string %s\n", debugstr_w(str));
760
761     *out_str = str;
762     return S_OK;
763 }
764
765 static HRESULT WINAPI IPersistStream_fnLoad(IPersistStream* iface,
766         IStream* pStm)
767 {
768     HRESULT r;
769     DWORD hdr[2];
770     DWORD read;
771     HlinkImpl *This = impl_from_IPersistStream(iface);
772
773     r = IStream_Read(pStm, hdr, sizeof(hdr), &read);
774     if (read != sizeof(hdr) || (hdr[0] != HLINK_SAVE_MAGIC))
775     {
776         r = E_FAIL;
777         goto end;
778     }
779     if (hdr[1] & ~HLINK_SAVE_ALL)
780         FIXME("unknown flag(s) 0x%x\n", hdr[1] & ~HLINK_SAVE_ALL);
781
782     if (hdr[1] & HLINK_SAVE_TARGET_FRAME_PRESENT)
783     {
784         TRACE("loading target frame name\n");
785         r = read_hlink_string(pStm, &This->TargetFrameName);
786         if (FAILED(r)) goto end;
787     }
788
789     if (hdr[1] & HLINK_SAVE_FRIENDLY_PRESENT)
790     {
791         TRACE("loading target friendly name\n");
792         if (!(hdr[1] & 0x4))
793             FIXME("0x4 flag not present with friendly name flag - not sure what this means\n");
794         r = read_hlink_string(pStm, &This->FriendlyName);
795         if (FAILED(r)) goto end;
796     }
797
798     if (hdr[1] & HLINK_SAVE_MONIKER_PRESENT)
799     {
800         TRACE("loading moniker\n");
801         r = OleLoadFromStream(pStm, &IID_IMoniker, (LPVOID*)&(This->Moniker));
802         if (FAILED(r))
803             goto end;
804         This->absolute = (hdr[1] & HLINK_SAVE_MONIKER_IS_ABSOLUTE) != 0;
805     }
806
807     if (hdr[1] & HLINK_SAVE_LOCATION_PRESENT)
808     {
809         TRACE("loading location\n");
810         r = read_hlink_string(pStm, &This->Location);
811         if (FAILED(r)) goto end;
812     }
813
814 end:
815     TRACE("Load Result 0x%x (%p)\n", r, This->Moniker);
816
817     return r;
818 }
819
820 static HRESULT WINAPI IPersistStream_fnSave(IPersistStream* iface,
821         IStream* pStm, BOOL fClearDirty)
822 {
823     HRESULT r;
824     HlinkImpl *This = impl_from_IPersistStream(iface);
825     DWORD hdr[2];
826     IMoniker *moniker;
827
828     TRACE("(%p) Moniker(%p)\n", This, This->Moniker);
829
830     r = __GetMoniker(This, &moniker, HLINKGETREF_DEFAULT);
831     if (FAILED(r))
832         return r;
833     r = E_FAIL;
834
835     hdr[0] = HLINK_SAVE_MAGIC;
836     hdr[1] = 0;
837
838     if (moniker)
839         hdr[1] |= HLINK_SAVE_MONIKER_PRESENT;
840     if (This->absolute)
841         hdr[1] |= HLINK_SAVE_MONIKER_IS_ABSOLUTE;
842     if (This->Location)
843         hdr[1] |= HLINK_SAVE_LOCATION_PRESENT;
844     if (This->FriendlyName)
845         hdr[1] |= HLINK_SAVE_FRIENDLY_PRESENT | 4 /* FIXME */;
846     if (This->TargetFrameName)
847         hdr[1] |= HLINK_SAVE_TARGET_FRAME_PRESENT;
848
849     IStream_Write(pStm, hdr, sizeof(hdr), NULL);
850
851     if (This->TargetFrameName)
852     {
853         r = write_hlink_string(pStm, This->TargetFrameName);
854         if (FAILED(r)) goto end;
855     }
856
857     if (This->FriendlyName)
858     {
859         r = write_hlink_string(pStm, This->FriendlyName);
860         if (FAILED(r)) goto end;
861     }
862
863     if (moniker)
864     {
865         IPersistStream* monstream;
866
867         monstream = NULL;
868         IMoniker_QueryInterface(moniker, &IID_IPersistStream,
869                 (LPVOID*)&monstream);
870         if (monstream)
871         {
872             r = OleSaveToStream(monstream, pStm);
873             IPersistStream_Release(monstream);
874         }
875         if (FAILED(r)) goto end;
876     }
877
878     if (This->Location)
879     {
880         r = write_hlink_string(pStm, This->Location);
881         if (FAILED(r)) goto end;
882     }
883
884 end:
885     if (moniker) IMoniker_Release(moniker);
886     TRACE("Save Result 0x%x\n", r);
887
888     return r;
889 }
890
891 static HRESULT WINAPI IPersistStream_fnGetSizeMax(IPersistStream* iface,
892         ULARGE_INTEGER* pcbSize)
893 {
894     HRESULT r;
895     HlinkImpl *This = impl_from_IPersistStream(iface);
896     IMoniker *moniker;
897
898     TRACE("(%p) Moniker(%p)\n", This, This->Moniker);
899
900     pcbSize->QuadPart = sizeof(DWORD)*2;
901
902     if (This->TargetFrameName)
903         pcbSize->QuadPart += size_hlink_string(This->TargetFrameName);
904
905     if (This->FriendlyName)
906         pcbSize->QuadPart += size_hlink_string(This->FriendlyName);
907
908     r = __GetMoniker(This, &moniker, HLINKGETREF_DEFAULT);
909     if (FAILED(r))
910         return r;
911     r = E_FAIL;
912
913     if (moniker)
914     {
915         IPersistStream* monstream = NULL;
916         IMoniker_QueryInterface(moniker, &IID_IPersistStream,
917                 (LPVOID*)&monstream);
918         if (monstream)
919         {
920             ULARGE_INTEGER mon_size;
921             r = IPersistStream_GetSizeMax(monstream, &mon_size);
922             pcbSize->QuadPart += mon_size.QuadPart;
923             IPersistStream_Release(monstream);
924         }
925         IMoniker_Release(moniker);
926     }
927
928     if (This->Location)
929         pcbSize->QuadPart += size_hlink_string(This->Location);
930
931     return r;
932 }
933
934 static const IPersistStreamVtbl psvt =
935 {
936     IPersistStream_fnQueryInterface,
937     IPersistStream_fnAddRef,
938     IPersistStream_fnRelease,
939     IPersistStream_fnGetClassID,
940     IPersistStream_fnIsDirty,
941     IPersistStream_fnLoad,
942     IPersistStream_fnSave,
943     IPersistStream_fnGetSizeMax,
944 };
945
946 HRESULT HLink_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
947 {
948     HlinkImpl * hl;
949
950     TRACE("unkOut=%p riid=%s\n", pUnkOuter, debugstr_guid(riid));
951     *ppv = NULL;
952
953     if (pUnkOuter)
954         return CLASS_E_NOAGGREGATION;
955
956     hl = heap_alloc_zero(sizeof(HlinkImpl));
957     if (!hl)
958         return E_OUTOFMEMORY;
959
960     hl->ref = 1;
961     hl->IHlink_iface.lpVtbl = &hlvt;
962     hl->IPersistStream_iface.lpVtbl = &psvt;
963     hl->IDataObject_iface.lpVtbl = &dovt;
964
965     *ppv = hl;
966     return S_OK;
967 }