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