summaryrefslogtreecommitdiffstats
path: root/dom/events/KeyEventHandler.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/events/KeyEventHandler.cpp721
1 files changed, 721 insertions, 0 deletions
diff --git a/dom/events/KeyEventHandler.cpp b/dom/events/KeyEventHandler.cpp
new file mode 100644
index 0000000000..34b7202c70
--- /dev/null
+++ b/dom/events/KeyEventHandler.cpp
@@ -0,0 +1,721 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+
+#include "ErrorList.h"
+#include "nsCOMPtr.h"
+#include "nsQueryObject.h"
+#include "KeyEventHandler.h"
+#include "nsContentUtils.h"
+#include "nsGlobalWindowCommands.h"
+#include "nsIContent.h"
+#include "nsAtom.h"
+#include "nsNameSpaceManager.h"
+#include "mozilla/dom/Document.h"
+#include "nsIController.h"
+#include "nsIControllers.h"
+#include "nsXULElement.h"
+#include "nsFocusManager.h"
+#include "nsIFormControl.h"
+#include "nsPIDOMWindow.h"
+#include "nsPIWindowRoot.h"
+#include "nsIScriptError.h"
+#include "nsIWeakReferenceUtils.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsGkAtoms.h"
+#include "nsDOMCID.h"
+#include "nsUnicharUtils.h"
+#include "nsCRT.h"
+#include "nsJSUtils.h"
+#include "mozilla/BasicEvents.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/JSEventHandler.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/EventHandlerBinding.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/dom/HTMLTextAreaElement.h"
+#include "mozilla/dom/KeyboardEvent.h"
+#include "mozilla/dom/KeyboardEventBinding.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/layers/KeyboardMap.h"
+#include "xpcpublic.h"
+
+namespace mozilla {
+
+using namespace mozilla::layers;
+
+uint32_t KeyEventHandler::gRefCnt = 0;
+
+const int32_t KeyEventHandler::cShift = (1 << 0);
+const int32_t KeyEventHandler::cAlt = (1 << 1);
+const int32_t KeyEventHandler::cControl = (1 << 2);
+const int32_t KeyEventHandler::cMeta = (1 << 3);
+
+const int32_t KeyEventHandler::cShiftMask = (1 << 5);
+const int32_t KeyEventHandler::cAltMask = (1 << 6);
+const int32_t KeyEventHandler::cControlMask = (1 << 7);
+const int32_t KeyEventHandler::cMetaMask = (1 << 8);
+
+const int32_t KeyEventHandler::cAllModifiers =
+ cShiftMask | cAltMask | cControlMask | cMetaMask;
+
+KeyEventHandler::KeyEventHandler(dom::Element* aHandlerElement,
+ ReservedKey aReserved)
+ : mHandlerElement(nullptr),
+ mIsXULKey(true),
+ mReserved(aReserved),
+ mNextHandler(nullptr) {
+ Init();
+
+ // Make sure our prototype is initialized.
+ ConstructPrototype(aHandlerElement);
+}
+
+KeyEventHandler::KeyEventHandler(ShortcutKeyData* aKeyData)
+ : mCommand(nullptr),
+ mIsXULKey(false),
+ mReserved(ReservedKey_False),
+ mNextHandler(nullptr) {
+ Init();
+
+ ConstructPrototype(nullptr, aKeyData->event, aKeyData->command,
+ aKeyData->keycode, aKeyData->key, aKeyData->modifiers);
+}
+
+KeyEventHandler::~KeyEventHandler() {
+ --gRefCnt;
+ if (mIsXULKey) {
+ NS_IF_RELEASE(mHandlerElement);
+ } else if (mCommand) {
+ free(mCommand);
+ }
+
+ // We own the next handler in the chain, so delete it now.
+ NS_CONTENT_DELETE_LIST_MEMBER(KeyEventHandler, this, mNextHandler);
+}
+
+void KeyEventHandler::GetCommand(nsAString& aCommand) const {
+ MOZ_ASSERT(aCommand.IsEmpty());
+ if (mIsXULKey) {
+ MOZ_ASSERT_UNREACHABLE("Not yet implemented");
+ return;
+ }
+ if (mCommand) {
+ aCommand.Assign(mCommand);
+ }
+}
+
+bool KeyEventHandler::TryConvertToKeyboardShortcut(
+ KeyboardShortcut* aOut) const {
+ // Convert the event type
+ KeyboardInput::KeyboardEventType eventType;
+
+ if (mEventName == nsGkAtoms::keydown) {
+ eventType = KeyboardInput::KEY_DOWN;
+ } else if (mEventName == nsGkAtoms::keypress) {
+ eventType = KeyboardInput::KEY_PRESS;
+ } else if (mEventName == nsGkAtoms::keyup) {
+ eventType = KeyboardInput::KEY_UP;
+ } else {
+ return false;
+ }
+
+ // Convert the modifiers
+ Modifiers modifiersMask = GetModifiersMask();
+ Modifiers modifiers = GetModifiers();
+
+ // Mask away any bits that won't be compared
+ modifiers &= modifiersMask;
+
+ // Convert the keyCode or charCode
+ uint32_t keyCode;
+ uint32_t charCode;
+
+ if (mMisc) {
+ keyCode = 0;
+ charCode = static_cast<uint32_t>(mDetail);
+ } else {
+ keyCode = static_cast<uint32_t>(mDetail);
+ charCode = 0;
+ }
+
+ NS_LossyConvertUTF16toASCII commandText(mCommand);
+ KeyboardScrollAction action;
+ if (!nsGlobalWindowCommands::FindScrollCommand(commandText.get(), &action)) {
+ // This action doesn't represent a scroll so we need to create a dispatch
+ // to content keyboard shortcut so APZ handles this command correctly
+ *aOut = KeyboardShortcut(eventType, keyCode, charCode, modifiers,
+ modifiersMask);
+ return true;
+ }
+
+ // This prototype is a command which represents a scroll action, so create
+ // a keyboard shortcut to handle it
+ *aOut = KeyboardShortcut(eventType, keyCode, charCode, modifiers,
+ modifiersMask, action);
+ return true;
+}
+
+bool KeyEventHandler::KeyElementIsDisabled() const {
+ RefPtr<dom::Element> keyElement = GetHandlerElement();
+ return keyElement &&
+ keyElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+ nsGkAtoms::_true, eCaseMatters);
+}
+
+already_AddRefed<dom::Element> KeyEventHandler::GetHandlerElement() const {
+ if (mIsXULKey) {
+ nsCOMPtr<dom::Element> element = do_QueryReferent(mHandlerElement);
+ return element.forget();
+ }
+
+ return nullptr;
+}
+
+nsresult KeyEventHandler::ExecuteHandler(dom::EventTarget* aTarget,
+ dom::Event* aEvent) {
+ // In both cases the union should be defined.
+ if (!mHandlerElement) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // XUL handlers and commands shouldn't be triggered by non-trusted
+ // events.
+ if (!aEvent->IsTrusted()) {
+ return NS_OK;
+ }
+
+ if (mIsXULKey) {
+ return DispatchXULKeyCommand(aEvent);
+ }
+
+ return DispatchXBLCommand(aTarget, aEvent);
+}
+
+nsresult KeyEventHandler::DispatchXBLCommand(dom::EventTarget* aTarget,
+ dom::Event* aEvent) {
+ // This is a special-case optimization to make command handling fast.
+ // It isn't really a part of XBL, but it helps speed things up.
+
+ if (aEvent) {
+ // See if preventDefault has been set. If so, don't execute.
+ if (aEvent->DefaultPrevented()) {
+ return NS_OK;
+ }
+ bool dispatchStopped = aEvent->IsDispatchStopped();
+ if (dispatchStopped) {
+ return NS_OK;
+ }
+ }
+
+ // Instead of executing JS, let's get the controller for the bound
+ // element and call doCommand on it.
+ nsCOMPtr<nsIController> controller;
+
+ nsCOMPtr<nsPIDOMWindowOuter> privateWindow;
+ nsCOMPtr<nsPIWindowRoot> windowRoot =
+ nsPIWindowRoot::FromEventTargetOrNull(aTarget);
+ if (windowRoot) {
+ privateWindow = windowRoot->GetWindow();
+ } else {
+ privateWindow = nsPIDOMWindowOuter::FromEventTargetOrNull(aTarget);
+ if (!privateWindow) {
+ nsCOMPtr<dom::Document> doc;
+ // XXXbz sXBL/XBL2 issue -- this should be the "scope doc" or
+ // something... whatever we use when wrapping DOM nodes
+ // normally. It's not clear that the owner doc is the right
+ // thing.
+ if (nsIContent* content = nsIContent::FromEventTargetOrNull(aTarget)) {
+ doc = content->OwnerDoc();
+ }
+
+ if (!doc) {
+ if (nsINode* node = nsINode::FromEventTargetOrNull(aTarget)) {
+ if (node->IsDocument()) {
+ doc = node->AsDocument();
+ }
+ }
+ }
+
+ if (!doc) {
+ return NS_ERROR_FAILURE;
+ }
+
+ privateWindow = doc->GetWindow();
+ if (!privateWindow) {
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ windowRoot = privateWindow->GetTopWindowRoot();
+ }
+
+ NS_LossyConvertUTF16toASCII command(mCommand);
+ if (windowRoot) {
+ // If user tries to do something, user must try to do it in visible window.
+ // So, let's retrieve controller of visible window.
+ windowRoot->GetControllerForCommand(command.get(), true,
+ getter_AddRefs(controller));
+ } else {
+ controller =
+ GetController(aTarget); // We're attached to the receiver possibly.
+ }
+
+ // We are the default action for this command.
+ // Stop any other default action from executing.
+ aEvent->PreventDefault();
+
+ if (mEventName == nsGkAtoms::keypress &&
+ mDetail == dom::KeyboardEvent_Binding::DOM_VK_SPACE && mMisc == 1) {
+ // get the focused element so that we can pageDown only at
+ // certain times.
+
+ nsCOMPtr<nsPIDOMWindowOuter> windowToCheck;
+ if (windowRoot) {
+ windowToCheck = windowRoot->GetWindow();
+ } else {
+ windowToCheck = privateWindow->GetPrivateRoot();
+ }
+
+ nsCOMPtr<nsIContent> focusedContent;
+ if (windowToCheck) {
+ nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
+ focusedContent = nsFocusManager::GetFocusedDescendant(
+ windowToCheck, nsFocusManager::eIncludeAllDescendants,
+ getter_AddRefs(focusedWindow));
+ }
+
+ // If the focus is in an editable region, don't scroll.
+ if (focusedContent && focusedContent->IsEditable()) {
+ return NS_OK;
+ }
+
+ // If the focus is in a form control, don't scroll.
+ for (nsIContent* c = focusedContent; c; c = c->GetParent()) {
+ nsCOMPtr<nsIFormControl> formControl = do_QueryInterface(c);
+ if (formControl) {
+ return NS_OK;
+ }
+ }
+ }
+
+ if (controller) {
+ controller->DoCommand(command.get());
+ }
+
+ return NS_OK;
+}
+
+nsresult KeyEventHandler::DispatchXULKeyCommand(dom::Event* aEvent) {
+ nsCOMPtr<dom::Element> handlerElement = GetHandlerElement();
+ NS_ENSURE_STATE(handlerElement);
+ if (handlerElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+ nsGkAtoms::_true, eCaseMatters)) {
+ // Don't dispatch command events for disabled keys.
+ return NS_SUCCESS_DOM_NO_OPERATION;
+ }
+
+ aEvent->PreventDefault();
+
+ // Copy the modifiers from the key event.
+ RefPtr<dom::KeyboardEvent> domKeyboardEvent = aEvent->AsKeyboardEvent();
+ if (!domKeyboardEvent) {
+ NS_ERROR("Trying to execute a key handler for a non-key event!");
+ return NS_ERROR_FAILURE;
+ }
+
+ // XXX We should use mozilla::Modifiers for supporting all modifiers.
+
+ bool isAlt = domKeyboardEvent->AltKey();
+ bool isControl = domKeyboardEvent->CtrlKey();
+ bool isShift = domKeyboardEvent->ShiftKey();
+ bool isMeta = domKeyboardEvent->MetaKey();
+
+ nsContentUtils::DispatchXULCommand(handlerElement, true, nullptr, nullptr,
+ isControl, isAlt, isShift, isMeta);
+ return NS_OK;
+}
+
+Modifiers KeyEventHandler::GetModifiers() const {
+ Modifiers modifiers = 0;
+
+ if (mKeyMask & cMeta) {
+ modifiers |= MODIFIER_META;
+ }
+ if (mKeyMask & cShift) {
+ modifiers |= MODIFIER_SHIFT;
+ }
+ if (mKeyMask & cAlt) {
+ modifiers |= MODIFIER_ALT;
+ }
+ if (mKeyMask & cControl) {
+ modifiers |= MODIFIER_CONTROL;
+ }
+
+ return modifiers;
+}
+
+Modifiers KeyEventHandler::GetModifiersMask() const {
+ Modifiers modifiersMask = 0;
+
+ if (mKeyMask & cMetaMask) {
+ modifiersMask |= MODIFIER_META;
+ }
+ if (mKeyMask & cShiftMask) {
+ modifiersMask |= MODIFIER_SHIFT;
+ }
+ if (mKeyMask & cAltMask) {
+ modifiersMask |= MODIFIER_ALT;
+ }
+ if (mKeyMask & cControlMask) {
+ modifiersMask |= MODIFIER_CONTROL;
+ }
+
+ return modifiersMask;
+}
+
+already_AddRefed<nsIController> KeyEventHandler::GetController(
+ dom::EventTarget* aTarget) {
+ if (!aTarget) {
+ return nullptr;
+ }
+
+ // XXX Fix this so there's a generic interface that describes controllers,
+ // This code should have no special knowledge of what objects might have
+ // controllers.
+ nsCOMPtr<nsIControllers> controllers;
+
+ if (nsIContent* targetContent = nsIContent::FromEventTarget(aTarget)) {
+ RefPtr<nsXULElement> xulElement = nsXULElement::FromNode(targetContent);
+ if (xulElement) {
+ controllers = xulElement->GetControllers(IgnoreErrors());
+ }
+
+ if (!controllers) {
+ dom::HTMLTextAreaElement* htmlTextArea =
+ dom::HTMLTextAreaElement::FromNode(targetContent);
+ if (htmlTextArea) {
+ htmlTextArea->GetControllers(getter_AddRefs(controllers));
+ }
+ }
+
+ if (!controllers) {
+ dom::HTMLInputElement* htmlInputElement =
+ dom::HTMLInputElement::FromNode(targetContent);
+ if (htmlInputElement) {
+ htmlInputElement->GetControllers(getter_AddRefs(controllers));
+ }
+ }
+ }
+
+ if (!controllers) {
+ if (nsCOMPtr<nsPIDOMWindowOuter> domWindow =
+ nsPIDOMWindowOuter::FromEventTarget(aTarget)) {
+ domWindow->GetControllers(getter_AddRefs(controllers));
+ }
+ }
+
+ // Return the first controller.
+ // XXX This code should be checking the command name and using supportscommand
+ // and iscommandenabled.
+ nsCOMPtr<nsIController> controller;
+ if (controllers) {
+ controllers->GetControllerAt(0, getter_AddRefs(controller));
+ }
+
+ return controller.forget();
+}
+
+bool KeyEventHandler::KeyEventMatched(
+ dom::KeyboardEvent* aDomKeyboardEvent, uint32_t aCharCode,
+ const IgnoreModifierState& aIgnoreModifierState) {
+ if (mDetail != -1) {
+ // Get the keycode or charcode of the key event.
+ uint32_t code;
+
+ if (mMisc) {
+ if (aCharCode) {
+ code = aCharCode;
+ } else {
+ code = aDomKeyboardEvent->CharCode();
+ }
+ if (IS_IN_BMP(code)) {
+ code = ToLowerCase(char16_t(code));
+ }
+ } else {
+ code = aDomKeyboardEvent->KeyCode();
+ }
+
+ if (code != static_cast<uint32_t>(mDetail)) {
+ return false;
+ }
+ }
+
+ return ModifiersMatchMask(aDomKeyboardEvent, aIgnoreModifierState);
+}
+
+struct keyCodeData {
+ const char* str;
+ uint16_t strlength;
+ uint16_t keycode;
+};
+
+// All of these must be uppercase, since the function below does
+// case-insensitive comparison by converting to uppercase.
+// XXX: be sure to check this periodically for new symbol additions!
+static const keyCodeData gKeyCodes[] = {
+
+#define NS_DEFINE_VK(aDOMKeyName, aDOMKeyCode) \
+ {#aDOMKeyName, sizeof(#aDOMKeyName) - 1, aDOMKeyCode},
+#include "mozilla/VirtualKeyCodeList.h"
+#undef NS_DEFINE_VK
+
+ {nullptr, 0, 0}};
+
+int32_t KeyEventHandler::GetMatchingKeyCode(const nsAString& aKeyName) {
+ nsAutoCString keyName;
+ LossyCopyUTF16toASCII(aKeyName, keyName);
+ ToUpperCase(keyName); // We want case-insensitive comparison with data
+ // stored as uppercase.
+
+ uint32_t keyNameLength = keyName.Length();
+ const char* keyNameStr = keyName.get();
+ for (unsigned long i = 0; i < ArrayLength(gKeyCodes) - 1; ++i) {
+ if (keyNameLength == gKeyCodes[i].strlength &&
+ !nsCRT::strcmp(gKeyCodes[i].str, keyNameStr)) {
+ return gKeyCodes[i].keycode;
+ }
+ }
+
+ return 0;
+}
+
+int32_t KeyEventHandler::KeyToMask(uint32_t key) {
+ switch (key) {
+ case dom::KeyboardEvent_Binding::DOM_VK_META:
+ case dom::KeyboardEvent_Binding::DOM_VK_WIN:
+ return cMeta | cMetaMask;
+
+ case dom::KeyboardEvent_Binding::DOM_VK_ALT:
+ return cAlt | cAltMask;
+
+ case dom::KeyboardEvent_Binding::DOM_VK_CONTROL:
+ default:
+ return cControl | cControlMask;
+ }
+}
+
+// static
+int32_t KeyEventHandler::AccelKeyMask() {
+ switch (WidgetInputEvent::AccelModifier()) {
+ case MODIFIER_ALT:
+ return KeyToMask(dom::KeyboardEvent_Binding::DOM_VK_ALT);
+ case MODIFIER_CONTROL:
+ return KeyToMask(dom::KeyboardEvent_Binding::DOM_VK_CONTROL);
+ case MODIFIER_META:
+ return KeyToMask(dom::KeyboardEvent_Binding::DOM_VK_META);
+ default:
+ MOZ_CRASH("Handle the new result of WidgetInputEvent::AccelModifier()");
+ return 0;
+ }
+}
+
+void KeyEventHandler::GetEventType(nsAString& aEvent) {
+ nsCOMPtr<dom::Element> handlerElement = GetHandlerElement();
+ if (!handlerElement) {
+ aEvent.Truncate();
+ return;
+ }
+ handlerElement->GetAttr(nsGkAtoms::event, aEvent);
+
+ if (aEvent.IsEmpty() && mIsXULKey) {
+ // If no type is specified for a XUL <key> element, let's assume that we're
+ // "keypress".
+ aEvent.AssignLiteral("keypress");
+ }
+}
+
+void KeyEventHandler::ConstructPrototype(dom::Element* aKeyElement,
+ const char16_t* aEvent,
+ const char16_t* aCommand,
+ const char16_t* aKeyCode,
+ const char16_t* aCharCode,
+ const char16_t* aModifiers) {
+ mDetail = -1;
+ mMisc = 0;
+ mKeyMask = 0;
+ nsAutoString modifiers;
+
+ if (mIsXULKey) {
+ nsWeakPtr weak = do_GetWeakReference(aKeyElement);
+ if (!weak) {
+ return;
+ }
+ weak.swap(mHandlerElement);
+
+ nsAutoString event;
+ GetEventType(event);
+ if (event.IsEmpty()) {
+ return;
+ }
+ mEventName = NS_Atomize(event);
+
+ aKeyElement->GetAttr(nsGkAtoms::modifiers, modifiers);
+ } else {
+ mCommand = ToNewUnicode(nsDependentString(aCommand));
+ mEventName = NS_Atomize(aEvent);
+ modifiers = aModifiers;
+ }
+
+ BuildModifiers(modifiers);
+
+ nsAutoString key(aCharCode);
+ if (key.IsEmpty()) {
+ if (mIsXULKey) {
+ aKeyElement->GetAttr(nsGkAtoms::key, key);
+ if (key.IsEmpty()) {
+ aKeyElement->GetAttr(nsGkAtoms::charcode, key);
+ }
+ }
+ }
+
+ if (!key.IsEmpty()) {
+ if (mKeyMask == 0) {
+ mKeyMask = cAllModifiers;
+ }
+ ToLowerCase(key);
+
+ // We have a charcode.
+ mMisc = 1;
+ mDetail = key[0];
+ const uint8_t GTK2Modifiers = cShift | cControl | cShiftMask | cControlMask;
+ if (mIsXULKey && (mKeyMask & GTK2Modifiers) == GTK2Modifiers &&
+ modifiers.First() != char16_t(',') &&
+ (mDetail == 'u' || mDetail == 'U')) {
+ ReportKeyConflict(key.get(), modifiers.get(), aKeyElement,
+ "GTK2Conflict2");
+ }
+ const uint8_t WinModifiers = cControl | cAlt | cControlMask | cAltMask;
+ if (mIsXULKey && (mKeyMask & WinModifiers) == WinModifiers &&
+ modifiers.First() != char16_t(',') &&
+ (('A' <= mDetail && mDetail <= 'Z') ||
+ ('a' <= mDetail && mDetail <= 'z'))) {
+ ReportKeyConflict(key.get(), modifiers.get(), aKeyElement,
+ "WinConflict2");
+ }
+ } else {
+ key.Assign(aKeyCode);
+ if (mIsXULKey) {
+ aKeyElement->GetAttr(nsGkAtoms::keycode, key);
+ }
+
+ if (!key.IsEmpty()) {
+ if (mKeyMask == 0) {
+ mKeyMask = cAllModifiers;
+ }
+ mDetail = GetMatchingKeyCode(key);
+ }
+ }
+}
+
+void KeyEventHandler::BuildModifiers(nsAString& aModifiers) {
+ if (!aModifiers.IsEmpty()) {
+ mKeyMask = cAllModifiers;
+ char* str = ToNewCString(aModifiers);
+ char* newStr;
+ char* token = nsCRT::strtok(str, ", \t", &newStr);
+ while (token != nullptr) {
+ if (strcmp(token, "shift") == 0) {
+ mKeyMask |= cShift | cShiftMask;
+ } else if (strcmp(token, "alt") == 0) {
+ mKeyMask |= cAlt | cAltMask;
+ } else if (strcmp(token, "meta") == 0) {
+ mKeyMask |= cMeta | cMetaMask;
+ } else if (strcmp(token, "control") == 0) {
+ mKeyMask |= cControl | cControlMask;
+ } else if (strcmp(token, "accel") == 0) {
+ mKeyMask |= AccelKeyMask();
+ } else if (strcmp(token, "access") == 0) {
+ mKeyMask |= KeyToMask(LookAndFeel::GetMenuAccessKey());
+ } else if (strcmp(token, "any") == 0) {
+ mKeyMask &= ~(mKeyMask << 5);
+ }
+
+ token = nsCRT::strtok(newStr, ", \t", &newStr);
+ }
+
+ free(str);
+ }
+}
+
+void KeyEventHandler::ReportKeyConflict(const char16_t* aKey,
+ const char16_t* aModifiers,
+ dom::Element* aKeyElement,
+ const char* aMessageName) {
+ nsCOMPtr<dom::Document> doc = aKeyElement->OwnerDoc();
+
+ nsAutoString id;
+ aKeyElement->GetAttr(nsGkAtoms::id, id);
+ AutoTArray<nsString, 3> params;
+ params.AppendElement(aKey);
+ params.AppendElement(aModifiers);
+ params.AppendElement(id);
+ nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
+ "Key dom::Event Handler"_ns, doc,
+ nsContentUtils::eDOM_PROPERTIES, aMessageName,
+ params, nullptr, u""_ns, 0);
+}
+
+bool KeyEventHandler::ModifiersMatchMask(
+ dom::UIEvent* aEvent, const IgnoreModifierState& aIgnoreModifierState) {
+ WidgetInputEvent* inputEvent = aEvent->WidgetEventPtr()->AsInputEvent();
+ NS_ENSURE_TRUE(inputEvent, false);
+
+ if ((mKeyMask & cMetaMask) && !aIgnoreModifierState.mMeta) {
+ if (inputEvent->IsMeta() != ((mKeyMask & cMeta) != 0)) {
+ return false;
+ }
+ }
+
+ if ((mKeyMask & cShiftMask) && !aIgnoreModifierState.mShift) {
+ if (inputEvent->IsShift() != ((mKeyMask & cShift) != 0)) {
+ return false;
+ }
+ }
+
+ if (mKeyMask & cAltMask) {
+ if (inputEvent->IsAlt() != ((mKeyMask & cAlt) != 0)) {
+ return false;
+ }
+ }
+
+ if (mKeyMask & cControlMask) {
+ if (inputEvent->IsControl() != ((mKeyMask & cControl) != 0)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+size_t KeyEventHandler::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+ size_t n = 0;
+ for (const KeyEventHandler* handler = this; handler;
+ handler = handler->mNextHandler) {
+ n += aMallocSizeOf(handler);
+ if (!mIsXULKey) {
+ n += aMallocSizeOf(handler->mCommand);
+ }
+ }
+ return n;
+}
+
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-13 17:16:10 +0000