dom/xbl/nsXBLEventHandler.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsCOMPtr.h"
   7 #include "nsIAtom.h"
   8 #include "nsIDOMEventListener.h"
   9 #include "nsIDOMKeyEvent.h"
  10 #include "nsIDOMMouseEvent.h"
  11 #include "nsXBLPrototypeHandler.h"
  12 #include "nsContentUtils.h"
  13 #include "mozilla/dom/Event.h" // for nsIDOMEvent::InternalDOMEvent()
  14 #include "mozilla/dom/EventTarget.h"
  15 #include "mozilla/TextEvents.h"
  16
  17 using namespace mozilla;
  18 using namespace mozilla::dom;
  19
  20 nsXBLEventHandler::nsXBLEventHandler(nsXBLPrototypeHandler* aHandler)
  21   : mProtoHandler(aHandler)
  22 {
  23 }
  24
  25 nsXBLEventHandler::~nsXBLEventHandler()
  26 {
  27 }
  28
  29 NS_IMPL_ISUPPORTS(nsXBLEventHandler, nsIDOMEventListener)
  30
  31 NS_IMETHODIMP
  32 nsXBLEventHandler::HandleEvent(nsIDOMEvent* aEvent)
  33 {
  34   if (!mProtoHandler)
  35     return NS_ERROR_FAILURE;
  36
  37   uint8_t phase = mProtoHandler->GetPhase();
  38   if (phase == NS_PHASE_TARGET) {
  39     uint16_t eventPhase;
  40     aEvent->GetEventPhase(&eventPhase);
  41     if (eventPhase != nsIDOMEvent::AT_TARGET)
  42       return NS_OK;
  43   }
  44
  45   if (!EventMatched(aEvent))
  46     return NS_OK;
  47
  48   mProtoHandler->ExecuteHandler(aEvent->InternalDOMEvent()->GetCurrentTarget(),
  49                                 aEvent);
  50
  51   return NS_OK;
  52 }
  53
  54 nsXBLMouseEventHandler::nsXBLMouseEventHandler(nsXBLPrototypeHandler* aHandler)
  55   : nsXBLEventHandler(aHandler)
  56 {
  57 }
  58
  59 nsXBLMouseEventHandler::~nsXBLMouseEventHandler()
  60 {
  61 }
  62
  63 bool
  64 nsXBLMouseEventHandler::EventMatched(nsIDOMEvent* aEvent)
  65 {
  66   nsCOMPtr<nsIDOMMouseEvent> mouse(do_QueryInterface(aEvent));
  67   return mouse && mProtoHandler->MouseEventMatched(mouse);
  68 }
  69
  70 nsXBLKeyEventHandler::nsXBLKeyEventHandler(nsIAtom* aEventType, uint8_t aPhase,
  71                                            uint8_t aType)
  72   : mEventType(aEventType),
  73     mPhase(aPhase),
  74     mType(aType),
  75     mIsBoundToChrome(false),
  76     mUsingContentXBLScope(false)
  77 {
  78 }
  79
  80 nsXBLKeyEventHandler::~nsXBLKeyEventHandler()
  81 {
  82 }
  83
  84 NS_IMPL_ISUPPORTS(nsXBLKeyEventHandler, nsIDOMEventListener)
  85
  86 bool
  87 nsXBLKeyEventHandler::ExecuteMatchedHandlers(
  88                         nsIDOMKeyEvent* aKeyEvent,
  89                         uint32_t aCharCode,
  90                         const IgnoreModifierState& aIgnoreModifierState)
  91 {
  92   WidgetEvent* event = aKeyEvent->GetInternalNSEvent();
  93   nsCOMPtr<EventTarget> target = aKeyEvent->InternalDOMEvent()->GetCurrentTarget();
  94
  95   bool executed = false;
  96   for (uint32_t i = 0; i < mProtoHandlers.Length(); ++i) {
  97     nsXBLPrototypeHandler* handler = mProtoHandlers[i];
  98     bool hasAllowUntrustedAttr = handler->HasAllowUntrustedAttr();
  99     if ((event->mFlags.mIsTrusted ||
 100         (hasAllowUntrustedAttr && handler->AllowUntrustedEvents()) ||
 101         (!hasAllowUntrustedAttr && !mIsBoundToChrome && !mUsingContentXBLScope)) &&
 102         handler->KeyEventMatched(aKeyEvent, aCharCode, aIgnoreModifierState)) {
 103       handler->ExecuteHandler(target, aKeyEvent);
 104       executed = true;
 105     }
 106   }
 107 #ifdef XP_WIN
 108   // Windows native applications ignore Windows-Logo key state when checking
 109   // shortcut keys even if the key is pressed.  Therefore, if there is no
 110   // shortcut key which exactly matches current modifier state, we should
 111   // retry to look for a shortcut key without the Windows-Logo key press.
 112   if (!executed && !aIgnoreModifierState.mOS) {
 113     WidgetKeyboardEvent* keyEvent = event->AsKeyboardEvent();
 114     if (keyEvent && keyEvent->IsOS()) {
 115       IgnoreModifierState ignoreModifierState(aIgnoreModifierState);
 116       ignoreModifierState.mOS = true;
 117       return ExecuteMatchedHandlers(aKeyEvent, aCharCode, ignoreModifierState);
 118     }
 119   }
 120 #endif
 121   return executed;
 122 }
 123
 124 NS_IMETHODIMP
 125 nsXBLKeyEventHandler::HandleEvent(nsIDOMEvent* aEvent)
 126 {
 127   uint32_t count = mProtoHandlers.Length();
 128   if (count == 0)
 129     return NS_ERROR_FAILURE;
 130
 131   if (mPhase == NS_PHASE_TARGET) {
 132     uint16_t eventPhase;
 133     aEvent->GetEventPhase(&eventPhase);
 134     if (eventPhase != nsIDOMEvent::AT_TARGET)
 135       return NS_OK;
 136   }
 137
 138   nsCOMPtr<nsIDOMKeyEvent> key(do_QueryInterface(aEvent));
 139   if (!key)
 140     return NS_OK;
 141
 142   nsAutoTArray<nsShortcutCandidate, 10> accessKeys;
 143   nsContentUtils::GetAccelKeyCandidates(key, accessKeys);
 144
 145   if (accessKeys.IsEmpty()) {
 146     ExecuteMatchedHandlers(key, 0, IgnoreModifierState());
 147     return NS_OK;
 148   }
 149
 150   for (uint32_t i = 0; i < accessKeys.Length(); ++i) {
 151     IgnoreModifierState ignoreModifierState;
 152     ignoreModifierState.mShift = accessKeys[i].mIgnoreShift;
 153     if (ExecuteMatchedHandlers(key, accessKeys[i].mCharCode,
 154                                ignoreModifierState)) {
 155       return NS_OK;
 156     }
 157   }
 158   return NS_OK;
 159 }
 160
 161 ///////////////////////////////////////////////////////////////////////////////////
 162
 163 nsresult
 164 NS_NewXBLEventHandler(nsXBLPrototypeHandler* aHandler,
 165                       nsIAtom* aEventType,
 166                       nsXBLEventHandler** aResult)
 167 {
 168   switch (nsContentUtils::GetEventClassID(nsDependentAtomString(aEventType))) {
 169     case eDragEventClass:
 170     case eMouseEventClass:
 171     case eMouseScrollEventClass:
 172     case eWheelEventClass:
 173     case eSimpleGestureEventClass:
 174       *aResult = new nsXBLMouseEventHandler(aHandler);
 175       break;
 176     default:
 177       *aResult = new nsXBLEventHandler(aHandler);
 178       break;
 179   }
 180
 181   if (!*aResult)
 182     return NS_ERROR_OUT_OF_MEMORY;
 183
 184   NS_ADDREF(*aResult);
 185
 186   return NS_OK;
 187 }
 188
 189 nsresult
 190 NS_NewXBLKeyEventHandler(nsIAtom* aEventType, uint8_t aPhase, uint8_t aType,
 191                          nsXBLKeyEventHandler** aResult)
 192 {
 193   *aResult = new nsXBLKeyEventHandler(aEventType, aPhase, aType);
 194
 195   if (!*aResult)
 196     return NS_ERROR_OUT_OF_MEMORY;
 197
 198   NS_ADDREF(*aResult);
 199
 200   return NS_OK;
 201 }