dlls/mshtml/htmlanchor.c

   1 /*
   2  * Copyright 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 #include <stdarg.h>
  20 #include <stdio.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28
  29 #include "mshtml_private.h"
  30 #include "htmlevent.h"
  31 #include "binding.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  36
  37 struct HTMLAnchorElement {
  38     HTMLElement element;
  39
  40     IHTMLAnchorElement IHTMLAnchorElement_iface;
  41
  42     nsIDOMHTMLAnchorElement *nsanchor;
  43 };
  44
  45 static HRESULT navigate_href_new_window(HTMLElement *element, nsAString *href_str, const WCHAR *target)
  46 {
  47     const PRUnichar *href;
  48     IUri *uri;
  49     HRESULT hres;
  50
  51     nsAString_GetData(href_str, &href);
  52     hres = create_relative_uri(element->node.doc->outer_window, href, &uri);
  53     if(FAILED(hres))
  54         return hres;
  55
  56     hres = navigate_new_window(element->node.doc->outer_window, uri, target, NULL, NULL);
  57     IUri_Release(uri);
  58     return hres;
  59 }
  60
  61 HTMLOuterWindow *get_target_window(HTMLOuterWindow *window, nsAString *target_str, BOOL *use_new_window)
  62 {
  63     HTMLOuterWindow *top_window, *ret_window;
  64     const PRUnichar *target;
  65     HRESULT hres;
  66
  67     *use_new_window = FALSE;
  68
  69     nsAString_GetData(target_str, &target);
  70     TRACE("%s\n", debugstr_w(target));
  71
  72     if(!*target || !wcsicmp(target, L"_self")) {
  73         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
  74         return window;
  75     }
  76
  77     if(!wcsicmp(target, L"_top")) {
  78         get_top_window(window, &top_window);
  79         IHTMLWindow2_AddRef(&top_window->base.IHTMLWindow2_iface);
  80         return top_window;
  81     }
  82
  83     if(!wcsicmp(target, L"_parent")) {
  84         if(!window->parent) {
  85             WARN("Window has no parent, treat as self\n");
  86             IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
  87             return window;
  88         }
  89
  90         IHTMLWindow2_AddRef(&window->parent->base.IHTMLWindow2_iface);
  91         return window->parent;
  92     }
  93
  94     get_top_window(window, &top_window);
  95
  96     hres = get_frame_by_name(top_window, target, TRUE, &ret_window);
  97     if(FAILED(hres) || !ret_window) {
  98         *use_new_window = TRUE;
  99         return NULL;
 100     }
 101
 102     IHTMLWindow2_AddRef(&ret_window->base.IHTMLWindow2_iface);
 103     return ret_window;
 104 }
 105
 106 static HRESULT navigate_href(HTMLElement *element, nsAString *href_str, nsAString *target_str)
 107 {
 108     HTMLOuterWindow *window;
 109     BOOL use_new_window;
 110     const PRUnichar *href;
 111     HRESULT hres;
 112
 113     window = get_target_window(element->node.doc->outer_window, target_str, &use_new_window);
 114     if(!window) {
 115         if(use_new_window) {
 116             const PRUnichar *target;
 117             nsAString_GetData(target_str, &target);
 118             return navigate_href_new_window(element, href_str, target);
 119         }else {
 120             return S_OK;
 121         }
 122     }
 123
 124     nsAString_GetData(href_str, &href);
 125     if(*href) {
 126         hres = navigate_url(window, href, window->uri_nofrag, BINDING_NAVIGATED);
 127     }else {
 128         TRACE("empty href\n");
 129         hres = S_OK;
 130     }
 131     IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
 132     return hres;
 133 }
 134
 135 HRESULT handle_link_click_event(HTMLElement *element, nsAString *href_str, nsAString *target_str,
 136                                 nsIDOMEvent *event, BOOL *prevent_default)
 137 {
 138     nsIDOMMouseEvent *mouse_event;
 139     INT16 button;
 140     nsresult nsres;
 141     HRESULT hres;
 142
 143     TRACE("CLICK\n");
 144
 145     nsres = nsIDOMEvent_QueryInterface(event, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 146     assert(nsres == NS_OK);
 147
 148     nsres = nsIDOMMouseEvent_GetButton(mouse_event, &button);
 149     assert(nsres == NS_OK);
 150
 151     nsIDOMMouseEvent_Release(mouse_event);
 152
 153     switch(button) {
 154     case 0:
 155         *prevent_default = TRUE;
 156         hres = navigate_href(element, href_str, target_str);
 157         break;
 158     case 1:
 159         *prevent_default = TRUE;
 160         hres = navigate_href_new_window(element, href_str, NULL);
 161         break;
 162     default:
 163         *prevent_default = FALSE;
 164         hres = S_OK;
 165     }
 166
 167     nsAString_Finish(href_str);
 168     nsAString_Finish(target_str);
 169     return hres;
 170 }
 171
 172 static IUri *get_anchor_uri(HTMLAnchorElement *anchor)
 173 {
 174     nsAString href_str;
 175     IUri *uri = NULL;
 176     nsresult nsres;
 177
 178     nsAString_Init(&href_str, NULL);
 179     nsres = nsIDOMHTMLAnchorElement_GetHref(anchor->nsanchor, &href_str);
 180     if(NS_SUCCEEDED(nsres)) {
 181         const PRUnichar *href;
 182
 183         nsAString_GetData(&href_str, &href);
 184         create_uri(href, 0, &uri);
 185     }else {
 186         ERR("GetHref failed: %08lx\n", nsres);
 187     }
 188
 189     nsAString_Finish(&href_str);
 190     return uri;
 191 }
 192
 193 static inline HTMLAnchorElement *impl_from_IHTMLAnchorElement(IHTMLAnchorElement *iface)
 194 {
 195     return CONTAINING_RECORD(iface, HTMLAnchorElement, IHTMLAnchorElement_iface);
 196 }
 197
 198 static HRESULT WINAPI HTMLAnchorElement_QueryInterface(IHTMLAnchorElement *iface,
 199         REFIID riid, void **ppv)
 200 {
 201     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 202
 203     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 204 }
 205
 206 static ULONG WINAPI HTMLAnchorElement_AddRef(IHTMLAnchorElement *iface)
 207 {
 208     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 209
 210     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 211 }
 212
 213 static ULONG WINAPI HTMLAnchorElement_Release(IHTMLAnchorElement *iface)
 214 {
 215     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 216
 217     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 218 }
 219
 220 static HRESULT WINAPI HTMLAnchorElement_GetTypeInfoCount(IHTMLAnchorElement *iface, UINT *pctinfo)
 221 {
 222     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 223     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 224 }
 225
 226 static HRESULT WINAPI HTMLAnchorElement_GetTypeInfo(IHTMLAnchorElement *iface, UINT iTInfo,
 227                                               LCID lcid, ITypeInfo **ppTInfo)
 228 {
 229     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 230     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 231             ppTInfo);
 232 }
 233
 234 static HRESULT WINAPI HTMLAnchorElement_GetIDsOfNames(IHTMLAnchorElement *iface, REFIID riid,
 235                                                 LPOLESTR *rgszNames, UINT cNames,
 236                                                 LCID lcid, DISPID *rgDispId)
 237 {
 238     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 239     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 240             cNames, lcid, rgDispId);
 241 }
 242
 243 static HRESULT WINAPI HTMLAnchorElement_Invoke(IHTMLAnchorElement *iface, DISPID dispIdMember,
 244                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 245                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 246 {
 247     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 248     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 249             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 250 }
 251
 252 static HRESULT WINAPI HTMLAnchorElement_put_href(IHTMLAnchorElement *iface, BSTR v)
 253 {
 254     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 255     nsAString nsstr;
 256     nsresult nsres;
 257
 258     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 259
 260     nsAString_InitDepend(&nsstr, v);
 261     nsres = nsIDOMHTMLAnchorElement_SetHref(This->nsanchor, &nsstr);
 262     nsAString_Finish(&nsstr);
 263     if(NS_FAILED(nsres))
 264         return E_FAIL;
 265
 266     return S_OK;
 267 }
 268
 269 static HRESULT WINAPI HTMLAnchorElement_get_href(IHTMLAnchorElement *iface, BSTR *p)
 270 {
 271     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 272     nsAString href_str;
 273     nsresult nsres;
 274     HRESULT hres;
 275
 276     TRACE("(%p)->(%p)\n", This, p);
 277
 278     nsAString_Init(&href_str, NULL);
 279     nsres = nsIDOMHTMLAnchorElement_GetHref(This->nsanchor, &href_str);
 280     if(NS_SUCCEEDED(nsres)) {
 281         const PRUnichar *href;
 282
 283         nsAString_GetData(&href_str, &href);
 284         hres = nsuri_to_url(href, TRUE, p);
 285     }else {
 286         ERR("GetHref failed: %08lx\n", nsres);
 287         hres = E_FAIL;
 288     }
 289
 290     nsAString_Finish(&href_str);
 291     return hres;
 292 }
 293
 294 static HRESULT WINAPI HTMLAnchorElement_put_target(IHTMLAnchorElement *iface, BSTR v)
 295 {
 296     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 297     nsAString nsstr;
 298     nsresult nsres;
 299
 300     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 301
 302     nsAString_InitDepend(&nsstr, v);
 303     nsres = nsIDOMHTMLAnchorElement_SetTarget(This->nsanchor, &nsstr);
 304     nsAString_Finish(&nsstr);
 305     if(NS_FAILED(nsres))
 306         return E_FAIL;
 307
 308     return S_OK;
 309 }
 310
 311 static HRESULT WINAPI HTMLAnchorElement_get_target(IHTMLAnchorElement *iface, BSTR *p)
 312 {
 313     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 314     nsAString target_str;
 315     nsresult nsres;
 316
 317     TRACE("(%p)->(%p)\n", This, p);
 318
 319     nsAString_Init(&target_str, NULL);
 320     nsres = nsIDOMHTMLAnchorElement_GetTarget(This->nsanchor, &target_str);
 321
 322     return return_nsstr(nsres, &target_str, p);
 323 }
 324
 325 static HRESULT WINAPI HTMLAnchorElement_put_rel(IHTMLAnchorElement *iface, BSTR v)
 326 {
 327     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 328     nsAString nsstr;
 329     nsresult nsres;
 330
 331     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 332
 333     nsAString_InitDepend(&nsstr, v);
 334     nsres = nsIDOMHTMLAnchorElement_SetRel(This->nsanchor, &nsstr);
 335     nsAString_Finish(&nsstr);
 336     if(NS_FAILED(nsres))
 337         return E_FAIL;
 338
 339     return S_OK;
 340 }
 341
 342 static HRESULT WINAPI HTMLAnchorElement_get_rel(IHTMLAnchorElement *iface, BSTR *p)
 343 {
 344     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 345     nsAString nsstr;
 346     nsresult nsres;
 347
 348     TRACE("(%p)->(%p)\n", This, p);
 349
 350     nsAString_Init(&nsstr, NULL);
 351     nsres = nsIDOMHTMLAnchorElement_GetRel(This->nsanchor, &nsstr);
 352     return return_nsstr(nsres, &nsstr, p);
 353 }
 354
 355 static HRESULT WINAPI HTMLAnchorElement_put_rev(IHTMLAnchorElement *iface, BSTR v)
 356 {
 357     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 358     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 359     return E_NOTIMPL;
 360 }
 361
 362 static HRESULT WINAPI HTMLAnchorElement_get_rev(IHTMLAnchorElement *iface, BSTR *p)
 363 {
 364     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 365     FIXME("(%p)->(%p)\n", This, p);
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT WINAPI HTMLAnchorElement_put_urn(IHTMLAnchorElement *iface, BSTR v)
 370 {
 371     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 372     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI HTMLAnchorElement_get_urn(IHTMLAnchorElement *iface, BSTR *p)
 377 {
 378     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 379     FIXME("(%p)->(%p)\n", This, p);
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI HTMLAnchorElement_put_Methods(IHTMLAnchorElement *iface, BSTR v)
 384 {
 385     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 386     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 387     return E_NOTIMPL;
 388 }
 389
 390 static HRESULT WINAPI HTMLAnchorElement_get_Methods(IHTMLAnchorElement *iface, BSTR *p)
 391 {
 392     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 393     FIXME("(%p)->(%p)\n", This, p);
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI HTMLAnchorElement_put_name(IHTMLAnchorElement *iface, BSTR v)
 398 {
 399     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 400     nsAString nsstr;
 401     nsresult nsres;
 402
 403     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 404
 405     nsAString_InitDepend(&nsstr, v);
 406     nsres = nsIDOMHTMLAnchorElement_SetName(This->nsanchor, &nsstr);
 407     nsAString_Finish(&nsstr);
 408     if(NS_FAILED(nsres))
 409         return E_FAIL;
 410
 411     return S_OK;
 412 }
 413
 414 static HRESULT WINAPI HTMLAnchorElement_get_name(IHTMLAnchorElement *iface, BSTR *p)
 415 {
 416     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 417     nsAString name_str;
 418     nsresult nsres;
 419
 420     TRACE("(%p)->(%p)\n", This, p);
 421
 422     nsAString_Init(&name_str, NULL);
 423     nsres = nsIDOMHTMLAnchorElement_GetName(This->nsanchor, &name_str);
 424
 425     return return_nsstr(nsres, &name_str, p);
 426 }
 427
 428 static HRESULT WINAPI HTMLAnchorElement_put_host(IHTMLAnchorElement *iface, BSTR v)
 429 {
 430     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 431     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI HTMLAnchorElement_get_host(IHTMLAnchorElement *iface, BSTR *p)
 436 {
 437     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 438     nsAString str;
 439     nsresult nsres;
 440
 441     TRACE("(%p)->(%p)\n", This, p);
 442
 443     /* FIXME: IE always appends port number, even if it's implicit default number */
 444     nsAString_InitDepend(&str, NULL);
 445     nsres = nsIDOMHTMLAnchorElement_GetHost(This->nsanchor, &str);
 446     return return_nsstr(nsres, &str, p);
 447 }
 448
 449 static HRESULT WINAPI HTMLAnchorElement_put_hostname(IHTMLAnchorElement *iface, BSTR v)
 450 {
 451     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 452     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI HTMLAnchorElement_get_hostname(IHTMLAnchorElement *iface, BSTR *p)
 457 {
 458     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 459     nsAString hostname_str;
 460     nsresult nsres;
 461
 462     TRACE("(%p)->(%p)\n", This, p);
 463
 464     nsAString_Init(&hostname_str, NULL);
 465     nsres = nsIDOMHTMLAnchorElement_GetHostname(This->nsanchor, &hostname_str);
 466     return return_nsstr(nsres, &hostname_str, p);
 467 }
 468
 469 static HRESULT WINAPI HTMLAnchorElement_put_pathname(IHTMLAnchorElement *iface, BSTR v)
 470 {
 471     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 472     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI HTMLAnchorElement_get_pathname(IHTMLAnchorElement *iface, BSTR *p)
 477 {
 478     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 479     nsAString pathname_str;
 480     nsresult nsres;
 481
 482     TRACE("(%p)->(%p)\n", This, p);
 483
 484     /* FIXME: IE prepends a slash for some protocols */
 485     nsAString_Init(&pathname_str, NULL);
 486     nsres = nsIDOMHTMLAnchorElement_GetPathname(This->nsanchor, &pathname_str);
 487     return return_nsstr(nsres, &pathname_str, p);
 488 }
 489
 490 static HRESULT WINAPI HTMLAnchorElement_put_port(IHTMLAnchorElement *iface, BSTR v)
 491 {
 492     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 493     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI HTMLAnchorElement_get_port(IHTMLAnchorElement *iface, BSTR *p)
 498 {
 499     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 500     IUri *uri;
 501     HRESULT hres;
 502     DWORD port;
 503     WCHAR buf[11];
 504     int len;
 505     BSTR str;
 506
 507     TRACE("(%p)->(%p)\n", This, p);
 508
 509     uri = get_anchor_uri(This);
 510     if(!uri) {
 511         WARN("Could not create IUri\n");
 512         *p = NULL;
 513         return S_OK;
 514     }
 515
 516     hres = IUri_GetPort(uri, &port);
 517     IUri_Release(uri);
 518     if(FAILED(hres))
 519         return hres;
 520     if(hres != S_OK) {
 521         *p = NULL;
 522         return S_OK;
 523     }
 524
 525     len = swprintf(buf, ARRAY_SIZE(buf), L"%u", port);
 526     str = SysAllocStringLen(buf, len);
 527     if (str)
 528         *p = str;
 529     else
 530         hres = E_OUTOFMEMORY;
 531
 532     return hres;
 533 }
 534
 535 static HRESULT WINAPI HTMLAnchorElement_put_protocol(IHTMLAnchorElement *iface, BSTR v)
 536 {
 537     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 538     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 539     return E_NOTIMPL;
 540 }
 541
 542 static HRESULT WINAPI HTMLAnchorElement_get_protocol(IHTMLAnchorElement *iface, BSTR *p)
 543 {
 544     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 545     BSTR scheme;
 546     size_t len;
 547     IUri *uri;
 548     HRESULT hres;
 549
 550     TRACE("(%p)->(%p)\n", This, p);
 551
 552     uri = get_anchor_uri(This);
 553     if(!uri) {
 554         WARN("Could not create IUri\n");
 555         *p = NULL;
 556         return S_OK;
 557     }
 558
 559     hres = IUri_GetSchemeName(uri, &scheme);
 560     IUri_Release(uri);
 561     if(FAILED(hres))
 562         return hres;
 563     if(hres != S_OK) {
 564         SysFreeString(scheme);
 565         *p = NULL;
 566         return S_OK;
 567     }
 568
 569     len = SysStringLen(scheme);
 570     if(len) {
 571         *p = SysAllocStringLen(scheme, len + 1);
 572         if(*p)
 573             (*p)[len] = ':';
 574         else
 575             hres = E_OUTOFMEMORY;
 576     }else {
 577         *p = NULL;
 578     }
 579     SysFreeString(scheme);
 580     return hres;
 581 }
 582
 583 static HRESULT WINAPI HTMLAnchorElement_put_search(IHTMLAnchorElement *iface, BSTR v)
 584 {
 585     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 586     nsAString nsstr;
 587     nsresult nsres;
 588
 589     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 590
 591     nsAString_InitDepend(&nsstr, v);
 592     nsres = nsIDOMHTMLAnchorElement_SetSearch(This->nsanchor, &nsstr);
 593     nsAString_Finish(&nsstr);
 594     if(NS_FAILED(nsres))
 595         return E_FAIL;
 596
 597     return S_OK;
 598 }
 599
 600 static HRESULT WINAPI HTMLAnchorElement_get_search(IHTMLAnchorElement *iface, BSTR *p)
 601 {
 602     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 603     nsAString search_str;
 604     nsresult nsres;
 605
 606     TRACE("(%p)->(%p)\n", This, p);
 607
 608     nsAString_Init(&search_str, NULL);
 609     nsres = nsIDOMHTMLAnchorElement_GetSearch(This->nsanchor, &search_str);
 610     return return_nsstr(nsres, &search_str, p);
 611 }
 612
 613 static HRESULT WINAPI HTMLAnchorElement_put_hash(IHTMLAnchorElement *iface, BSTR v)
 614 {
 615     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 616     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 617     return E_NOTIMPL;
 618 }
 619
 620 static HRESULT WINAPI HTMLAnchorElement_get_hash(IHTMLAnchorElement *iface, BSTR *p)
 621 {
 622     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 623     nsAString hash_str;
 624     nsresult nsres;
 625
 626     TRACE("(%p)->(%p)\n", This, p);
 627
 628     nsAString_Init(&hash_str, NULL);
 629     nsres = nsIDOMHTMLAnchorElement_GetHash(This->nsanchor, &hash_str);
 630     return return_nsstr(nsres, &hash_str, p);
 631 }
 632
 633 static HRESULT WINAPI HTMLAnchorElement_put_onblur(IHTMLAnchorElement *iface, VARIANT v)
 634 {
 635     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 636
 637     TRACE("(%p)->()\n", This);
 638
 639     return IHTMLElement2_put_onblur(&This->element.IHTMLElement2_iface, v);
 640 }
 641
 642 static HRESULT WINAPI HTMLAnchorElement_get_onblur(IHTMLAnchorElement *iface, VARIANT *p)
 643 {
 644     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 645
 646     TRACE("(%p)->(%p)\n", This, p);
 647
 648     return IHTMLElement2_get_onblur(&This->element.IHTMLElement2_iface, p);
 649 }
 650
 651 static HRESULT WINAPI HTMLAnchorElement_put_onfocus(IHTMLAnchorElement *iface, VARIANT v)
 652 {
 653     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 654
 655     TRACE("(%p)->()\n", This);
 656
 657     return IHTMLElement2_put_onfocus(&This->element.IHTMLElement2_iface, v);
 658 }
 659
 660 static HRESULT WINAPI HTMLAnchorElement_get_onfocus(IHTMLAnchorElement *iface, VARIANT *p)
 661 {
 662     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 663
 664     TRACE("(%p)->(%p)\n", This, p);
 665
 666     return IHTMLElement2_get_onfocus(&This->element.IHTMLElement2_iface, p);
 667 }
 668
 669 static HRESULT WINAPI HTMLAnchorElement_put_accessKey(IHTMLAnchorElement *iface, BSTR v)
 670 {
 671     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 672
 673     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 674
 675     return IHTMLElement2_put_accessKey(&This->element.IHTMLElement2_iface, v);
 676 }
 677
 678 static HRESULT WINAPI HTMLAnchorElement_get_accessKey(IHTMLAnchorElement *iface, BSTR *p)
 679 {
 680     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 681
 682     TRACE("(%p)->(%p)\n", This, p);
 683
 684     return IHTMLElement2_get_accessKey(&This->element.IHTMLElement2_iface, p);
 685 }
 686
 687 static HRESULT WINAPI HTMLAnchorElement_get_protocolLong(IHTMLAnchorElement *iface, BSTR *p)
 688 {
 689     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 690     FIXME("(%p)->(%p)\n", This, p);
 691     return E_NOTIMPL;
 692 }
 693
 694 static HRESULT WINAPI HTMLAnchorElement_get_mimeType(IHTMLAnchorElement *iface, BSTR *p)
 695 {
 696     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 697     FIXME("(%p)->(%p)\n", This, p);
 698     return E_NOTIMPL;
 699 }
 700
 701 static HRESULT WINAPI HTMLAnchorElement_get_nameProp(IHTMLAnchorElement *iface, BSTR *p)
 702 {
 703     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 704     FIXME("(%p)->(%p)\n", This, p);
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI HTMLAnchorElement_put_tabIndex(IHTMLAnchorElement *iface, short v)
 709 {
 710     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 711
 712     TRACE("(%p)->()\n", This);
 713
 714     return IHTMLElement2_put_tabIndex(&This->element.IHTMLElement2_iface, v);
 715 }
 716
 717 static HRESULT WINAPI HTMLAnchorElement_get_tabIndex(IHTMLAnchorElement *iface, short *p)
 718 {
 719     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 720
 721     TRACE("(%p)->(%p)\n", This, p);
 722
 723     return IHTMLElement2_get_tabIndex(&This->element.IHTMLElement2_iface, p);
 724 }
 725
 726 static HRESULT WINAPI HTMLAnchorElement_focus(IHTMLAnchorElement *iface)
 727 {
 728     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 729
 730     TRACE("(%p)\n", This);
 731
 732     return IHTMLElement2_focus(&This->element.IHTMLElement2_iface);
 733 }
 734
 735 static HRESULT WINAPI HTMLAnchorElement_blur(IHTMLAnchorElement *iface)
 736 {
 737     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 738
 739     TRACE("(%p)\n", This);
 740
 741     return IHTMLElement2_blur(&This->element.IHTMLElement2_iface);
 742 }
 743
 744 static const IHTMLAnchorElementVtbl HTMLAnchorElementVtbl = {
 745     HTMLAnchorElement_QueryInterface,
 746     HTMLAnchorElement_AddRef,
 747     HTMLAnchorElement_Release,
 748     HTMLAnchorElement_GetTypeInfoCount,
 749     HTMLAnchorElement_GetTypeInfo,
 750     HTMLAnchorElement_GetIDsOfNames,
 751     HTMLAnchorElement_Invoke,
 752     HTMLAnchorElement_put_href,
 753     HTMLAnchorElement_get_href,
 754     HTMLAnchorElement_put_target,
 755     HTMLAnchorElement_get_target,
 756     HTMLAnchorElement_put_rel,
 757     HTMLAnchorElement_get_rel,
 758     HTMLAnchorElement_put_rev,
 759     HTMLAnchorElement_get_rev,
 760     HTMLAnchorElement_put_urn,
 761     HTMLAnchorElement_get_urn,
 762     HTMLAnchorElement_put_Methods,
 763     HTMLAnchorElement_get_Methods,
 764     HTMLAnchorElement_put_name,
 765     HTMLAnchorElement_get_name,
 766     HTMLAnchorElement_put_host,
 767     HTMLAnchorElement_get_host,
 768     HTMLAnchorElement_put_hostname,
 769     HTMLAnchorElement_get_hostname,
 770     HTMLAnchorElement_put_pathname,
 771     HTMLAnchorElement_get_pathname,
 772     HTMLAnchorElement_put_port,
 773     HTMLAnchorElement_get_port,
 774     HTMLAnchorElement_put_protocol,
 775     HTMLAnchorElement_get_protocol,
 776     HTMLAnchorElement_put_search,
 777     HTMLAnchorElement_get_search,
 778     HTMLAnchorElement_put_hash,
 779     HTMLAnchorElement_get_hash,
 780     HTMLAnchorElement_put_onblur,
 781     HTMLAnchorElement_get_onblur,
 782     HTMLAnchorElement_put_onfocus,
 783     HTMLAnchorElement_get_onfocus,
 784     HTMLAnchorElement_put_accessKey,
 785     HTMLAnchorElement_get_accessKey,
 786     HTMLAnchorElement_get_protocolLong,
 787     HTMLAnchorElement_get_mimeType,
 788     HTMLAnchorElement_get_nameProp,
 789     HTMLAnchorElement_put_tabIndex,
 790     HTMLAnchorElement_get_tabIndex,
 791     HTMLAnchorElement_focus,
 792     HTMLAnchorElement_blur
 793 };
 794
 795 static inline HTMLAnchorElement *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 796 {
 797     return CONTAINING_RECORD(iface, HTMLAnchorElement, element.node);
 798 }
 799
 800 static HRESULT HTMLAnchorElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 801 {
 802     HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
 803
 804     *ppv = NULL;
 805
 806     if(IsEqualGUID(&IID_IUnknown, riid)) {
 807         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 808         *ppv = &This->IHTMLAnchorElement_iface;
 809     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 810         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 811         *ppv = &This->IHTMLAnchorElement_iface;
 812     }else if(IsEqualGUID(&IID_IHTMLAnchorElement, riid)) {
 813         TRACE("(%p)->(IID_IHTMLAnchorElement %p)\n", This, ppv);
 814         *ppv = &This->IHTMLAnchorElement_iface;
 815     }
 816
 817     if(*ppv) {
 818         IUnknown_AddRef((IUnknown*)*ppv);
 819         return S_OK;
 820     }
 821
 822     return HTMLElement_QI(&This->element.node, riid, ppv);
 823 }
 824
 825 static HRESULT HTMLAnchorElement_handle_event(HTMLDOMNode *iface, DWORD eid, nsIDOMEvent *event, BOOL *prevent_default)
 826 {
 827     HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
 828     nsAString href_str, target_str;
 829     nsresult nsres;
 830
 831     if(eid == EVENTID_CLICK) {
 832         nsAString_Init(&href_str, NULL);
 833         nsres = nsIDOMHTMLAnchorElement_GetHref(This->nsanchor, &href_str);
 834         if (NS_FAILED(nsres)) {
 835             ERR("Could not get anchor href: %08lx\n", nsres);
 836             goto fallback;
 837         }
 838
 839         nsAString_Init(&target_str, NULL);
 840         nsres = nsIDOMHTMLAnchorElement_GetTarget(This->nsanchor, &target_str);
 841         if (NS_FAILED(nsres)) {
 842             ERR("Could not get anchor target: %08lx\n", nsres);
 843             goto fallback;
 844         }
 845
 846         return handle_link_click_event(&This->element, &href_str, &target_str, event, prevent_default);
 847
 848 fallback:
 849         nsAString_Finish(&href_str);
 850         nsAString_Finish(&target_str);
 851     }
 852
 853     return HTMLElement_handle_event(&This->element.node, eid, event, prevent_default);
 854 }
 855
 856 static void HTMLAnchorElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
 857 {
 858     HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
 859
 860     if(This->nsanchor)
 861         note_cc_edge((nsISupports*)This->nsanchor, "This->nsanchor", cb);
 862 }
 863
 864 static void HTMLAnchorElement_unlink(HTMLDOMNode *iface)
 865 {
 866     HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
 867
 868     if(This->nsanchor) {
 869         nsIDOMHTMLAnchorElement *nsanchor = This->nsanchor;
 870
 871         This->nsanchor = NULL;
 872         nsIDOMHTMLAnchorElement_Release(nsanchor);
 873     }
 874 }
 875
 876 static const NodeImplVtbl HTMLAnchorElementImplVtbl = {
 877     &CLSID_HTMLAnchorElement,
 878     HTMLAnchorElement_QI,
 879     HTMLElement_destructor,
 880     HTMLElement_cpc,
 881     HTMLElement_clone,
 882     HTMLAnchorElement_handle_event,
 883     HTMLElement_get_attr_col,
 884     NULL,
 885     NULL,
 886     NULL,
 887     NULL,
 888     NULL,
 889     NULL,
 890     NULL,
 891     NULL,
 892     NULL,
 893     HTMLAnchorElement_traverse,
 894     HTMLAnchorElement_unlink
 895 };
 896
 897 static const tid_t HTMLAnchorElement_iface_tids[] = {
 898     IHTMLAnchorElement_tid,
 899     HTMLELEMENT_TIDS,
 900     0
 901 };
 902
 903 static dispex_static_data_t HTMLAnchorElement_dispex = {
 904     L"HTMLAnchorElement",
 905     NULL,
 906     DispHTMLAnchorElement_tid,
 907     HTMLAnchorElement_iface_tids,
 908     HTMLElement_init_dispex_info
 909 };
 910
 911 HRESULT HTMLAnchorElement_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 912 {
 913     HTMLAnchorElement *ret;
 914     nsresult nsres;
 915
 916     ret = calloc(1, sizeof(HTMLAnchorElement));
 917     if(!ret)
 918         return E_OUTOFMEMORY;
 919
 920     ret->IHTMLAnchorElement_iface.lpVtbl = &HTMLAnchorElementVtbl;
 921     ret->element.node.vtbl = &HTMLAnchorElementImplVtbl;
 922
 923     HTMLElement_Init(&ret->element, doc, nselem, &HTMLAnchorElement_dispex);
 924
 925     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLAnchorElement, (void**)&ret->nsanchor);
 926     assert(nsres == NS_OK);
 927
 928     *elem = &ret->element;
 929     return S_OK;
 930 }