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