dlls/mshtml/htmlimg.c

   1 /*
   2  * Copyright 2008 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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31 #include "htmlevent.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  34
  35 struct HTMLImg {
  36     HTMLElement element;
  37
  38     IHTMLImgElement IHTMLImgElement_iface;
  39
  40     nsIDOMHTMLImageElement *nsimg;
  41 };
  42
  43 static inline HTMLImg *impl_from_IHTMLImgElement(IHTMLImgElement *iface)
  44 {
  45     return CONTAINING_RECORD(iface, HTMLImg, IHTMLImgElement_iface);
  46 }
  47
  48 static HRESULT WINAPI HTMLImgElement_QueryInterface(IHTMLImgElement *iface, REFIID riid, void **ppv)
  49 {
  50     HTMLImg *This = impl_from_IHTMLImgElement(iface);
  51
  52     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
  53 }
  54
  55 static ULONG WINAPI HTMLImgElement_AddRef(IHTMLImgElement *iface)
  56 {
  57     HTMLImg *This = impl_from_IHTMLImgElement(iface);
  58
  59     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
  60 }
  61
  62 static ULONG WINAPI HTMLImgElement_Release(IHTMLImgElement *iface)
  63 {
  64     HTMLImg *This = impl_from_IHTMLImgElement(iface);
  65
  66     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
  67 }
  68
  69 static HRESULT WINAPI HTMLImgElement_GetTypeInfoCount(IHTMLImgElement *iface, UINT *pctinfo)
  70 {
  71     HTMLImg *This = impl_from_IHTMLImgElement(iface);
  72     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
  73 }
  74
  75 static HRESULT WINAPI HTMLImgElement_GetTypeInfo(IHTMLImgElement *iface, UINT iTInfo,
  76                                               LCID lcid, ITypeInfo **ppTInfo)
  77 {
  78     HTMLImg *This = impl_from_IHTMLImgElement(iface);
  79     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
  80             ppTInfo);
  81 }
  82
  83 static HRESULT WINAPI HTMLImgElement_GetIDsOfNames(IHTMLImgElement *iface, REFIID riid,
  84                                                 LPOLESTR *rgszNames, UINT cNames,
  85                                                 LCID lcid, DISPID *rgDispId)
  86 {
  87     HTMLImg *This = impl_from_IHTMLImgElement(iface);
  88     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
  89             cNames, lcid, rgDispId);
  90 }
  91
  92 static HRESULT WINAPI HTMLImgElement_Invoke(IHTMLImgElement *iface, DISPID dispIdMember,
  93                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
  94                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
  95 {
  96     HTMLImg *This = impl_from_IHTMLImgElement(iface);
  97     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
  98             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
  99 }
 100
 101 static HRESULT WINAPI HTMLImgElement_put_isMap(IHTMLImgElement *iface, VARIANT_BOOL v)
 102 {
 103     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 104     nsresult nsres;
 105
 106     TRACE("(%p)->(%x)\n", This, v);
 107
 108     nsres = nsIDOMHTMLImageElement_SetIsMap(This->nsimg, v != VARIANT_FALSE);
 109     if (NS_FAILED(nsres)) {
 110         ERR("Set IsMap failed: %08lx\n", nsres);
 111         return E_FAIL;
 112     }
 113
 114     return S_OK;
 115 }
 116
 117 static HRESULT WINAPI HTMLImgElement_get_isMap(IHTMLImgElement *iface, VARIANT_BOOL *p)
 118 {
 119     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 120     cpp_bool b;
 121     nsresult nsres;
 122
 123     TRACE("(%p)->(%p)\n", This, p);
 124
 125     if (p == NULL)
 126         return E_INVALIDARG;
 127
 128     nsres = nsIDOMHTMLImageElement_GetIsMap(This->nsimg, &b);
 129     if (NS_FAILED(nsres)) {
 130         ERR("Get IsMap failed: %08lx\n", nsres);
 131         return E_FAIL;
 132     }
 133
 134     *p = variant_bool(b);
 135     return S_OK;
 136 }
 137
 138 static HRESULT WINAPI HTMLImgElement_put_useMap(IHTMLImgElement *iface, BSTR v)
 139 {
 140     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 141     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI HTMLImgElement_get_useMap(IHTMLImgElement *iface, BSTR *p)
 146 {
 147     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 148     FIXME("(%p)->(%p)\n", This, p);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI HTMLImgElement_get_mimeType(IHTMLImgElement *iface, BSTR *p)
 153 {
 154     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 155     FIXME("(%p)->(%p)\n", This, p);
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI HTMLImgElement_get_fileSize(IHTMLImgElement *iface, BSTR *p)
 160 {
 161     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 162     FIXME("(%p)->(%p)\n", This, p);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI HTMLImgElement_get_fileCreatedDate(IHTMLImgElement *iface, BSTR *p)
 167 {
 168     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 169     FIXME("(%p)->(%p)\n", This, p);
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI HTMLImgElement_get_fileModifiedDate(IHTMLImgElement *iface, BSTR *p)
 174 {
 175     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 176     FIXME("(%p)->(%p)\n", This, p);
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI HTMLImgElement_get_fileUpdatedDate(IHTMLImgElement *iface, BSTR *p)
 181 {
 182     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 183     FIXME("(%p)->(%p)\n", This, p);
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI HTMLImgElement_get_protocol(IHTMLImgElement *iface, BSTR *p)
 188 {
 189     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 190     FIXME("(%p)->(%p)\n", This, p);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI HTMLImgElement_get_href(IHTMLImgElement *iface, BSTR *p)
 195 {
 196     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 197     FIXME("(%p)->(%p)\n", This, p);
 198     return E_NOTIMPL;
 199 }
 200
 201 static HRESULT WINAPI HTMLImgElement_get_nameProp(IHTMLImgElement *iface, BSTR *p)
 202 {
 203     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 204     FIXME("(%p)->(%p)\n", This, p);
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI HTMLImgElement_put_border(IHTMLImgElement *iface, VARIANT v)
 209 {
 210     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 211     FIXME("(%p)->()\n", This);
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI HTMLImgElement_get_border(IHTMLImgElement *iface, VARIANT *p)
 216 {
 217     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 218     FIXME("(%p)->(%p)\n", This, p);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI HTMLImgElement_put_vspace(IHTMLImgElement *iface, LONG v)
 223 {
 224     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 225     FIXME("(%p)->(%ld)\n", This, v);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI HTMLImgElement_get_vspace(IHTMLImgElement *iface, LONG *p)
 230 {
 231     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 232     FIXME("(%p)->(%p)\n", This, p);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI HTMLImgElement_put_hspace(IHTMLImgElement *iface, LONG v)
 237 {
 238     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 239     FIXME("(%p)->(%ld)\n", This, v);
 240     return E_NOTIMPL;
 241 }
 242
 243 static HRESULT WINAPI HTMLImgElement_get_hspace(IHTMLImgElement *iface, LONG *p)
 244 {
 245     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 246     FIXME("(%p)->(%p)\n", This, p);
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI HTMLImgElement_put_alt(IHTMLImgElement *iface, BSTR v)
 251 {
 252     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 253     nsAString alt_str;
 254     nsresult nsres;
 255
 256     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 257
 258     nsAString_InitDepend(&alt_str, v);
 259     nsres = nsIDOMHTMLImageElement_SetAlt(This->nsimg, &alt_str);
 260     nsAString_Finish(&alt_str);
 261     if(NS_FAILED(nsres))
 262         ERR("SetAlt failed: %08lx\n", nsres);
 263
 264     return S_OK;
 265 }
 266
 267 static HRESULT WINAPI HTMLImgElement_get_alt(IHTMLImgElement *iface, BSTR *p)
 268 {
 269     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 270     nsAString alt_str;
 271     nsresult nsres;
 272
 273     TRACE("(%p)->(%p)\n", This, p);
 274
 275     nsAString_Init(&alt_str, NULL);
 276     nsres = nsIDOMHTMLImageElement_GetAlt(This->nsimg, &alt_str);
 277     return return_nsstr(nsres, &alt_str, p);
 278 }
 279
 280 static HRESULT WINAPI HTMLImgElement_put_src(IHTMLImgElement *iface, BSTR v)
 281 {
 282     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 283     nsAString src_str;
 284     nsresult nsres;
 285
 286     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 287
 288     nsAString_InitDepend(&src_str, v);
 289     nsres = nsIDOMHTMLImageElement_SetSrc(This->nsimg, &src_str);
 290     nsAString_Finish(&src_str);
 291     if(NS_FAILED(nsres))
 292         ERR("SetSrc failed: %08lx\n", nsres);
 293
 294     return S_OK;
 295 }
 296
 297 static HRESULT WINAPI HTMLImgElement_get_src(IHTMLImgElement *iface, BSTR *p)
 298 {
 299     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 300     const PRUnichar *src;
 301     nsAString src_str;
 302     nsresult nsres;
 303     HRESULT hres = S_OK;
 304
 305     TRACE("(%p)->(%p)\n", This, p);
 306
 307     nsAString_Init(&src_str, NULL);
 308     nsres = nsIDOMHTMLImageElement_GetSrc(This->nsimg, &src_str);
 309     if(NS_SUCCEEDED(nsres)) {
 310         nsAString_GetData(&src_str, &src);
 311
 312         if(!wcsnicmp(src, L"BLOCKED::", ARRAY_SIZE(L"BLOCKED::")-1)) {
 313             TRACE("returning BLOCKED::\n");
 314             *p = SysAllocString(L"BLOCKED::");
 315             if(!*p)
 316                 hres = E_OUTOFMEMORY;
 317         }else {
 318             hres = nsuri_to_url(src, TRUE, p);
 319         }
 320     }else {
 321         ERR("GetSrc failed: %08lx\n", nsres);
 322         hres = E_FAIL;
 323     }
 324
 325     nsAString_Finish(&src_str);
 326     return hres;
 327 }
 328
 329 static HRESULT WINAPI HTMLImgElement_put_lowsrc(IHTMLImgElement *iface, BSTR v)
 330 {
 331     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 332     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI HTMLImgElement_get_lowsrc(IHTMLImgElement *iface, BSTR *p)
 337 {
 338     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 339     FIXME("(%p)->(%p)\n", This, p);
 340     return E_NOTIMPL;
 341 }
 342
 343 static HRESULT WINAPI HTMLImgElement_put_vrml(IHTMLImgElement *iface, BSTR v)
 344 {
 345     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 346     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 347     return E_NOTIMPL;
 348 }
 349
 350 static HRESULT WINAPI HTMLImgElement_get_vrml(IHTMLImgElement *iface, BSTR *p)
 351 {
 352     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 353     FIXME("(%p)->(%p)\n", This, p);
 354     return E_NOTIMPL;
 355 }
 356
 357 static HRESULT WINAPI HTMLImgElement_put_dynsrc(IHTMLImgElement *iface, BSTR v)
 358 {
 359     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 360     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 361     return E_NOTIMPL;
 362 }
 363
 364 static HRESULT WINAPI HTMLImgElement_get_dynsrc(IHTMLImgElement *iface, BSTR *p)
 365 {
 366     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 367     FIXME("(%p)->(%p)\n", This, p);
 368     return E_NOTIMPL;
 369 }
 370
 371 static HRESULT WINAPI HTMLImgElement_get_readyState(IHTMLImgElement *iface, BSTR *p)
 372 {
 373     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 374     FIXME("(%p)->(%p)\n", This, p);
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT WINAPI HTMLImgElement_get_complete(IHTMLImgElement *iface, VARIANT_BOOL *p)
 379 {
 380     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 381     cpp_bool complete;
 382     nsresult nsres;
 383
 384     TRACE("(%p)->(%p)\n", This, p);
 385
 386     nsres = nsIDOMHTMLImageElement_GetComplete(This->nsimg, &complete);
 387     if(NS_FAILED(nsres)) {
 388         ERR("GetComplete failed: %08lx\n", nsres);
 389         return E_FAIL;
 390     }
 391
 392     *p = variant_bool(complete);
 393     return S_OK;
 394 }
 395
 396 static HRESULT WINAPI HTMLImgElement_put_loop(IHTMLImgElement *iface, VARIANT v)
 397 {
 398     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 399     FIXME("(%p)->()\n", This);
 400     return E_NOTIMPL;
 401 }
 402
 403 static HRESULT WINAPI HTMLImgElement_get_loop(IHTMLImgElement *iface, VARIANT *p)
 404 {
 405     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 406     FIXME("(%p)->(%p)\n", This, p);
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI HTMLImgElement_put_align(IHTMLImgElement *iface, BSTR v)
 411 {
 412     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 413     nsAString str;
 414     nsresult nsres;
 415
 416     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 417
 418     nsAString_InitDepend(&str, v);
 419
 420     nsres = nsIDOMHTMLImageElement_SetAlign(This->nsimg, &str);
 421     nsAString_Finish(&str);
 422     if (NS_FAILED(nsres)){
 423         ERR("Set Align(%s) failed: %08lx\n", debugstr_w(v), nsres);
 424         return E_FAIL;
 425     }
 426
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI HTMLImgElement_get_align(IHTMLImgElement *iface, BSTR *p)
 431 {
 432     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 433     nsAString str;
 434     nsresult nsres;
 435
 436     TRACE("(%p)->(%p)\n", This, p);
 437
 438     nsAString_Init(&str, NULL);
 439     nsres = nsIDOMHTMLImageElement_GetAlign(This->nsimg, &str);
 440
 441     return return_nsstr(nsres, &str, p);
 442 }
 443
 444 static HRESULT WINAPI HTMLImgElement_put_onload(IHTMLImgElement *iface, VARIANT v)
 445 {
 446     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 447
 448     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 449
 450     return set_node_event(&This->element.node, EVENTID_LOAD, &v);
 451 }
 452
 453 static HRESULT WINAPI HTMLImgElement_get_onload(IHTMLImgElement *iface, VARIANT *p)
 454 {
 455     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 456
 457     TRACE("(%p)->(%p)\n", This, p);
 458
 459     return get_node_event(&This->element.node, EVENTID_LOAD, p);
 460 }
 461
 462 static HRESULT WINAPI HTMLImgElement_put_onerror(IHTMLImgElement *iface, VARIANT v)
 463 {
 464     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 465
 466     TRACE("(%p)->()\n", This);
 467
 468     return set_node_event(&This->element.node, EVENTID_ERROR, &v);
 469 }
 470
 471 static HRESULT WINAPI HTMLImgElement_get_onerror(IHTMLImgElement *iface, VARIANT *p)
 472 {
 473     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 474
 475     TRACE("(%p)->(%p)\n", This, p);
 476
 477     return get_node_event(&This->element.node, EVENTID_ERROR, p);
 478 }
 479
 480 static HRESULT WINAPI HTMLImgElement_put_onabort(IHTMLImgElement *iface, VARIANT v)
 481 {
 482     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 483
 484     TRACE("(%p)->()\n", This);
 485
 486     return set_node_event(&This->element.node, EVENTID_ABORT, &v);
 487 }
 488
 489 static HRESULT WINAPI HTMLImgElement_get_onabort(IHTMLImgElement *iface, VARIANT *p)
 490 {
 491     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 492
 493     TRACE("(%p)->(%p)\n", This, p);
 494
 495     return get_node_event(&This->element.node, EVENTID_ABORT, p);
 496 }
 497
 498 static HRESULT WINAPI HTMLImgElement_put_name(IHTMLImgElement *iface, BSTR v)
 499 {
 500     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 501     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI HTMLImgElement_get_name(IHTMLImgElement *iface, BSTR *p)
 506 {
 507     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 508     nsAString name;
 509     nsresult nsres;
 510
 511     TRACE("(%p)->(%p)\n", This, p);
 512
 513     nsAString_Init(&name, NULL);
 514     nsres = nsIDOMHTMLImageElement_GetName(This->nsimg, &name);
 515     return return_nsstr(nsres, &name, p);
 516 }
 517
 518 static HRESULT WINAPI HTMLImgElement_put_width(IHTMLImgElement *iface, LONG v)
 519 {
 520     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 521     nsresult nsres;
 522
 523     TRACE("(%p)->(%ld)\n", This, v);
 524
 525     nsres = nsIDOMHTMLImageElement_SetWidth(This->nsimg, v);
 526     if(NS_FAILED(nsres)) {
 527         ERR("SetWidth failed: %08lx\n", nsres);
 528         return E_FAIL;
 529     }
 530
 531     return S_OK;
 532 }
 533
 534 static HRESULT WINAPI HTMLImgElement_get_width(IHTMLImgElement *iface, LONG *p)
 535 {
 536     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 537     UINT32 width;
 538     nsresult nsres;
 539
 540     TRACE("(%p)->(%p)\n", This, p);
 541
 542     nsres = nsIDOMHTMLImageElement_GetWidth(This->nsimg, &width);
 543     if(NS_FAILED(nsres)) {
 544         ERR("GetWidth failed: %08lx\n", nsres);
 545         return E_FAIL;
 546     }
 547
 548     *p = width;
 549     return S_OK;
 550 }
 551
 552 static HRESULT WINAPI HTMLImgElement_put_height(IHTMLImgElement *iface, LONG v)
 553 {
 554     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 555     nsresult nsres;
 556
 557     TRACE("(%p)->(%ld)\n", This, v);
 558
 559     nsres = nsIDOMHTMLImageElement_SetHeight(This->nsimg, v);
 560     if(NS_FAILED(nsres)) {
 561         ERR("SetHeight failed: %08lx\n", nsres);
 562         return E_FAIL;
 563     }
 564
 565     return S_OK;
 566 }
 567
 568 static HRESULT WINAPI HTMLImgElement_get_height(IHTMLImgElement *iface, LONG *p)
 569 {
 570     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 571     UINT32 height;
 572     nsresult nsres;
 573
 574     TRACE("(%p)->(%p)\n", This, p);
 575
 576     nsres = nsIDOMHTMLImageElement_GetHeight(This->nsimg, &height);
 577     if(NS_FAILED(nsres)) {
 578         ERR("GetHeight failed: %08lx\n", nsres);
 579         return E_FAIL;
 580     }
 581
 582     *p = height;
 583     return S_OK;
 584 }
 585
 586 static HRESULT WINAPI HTMLImgElement_put_start(IHTMLImgElement *iface, BSTR v)
 587 {
 588     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 589     FIXME("(%p)->()\n", This);
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI HTMLImgElement_get_start(IHTMLImgElement *iface, BSTR *p)
 594 {
 595     HTMLImg *This = impl_from_IHTMLImgElement(iface);
 596     FIXME("(%p)->(%p)\n", This, p);
 597     return E_NOTIMPL;
 598 }
 599
 600 static const IHTMLImgElementVtbl HTMLImgElementVtbl = {
 601     HTMLImgElement_QueryInterface,
 602     HTMLImgElement_AddRef,
 603     HTMLImgElement_Release,
 604     HTMLImgElement_GetTypeInfoCount,
 605     HTMLImgElement_GetTypeInfo,
 606     HTMLImgElement_GetIDsOfNames,
 607     HTMLImgElement_Invoke,
 608     HTMLImgElement_put_isMap,
 609     HTMLImgElement_get_isMap,
 610     HTMLImgElement_put_useMap,
 611     HTMLImgElement_get_useMap,
 612     HTMLImgElement_get_mimeType,
 613     HTMLImgElement_get_fileSize,
 614     HTMLImgElement_get_fileCreatedDate,
 615     HTMLImgElement_get_fileModifiedDate,
 616     HTMLImgElement_get_fileUpdatedDate,
 617     HTMLImgElement_get_protocol,
 618     HTMLImgElement_get_href,
 619     HTMLImgElement_get_nameProp,
 620     HTMLImgElement_put_border,
 621     HTMLImgElement_get_border,
 622     HTMLImgElement_put_vspace,
 623     HTMLImgElement_get_vspace,
 624     HTMLImgElement_put_hspace,
 625     HTMLImgElement_get_hspace,
 626     HTMLImgElement_put_alt,
 627     HTMLImgElement_get_alt,
 628     HTMLImgElement_put_src,
 629     HTMLImgElement_get_src,
 630     HTMLImgElement_put_lowsrc,
 631     HTMLImgElement_get_lowsrc,
 632     HTMLImgElement_put_vrml,
 633     HTMLImgElement_get_vrml,
 634     HTMLImgElement_put_dynsrc,
 635     HTMLImgElement_get_dynsrc,
 636     HTMLImgElement_get_readyState,
 637     HTMLImgElement_get_complete,
 638     HTMLImgElement_put_loop,
 639     HTMLImgElement_get_loop,
 640     HTMLImgElement_put_align,
 641     HTMLImgElement_get_align,
 642     HTMLImgElement_put_onload,
 643     HTMLImgElement_get_onload,
 644     HTMLImgElement_put_onerror,
 645     HTMLImgElement_get_onerror,
 646     HTMLImgElement_put_onabort,
 647     HTMLImgElement_get_onabort,
 648     HTMLImgElement_put_name,
 649     HTMLImgElement_get_name,
 650     HTMLImgElement_put_width,
 651     HTMLImgElement_get_width,
 652     HTMLImgElement_put_height,
 653     HTMLImgElement_get_height,
 654     HTMLImgElement_put_start,
 655     HTMLImgElement_get_start
 656 };
 657
 658 static inline HTMLImg *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 659 {
 660     return CONTAINING_RECORD(iface, HTMLImg, element.node);
 661 }
 662
 663 static HRESULT HTMLImgElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 664 {
 665     HTMLImg *This = impl_from_HTMLDOMNode(iface);
 666
 667     *ppv = NULL;
 668
 669     if(IsEqualGUID(&IID_IHTMLImgElement, riid)) {
 670         TRACE("(%p)->(IID_IHTMLImgElement %p)\n", This, ppv);
 671         *ppv = &This->IHTMLImgElement_iface;
 672     }else {
 673         return HTMLElement_QI(&This->element.node, riid, ppv);
 674     }
 675
 676     IUnknown_AddRef((IUnknown*)*ppv);
 677     return S_OK;
 678 }
 679
 680 static HRESULT HTMLImgElement_get_readystate(HTMLDOMNode *iface, BSTR *p)
 681 {
 682     HTMLImg *This = impl_from_HTMLDOMNode(iface);
 683
 684     return IHTMLImgElement_get_readyState(&This->IHTMLImgElement_iface, p);
 685 }
 686
 687 static void HTMLImgElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
 688 {
 689     HTMLImg *This = impl_from_HTMLDOMNode(iface);
 690
 691     if(This->nsimg)
 692         note_cc_edge((nsISupports*)This->nsimg, "This->nsimg", cb);
 693 }
 694
 695 static void HTMLImgElement_unlink(HTMLDOMNode *iface)
 696 {
 697     HTMLImg *This = impl_from_HTMLDOMNode(iface);
 698
 699     if(This->nsimg) {
 700         nsIDOMHTMLImageElement *nsimg = This->nsimg;
 701
 702         This->nsimg = NULL;
 703         nsIDOMHTMLImageElement_Release(nsimg);
 704     }
 705 }
 706
 707 static const NodeImplVtbl HTMLImgElementImplVtbl = {
 708     &CLSID_HTMLImg,
 709     HTMLImgElement_QI,
 710     HTMLElement_destructor,
 711     HTMLElement_cpc,
 712     HTMLElement_clone,
 713     HTMLElement_handle_event,
 714     HTMLElement_get_attr_col,
 715     NULL,
 716     NULL,
 717     NULL,
 718     NULL,
 719     HTMLImgElement_get_readystate,
 720     NULL,
 721     NULL,
 722     NULL,
 723     HTMLImgElement_traverse,
 724     HTMLImgElement_unlink
 725 };
 726
 727 static const tid_t HTMLImgElement_iface_tids[] = {
 728     HTMLELEMENT_TIDS,
 729     IHTMLImgElement_tid,
 730     0
 731 };
 732 static dispex_static_data_t HTMLImgElement_dispex = {
 733     L"HTMLImageElement",
 734     NULL,
 735     DispHTMLImg_tid,
 736     HTMLImgElement_iface_tids,
 737     HTMLElement_init_dispex_info
 738 };
 739
 740 HRESULT HTMLImgElement_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 741 {
 742     HTMLImg *ret;
 743     nsresult nsres;
 744
 745     ret = heap_alloc_zero(sizeof(HTMLImg));
 746     if(!ret)
 747         return E_OUTOFMEMORY;
 748
 749     ret->IHTMLImgElement_iface.lpVtbl = &HTMLImgElementVtbl;
 750     ret->element.node.vtbl = &HTMLImgElementImplVtbl;
 751
 752     HTMLElement_Init(&ret->element, doc, nselem, &HTMLImgElement_dispex);
 753
 754     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLImageElement, (void**)&ret->nsimg);
 755     assert(nsres == NS_OK);
 756
 757     *elem = &ret->element;
 758     return S_OK;
 759 }
 760
 761 static inline HTMLImageElementFactory *impl_from_IHTMLImageElementFactory(IHTMLImageElementFactory *iface)
 762 {
 763     return CONTAINING_RECORD(iface, HTMLImageElementFactory, IHTMLImageElementFactory_iface);
 764 }
 765
 766 static HRESULT WINAPI HTMLImageElementFactory_QueryInterface(IHTMLImageElementFactory *iface,
 767         REFIID riid, void **ppv)
 768 {
 769     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 770
 771     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 772
 773     if(IsEqualGUID(&IID_IUnknown, riid)) {
 774         *ppv = &This->IHTMLImageElementFactory_iface;
 775     }else if(IsEqualGUID(&IID_IHTMLImageElementFactory, riid)) {
 776         *ppv = &This->IHTMLImageElementFactory_iface;
 777     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 778         return *ppv ? S_OK : E_NOINTERFACE;
 779     }else {
 780         *ppv = NULL;
 781         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 782         return E_NOINTERFACE;
 783     }
 784
 785     IUnknown_AddRef((IUnknown*)*ppv);
 786     return S_OK;
 787 }
 788
 789 static ULONG WINAPI HTMLImageElementFactory_AddRef(IHTMLImageElementFactory *iface)
 790 {
 791     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 792     LONG ref = InterlockedIncrement(&This->ref);
 793
 794     TRACE("(%p) ref=%ld\n", This, ref);
 795
 796     return ref;
 797 }
 798
 799 static ULONG WINAPI HTMLImageElementFactory_Release(IHTMLImageElementFactory *iface)
 800 {
 801     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 802     LONG ref = InterlockedDecrement(&This->ref);
 803
 804     TRACE("(%p) ref=%ld\n", This, ref);
 805
 806     if(!ref)
 807         heap_free(This);
 808
 809     return ref;
 810 }
 811
 812 static HRESULT WINAPI HTMLImageElementFactory_GetTypeInfoCount(IHTMLImageElementFactory *iface,
 813         UINT *pctinfo)
 814 {
 815     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 816     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 817 }
 818
 819 static HRESULT WINAPI HTMLImageElementFactory_GetTypeInfo(IHTMLImageElementFactory *iface,
 820         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 821 {
 822     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 823     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 824 }
 825
 826 static HRESULT WINAPI HTMLImageElementFactory_GetIDsOfNames(IHTMLImageElementFactory *iface,
 827         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 828         DISPID *rgDispId)
 829 {
 830     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 831     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
 832 }
 833
 834 static HRESULT WINAPI HTMLImageElementFactory_Invoke(IHTMLImageElementFactory *iface,
 835         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 836         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
 837         UINT *puArgErr)
 838 {
 839     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 840     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 841             pDispParams, pVarResult, pExcepInfo, puArgErr);
 842 }
 843
 844 static LONG var_to_size(const VARIANT *v)
 845 {
 846     switch(V_VT(v)) {
 847     case VT_EMPTY:
 848         return 0;
 849     case VT_I4:
 850         return V_I4(v);
 851     case VT_BSTR: {
 852         LONG ret;
 853         HRESULT hres;
 854
 855         hres = VarI4FromStr(V_BSTR(v), 0, 0, &ret);
 856         if(FAILED(hres)) {
 857             FIXME("VarI4FromStr failed: %08lx\n", hres);
 858             return 0;
 859         }
 860         return ret;
 861     }
 862     default:
 863         FIXME("unsupported size %s\n", debugstr_variant(v));
 864     }
 865     return 0;
 866 }
 867
 868 static HRESULT WINAPI HTMLImageElementFactory_create(IHTMLImageElementFactory *iface,
 869         VARIANT width, VARIANT height, IHTMLImgElement **img_elem)
 870 {
 871     HTMLImageElementFactory *This = impl_from_IHTMLImageElementFactory(iface);
 872     HTMLDocumentNode *doc;
 873     IHTMLImgElement *img;
 874     HTMLElement *elem;
 875     nsIDOMElement *nselem;
 876     LONG l;
 877     HRESULT hres;
 878
 879     TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(&width),
 880             debugstr_variant(&height), img_elem);
 881
 882     if(!This->window || !This->window->doc) {
 883         WARN("NULL doc\n");
 884         return E_UNEXPECTED;
 885     }
 886
 887     doc = This->window->doc;
 888
 889     *img_elem = NULL;
 890
 891     hres = create_nselem(doc, L"IMG", &nselem);
 892     if(FAILED(hres))
 893         return hres;
 894
 895     hres = HTMLElement_Create(doc, (nsIDOMNode*)nselem, FALSE, &elem);
 896     nsIDOMElement_Release(nselem);
 897     if(FAILED(hres)) {
 898         ERR("HTMLElement_Create failed\n");
 899         return hres;
 900     }
 901
 902     hres = IHTMLElement_QueryInterface(&elem->IHTMLElement_iface, &IID_IHTMLImgElement,
 903             (void**)&img);
 904     IHTMLElement_Release(&elem->IHTMLElement_iface);
 905     if(FAILED(hres)) {
 906         ERR("IHTMLElement_QueryInterface failed: 0x%08lx\n", hres);
 907         return hres;
 908     }
 909
 910     l = var_to_size(&width);
 911     if(l)
 912         IHTMLImgElement_put_width(img, l);
 913     l = var_to_size(&height);
 914     if(l)
 915         IHTMLImgElement_put_height(img, l);
 916
 917     *img_elem = img;
 918     return S_OK;
 919 }
 920
 921 static const IHTMLImageElementFactoryVtbl HTMLImageElementFactoryVtbl = {
 922     HTMLImageElementFactory_QueryInterface,
 923     HTMLImageElementFactory_AddRef,
 924     HTMLImageElementFactory_Release,
 925     HTMLImageElementFactory_GetTypeInfoCount,
 926     HTMLImageElementFactory_GetTypeInfo,
 927     HTMLImageElementFactory_GetIDsOfNames,
 928     HTMLImageElementFactory_Invoke,
 929     HTMLImageElementFactory_create
 930 };
 931
 932 static inline HTMLImageElementFactory *impl_from_DispatchEx(DispatchEx *iface)
 933 {
 934     return CONTAINING_RECORD(iface, HTMLImageElementFactory, dispex);
 935 }
 936
 937 static HRESULT HTMLImageElementFactory_value(DispatchEx *dispex, LCID lcid,
 938         WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei,
 939         IServiceProvider *caller)
 940 {
 941     HTMLImageElementFactory *This = impl_from_DispatchEx(dispex);
 942     IHTMLImgElement *img;
 943     VARIANT empty, *width, *height;
 944     HRESULT hres;
 945     int argc = params->cArgs - params->cNamedArgs;
 946
 947     V_VT(res) = VT_NULL;
 948
 949     V_VT(&empty) = VT_EMPTY;
 950
 951     width = argc >= 1 ? params->rgvarg + (params->cArgs - 1) : &empty;
 952     height = argc >= 2 ? params->rgvarg + (params->cArgs - 2) : &empty;
 953
 954     hres = IHTMLImageElementFactory_create(&This->IHTMLImageElementFactory_iface, *width, *height,
 955             &img);
 956     if(FAILED(hres))
 957         return hres;
 958
 959     V_VT(res) = VT_DISPATCH;
 960     V_DISPATCH(res) = (IDispatch*)img;
 961
 962     return S_OK;
 963 }
 964
 965 static const tid_t HTMLImageElementFactory_iface_tids[] = {
 966     IHTMLImageElementFactory_tid,
 967     0
 968 };
 969
 970 static const dispex_static_data_vtbl_t HTMLImageElementFactory_dispex_vtbl = {
 971     HTMLImageElementFactory_value,
 972     NULL,
 973     NULL,
 974     NULL
 975 };
 976
 977 static dispex_static_data_t HTMLImageElementFactory_dispex = {
 978     L"Function",
 979     &HTMLImageElementFactory_dispex_vtbl,
 980     IHTMLImageElementFactory_tid,
 981     HTMLImageElementFactory_iface_tids
 982 };
 983
 984 HRESULT HTMLImageElementFactory_Create(HTMLInnerWindow *window, HTMLImageElementFactory **ret_val)
 985 {
 986     HTMLImageElementFactory *ret;
 987
 988     ret = heap_alloc(sizeof(HTMLImageElementFactory));
 989     if(!ret)
 990         return E_OUTOFMEMORY;
 991
 992     ret->IHTMLImageElementFactory_iface.lpVtbl = &HTMLImageElementFactoryVtbl;
 993     ret->ref = 1;
 994     ret->window = window;
 995
 996     init_dispatch(&ret->dispex, (IUnknown*)&ret->IHTMLImageElementFactory_iface,
 997                   &HTMLImageElementFactory_dispex, dispex_compat_mode(&window->event_target.dispex));
 998
 999     *ret_val = ret;
1000     return S_OK;
1001 }