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 typedef struct {
  39     HTMLElement element;
  40
  41     IHTMLAnchorElement IHTMLAnchorElement_iface;
  42
  43     nsIDOMHTMLAnchorElement *nsanchor;
  44 } HTMLAnchorElement;
  45
  46 static HRESULT navigate_anchor_window(HTMLAnchorElement *This, const WCHAR *target)
  47 {
  48     nsAString href_str;
  49     IUri *uri;
  50     nsresult nsres;
  51     HRESULT hres;
  52
  53     nsAString_Init(&href_str, NULL);
  54     nsres = nsIDOMHTMLAnchorElement_GetHref(This->nsanchor, &href_str);
  55     if(NS_SUCCEEDED(nsres)) {
  56         const PRUnichar *href;
  57
  58         nsAString_GetData(&href_str, &href);
  59         hres = create_relative_uri(This->element.node.doc->basedoc.window, href, &uri);
  60     }else {
  61         ERR("Could not get anchor href: %08x\n", nsres);
  62         hres = E_FAIL;
  63     }
  64     nsAString_Finish(&href_str);
  65     if(FAILED(hres))
  66         return hres;
  67
  68     hres = navigate_new_window(This->element.node.doc->basedoc.window, uri, target, NULL);
  69     IUri_Release(uri);
  70     return hres;
  71 }
  72
  73 static HRESULT navigate_anchor(HTMLAnchorElement *This)
  74 {
  75     nsAString href_str, target_str;
  76     HTMLOuterWindow *window = NULL;
  77     nsresult nsres;
  78     HRESULT hres = E_FAIL;
  79
  80     static const WCHAR _parentW[] = {'_','p','a','r','e','n','t',0};
  81     static const WCHAR _selfW[] = {'_','s','e','l','f',0};
  82     static const WCHAR _topW[] = {'_','t','o','p',0};
  83
  84     nsAString_Init(&target_str, NULL);
  85     nsres = nsIDOMHTMLAnchorElement_GetTarget(This->nsanchor, &target_str);
  86     if(NS_SUCCEEDED(nsres)) {
  87         const PRUnichar *target;
  88
  89         nsAString_GetData(&target_str, &target);
  90         TRACE("target %s\n", debugstr_w(target));
  91         if(*target && strcmpiW(target, _selfW)) {
  92             if(!strcmpiW(target, _topW)) {
  93                 TRACE("target _top\n");
  94                 get_top_window(This->element.node.doc->basedoc.window, &window);
  95             }else if(!strcmpiW(target, _parentW)) {
  96                 window = This->element.node.doc->basedoc.window;
  97                 if(!window->parent) {
  98                     WARN("Window has no parent\n");
  99                     nsAString_Finish(&target_str);
 100                     return S_OK;
 101                 }
 102                 window = window->parent;
 103             }else {
 104                 HTMLOuterWindow *top_window;
 105
 106                 get_top_window(This->element.node.doc->basedoc.window, &top_window);
 107
 108                 hres = get_frame_by_name(top_window, target, TRUE, &window);
 109                 if(FAILED(hres) || !window) {
 110                     hres = navigate_anchor_window(This, target);
 111                     nsAString_Finish(&target_str);
 112                     return hres;
 113                 }
 114             }
 115         }
 116     }
 117     nsAString_Finish(&target_str);
 118
 119     nsAString_Init(&href_str, NULL);
 120     nsres = nsIDOMHTMLAnchorElement_GetHref(This->nsanchor, &href_str);
 121     if(NS_SUCCEEDED(nsres)) {
 122         const PRUnichar *href;
 123
 124         nsAString_GetData(&href_str, &href);
 125         if(*href) {
 126             if(!window)
 127                 window = This->element.node.doc->basedoc.window;
 128             hres = navigate_url(window, href, window->uri_nofrag, BINDING_NAVIGATED);
 129         }else {
 130             TRACE("empty href\n");
 131             hres = S_OK;
 132         }
 133     }
 134     nsAString_Finish(&href_str);
 135     return hres;
 136 }
 137
 138 static inline HTMLAnchorElement *impl_from_IHTMLAnchorElement(IHTMLAnchorElement *iface)
 139 {
 140     return CONTAINING_RECORD(iface, HTMLAnchorElement, IHTMLAnchorElement_iface);
 141 }
 142
 143 static HRESULT WINAPI HTMLAnchorElement_QueryInterface(IHTMLAnchorElement *iface,
 144         REFIID riid, void **ppv)
 145 {
 146     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 147
 148     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 149 }
 150
 151 static ULONG WINAPI HTMLAnchorElement_AddRef(IHTMLAnchorElement *iface)
 152 {
 153     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 154
 155     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 156 }
 157
 158 static ULONG WINAPI HTMLAnchorElement_Release(IHTMLAnchorElement *iface)
 159 {
 160     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 161
 162     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 163 }
 164
 165 static HRESULT WINAPI HTMLAnchorElement_GetTypeInfoCount(IHTMLAnchorElement *iface, UINT *pctinfo)
 166 {
 167     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 168     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 169 }
 170
 171 static HRESULT WINAPI HTMLAnchorElement_GetTypeInfo(IHTMLAnchorElement *iface, UINT iTInfo,
 172                                               LCID lcid, ITypeInfo **ppTInfo)
 173 {
 174     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 175     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 176             ppTInfo);
 177 }
 178
 179 static HRESULT WINAPI HTMLAnchorElement_GetIDsOfNames(IHTMLAnchorElement *iface, REFIID riid,
 180                                                 LPOLESTR *rgszNames, UINT cNames,
 181                                                 LCID lcid, DISPID *rgDispId)
 182 {
 183     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 184     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 185             cNames, lcid, rgDispId);
 186 }
 187
 188 static HRESULT WINAPI HTMLAnchorElement_Invoke(IHTMLAnchorElement *iface, DISPID dispIdMember,
 189                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 190                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 191 {
 192     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 193     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 194             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 195 }
 196
 197 static HRESULT WINAPI HTMLAnchorElement_put_href(IHTMLAnchorElement *iface, BSTR v)
 198 {
 199     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 200     nsAString nsstr;
 201     nsresult nsres;
 202
 203     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 204
 205     nsAString_InitDepend(&nsstr, v);
 206     nsres = nsIDOMHTMLAnchorElement_SetHref(This->nsanchor, &nsstr);
 207     nsAString_Finish(&nsstr);
 208     if(NS_FAILED(nsres))
 209         return E_FAIL;
 210
 211     return S_OK;
 212 }
 213
 214 static HRESULT WINAPI HTMLAnchorElement_get_href(IHTMLAnchorElement *iface, BSTR *p)
 215 {
 216     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 217     nsAString href_str;
 218     nsresult nsres;
 219     HRESULT hres;
 220
 221     TRACE("(%p)->(%p)\n", This, p);
 222
 223     nsAString_Init(&href_str, NULL);
 224     nsres = nsIDOMHTMLAnchorElement_GetHref(This->nsanchor, &href_str);
 225     if(NS_SUCCEEDED(nsres)) {
 226         const PRUnichar *href;
 227
 228         nsAString_GetData(&href_str, &href);
 229         hres = nsuri_to_url(href, TRUE, p);
 230     }else {
 231         ERR("GetHref failed: %08x\n", nsres);
 232         hres = E_FAIL;
 233     }
 234
 235     nsAString_Finish(&href_str);
 236     return hres;
 237 }
 238
 239 static HRESULT WINAPI HTMLAnchorElement_put_target(IHTMLAnchorElement *iface, BSTR v)
 240 {
 241     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 242     nsAString nsstr;
 243     nsresult nsres;
 244
 245     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 246
 247     nsAString_InitDepend(&nsstr, v);
 248     nsres = nsIDOMHTMLAnchorElement_SetTarget(This->nsanchor, &nsstr);
 249     nsAString_Finish(&nsstr);
 250     if(NS_FAILED(nsres))
 251         return E_FAIL;
 252
 253     return S_OK;
 254 }
 255
 256 static HRESULT WINAPI HTMLAnchorElement_get_target(IHTMLAnchorElement *iface, BSTR *p)
 257 {
 258     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 259     nsAString target_str;
 260     nsresult nsres;
 261
 262     TRACE("(%p)->(%p)\n", This, p);
 263
 264     nsAString_Init(&target_str, NULL);
 265     nsres = nsIDOMHTMLAnchorElement_GetTarget(This->nsanchor, &target_str);
 266
 267     return return_nsstr(nsres, &target_str, p);
 268 }
 269
 270 static HRESULT WINAPI HTMLAnchorElement_put_rel(IHTMLAnchorElement *iface, BSTR v)
 271 {
 272     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 273     nsAString nsstr;
 274     nsresult nsres;
 275
 276     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 277
 278     nsAString_InitDepend(&nsstr, v);
 279     nsres = nsIDOMHTMLAnchorElement_SetRel(This->nsanchor, &nsstr);
 280     nsAString_Finish(&nsstr);
 281     if(NS_FAILED(nsres))
 282         return E_FAIL;
 283
 284     return S_OK;
 285 }
 286
 287 static HRESULT WINAPI HTMLAnchorElement_get_rel(IHTMLAnchorElement *iface, BSTR *p)
 288 {
 289     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 290     nsAString nsstr;
 291     nsresult nsres;
 292
 293     TRACE("(%p)->(%p)\n", This, p);
 294
 295     nsAString_Init(&nsstr, NULL);
 296     nsres = nsIDOMHTMLAnchorElement_GetRel(This->nsanchor, &nsstr);
 297     return return_nsstr(nsres, &nsstr, p);
 298 }
 299
 300 static HRESULT WINAPI HTMLAnchorElement_put_rev(IHTMLAnchorElement *iface, BSTR v)
 301 {
 302     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 303     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI HTMLAnchorElement_get_rev(IHTMLAnchorElement *iface, BSTR *p)
 308 {
 309     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 310     FIXME("(%p)->(%p)\n", This, p);
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT WINAPI HTMLAnchorElement_put_urn(IHTMLAnchorElement *iface, BSTR v)
 315 {
 316     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 317     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI HTMLAnchorElement_get_urn(IHTMLAnchorElement *iface, BSTR *p)
 322 {
 323     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 324     FIXME("(%p)->(%p)\n", This, p);
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT WINAPI HTMLAnchorElement_put_Methods(IHTMLAnchorElement *iface, BSTR v)
 329 {
 330     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 331     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 332     return E_NOTIMPL;
 333 }
 334
 335 static HRESULT WINAPI HTMLAnchorElement_get_Methods(IHTMLAnchorElement *iface, BSTR *p)
 336 {
 337     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 338     FIXME("(%p)->(%p)\n", This, p);
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT WINAPI HTMLAnchorElement_put_name(IHTMLAnchorElement *iface, BSTR v)
 343 {
 344     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 345     nsAString nsstr;
 346     nsresult nsres;
 347
 348     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 349
 350     nsAString_InitDepend(&nsstr, v);
 351     nsres = nsIDOMHTMLAnchorElement_SetName(This->nsanchor, &nsstr);
 352     nsAString_Finish(&nsstr);
 353     if(NS_FAILED(nsres))
 354         return E_FAIL;
 355
 356     return S_OK;
 357 }
 358
 359 static HRESULT WINAPI HTMLAnchorElement_get_name(IHTMLAnchorElement *iface, BSTR *p)
 360 {
 361     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 362     nsAString name_str;
 363     nsresult nsres;
 364
 365     TRACE("(%p)->(%p)\n", This, p);
 366
 367     nsAString_Init(&name_str, NULL);
 368     nsres = nsIDOMHTMLAnchorElement_GetName(This->nsanchor, &name_str);
 369
 370     return return_nsstr(nsres, &name_str, p);
 371 }
 372
 373 static HRESULT WINAPI HTMLAnchorElement_put_host(IHTMLAnchorElement *iface, BSTR v)
 374 {
 375     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 376     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT WINAPI HTMLAnchorElement_get_host(IHTMLAnchorElement *iface, BSTR *p)
 381 {
 382     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 383     FIXME("(%p)->(%p)\n", This, p);
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI HTMLAnchorElement_put_hostname(IHTMLAnchorElement *iface, BSTR v)
 388 {
 389     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 390     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 391     return E_NOTIMPL;
 392 }
 393
 394 static HRESULT WINAPI HTMLAnchorElement_get_hostname(IHTMLAnchorElement *iface, BSTR *p)
 395 {
 396     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 397     nsAString hostname_str;
 398     nsresult nsres;
 399
 400     TRACE("(%p)->(%p)\n", This, p);
 401
 402     nsAString_Init(&hostname_str, NULL);
 403     nsres = nsIDOMHTMLAnchorElement_GetHostname(This->nsanchor, &hostname_str);
 404     return return_nsstr(nsres, &hostname_str, p);
 405 }
 406
 407 static HRESULT WINAPI HTMLAnchorElement_put_pathname(IHTMLAnchorElement *iface, BSTR v)
 408 {
 409     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 410     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 411     return E_NOTIMPL;
 412 }
 413
 414 static HRESULT WINAPI HTMLAnchorElement_get_pathname(IHTMLAnchorElement *iface, BSTR *p)
 415 {
 416     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 417     FIXME("(%p)->(%p)\n", This, p);
 418     return E_NOTIMPL;
 419 }
 420
 421 static HRESULT WINAPI HTMLAnchorElement_put_port(IHTMLAnchorElement *iface, BSTR v)
 422 {
 423     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 424     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 425     return E_NOTIMPL;
 426 }
 427
 428 static HRESULT WINAPI HTMLAnchorElement_get_port(IHTMLAnchorElement *iface, BSTR *p)
 429 {
 430     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 431     FIXME("(%p)->(%p)\n", This, p);
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI HTMLAnchorElement_put_protocol(IHTMLAnchorElement *iface, BSTR v)
 436 {
 437     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 438     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI HTMLAnchorElement_get_protocol(IHTMLAnchorElement *iface, BSTR *p)
 443 {
 444     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 445     FIXME("(%p)->(%p)\n", This, p);
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI HTMLAnchorElement_put_search(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_search(IHTMLAnchorElement *iface, BSTR *p)
 457 {
 458     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 459     FIXME("(%p)->(%p)\n", This, p);
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI HTMLAnchorElement_put_hash(IHTMLAnchorElement *iface, BSTR v)
 464 {
 465     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 466     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 467     return E_NOTIMPL;
 468 }
 469
 470 static HRESULT WINAPI HTMLAnchorElement_get_hash(IHTMLAnchorElement *iface, BSTR *p)
 471 {
 472     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 473     nsAString hash_str;
 474     nsresult nsres;
 475
 476     TRACE("(%p)->(%p)\n", This, p);
 477
 478     nsAString_Init(&hash_str, NULL);
 479     nsres = nsIDOMHTMLAnchorElement_GetHash(This->nsanchor, &hash_str);
 480     return return_nsstr(nsres, &hash_str, p);
 481 }
 482
 483 static HRESULT WINAPI HTMLAnchorElement_put_onblur(IHTMLAnchorElement *iface, VARIANT v)
 484 {
 485     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 486
 487     TRACE("(%p)->()\n", This);
 488
 489     return IHTMLElement2_put_onblur(&This->element.IHTMLElement2_iface, v);
 490 }
 491
 492 static HRESULT WINAPI HTMLAnchorElement_get_onblur(IHTMLAnchorElement *iface, VARIANT *p)
 493 {
 494     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 495
 496     TRACE("(%p)->(%p)\n", This, p);
 497
 498     return IHTMLElement2_get_onblur(&This->element.IHTMLElement2_iface, p);
 499 }
 500
 501 static HRESULT WINAPI HTMLAnchorElement_put_onfocus(IHTMLAnchorElement *iface, VARIANT v)
 502 {
 503     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 504
 505     TRACE("(%p)->()\n", This);
 506
 507     return IHTMLElement2_put_onfocus(&This->element.IHTMLElement2_iface, v);
 508 }
 509
 510 static HRESULT WINAPI HTMLAnchorElement_get_onfocus(IHTMLAnchorElement *iface, VARIANT *p)
 511 {
 512     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 513
 514     TRACE("(%p)->(%p)\n", This, p);
 515
 516     return IHTMLElement2_get_onfocus(&This->element.IHTMLElement2_iface, p);
 517 }
 518
 519 static HRESULT WINAPI HTMLAnchorElement_put_accessKey(IHTMLAnchorElement *iface, BSTR v)
 520 {
 521     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 522
 523     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 524
 525     return IHTMLElement2_put_accessKey(&This->element.IHTMLElement2_iface, v);
 526 }
 527
 528 static HRESULT WINAPI HTMLAnchorElement_get_accessKey(IHTMLAnchorElement *iface, BSTR *p)
 529 {
 530     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 531
 532     TRACE("(%p)->(%p)\n", This, p);
 533
 534     return IHTMLElement2_get_accessKey(&This->element.IHTMLElement2_iface, p);
 535 }
 536
 537 static HRESULT WINAPI HTMLAnchorElement_get_protocolLong(IHTMLAnchorElement *iface, BSTR *p)
 538 {
 539     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 540     FIXME("(%p)->(%p)\n", This, p);
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI HTMLAnchorElement_get_mimeType(IHTMLAnchorElement *iface, BSTR *p)
 545 {
 546     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 547     FIXME("(%p)->(%p)\n", This, p);
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT WINAPI HTMLAnchorElement_get_nameProp(IHTMLAnchorElement *iface, BSTR *p)
 552 {
 553     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 554     FIXME("(%p)->(%p)\n", This, p);
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI HTMLAnchorElement_put_tabIndex(IHTMLAnchorElement *iface, short v)
 559 {
 560     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 561
 562     TRACE("(%p)->()\n", This);
 563
 564     return IHTMLElement2_put_tabIndex(&This->element.IHTMLElement2_iface, v);
 565 }
 566
 567 static HRESULT WINAPI HTMLAnchorElement_get_tabIndex(IHTMLAnchorElement *iface, short *p)
 568 {
 569     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 570
 571     TRACE("(%p)->(%p)\n", This, p);
 572
 573     return IHTMLElement2_get_tabIndex(&This->element.IHTMLElement2_iface, p);
 574 }
 575
 576 static HRESULT WINAPI HTMLAnchorElement_focus(IHTMLAnchorElement *iface)
 577 {
 578     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 579
 580     TRACE("(%p)\n", This);
 581
 582     return IHTMLElement2_focus(&This->element.IHTMLElement2_iface);
 583 }
 584
 585 static HRESULT WINAPI HTMLAnchorElement_blur(IHTMLAnchorElement *iface)
 586 {
 587     HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
 588
 589     TRACE("(%p)\n", This);
 590
 591     return IHTMLElement2_blur(&This->element.IHTMLElement2_iface);
 592 }
 593
 594 static const IHTMLAnchorElementVtbl HTMLAnchorElementVtbl = {
 595     HTMLAnchorElement_QueryInterface,
 596     HTMLAnchorElement_AddRef,
 597     HTMLAnchorElement_Release,
 598     HTMLAnchorElement_GetTypeInfoCount,
 599     HTMLAnchorElement_GetTypeInfo,
 600     HTMLAnchorElement_GetIDsOfNames,
 601     HTMLAnchorElement_Invoke,
 602     HTMLAnchorElement_put_href,
 603     HTMLAnchorElement_get_href,
 604     HTMLAnchorElement_put_target,
 605     HTMLAnchorElement_get_target,
 606     HTMLAnchorElement_put_rel,
 607     HTMLAnchorElement_get_rel,
 608     HTMLAnchorElement_put_rev,
 609     HTMLAnchorElement_get_rev,
 610     HTMLAnchorElement_put_urn,
 611     HTMLAnchorElement_get_urn,
 612     HTMLAnchorElement_put_Methods,
 613     HTMLAnchorElement_get_Methods,
 614     HTMLAnchorElement_put_name,
 615     HTMLAnchorElement_get_name,
 616     HTMLAnchorElement_put_host,
 617     HTMLAnchorElement_get_host,
 618     HTMLAnchorElement_put_hostname,
 619     HTMLAnchorElement_get_hostname,
 620     HTMLAnchorElement_put_pathname,
 621     HTMLAnchorElement_get_pathname,
 622     HTMLAnchorElement_put_port,
 623     HTMLAnchorElement_get_port,
 624     HTMLAnchorElement_put_protocol,
 625     HTMLAnchorElement_get_protocol,
 626     HTMLAnchorElement_put_search,
 627     HTMLAnchorElement_get_search,
 628     HTMLAnchorElement_put_hash,
 629     HTMLAnchorElement_get_hash,
 630     HTMLAnchorElement_put_onblur,
 631     HTMLAnchorElement_get_onblur,
 632     HTMLAnchorElement_put_onfocus,
 633     HTMLAnchorElement_get_onfocus,
 634     HTMLAnchorElement_put_accessKey,
 635     HTMLAnchorElement_get_accessKey,
 636     HTMLAnchorElement_get_protocolLong,
 637     HTMLAnchorElement_get_mimeType,
 638     HTMLAnchorElement_get_nameProp,
 639     HTMLAnchorElement_put_tabIndex,
 640     HTMLAnchorElement_get_tabIndex,
 641     HTMLAnchorElement_focus,
 642     HTMLAnchorElement_blur
 643 };
 644
 645 static inline HTMLAnchorElement *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 646 {
 647     return CONTAINING_RECORD(iface, HTMLAnchorElement, element.node);
 648 }
 649
 650 static HRESULT HTMLAnchorElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 651 {
 652     HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
 653
 654     *ppv = NULL;
 655
 656     if(IsEqualGUID(&IID_IUnknown, riid)) {
 657         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 658         *ppv = &This->IHTMLAnchorElement_iface;
 659     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 660         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 661         *ppv = &This->IHTMLAnchorElement_iface;
 662     }else if(IsEqualGUID(&IID_IHTMLAnchorElement, riid)) {
 663         TRACE("(%p)->(IID_IHTMLAnchorElement %p)\n", This, ppv);
 664         *ppv = &This->IHTMLAnchorElement_iface;
 665     }
 666
 667     if(*ppv) {
 668         IUnknown_AddRef((IUnknown*)*ppv);
 669         return S_OK;
 670     }
 671
 672     return HTMLElement_QI(&This->element.node, riid, ppv);
 673 }
 674
 675 static HRESULT HTMLAnchorElement_handle_event(HTMLDOMNode *iface, eventid_t eid, nsIDOMEvent *event, BOOL *prevent_default)
 676 {
 677     HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
 678
 679     if(eid == EVENTID_CLICK) {
 680         nsIDOMMouseEvent *mouse_event;
 681         UINT16 button;
 682         nsresult nsres;
 683
 684         TRACE("CLICK\n");
 685
 686         nsres = nsIDOMEvent_QueryInterface(event, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 687         assert(nsres == NS_OK);
 688
 689         nsres = nsIDOMMouseEvent_GetButton(mouse_event, &button);
 690         assert(nsres == NS_OK);
 691
 692         nsIDOMMouseEvent_Release(mouse_event);
 693
 694         switch(button) {
 695         case 0:
 696             *prevent_default = TRUE;
 697             return navigate_anchor(This);
 698         case 1:
 699             *prevent_default = TRUE;
 700             return navigate_anchor_window(This, NULL);
 701         default:
 702             *prevent_default = FALSE;
 703             return S_OK;
 704         }
 705     }
 706
 707     return HTMLElement_handle_event(&This->element.node, eid, event, prevent_default);
 708 }
 709
 710 static const NodeImplVtbl HTMLAnchorElementImplVtbl = {
 711     HTMLAnchorElement_QI,
 712     HTMLElement_destructor,
 713     HTMLElement_cpc,
 714     HTMLElement_clone,
 715     HTMLAnchorElement_handle_event,
 716     HTMLElement_get_attr_col
 717 };
 718
 719 static const tid_t HTMLAnchorElement_iface_tids[] = {
 720     IHTMLAnchorElement_tid,
 721     HTMLELEMENT_TIDS,
 722     IHTMLUniqueName_tid,
 723     0
 724 };
 725
 726 static dispex_static_data_t HTMLAnchorElement_dispex = {
 727     NULL,
 728     DispHTMLAnchorElement_tid,
 729     NULL,
 730     HTMLAnchorElement_iface_tids
 731 };
 732
 733 HRESULT HTMLAnchorElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
 734 {
 735     HTMLAnchorElement *ret;
 736     nsresult nsres;
 737
 738     ret = heap_alloc_zero(sizeof(HTMLAnchorElement));
 739     if(!ret)
 740         return E_OUTOFMEMORY;
 741
 742     ret->IHTMLAnchorElement_iface.lpVtbl = &HTMLAnchorElementVtbl;
 743     ret->element.node.vtbl = &HTMLAnchorElementImplVtbl;
 744
 745     HTMLElement_Init(&ret->element, doc, nselem, &HTMLAnchorElement_dispex);
 746
 747     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLAnchorElement, (void**)&ret->nsanchor);
 748
 749     /* Shere the reference with nsnode */
 750     assert(nsres == NS_OK && (nsIDOMNode*)ret->nsanchor == ret->element.node.nsnode);
 751     nsIDOMNode_Release(ret->element.node.nsnode);
 752
 753     *elem = &ret->element;
 754     return S_OK;
 755 }