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