dlls/shdocvw/navigate.c

   1 /*
   2  * Copyright 2006-2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define NONAMELESSUNION
  20 #define NONAMELESSSTRUCT
  21
  22 #include "wine/debug.h"
  23
  24 #include "shdocvw.h"
  25 #include "exdispid.h"
  26 #include "shellapi.h"
  27 #include "winreg.h"
  28 #include "shlwapi.h"
  29 #include "wininet.h"
  30 #include "mshtml.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(shdocvw);
  33
  34 static const WCHAR emptyW[] = {0};
  35
  36 typedef struct {
  37     IBindStatusCallback  IBindStatusCallback_iface;
  38     IHttpNegotiate       IHttpNegotiate_iface;
  39
  40     LONG ref;
  41
  42     DocHost *doc_host;
  43     IBinding *binding;
  44
  45     LPWSTR url;
  46     HGLOBAL post_data;
  47     BSTR headers;
  48     ULONG post_data_len;
  49 } BindStatusCallback;
  50
  51 static void dump_BINDINFO(BINDINFO *bi)
  52 {
  53     static const char * const BINDINFOF_str[] = {
  54         "#0",
  55         "BINDINFOF_URLENCODESTGMEDDATA",
  56         "BINDINFOF_URLENCODEDEXTRAINFO"
  57     };
  58
  59     static const char * const BINDVERB_str[] = {
  60         "BINDVERB_GET",
  61         "BINDVERB_POST",
  62         "BINDVERB_PUT",
  63         "BINDVERB_CUSTOM"
  64     };
  65
  66     TRACE("\n"
  67             "BINDINFO = {\n"
  68             "    %d, %s,\n"
  69             "    {%d, %p, %p},\n"
  70             "    %s,\n"
  71             "    %s,\n"
  72             "    %s,\n"
  73             "    %d, %08x, %d, %d\n"
  74             "    {%d %p %x},\n"
  75             "    %s\n"
  76             "    %p, %d\n"
  77             "}\n",
  78
  79             bi->cbSize, debugstr_w(bi->szExtraInfo),
  80             bi->stgmedData.tymed, bi->stgmedData.u.hGlobal, bi->stgmedData.pUnkForRelease,
  81             bi->grfBindInfoF > BINDINFOF_URLENCODEDEXTRAINFO
  82                 ? "unknown" : BINDINFOF_str[bi->grfBindInfoF],
  83             bi->dwBindVerb > BINDVERB_CUSTOM
  84                 ? "unknown" : BINDVERB_str[bi->dwBindVerb],
  85             debugstr_w(bi->szCustomVerb),
  86             bi->cbstgmedData, bi->dwOptions, bi->dwOptionsFlags, bi->dwCodePage,
  87             bi->securityAttributes.nLength,
  88             bi->securityAttributes.lpSecurityDescriptor,
  89             bi->securityAttributes.bInheritHandle,
  90             debugstr_guid(&bi->iid),
  91             bi->pUnk, bi->dwReserved
  92             );
  93 }
  94
  95 static void set_status_text(BindStatusCallback *This, LPCWSTR str)
  96 {
  97     VARIANTARG arg;
  98     DISPPARAMS dispparams = {&arg, NULL, 1, 0};
  99
 100     if(!This->doc_host)
 101         return;
 102
 103     V_VT(&arg) = VT_BSTR;
 104     V_BSTR(&arg) = str ? SysAllocString(str) : NULL;
 105     call_sink(This->doc_host->cps.wbe2, DISPID_STATUSTEXTCHANGE, &dispparams);
 106     VariantClear(&arg);
 107
 108     if(This->doc_host->frame)
 109         IOleInPlaceFrame_SetStatusText(This->doc_host->frame, str);
 110 }
 111
 112 static HRESULT set_dochost_url(DocHost *This, const WCHAR *url)
 113 {
 114     WCHAR *new_url;
 115
 116     if(url) {
 117         new_url = heap_strdupW(url);
 118         if(!new_url)
 119             return E_OUTOFMEMORY;
 120     }else {
 121         new_url = NULL;
 122     }
 123
 124     heap_free(This->url);
 125     This->url = new_url;
 126
 127     This->container_vtbl->SetURL(This, This->url);
 128     return S_OK;
 129 }
 130
 131 static inline BindStatusCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
 132 {
 133     return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface);
 134 }
 135
 136 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
 137                                                         REFIID riid, void **ppv)
 138 {
 139     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 140
 141     if(IsEqualGUID(&IID_IUnknown, riid)) {
 142         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 143         *ppv = &This->IBindStatusCallback_iface;
 144     }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
 145         TRACE("(%p)->(IID_IBindStatusCallback %p)\n", This, ppv);
 146         *ppv = &This->IBindStatusCallback_iface;
 147     }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
 148         TRACE("(%p)->(IID_IHttpNegotiate %p)\n", This, ppv);
 149         *ppv = &This->IHttpNegotiate_iface;
 150     }else {
 151         *ppv = NULL;
 152         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 153         return E_NOINTERFACE;
 154     }
 155
 156     IUnknown_AddRef((IUnknown*)*ppv);
 157     return S_OK;
 158 }
 159
 160 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
 161 {
 162     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 163     LONG ref = InterlockedIncrement(&This->ref);
 164
 165     TRACE("(%p) ref=%d\n", This, ref);
 166
 167     return ref;
 168 }
 169
 170 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
 171 {
 172     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 173     LONG ref = InterlockedDecrement(&This->ref);
 174
 175     TRACE("(%p) ref=%d\n", This, ref);
 176
 177     if(!ref) {
 178         if(This->doc_host)
 179             IOleClientSite_Release(&This->doc_host->IOleClientSite_iface);
 180         if(This->binding)
 181             IBinding_Release(This->binding);
 182         if(This->post_data)
 183             GlobalFree(This->post_data);
 184         SysFreeString(This->headers);
 185         heap_free(This->url);
 186         heap_free(This);
 187     }
 188
 189     return ref;
 190 }
 191
 192 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
 193        DWORD dwReserved, IBinding *pbind)
 194 {
 195     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 196
 197     TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
 198
 199     This->binding = pbind;
 200     IBinding_AddRef(This->binding);
 201
 202     return S_OK;
 203 }
 204
 205 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface,
 206        LONG *pnPriority)
 207 {
 208     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 209     FIXME("(%p)->(%p)\n", This, pnPriority);
 210     return E_NOTIMPL;
 211 }
 212
 213 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface,
 214        DWORD reserved)
 215 {
 216     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 217     FIXME("(%p)->(%d)\n", This, reserved);
 218     return E_NOTIMPL;
 219 }
 220
 221 static DWORD get_http_status_code(IBinding *binding)
 222 {
 223     IWinInetHttpInfo *http_info;
 224     DWORD status, size = sizeof(DWORD);
 225     HRESULT hres;
 226
 227     hres = IBinding_QueryInterface(binding, &IID_IWinInetHttpInfo, (void**)&http_info);
 228     if(FAILED(hres))
 229         return HTTP_STATUS_OK;
 230
 231     hres = IWinInetHttpInfo_QueryInfo(http_info, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER,
 232             &status, &size, NULL, NULL);
 233     IWinInetHttpInfo_Release(http_info);
 234
 235     if(FAILED(hres))
 236         return HTTP_STATUS_OK;
 237     return status;
 238 }
 239
 240 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface,
 241         ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 242 {
 243     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 244     DWORD status_code;
 245
 246     TRACE("(%p)->(%d %d %d %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 247           debugstr_w(szStatusText));
 248
 249     switch(ulStatusCode) {
 250     case BINDSTATUS_REDIRECTING:
 251         return set_dochost_url(This->doc_host, szStatusText);
 252     case BINDSTATUS_BEGINDOWNLOADDATA:
 253         set_status_text(This, szStatusText); /* FIXME: "Start downloading from site: %s" */
 254         status_code = get_http_status_code(This->binding);
 255         if(status_code != HTTP_STATUS_OK)
 256             handle_navigation_error(This->doc_host, status_code, This->url, NULL);
 257         return S_OK;
 258     case BINDSTATUS_ENDDOWNLOADDATA:
 259         set_status_text(This, szStatusText); /* FIXME: "Downloading from site: %s" */
 260         return S_OK;
 261     case BINDSTATUS_CLASSIDAVAILABLE:
 262     case BINDSTATUS_MIMETYPEAVAILABLE:
 263     case BINDSTATUS_BEGINSYNCOPERATION:
 264     case BINDSTATUS_ENDSYNCOPERATION:
 265         return S_OK;
 266     default:
 267         FIXME("status code %u\n", ulStatusCode);
 268     }
 269
 270     return S_OK;
 271 }
 272
 273 void handle_navigation_error(DocHost* doc_host, HRESULT hres, BSTR url, IHTMLWindow2 *win2)
 274 {
 275     VARIANT var_status_code, var_frame_name, var_url;
 276     DISPPARAMS dispparams;
 277     VARIANTARG params[5];
 278     VARIANT_BOOL cancel = VARIANT_FALSE;
 279
 280     dispparams.cArgs = 5;
 281     dispparams.cNamedArgs = 0;
 282     dispparams.rgdispidNamedArgs = NULL;
 283     dispparams.rgvarg = params;
 284
 285     V_VT(params) = VT_BOOL|VT_BYREF;
 286     V_BOOLREF(params) = &cancel;
 287
 288     V_VT(params+1) = VT_VARIANT|VT_BYREF;
 289     V_VARIANTREF(params+1) = &var_status_code;
 290     V_VT(&var_status_code) = VT_I4;
 291     V_I4(&var_status_code) = hres;
 292
 293     V_VT(params+2) = VT_VARIANT|VT_BYREF;
 294     V_VARIANTREF(params+2) = &var_frame_name;
 295     V_VT(&var_frame_name) = VT_BSTR;
 296     if(win2) {
 297         hres = IHTMLWindow2_get_name(win2, &V_BSTR(&var_frame_name));
 298         if(FAILED(hres))
 299             V_BSTR(&var_frame_name) = NULL;
 300     } else
 301         V_BSTR(&var_frame_name) = NULL;
 302
 303     V_VT(params+3) = VT_VARIANT|VT_BYREF;
 304     V_VARIANTREF(params+3) = &var_url;
 305     V_VT(&var_url) = VT_BSTR;
 306     V_BSTR(&var_url) = url;
 307
 308     V_VT(params+4) = VT_DISPATCH;
 309     V_DISPATCH(params+4) = doc_host->disp;
 310
 311     call_sink(doc_host->cps.wbe2, DISPID_NAVIGATEERROR, &dispparams);
 312     SysFreeString(V_BSTR(&var_frame_name));
 313
 314     if(!cancel)
 315         FIXME("Navigate to error page\n");
 316 }
 317
 318 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
 319         HRESULT hresult, LPCWSTR szError)
 320 {
 321     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 322
 323     TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
 324
 325     set_status_text(This, emptyW);
 326
 327     if(!This->doc_host)
 328         return S_OK;
 329
 330     if(FAILED(hresult))
 331         handle_navigation_error(This->doc_host, hresult, This->url, NULL);
 332
 333     IOleClientSite_Release(&This->doc_host->IOleClientSite_iface);
 334     This->doc_host = NULL;
 335
 336     IBinding_Release(This->binding);
 337     This->binding = NULL;
 338
 339     return S_OK;
 340 }
 341
 342 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
 343         DWORD *grfBINDF, BINDINFO *pbindinfo)
 344 {
 345     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 346
 347     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 348
 349     *grfBINDF = BINDF_ASYNCHRONOUS;
 350
 351     if(This->post_data) {
 352         pbindinfo->dwBindVerb = BINDVERB_POST;
 353
 354         pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
 355         pbindinfo->stgmedData.u.hGlobal = This->post_data;
 356         pbindinfo->cbstgmedData = This->post_data_len;
 357         pbindinfo->stgmedData.pUnkForRelease = (IUnknown*)&This->IBindStatusCallback_iface;
 358         IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 359     }
 360
 361     return S_OK;
 362 }
 363
 364 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
 365         DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
 366 {
 367     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 368     FIXME("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
 369     return E_NOTIMPL;
 370 }
 371
 372 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
 373         REFIID riid, IUnknown *punk)
 374 {
 375     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 376
 377     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
 378
 379     return dochost_object_available(This->doc_host, punk);
 380 }
 381
 382 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 383     BindStatusCallback_QueryInterface,
 384     BindStatusCallback_AddRef,
 385     BindStatusCallback_Release,
 386     BindStatusCallback_OnStartBinding,
 387     BindStatusCallback_GetPriority,
 388     BindStatusCallback_OnLowResource,
 389     BindStatusCallback_OnProgress,
 390     BindStatusCallback_OnStopBinding,
 391     BindStatusCallback_GetBindInfo,
 392     BindStatusCallback_OnDataAvailable,
 393     BindStatusCallback_OnObjectAvailable
 394 };
 395
 396 static inline BindStatusCallback *impl_from_IHttpNegotiate(IHttpNegotiate *iface)
 397 {
 398     return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface);
 399 }
 400
 401 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate *iface,
 402                                                    REFIID riid, void **ppv)
 403 {
 404     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 405     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 406 }
 407
 408 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate *iface)
 409 {
 410     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 411     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 412 }
 413
 414 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate *iface)
 415 {
 416     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 417     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 418 }
 419
 420 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate *iface,
 421         LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
 422 {
 423     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 424
 425     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders),
 426           dwReserved, pszAdditionalHeaders);
 427
 428     if(This->headers) {
 429         int size = (strlenW(This->headers)+1)*sizeof(WCHAR);
 430         *pszAdditionalHeaders = CoTaskMemAlloc(size);
 431         memcpy(*pszAdditionalHeaders, This->headers, size);
 432     }
 433
 434     return S_OK;
 435 }
 436
 437 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate *iface,
 438         DWORD dwResponseCode, LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders,
 439         LPWSTR *pszAdditionalRequestHeaders)
 440 {
 441     BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
 442     TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders),
 443           debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
 444     return S_OK;
 445 }
 446
 447 static const IHttpNegotiateVtbl HttpNegotiateVtbl = {
 448     HttpNegotiate_QueryInterface,
 449     HttpNegotiate_AddRef,
 450     HttpNegotiate_Release,
 451     HttpNegotiate_BeginningTransaction,
 452     HttpNegotiate_OnResponse
 453 };
 454
 455 static BindStatusCallback *create_callback(DocHost *doc_host, LPCWSTR url, PBYTE post_data,
 456         ULONG post_data_len, LPCWSTR headers)
 457 {
 458     BindStatusCallback *ret = heap_alloc(sizeof(BindStatusCallback));
 459
 460     ret->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
 461     ret->IHttpNegotiate_iface.lpVtbl      = &HttpNegotiateVtbl;
 462
 463     ret->ref = 1;
 464     ret->url = heap_strdupW(url);
 465     ret->post_data = NULL;
 466     ret->post_data_len = post_data_len;
 467     ret->headers = headers ? SysAllocString(headers) : NULL;
 468
 469     ret->doc_host = doc_host;
 470     IOleClientSite_AddRef(&doc_host->IOleClientSite_iface);
 471
 472     ret->binding = NULL;
 473
 474     if(post_data) {
 475         ret->post_data = GlobalAlloc(0, post_data_len);
 476         memcpy(ret->post_data, post_data, post_data_len);
 477     }
 478
 479     return ret;
 480 }
 481
 482 static void on_before_navigate2(DocHost *This, LPCWSTR url, SAFEARRAY *post_data, LPWSTR headers, VARIANT_BOOL *cancel)
 483 {
 484     VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
 485     DISPPARAMS dispparams;
 486     VARIANTARG params[7];
 487
 488     dispparams.cArgs = 7;
 489     dispparams.cNamedArgs = 0;
 490     dispparams.rgdispidNamedArgs = NULL;
 491     dispparams.rgvarg = params;
 492
 493     This->busy = VARIANT_TRUE;
 494
 495     V_VT(params) = VT_BOOL|VT_BYREF;
 496     V_BOOLREF(params) = cancel;
 497
 498     V_VT(params+1) = (VT_BYREF|VT_VARIANT);
 499     V_VARIANTREF(params+1) = &var_headers;
 500     V_VT(&var_headers) = VT_BSTR;
 501     V_BSTR(&var_headers) = headers;
 502
 503     V_VT(params+2) = (VT_BYREF|VT_VARIANT);
 504     V_VARIANTREF(params+2) = &var_post_data2;
 505     V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
 506     V_VARIANTREF(&var_post_data2) = &var_post_data;
 507
 508     if(post_data) {
 509         V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
 510         V_ARRAY(&var_post_data) = post_data;
 511     }else {
 512         V_VT(&var_post_data) = VT_EMPTY;
 513     }
 514
 515     V_VT(params+3) = (VT_BYREF|VT_VARIANT);
 516     V_VARIANTREF(params+3) = &var_frame_name;
 517     V_VT(&var_frame_name) = VT_BSTR;
 518     V_BSTR(&var_frame_name) = NULL;
 519
 520     V_VT(params+4) = (VT_BYREF|VT_VARIANT);
 521     V_VARIANTREF(params+4) = &var_flags;
 522     V_VT(&var_flags) = VT_I4;
 523     V_I4(&var_flags) = 0;
 524
 525     V_VT(params+5) = (VT_BYREF|VT_VARIANT);
 526     V_VARIANTREF(params+5) = &var_url;
 527     V_VT(&var_url) = VT_BSTR;
 528     V_BSTR(&var_url) = SysAllocString(url);
 529
 530     V_VT(params+6) = (VT_DISPATCH);
 531     V_DISPATCH(params+6) = This->disp;
 532
 533     call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams);
 534
 535     SysFreeString(V_BSTR(&var_url));
 536 }
 537
 538 /* FIXME: urlmon should handle it */
 539 static BOOL try_application_url(LPCWSTR url)
 540 {
 541     SHELLEXECUTEINFOW exec_info;
 542     WCHAR app[64];
 543     HKEY hkey;
 544     DWORD res, type;
 545     HRESULT hres;
 546
 547     static const WCHAR wszURLProtocol[] = {'U','R','L',' ','P','r','o','t','o','c','o','l',0};
 548
 549     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, app, sizeof(app)/sizeof(WCHAR), NULL, 0);
 550     if(FAILED(hres))
 551         return FALSE;
 552
 553     res = RegOpenKeyW(HKEY_CLASSES_ROOT, app, &hkey);
 554     if(res != ERROR_SUCCESS)
 555         return FALSE;
 556
 557     res = RegQueryValueExW(hkey, wszURLProtocol, NULL, &type, NULL, NULL);
 558     RegCloseKey(hkey);
 559     if(res != ERROR_SUCCESS || type != REG_SZ)
 560         return FALSE;
 561
 562     TRACE("openning application %s\n", debugstr_w(app));
 563
 564     memset(&exec_info, 0, sizeof(exec_info));
 565     exec_info.cbSize = sizeof(exec_info);
 566     exec_info.lpFile = url;
 567     exec_info.nShow = SW_SHOW;
 568
 569     return ShellExecuteExW(&exec_info);
 570 }
 571
 572 static HRESULT create_moniker(LPCWSTR url, IMoniker **mon)
 573 {
 574     WCHAR new_url[INTERNET_MAX_URL_LENGTH];
 575     DWORD size;
 576     HRESULT hres;
 577
 578     if(PathIsURLW(url))
 579         return CreateURLMoniker(NULL, url, mon);
 580
 581     size = sizeof(new_url)/sizeof(WCHAR);
 582     hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE);
 583     TRACE("was %s got %s\n", debugstr_w(url), debugstr_w(new_url));
 584     if(FAILED(hres)) {
 585         WARN("UrlApplyScheme failed: %08x\n", hres);
 586         return hres;
 587     }
 588
 589     return CreateURLMoniker(NULL, new_url, mon);
 590 }
 591
 592 static HRESULT bind_to_object(DocHost *This, IMoniker *mon, LPCWSTR url, IBindCtx *bindctx,
 593                               IBindStatusCallback *callback)
 594 {
 595     IUnknown *unk = NULL;
 596     WCHAR *display_name;
 597     HRESULT hres;
 598
 599     if(mon) {
 600         IMoniker_AddRef(mon);
 601     }else {
 602         hres = create_moniker(url, &mon);
 603         if(FAILED(hres))
 604             return hres;
 605     }
 606
 607     hres = IMoniker_GetDisplayName(mon, 0, NULL, &display_name);
 608     if(FAILED(hres)) {
 609         FIXME("GetDisplayName failed: %08x\n", hres);
 610         return hres;
 611     }
 612
 613     hres = set_dochost_url(This, display_name);
 614     CoTaskMemFree(display_name);
 615     if(FAILED(hres))
 616         return hres;
 617
 618     IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM,
 619                                  (IUnknown*)&This->IOleClientSite_iface);
 620
 621     hres = IMoniker_BindToObject(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
 622     if(SUCCEEDED(hres)) {
 623         hres = S_OK;
 624         if(unk)
 625             IUnknown_Release(unk);
 626     }else if(try_application_url(url)) {
 627         hres = S_OK;
 628     }else {
 629         FIXME("BindToObject failed: %08x\n", hres);
 630     }
 631
 632     IMoniker_Release(mon);
 633     return S_OK;
 634 }
 635
 636 static void html_window_navigate(DocHost *This, IHTMLPrivateWindow *window, BSTR url, BSTR headers, SAFEARRAY *post_data)
 637 {
 638     VARIANT headers_var, post_data_var;
 639     BSTR empty_str;
 640     HRESULT hres;
 641
 642     hres = set_dochost_url(This, url);
 643     if(FAILED(hres))
 644         return;
 645
 646     empty_str = SysAllocStringLen(NULL, 0);
 647
 648     if(headers) {
 649         V_VT(&headers_var) = VT_BSTR;
 650         V_BSTR(&headers_var) = headers;
 651     }else {
 652         V_VT(&headers_var) = VT_EMPTY;
 653     }
 654
 655     if(post_data) {
 656         V_VT(&post_data_var) = VT_UI1|VT_ARRAY;
 657         V_ARRAY(&post_data_var) = post_data;
 658     }else {
 659         V_VT(&post_data_var) = VT_EMPTY;
 660     }
 661
 662     set_doc_state(This, READYSTATE_LOADING);
 663     hres = IHTMLPrivateWindow_SuperNavigate(window, url, empty_str, NULL, NULL, &post_data_var, &headers_var, 0);
 664     SysFreeString(empty_str);
 665     if(FAILED(hres))
 666         WARN("SuprtNavigate failed: %08x\n", hres);
 667 }
 668
 669 typedef struct {
 670     task_header_t header;
 671     BSTR url;
 672     BSTR headers;
 673     SAFEARRAY *post_data;
 674     BOOL async_notif;
 675 } task_doc_navigate_t;
 676
 677 static HRESULT free_doc_navigate_task(task_doc_navigate_t *task, BOOL free_task)
 678 {
 679     SysFreeString(task->url);
 680     SysFreeString(task->headers);
 681     if(task->post_data)
 682         SafeArrayDestroy(task->post_data);
 683     if(free_task)
 684         heap_free(task);
 685     return E_OUTOFMEMORY;
 686 }
 687
 688 static void doc_navigate_proc(DocHost *This, task_header_t *t)
 689 {
 690     task_doc_navigate_t *task = (task_doc_navigate_t*)t;
 691     IHTMLPrivateWindow *priv_window;
 692     HRESULT hres;
 693
 694     if(!This->doc_navigate)
 695         return;
 696
 697     if(task->async_notif) {
 698         VARIANT_BOOL cancel = VARIANT_FALSE;
 699         on_before_navigate2(This, task->url, task->post_data, task->headers, &cancel);
 700         if(cancel) {
 701             TRACE("Navigation calnceled\n");
 702             free_doc_navigate_task(task, FALSE);
 703             return;
 704         }
 705     }
 706
 707     hres = IUnknown_QueryInterface(This->doc_navigate, &IID_IHTMLPrivateWindow, (void**)&priv_window);
 708     if(SUCCEEDED(hres)) {
 709         html_window_navigate(This, priv_window, task->url, task->headers, task->post_data);
 710         IHTMLPrivateWindow_Release(priv_window);
 711     }else {
 712         WARN("Could not get IHTMLPrivateWindow iface: %08x\n", hres);
 713     }
 714
 715     free_doc_navigate_task(task, FALSE);
 716 }
 717
 718 static HRESULT async_doc_navigate(DocHost *This, LPCWSTR url, LPCWSTR headers, PBYTE post_data, ULONG post_data_size,
 719         BOOL async_notif)
 720 {
 721     task_doc_navigate_t *task;
 722
 723     task = heap_alloc_zero(sizeof(*task));
 724     if(!task)
 725         return E_OUTOFMEMORY;
 726
 727     task->url = SysAllocString(url);
 728     if(!task->url)
 729         return free_doc_navigate_task(task, TRUE);
 730
 731     if(headers) {
 732         task->headers = SysAllocString(headers);
 733         if(!task->headers)
 734             return free_doc_navigate_task(task, TRUE);
 735     }
 736
 737     if(post_data) {
 738         task->post_data = SafeArrayCreateVector(VT_UI1, 0, post_data_size);
 739         if(!task->post_data)
 740             return free_doc_navigate_task(task, TRUE);
 741         memcpy(task->post_data->pvData, post_data, post_data_size);
 742     }
 743
 744     if(!async_notif) {
 745         VARIANT_BOOL cancel = VARIANT_FALSE;
 746
 747         on_before_navigate2(This, task->url, task->post_data, task->headers, &cancel);
 748         if(cancel) {
 749             TRACE("Navigation calnceled\n");
 750             free_doc_navigate_task(task, TRUE);
 751             return S_OK;
 752         }
 753     }
 754
 755     task->async_notif = async_notif;
 756     push_dochost_task(This, &task->header, doc_navigate_proc, FALSE);
 757     return S_OK;
 758 }
 759
 760 static HRESULT navigate_bsc(DocHost *This, BindStatusCallback *bsc, IMoniker *mon)
 761 {
 762     VARIANT_BOOL cancel = VARIANT_FALSE;
 763     SAFEARRAY *post_data = NULL;
 764     IBindCtx *bindctx;
 765     HRESULT hres;
 766
 767     set_doc_state(This, READYSTATE_LOADING);
 768
 769     if(bsc->post_data) {
 770         post_data = SafeArrayCreateVector(VT_UI1, 0, bsc->post_data_len);
 771         memcpy(post_data->pvData, post_data, bsc->post_data_len);
 772     }
 773
 774     on_before_navigate2(This, bsc->url, post_data, bsc->headers, &cancel);
 775     if(post_data)
 776         SafeArrayDestroy(post_data);
 777     if(cancel) {
 778         FIXME("Navigation canceled\n");
 779         return S_OK;
 780     }
 781
 782     if(This->document)
 783         deactivate_document(This);
 784
 785     CreateAsyncBindCtx(0, &bsc->IBindStatusCallback_iface, 0, &bindctx);
 786
 787     if(This->frame)
 788         IOleInPlaceFrame_EnableModeless(This->frame, FALSE);
 789
 790     hres = bind_to_object(This, mon, bsc->url, bindctx, &bsc->IBindStatusCallback_iface);
 791
 792     if(This->frame)
 793         IOleInPlaceFrame_EnableModeless(This->frame, TRUE);
 794
 795     IBindCtx_Release(bindctx);
 796
 797     return hres;
 798 }
 799
 800 typedef struct {
 801     task_header_t header;
 802     BindStatusCallback *bsc;
 803 } task_navigate_bsc_t;
 804
 805 static void navigate_bsc_proc(DocHost *This, task_header_t *t)
 806 {
 807     task_navigate_bsc_t *task = (task_navigate_bsc_t*)t;
 808
 809     if(!This->hwnd)
 810         create_doc_view_hwnd(This);
 811
 812     navigate_bsc(This, task->bsc, NULL);
 813
 814     IBindStatusCallback_Release(&task->bsc->IBindStatusCallback_iface);
 815 }
 816
 817
 818 HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags,
 819                      const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
 820 {
 821     PBYTE post_data = NULL;
 822     ULONG post_data_len = 0;
 823     LPWSTR headers = NULL;
 824     HRESULT hres = S_OK;
 825
 826     TRACE("navigating to %s\n", debugstr_w(url));
 827
 828     if((Flags && V_VT(Flags) != VT_EMPTY)
 829        || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY))
 830         FIXME("Unsupported args (Flags %p:%d; TargetFrameName %p:%d)\n",
 831                 Flags, Flags ? V_VT(Flags) : -1, TargetFrameName,
 832                 TargetFrameName ? V_VT(TargetFrameName) : -1);
 833
 834     if(PostData && V_VT(PostData) == (VT_ARRAY | VT_UI1) && V_ARRAY(PostData)) {
 835         SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data);
 836         post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements;
 837     }
 838
 839     if(Headers && V_VT(Headers) == VT_BSTR) {
 840         headers = V_BSTR(Headers);
 841         TRACE("Headers: %s\n", debugstr_w(headers));
 842     }
 843
 844     set_doc_state(This, READYSTATE_LOADING);
 845     This->ready_state = READYSTATE_LOADING;
 846
 847     if(This->doc_navigate) {
 848         WCHAR new_url[INTERNET_MAX_URL_LENGTH];
 849
 850         if(PathIsURLW(url)) {
 851             new_url[0] = 0;
 852         }else {
 853             DWORD size;
 854
 855             size = sizeof(new_url)/sizeof(WCHAR);
 856             hres = UrlApplySchemeW(url, new_url, &size,
 857                     URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT);
 858             if(FAILED(hres)) {
 859                 WARN("UrlApplyScheme failed: %08x\n", hres);
 860                 new_url[0] = 0;
 861             }
 862         }
 863
 864         hres = async_doc_navigate(This, *new_url ? new_url : url, headers, post_data,
 865                 post_data_len, TRUE);
 866     }else {
 867         task_navigate_bsc_t *task;
 868
 869         task = heap_alloc(sizeof(*task));
 870         task->bsc = create_callback(This, url, post_data, post_data_len, headers);
 871         push_dochost_task(This, &task->header, navigate_bsc_proc, This->url == NULL);
 872     }
 873
 874     if(post_data)
 875         SafeArrayUnaccessData(V_ARRAY(PostData));
 876
 877     return hres;
 878 }
 879
 880 static HRESULT navigate_hlink(DocHost *This, IMoniker *mon, IBindCtx *bindctx,
 881                               IBindStatusCallback *callback)
 882 {
 883     IHttpNegotiate *http_negotiate;
 884     BindStatusCallback *bsc;
 885     PBYTE post_data = NULL;
 886     ULONG post_data_len = 0;
 887     LPWSTR headers = NULL, url;
 888     BINDINFO bindinfo;
 889     DWORD bindf = 0;
 890     HRESULT hres;
 891
 892     hres = IMoniker_GetDisplayName(mon, 0, NULL, &url);
 893     if(FAILED(hres))
 894         FIXME("GetDisplayName failed: %08x\n", hres);
 895
 896     hres = IBindStatusCallback_QueryInterface(callback, &IID_IHttpNegotiate,
 897                                               (void**)&http_negotiate);
 898     if(SUCCEEDED(hres)) {
 899         static const WCHAR null_string[] = {0};
 900
 901         IHttpNegotiate_BeginningTransaction(http_negotiate, null_string, null_string, 0,
 902                                             &headers);
 903         IHttpNegotiate_Release(http_negotiate);
 904     }
 905
 906     memset(&bindinfo, 0, sizeof(bindinfo));
 907     bindinfo.cbSize = sizeof(bindinfo);
 908
 909     hres = IBindStatusCallback_GetBindInfo(callback, &bindf, &bindinfo);
 910     dump_BINDINFO(&bindinfo);
 911     if(bindinfo.dwBindVerb == BINDVERB_POST) {
 912         post_data_len = bindinfo.cbstgmedData;
 913         if(post_data_len)
 914             post_data = bindinfo.stgmedData.u.hGlobal;
 915     }
 916
 917     if(This->doc_navigate) {
 918         hres = async_doc_navigate(This, url, headers, post_data, post_data_len, FALSE);
 919     }else {
 920         bsc = create_callback(This, url, post_data, post_data_len, headers);
 921         hres = navigate_bsc(This, bsc, mon);
 922         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 923     }
 924
 925     CoTaskMemFree(url);
 926     CoTaskMemFree(headers);
 927     ReleaseBindInfo(&bindinfo);
 928
 929     return hres;
 930 }
 931
 932 HRESULT go_home(DocHost *This)
 933 {
 934     HKEY hkey;
 935     DWORD res, type, size;
 936     WCHAR wszPageName[MAX_PATH];
 937     static const WCHAR wszAboutBlank[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 938     static const WCHAR wszStartPage[] = {'S','t','a','r','t',' ','P','a','g','e',0};
 939     static const WCHAR wszSubKey[] = {'S','o','f','t','w','a','r','e','\\',
 940                                       'M','i','c','r','o','s','o','f','t','\\',
 941                                       'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
 942                                       'M','a','i','n',0};
 943
 944     res = RegOpenKeyW(HKEY_CURRENT_USER, wszSubKey, &hkey);
 945     if (res != ERROR_SUCCESS)
 946         return navigate_url(This, wszAboutBlank, NULL, NULL, NULL, NULL);
 947
 948     size = sizeof(wszPageName);
 949     res = RegQueryValueExW(hkey, wszStartPage, NULL, &type, (LPBYTE)wszPageName, &size);
 950     RegCloseKey(hkey);
 951     if (res != ERROR_SUCCESS || type != REG_SZ)
 952         return navigate_url(This, wszAboutBlank, NULL, NULL, NULL, NULL);
 953
 954     return navigate_url(This, wszPageName, NULL, NULL, NULL, NULL);
 955 }
 956
 957 HRESULT get_location_url(DocHost *This, BSTR *ret)
 958 {
 959     FIXME("semi-stub\n");
 960
 961     *ret = This->url ? SysAllocString(This->url) : SysAllocStringLen(NULL, 0);
 962     if(!*ret)
 963         return E_OUTOFMEMORY;
 964
 965     return This->url ? S_OK : S_FALSE;
 966 }
 967
 968 static inline HlinkFrame *impl_from_IHlinkFrame(IHlinkFrame *iface)
 969 {
 970     return CONTAINING_RECORD(iface, HlinkFrame, IHlinkFrame_iface);
 971 }
 972
 973 static HRESULT WINAPI HlinkFrame_QueryInterface(IHlinkFrame *iface, REFIID riid, void **ppv)
 974 {
 975     HlinkFrame *This = impl_from_IHlinkFrame(iface);
 976     return IUnknown_QueryInterface(This->outer, riid, ppv);
 977 }
 978
 979 static ULONG WINAPI HlinkFrame_AddRef(IHlinkFrame *iface)
 980 {
 981     HlinkFrame *This = impl_from_IHlinkFrame(iface);
 982     return IUnknown_AddRef(This->outer);
 983 }
 984
 985 static ULONG WINAPI HlinkFrame_Release(IHlinkFrame *iface)
 986 {
 987     HlinkFrame *This = impl_from_IHlinkFrame(iface);
 988     return IUnknown_Release(This->outer);
 989 }
 990
 991 static HRESULT WINAPI HlinkFrame_SetBrowseContext(IHlinkFrame *iface,
 992                                                   IHlinkBrowseContext *pihlbc)
 993 {
 994     HlinkFrame *This = impl_from_IHlinkFrame(iface);
 995     FIXME("(%p)->(%p)\n", This, pihlbc);
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI HlinkFrame_GetBrowseContext(IHlinkFrame *iface,
1000                                                   IHlinkBrowseContext **ppihlbc)
1001 {
1002     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1003     FIXME("(%p)->(%p)\n", This, ppihlbc);
1004     return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI HlinkFrame_Navigate(IHlinkFrame *iface, DWORD grfHLNF, LPBC pbc,
1008                                           IBindStatusCallback *pibsc, IHlink *pihlNavigate)
1009 {
1010     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1011     IMoniker *mon;
1012     LPWSTR location = NULL;
1013
1014     TRACE("(%p)->(%08x %p %p %p)\n", This, grfHLNF, pbc, pibsc, pihlNavigate);
1015
1016     if(grfHLNF)
1017         FIXME("unsupported grfHLNF=%08x\n", grfHLNF);
1018
1019     /* Windows calls GetTargetFrameName here. */
1020
1021     IHlink_GetMonikerReference(pihlNavigate, 1, &mon, &location);
1022
1023     if(location) {
1024         FIXME("location = %s\n", debugstr_w(location));
1025         CoTaskMemFree(location);
1026     }
1027
1028     /* Windows calls GetHlinkSite here */
1029
1030     if(grfHLNF & HLNF_OPENINNEWWINDOW) {
1031         FIXME("Not supported HLNF_OPENINNEWWINDOW\n");
1032         return E_NOTIMPL;
1033     }
1034
1035     return navigate_hlink(This->doc_host, mon, pbc, pibsc);
1036 }
1037
1038 static HRESULT WINAPI HlinkFrame_OnNavigate(IHlinkFrame *iface, DWORD grfHLNF,
1039         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName, DWORD dwreserved)
1040 {
1041     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1042     FIXME("(%p)->(%08x %p %s %s %d)\n", This, grfHLNF, pimkTarget, debugstr_w(pwzLocation),
1043           debugstr_w(pwzFriendlyName), dwreserved);
1044     return E_NOTIMPL;
1045 }
1046
1047 static HRESULT WINAPI HlinkFrame_UpdateHlink(IHlinkFrame *iface, ULONG uHLID,
1048         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName)
1049 {
1050     HlinkFrame *This = impl_from_IHlinkFrame(iface);
1051     FIXME("(%p)->(%u %p %s %s)\n", This, uHLID, pimkTarget, debugstr_w(pwzLocation),
1052           debugstr_w(pwzFriendlyName));
1053     return E_NOTIMPL;
1054 }
1055
1056 static const IHlinkFrameVtbl HlinkFrameVtbl = {
1057     HlinkFrame_QueryInterface,
1058     HlinkFrame_AddRef,
1059     HlinkFrame_Release,
1060     HlinkFrame_SetBrowseContext,
1061     HlinkFrame_GetBrowseContext,
1062     HlinkFrame_Navigate,
1063     HlinkFrame_OnNavigate,
1064     HlinkFrame_UpdateHlink
1065 };
1066
1067 static inline HlinkFrame *impl_from_ITargetFrame2(ITargetFrame2 *iface)
1068 {
1069     return CONTAINING_RECORD(iface, HlinkFrame, IHlinkFrame_iface);
1070 }
1071
1072 static HRESULT WINAPI TargetFrame2_QueryInterface(ITargetFrame2 *iface, REFIID riid, void **ppv)
1073 {
1074     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1075     return IUnknown_QueryInterface(This->outer, riid, ppv);
1076 }
1077
1078 static ULONG WINAPI TargetFrame2_AddRef(ITargetFrame2 *iface)
1079 {
1080     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1081     return IUnknown_AddRef(This->outer);
1082 }
1083
1084 static ULONG WINAPI TargetFrame2_Release(ITargetFrame2 *iface)
1085 {
1086     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1087     return IUnknown_Release(This->outer);
1088 }
1089
1090 static HRESULT WINAPI TargetFrame2_SetFrameName(ITargetFrame2 *iface, LPCWSTR pszFrameName)
1091 {
1092     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1093     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFrameName));
1094     return E_NOTIMPL;
1095 }
1096
1097 static HRESULT WINAPI TargetFrame2_GetFrameName(ITargetFrame2 *iface, LPWSTR *ppszFrameName)
1098 {
1099     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1100     FIXME("(%p)->(%p)\n", This, ppszFrameName);
1101     return E_NOTIMPL;
1102 }
1103
1104 static HRESULT WINAPI TargetFrame2_GetParentFrame(ITargetFrame2 *iface, IUnknown **ppunkParent)
1105 {
1106     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1107     FIXME("(%p)->(%p)\n", This, ppunkParent);
1108     return E_NOTIMPL;
1109 }
1110
1111 static HRESULT WINAPI TargetFrame2_SetFrameSrc(ITargetFrame2 *iface, LPCWSTR pszFrameSrc)
1112 {
1113     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1114     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFrameSrc));
1115     return E_NOTIMPL;
1116 }
1117
1118 static HRESULT WINAPI TargetFrame2_GetFrameSrc(ITargetFrame2 *iface, LPWSTR *ppszFrameSrc)
1119 {
1120     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1121     FIXME("(%p)->()\n", This);
1122     return E_NOTIMPL;
1123 }
1124
1125 static HRESULT WINAPI TargetFrame2_GetFramesContainer(ITargetFrame2 *iface, IOleContainer **ppContainer)
1126 {
1127     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1128     FIXME("(%p)->(%p)\n", This, ppContainer);
1129     return E_NOTIMPL;
1130 }
1131
1132 static HRESULT WINAPI TargetFrame2_SetFrameOptions(ITargetFrame2 *iface, DWORD dwFlags)
1133 {
1134     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1135     FIXME("(%p)->(%x)\n", This, dwFlags);
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI TargetFrame2_GetFrameOptions(ITargetFrame2 *iface, DWORD *pdwFlags)
1140 {
1141     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1142     FIXME("(%p)->(%p)\n", This, pdwFlags);
1143     return E_NOTIMPL;
1144 }
1145
1146 static HRESULT WINAPI TargetFrame2_SetFrameMargins(ITargetFrame2 *iface, DWORD dwWidth, DWORD dwHeight)
1147 {
1148     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1149     FIXME("(%p)->(%d %d)\n", This, dwWidth, dwHeight);
1150     return E_NOTIMPL;
1151 }
1152
1153 static HRESULT WINAPI TargetFrame2_GetFrameMargins(ITargetFrame2 *iface, DWORD *pdwWidth, DWORD *pdwHeight)
1154 {
1155     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1156     FIXME("(%p)->(%p %p)\n", This, pdwWidth, pdwHeight);
1157     return E_NOTIMPL;
1158 }
1159
1160 static HRESULT WINAPI TargetFrame2_FindFrame(ITargetFrame2 *iface, LPCWSTR pszTargetName, DWORD dwFlags, IUnknown **ppunkTargetFrame)
1161 {
1162     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1163     FIXME("(%p)->(%s %x %p)\n", This, debugstr_w(pszTargetName), dwFlags, ppunkTargetFrame);
1164     return E_NOTIMPL;
1165 }
1166
1167 static HRESULT WINAPI TargetFrame2_GetTargetAlias(ITargetFrame2 *iface, LPCWSTR pszTargetName, LPWSTR *ppszTargetAlias)
1168 {
1169     HlinkFrame *This = impl_from_ITargetFrame2(iface);
1170     FIXME("(%p)->(%s %p)\n", This, debugstr_w(pszTargetName), ppszTargetAlias);
1171     return E_NOTIMPL;
1172 }
1173
1174 static const ITargetFrame2Vtbl TargetFrame2Vtbl = {
1175     TargetFrame2_QueryInterface,
1176     TargetFrame2_AddRef,
1177     TargetFrame2_Release,
1178     TargetFrame2_SetFrameName,
1179     TargetFrame2_GetFrameName,
1180     TargetFrame2_GetParentFrame,
1181     TargetFrame2_SetFrameSrc,
1182     TargetFrame2_GetFrameSrc,
1183     TargetFrame2_GetFramesContainer,
1184     TargetFrame2_SetFrameOptions,
1185     TargetFrame2_GetFrameOptions,
1186     TargetFrame2_SetFrameMargins,
1187     TargetFrame2_GetFrameMargins,
1188     TargetFrame2_FindFrame,
1189     TargetFrame2_GetTargetAlias
1190 };
1191
1192 BOOL HlinkFrame_QI(HlinkFrame *This, REFIID riid, void **ppv)
1193 {
1194     if(IsEqualGUID(&IID_IHlinkFrame, riid)) {
1195         TRACE("(%p)->(IID_IHlinkFrame %p)\n", This, ppv);
1196         *ppv = &This->IHlinkFrame_iface;
1197     }else if(IsEqualGUID(&IID_ITargetFrame2, riid)) {
1198         TRACE("(%p)->(IID_ITargetFrame2 %p)\n", This, ppv);
1199         *ppv = &This->ITargetFrame2_iface;
1200     }else {
1201         return FALSE;
1202     }
1203
1204     IUnknown_AddRef((IUnknown*)*ppv);
1205     return TRUE;
1206 }
1207
1208 void HlinkFrame_Init(HlinkFrame *This, IUnknown *outer, DocHost *doc_host)
1209 {
1210     This->IHlinkFrame_iface.lpVtbl   = &HlinkFrameVtbl;
1211     This->ITargetFrame2_iface.lpVtbl = &TargetFrame2Vtbl;
1212
1213     This->outer = outer;
1214     This->doc_host = doc_host;
1215 }