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