dlls/mshtml/nsevents.c

   1 /*
   2  * Copyright 2007-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 #include "mshtmcid.h"
  28 #include "shlguid.h"
  29
  30 #include "wine/debug.h"
  31
  32 #include "mshtml_private.h"
  33 #include "htmlscript.h"
  34 #include "htmlevent.h"
  35 #include "binding.h"
  36 #include "resource.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39
  40 typedef nsresult (*handler_t)(HTMLDocumentNode*,nsIDOMEvent*);
  41
  42 typedef struct {
  43     nsIDOMEventListener nsIDOMEventListener_iface;
  44     nsDocumentEventListener *This;
  45     handler_t handler;
  46 } nsEventListener;
  47
  48 static nsresult handle_blur(HTMLDocumentNode*,nsIDOMEvent*);
  49 static nsresult handle_focus(HTMLDocumentNode*,nsIDOMEvent*);
  50 static nsresult handle_keypress(HTMLDocumentNode*,nsIDOMEvent*);
  51 static nsresult handle_pageshow(HTMLDocumentNode*,nsIDOMEvent*);
  52 static nsresult handle_pagehide(HTMLDocumentNode*,nsIDOMEvent*);
  53 static nsresult handle_load(HTMLDocumentNode*,nsIDOMEvent*);
  54 static nsresult handle_beforeunload(HTMLDocumentNode*,nsIDOMEvent*);
  55 static nsresult handle_unload(HTMLDocumentNode*,nsIDOMEvent*);
  56
  57 enum doc_event_listener_flags {
  58     BUBBLES  = 0x0001,
  59     OVERRIDE = 0x0002,
  60 };
  61
  62 static const struct {
  63     eventid_t id;
  64     enum doc_event_listener_flags flags;
  65     handler_t handler;
  66 } doc_event_listeners[] = {
  67     { EVENTID_BLUR,             0,                  handle_blur },
  68     { EVENTID_FOCUS,            0,                  handle_focus },
  69     { EVENTID_KEYPRESS,         BUBBLES,            handle_keypress },
  70     { EVENTID_PAGESHOW,         OVERRIDE,           handle_pageshow },
  71     { EVENTID_PAGEHIDE,         OVERRIDE,           handle_pagehide },
  72     { EVENTID_LOAD,             OVERRIDE,           handle_load },
  73     { EVENTID_BEFOREUNLOAD,     OVERRIDE,           handle_beforeunload },
  74     { EVENTID_UNLOAD,           OVERRIDE,           handle_unload },
  75 };
  76
  77 struct nsDocumentEventListener {
  78     nsEventListener listener[ARRAY_SIZE(doc_event_listeners)];
  79     nsEventListener htmlevent_listener;
  80
  81     LONG ref;
  82
  83     HTMLDocumentNode *doc;
  84 };
  85
  86 static LONG release_listener(nsDocumentEventListener *This)
  87 {
  88     LONG ref = InterlockedDecrement(&This->ref);
  89
  90     TRACE("(%p) ref=%ld\n", This, ref);
  91
  92     if(!ref)
  93         free(This);
  94
  95     return ref;
  96 }
  97
  98 static inline nsEventListener *impl_from_nsIDOMEventListener(nsIDOMEventListener *iface)
  99 {
 100     return CONTAINING_RECORD(iface, nsEventListener, nsIDOMEventListener_iface);
 101 }
 102
 103 static nsresult NSAPI nsDOMEventListener_QueryInterface(nsIDOMEventListener *iface,
 104         nsIIDRef riid, void **result)
 105 {
 106     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
 107
 108     *result = NULL;
 109
 110     if(IsEqualGUID(&IID_nsISupports, riid)) {
 111         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
 112         *result = &This->nsIDOMEventListener_iface;
 113     }else if(IsEqualGUID(&IID_nsIDOMEventListener, riid)) {
 114         TRACE("(%p)->(IID_nsIDOMEventListener %p)\n", This, result);
 115         *result = &This->nsIDOMEventListener_iface;
 116     }
 117
 118     if(*result) {
 119         nsIDOMEventListener_AddRef(&This->nsIDOMEventListener_iface);
 120         return NS_OK;
 121     }
 122
 123     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 124     return NS_NOINTERFACE;
 125 }
 126
 127 static nsrefcnt NSAPI nsDOMEventListener_AddRef(nsIDOMEventListener *iface)
 128 {
 129     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
 130     LONG ref = InterlockedIncrement(&This->This->ref);
 131
 132     TRACE("(%p) ref=%ld\n", This->This, ref);
 133
 134     return ref;
 135 }
 136
 137 static nsrefcnt NSAPI nsDOMEventListener_Release(nsIDOMEventListener *iface)
 138 {
 139     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
 140
 141     return release_listener(This->This);
 142 }
 143
 144 static nsresult NSAPI nsDOMEventListener_HandleEvent(nsIDOMEventListener *iface, nsIDOMEvent *event)
 145 {
 146     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
 147     HTMLDocumentNode *doc = This->This->doc;
 148     HTMLInnerWindow *window;
 149     nsresult nsres;
 150
 151     if(!doc) {
 152         WARN("NULL doc!\n");
 153         return NS_ERROR_FAILURE;
 154     }
 155
 156     /* Hold a ref to the window, as some apps load another document during handlers */
 157     window = doc->window;
 158     if(window)
 159         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 160
 161     nsres = This->handler(doc, event);
 162
 163     if(window)
 164         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
 165
 166     return nsres;
 167 }
 168
 169 static const nsIDOMEventListenerVtbl nsDOMEventListenerVtbl = {
 170     nsDOMEventListener_QueryInterface,
 171     nsDOMEventListener_AddRef,
 172     nsDOMEventListener_Release,
 173     nsDOMEventListener_HandleEvent
 174 };
 175
 176 static BOOL is_doc_child_focus(GeckoBrowser *nscontainer)
 177 {
 178     HWND hwnd;
 179
 180     for(hwnd = GetFocus(); hwnd && hwnd != nscontainer->hwnd; hwnd = GetParent(hwnd));
 181
 182     return hwnd != NULL;
 183 }
 184
 185 static nsresult handle_blur(HTMLDocumentNode *doc, nsIDOMEvent *event)
 186 {
 187     HTMLDocumentObj *doc_obj;
 188
 189     TRACE("(%p)\n", doc);
 190
 191     if(!doc->doc_obj)
 192         return NS_ERROR_FAILURE;
 193     doc_obj = doc->doc_obj;
 194
 195     if(doc_obj->focus && !is_doc_child_focus(doc_obj->nscontainer)) {
 196         doc_obj->focus = FALSE;
 197         notif_focus(doc_obj);
 198     }
 199
 200     return NS_OK;
 201 }
 202
 203 static nsresult handle_focus(HTMLDocumentNode *doc, nsIDOMEvent *event)
 204 {
 205     HTMLDocumentObj *doc_obj;
 206
 207     TRACE("(%p)\n", doc);
 208
 209     if(!doc->doc_obj)
 210         return NS_ERROR_FAILURE;
 211     doc_obj = doc->doc_obj;
 212
 213     if(!doc_obj->focus) {
 214         doc_obj->focus = TRUE;
 215         notif_focus(doc_obj);
 216     }
 217
 218     return NS_OK;
 219 }
 220
 221 static nsresult handle_keypress(HTMLDocumentNode *doc, nsIDOMEvent *event)
 222 {
 223     if(!doc->browser || !doc->browser->doc)
 224         return NS_ERROR_FAILURE;
 225
 226     TRACE("(%p)->(%p)\n", doc, event);
 227
 228     update_doc(doc->browser->doc, UPDATE_UI);
 229     if(doc->browser->usermode == EDITMODE)
 230         handle_edit_event(doc, event);
 231
 232     return NS_OK;
 233 }
 234
 235 static nsresult handle_pageshow(HTMLDocumentNode *doc, nsIDOMEvent *nsevent)
 236 {
 237     HTMLInnerWindow *window;
 238     DOMEvent *event;
 239     HRESULT hres;
 240
 241     if(!(window = doc->window) || !doc->dom_document || doc->document_mode < COMPAT_MODE_IE11)
 242         return NS_OK;
 243
 244     hres = create_document_event(doc, EVENTID_PAGESHOW, &event);
 245     if(SUCCEEDED(hres)) {
 246         dispatch_event(&window->event_target, event);
 247         IDOMEvent_Release(&event->IDOMEvent_iface);
 248     }
 249
 250     return NS_OK;
 251 }
 252
 253 static nsresult handle_pagehide(HTMLDocumentNode *doc, nsIDOMEvent *nsevent)
 254 {
 255     HTMLInnerWindow *window;
 256     DOMEvent *event;
 257     HRESULT hres;
 258
 259     if(!(window = doc->window) || !doc->dom_document || doc->document_mode < COMPAT_MODE_IE11 || doc->unload_sent)
 260         return NS_OK;
 261
 262     hres = create_document_event(doc, EVENTID_PAGEHIDE, &event);
 263     if(SUCCEEDED(hres)) {
 264         dispatch_event(&window->event_target, event);
 265         IDOMEvent_Release(&event->IDOMEvent_iface);
 266     }
 267
 268     return NS_OK;
 269 }
 270
 271 static void handle_docobj_load(HTMLDocumentObj *doc)
 272 {
 273     IOleCommandTarget *olecmd = NULL;
 274     HRESULT hres;
 275
 276     unlink_ref(&doc->nscontainer->editor_controller);
 277
 278     if(doc->nscontainer->usermode == EDITMODE)
 279         setup_editor_controller(doc->nscontainer);
 280
 281     if(doc->client) {
 282         hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 283         if(FAILED(hres))
 284             olecmd = NULL;
 285     }
 286
 287     if(doc->download_state) {
 288         if(olecmd) {
 289             VARIANT progress;
 290
 291             V_VT(&progress) = VT_I4;
 292             V_I4(&progress) = 0;
 293             IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS,
 294                     OLECMDEXECOPT_DONTPROMPTUSER, &progress, NULL);
 295         }
 296
 297         set_download_state(doc, 0);
 298     }
 299
 300     if(olecmd) {
 301         IOleCommandTarget_Exec(olecmd, &CGID_ShellDocView, 103, 0, NULL, NULL);
 302         IOleCommandTarget_Exec(olecmd, &CGID_MSHTML, IDM_PARSECOMPLETE, 0, NULL, NULL);
 303         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_HTTPEQUIV_DONE, 0, NULL, NULL);
 304
 305         IOleCommandTarget_Release(olecmd);
 306     }
 307 }
 308
 309 static nsresult handle_load(HTMLDocumentNode *doc, nsIDOMEvent *event)
 310 {
 311     HTMLDocumentObj *doc_obj = NULL;
 312     DOMEvent *load_event;
 313     HRESULT hres;
 314
 315     TRACE("(%p)\n", doc);
 316
 317     if(!doc->window || !doc->window->base.outer_window)
 318         return NS_ERROR_FAILURE;
 319     if(doc->doc_obj && doc->doc_obj->doc_node == doc) {
 320         doc_obj = doc->doc_obj;
 321         IUnknown_AddRef(doc_obj->outer_unk);
 322     }
 323     connect_scripts(doc->window);
 324
 325     if(doc_obj)
 326         handle_docobj_load(doc_obj);
 327
 328     doc->window->dom_complete_time = get_time_stamp();
 329     if(doc->window->base.outer_window)
 330         set_ready_state(doc->window->base.outer_window, READYSTATE_COMPLETE);
 331
 332     if(doc_obj) {
 333         if(doc_obj->view_sink)
 334             IAdviseSink_OnViewChange(doc_obj->view_sink, DVASPECT_CONTENT, -1);
 335
 336         set_statustext(doc_obj, IDS_STATUS_DONE, NULL);
 337
 338         update_title(doc_obj);
 339
 340         if(doc_obj->doc_object_service && doc->window->base.outer_window && !(doc->window->base.outer_window->load_flags & BINDING_REFRESH))
 341             IDocObjectService_FireDocumentComplete(doc_obj->doc_object_service,
 342                     &doc->window->base.outer_window->base.IHTMLWindow2_iface, 0);
 343
 344         IUnknown_Release(doc_obj->outer_unk);
 345     }
 346
 347     doc->window->load_event_start_time = get_time_stamp();
 348
 349     if(doc->dom_document) {
 350         hres = create_document_event(doc, EVENTID_LOAD, &load_event);
 351         if(SUCCEEDED(hres)) {
 352             dispatch_event(&doc->node.event_target, load_event);
 353             IDOMEvent_Release(&load_event->IDOMEvent_iface);
 354         }
 355     }else {
 356         WARN("no dom_document\n");
 357     }
 358
 359     hres = create_event_from_nsevent(event, doc->script_global, dispex_compat_mode(&doc->node.event_target.dispex), &load_event);
 360     if(SUCCEEDED(hres)) {
 361         dispatch_event(&doc->window->event_target, load_event);
 362         IDOMEvent_Release(&load_event->IDOMEvent_iface);
 363     }
 364
 365     doc->window->load_event_end_time = get_time_stamp();
 366     return NS_OK;
 367 }
 368
 369 static nsresult handle_beforeunload(HTMLDocumentNode *doc, nsIDOMEvent *nsevent)
 370 {
 371     HTMLInnerWindow *window;
 372     DOMEvent *event;
 373     HRESULT hres;
 374
 375     if(!(window = doc->window) || doc->unload_sent)
 376         return NS_OK;
 377
 378     /* Gecko dispatches this to the document, but IE dispatches it to the window */
 379     hres = create_event_from_nsevent(nsevent, doc->script_global, dispex_compat_mode(&doc->node.event_target.dispex), &event);
 380     if(SUCCEEDED(hres)) {
 381         dispatch_event(&window->event_target, event);
 382         IDOMEvent_Release(&event->IDOMEvent_iface);
 383     }
 384
 385     return NS_OK;
 386 }
 387
 388 static nsresult handle_unload(HTMLDocumentNode *doc, nsIDOMEvent *nsevent)
 389 {
 390     HTMLInnerWindow *window, *pending_window;
 391     DOMEvent *event;
 392     HRESULT hres;
 393
 394     if(!(window = doc->window) || doc->unload_sent)
 395         return NS_OK;
 396     doc->unload_sent = TRUE;
 397
 398     pending_window = window->base.outer_window->pending_window;
 399     if(pending_window)
 400         pending_window->unload_event_start_time = get_time_stamp();
 401
 402     hres = create_event_from_nsevent(nsevent, doc->script_global, dispex_compat_mode(&doc->node.event_target.dispex), &event);
 403     if(SUCCEEDED(hres)) {
 404         dispatch_event(&window->event_target, event);
 405         IDOMEvent_Release(&event->IDOMEvent_iface);
 406     }
 407
 408     if(pending_window)
 409         pending_window->unload_event_end_time = get_time_stamp();
 410
 411     return NS_OK;
 412 }
 413
 414 static nsresult handle_htmlevent(HTMLDocumentNode *doc, nsIDOMEvent *nsevent)
 415 {
 416     nsIDOMEventTarget *event_target;
 417     EventTarget *target;
 418     nsIDOMNode *nsnode;
 419     HTMLDOMNode *node = NULL;
 420     DOMEvent *event;
 421     nsresult nsres;
 422     HRESULT hres;
 423
 424     TRACE("%p\n", doc);
 425
 426     nsres = nsIDOMEvent_GetTarget(nsevent, &event_target);
 427     if(NS_FAILED(nsres) || !event_target) {
 428         ERR("GetEventTarget failed: %08lx\n", nsres);
 429         return NS_OK;
 430     }
 431
 432     nsres = nsIDOMEventTarget_QueryInterface(event_target, &IID_nsIDOMNode, (void**)&nsnode);
 433     nsIDOMEventTarget_Release(event_target);
 434     if(NS_FAILED(nsres)) {
 435         if(!doc->window)
 436             return NS_OK;
 437         target = &doc->window->event_target;
 438         IHTMLWindow2_AddRef(&doc->window->base.IHTMLWindow2_iface);
 439     }else {
 440         hres = get_node(nsnode, TRUE, &node);
 441         nsIDOMNode_Release(nsnode);
 442         if(FAILED(hres))
 443             return NS_OK;
 444         target = &node->event_target;
 445     }
 446
 447     hres = create_event_from_nsevent(nsevent, doc->script_global, dispex_compat_mode(&target->dispex), &event);
 448     if(FAILED(hres)) {
 449         IEventTarget_Release(&target->IEventTarget_iface);
 450         return NS_OK;
 451     }
 452
 453     /* If we fine need for more special cases here, we may consider handling it in a more generic way. */
 454     if((!node || doc == node->doc) && (event->event_id == EVENTID_FOCUS || event->event_id == EVENTID_BLUR)) {
 455         DOMEvent *focus_event;
 456
 457         hres = create_document_event(doc, event->event_id == EVENTID_FOCUS ? EVENTID_FOCUSIN : EVENTID_FOCUSOUT, &focus_event);
 458         if(SUCCEEDED(hres)) {
 459             dispatch_event(target, focus_event);
 460             IDOMEvent_Release(&focus_event->IDOMEvent_iface);
 461         }
 462     }
 463
 464     dispatch_event(target, event);
 465
 466     IDOMEvent_Release(&event->IDOMEvent_iface);
 467     IEventTarget_Release(&target->IEventTarget_iface);
 468     return NS_OK;
 469 }
 470
 471 static void init_event(nsIDOMEventTarget *target, const PRUnichar *type,
 472         nsIDOMEventListener *listener, BOOL capture)
 473 {
 474     nsAString type_str;
 475     nsresult nsres;
 476
 477     nsAString_InitDepend(&type_str, type);
 478     nsres = nsIDOMEventTarget_AddEventListener(target, &type_str, listener, capture, FALSE, 1);
 479     nsAString_Finish(&type_str);
 480     if(NS_FAILED(nsres))
 481         ERR("AddEventTarget failed: %08lx\n", nsres);
 482
 483 }
 484
 485 static void init_listener(nsEventListener *This, nsDocumentEventListener *listener, handler_t handler)
 486 {
 487     This->nsIDOMEventListener_iface.lpVtbl = &nsDOMEventListenerVtbl;
 488     This->handler = handler;
 489     This->This = listener;
 490 }
 491
 492 static nsIDOMEventTarget *get_default_document_target(HTMLDocumentNode *doc)
 493 {
 494     nsIDOMEventTarget *target;
 495     nsISupports *target_iface;
 496     nsresult nsres;
 497
 498     target_iface = doc->window && doc->window->base.outer_window ? (nsISupports*)doc->window->base.outer_window->nswindow : (nsISupports*)doc->dom_document;
 499     nsres = nsISupports_QueryInterface(target_iface, &IID_nsIDOMEventTarget, (void**)&target);
 500     return NS_SUCCEEDED(nsres) ? target : NULL;
 501 }
 502
 503 void add_nsevent_listener(HTMLDocumentNode *doc, nsIDOMNode *nsnode, LPCWSTR type)
 504 {
 505     nsIDOMEventTarget *target;
 506     nsresult nsres;
 507
 508     if(nsnode) {
 509         nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMEventTarget, (void**)&target);
 510         assert(nsres == NS_OK);
 511     }else {
 512         target = get_default_document_target(doc);
 513         if(!target)
 514             return;
 515     }
 516
 517     init_event(target, type, &doc->nsevent_listener->htmlevent_listener.nsIDOMEventListener_iface,
 518             TRUE);
 519     nsIDOMEventTarget_Release(target);
 520 }
 521
 522 static void detach_nslistener(HTMLDocumentNode *doc, const WCHAR *type, nsEventListener *listener, cpp_bool is_capture)
 523 {
 524     nsIDOMEventTarget *target;
 525     nsAString type_str;
 526     nsresult nsres;
 527
 528     target = get_default_document_target(doc);
 529     if(!target)
 530         return;
 531
 532     nsAString_InitDepend(&type_str, type);
 533     nsres = nsIDOMEventTarget_RemoveEventListener(target, &type_str,
 534             &listener->nsIDOMEventListener_iface, is_capture);
 535     nsAString_Finish(&type_str);
 536     nsIDOMEventTarget_Release(target);
 537     if(NS_FAILED(nsres))
 538         ERR("RemoveEventTarget failed: %08lx\n", nsres);
 539 }
 540
 541 void detach_nsevent(HTMLDocumentNode *doc, const WCHAR *type)
 542 {
 543     detach_nslistener(doc, type, &doc->nsevent_listener->htmlevent_listener, TRUE);
 544 }
 545
 546 void release_nsevents(HTMLDocumentNode *doc)
 547 {
 548     nsDocumentEventListener *listener = doc->nsevent_listener;
 549     unsigned i;
 550
 551     TRACE("%p %p\n", doc, doc->nsevent_listener);
 552
 553     if(!listener)
 554         return;
 555
 556     for(i = 0; i < ARRAY_SIZE(doc_event_listeners); i++)
 557         detach_nslistener(doc, get_event_name(doc_event_listeners[i].id), &listener->listener[i], !(doc_event_listeners[i].flags & BUBBLES));
 558
 559     listener->doc = NULL;
 560     release_listener(listener);
 561     doc->nsevent_listener = NULL;
 562 }
 563
 564 void init_nsevents(HTMLDocumentNode *doc)
 565 {
 566     nsDocumentEventListener *listener;
 567     nsIDOMEventTarget *target;
 568     unsigned i;
 569
 570     listener = malloc(sizeof(nsDocumentEventListener));
 571     if(!listener)
 572         return;
 573
 574     TRACE("%p %p\n", doc, listener);
 575
 576     listener->ref = 1;
 577     listener->doc = doc;
 578
 579     for(i = 0; i < ARRAY_SIZE(doc_event_listeners); i++)
 580         init_listener(&listener->listener[i], listener, doc_event_listeners[i].handler);
 581     init_listener(&listener->htmlevent_listener, listener, handle_htmlevent);
 582
 583     doc->nsevent_listener = listener;
 584
 585     target = get_default_document_target(doc);
 586     if(!target)
 587         return;
 588
 589     for(i = 0; i < ARRAY_SIZE(doc_event_listeners); i++) {
 590         init_event(target, get_event_name(doc_event_listeners[i].id), &listener->listener[i].nsIDOMEventListener_iface,
 591                    !(doc_event_listeners[i].flags & BUBBLES));
 592
 593         if(doc_event_listeners[i].flags & OVERRIDE)
 594             doc->event_vector[doc_event_listeners[i].id] = TRUE;
 595     }
 596
 597     nsIDOMEventTarget_Release(target);
 598 }