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