summaryrefslogtreecommitdiffstats
path: root/dom/events/KeyboardEvent.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/events/KeyboardEvent.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/events/KeyboardEvent.cpp')
-rw-r--r--dom/events/KeyboardEvent.cpp365
1 files changed, 365 insertions, 0 deletions
diff --git a/dom/events/KeyboardEvent.cpp b/dom/events/KeyboardEvent.cpp
new file mode 100644
index 000000000..f0831d97b
--- /dev/null
+++ b/dom/events/KeyboardEvent.cpp
@@ -0,0 +1,365 @@
+/* -*- 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/dom/KeyboardEvent.h"
+#include "mozilla/TextEvents.h"
+#include "prtime.h"
+
+namespace mozilla {
+namespace dom {
+
+KeyboardEvent::KeyboardEvent(EventTarget* aOwner,
+ nsPresContext* aPresContext,
+ WidgetKeyboardEvent* aEvent)
+ : UIEvent(aOwner, aPresContext,
+ aEvent ? aEvent :
+ new WidgetKeyboardEvent(false, eVoidEvent, nullptr))
+ , mInitializedByCtor(false)
+ , mInitializedWhichValue(0)
+{
+ if (aEvent) {
+ mEventIsInternal = false;
+ }
+ else {
+ mEventIsInternal = true;
+ mEvent->mTime = PR_Now();
+ mEvent->AsKeyboardEvent()->mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
+ }
+}
+
+NS_IMPL_ADDREF_INHERITED(KeyboardEvent, UIEvent)
+NS_IMPL_RELEASE_INHERITED(KeyboardEvent, UIEvent)
+
+NS_INTERFACE_MAP_BEGIN(KeyboardEvent)
+ NS_INTERFACE_MAP_ENTRY(nsIDOMKeyEvent)
+NS_INTERFACE_MAP_END_INHERITING(UIEvent)
+
+bool
+KeyboardEvent::AltKey()
+{
+ return mEvent->AsKeyboardEvent()->IsAlt();
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetAltKey(bool* aIsDown)
+{
+ NS_ENSURE_ARG_POINTER(aIsDown);
+ *aIsDown = AltKey();
+ return NS_OK;
+}
+
+bool
+KeyboardEvent::CtrlKey()
+{
+ return mEvent->AsKeyboardEvent()->IsControl();
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetCtrlKey(bool* aIsDown)
+{
+ NS_ENSURE_ARG_POINTER(aIsDown);
+ *aIsDown = CtrlKey();
+ return NS_OK;
+}
+
+bool
+KeyboardEvent::ShiftKey()
+{
+ return mEvent->AsKeyboardEvent()->IsShift();
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetShiftKey(bool* aIsDown)
+{
+ NS_ENSURE_ARG_POINTER(aIsDown);
+ *aIsDown = ShiftKey();
+ return NS_OK;
+}
+
+bool
+KeyboardEvent::MetaKey()
+{
+ return mEvent->AsKeyboardEvent()->IsMeta();
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetMetaKey(bool* aIsDown)
+{
+ NS_ENSURE_ARG_POINTER(aIsDown);
+ *aIsDown = MetaKey();
+ return NS_OK;
+}
+
+bool
+KeyboardEvent::Repeat()
+{
+ return mEvent->AsKeyboardEvent()->mIsRepeat;
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetRepeat(bool* aIsRepeat)
+{
+ NS_ENSURE_ARG_POINTER(aIsRepeat);
+ *aIsRepeat = Repeat();
+ return NS_OK;
+}
+
+bool
+KeyboardEvent::IsComposing()
+{
+ return mEvent->AsKeyboardEvent()->mIsComposing;
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetModifierState(const nsAString& aKey,
+ bool* aState)
+{
+ NS_ENSURE_ARG_POINTER(aState);
+
+ *aState = GetModifierState(aKey);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetKey(nsAString& aKeyName)
+{
+ mEvent->AsKeyboardEvent()->GetDOMKeyName(aKeyName);
+ return NS_OK;
+}
+
+void
+KeyboardEvent::GetCode(nsAString& aCodeName)
+{
+ mEvent->AsKeyboardEvent()->GetDOMCodeName(aCodeName);
+}
+
+void KeyboardEvent::GetInitDict(KeyboardEventInit& aParam)
+{
+ GetKey(aParam.mKey);
+ GetCode(aParam.mCode);
+ aParam.mLocation = Location();
+ aParam.mRepeat = Repeat();
+ aParam.mIsComposing = IsComposing();
+
+ // legacy attributes
+ aParam.mKeyCode = KeyCode();
+ aParam.mCharCode = CharCode();
+ aParam.mWhich = Which();
+
+ // modifiers from EventModifierInit
+ aParam.mCtrlKey = CtrlKey();
+ aParam.mShiftKey = ShiftKey();
+ aParam.mAltKey = AltKey();
+ aParam.mMetaKey = MetaKey();
+
+ WidgetKeyboardEvent* internalEvent = mEvent->AsKeyboardEvent();
+ aParam.mModifierAltGraph = internalEvent->IsAltGraph();
+ aParam.mModifierCapsLock = internalEvent->IsCapsLocked();
+ aParam.mModifierFn = internalEvent->IsFn();
+ aParam.mModifierFnLock = internalEvent->IsFnLocked();
+ aParam.mModifierNumLock = internalEvent->IsNumLocked();
+ aParam.mModifierOS = internalEvent->IsOS();
+ aParam.mModifierScrollLock = internalEvent->IsScrollLocked();
+ aParam.mModifierSymbol = internalEvent->IsSymbol();
+ aParam.mModifierSymbolLock = internalEvent->IsSymbolLocked();
+
+ // EventInit
+ aParam.mBubbles = internalEvent->mFlags.mBubbles;
+ aParam.mCancelable = internalEvent->mFlags.mCancelable;
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetCharCode(uint32_t* aCharCode)
+{
+ NS_ENSURE_ARG_POINTER(aCharCode);
+ *aCharCode = CharCode();
+ return NS_OK;
+}
+
+uint32_t
+KeyboardEvent::CharCode()
+{
+ // If this event is initialized with ctor, we shouldn't check event type.
+ if (mInitializedByCtor) {
+ return mEvent->AsKeyboardEvent()->mCharCode;
+ }
+
+ switch (mEvent->mMessage) {
+ case eBeforeKeyDown:
+ case eKeyDown:
+ case eKeyDownOnPlugin:
+ case eAfterKeyDown:
+ case eBeforeKeyUp:
+ case eKeyUp:
+ case eKeyUpOnPlugin:
+ case eAfterKeyUp:
+ return 0;
+ case eKeyPress:
+ case eAccessKeyNotFound:
+ return mEvent->AsKeyboardEvent()->mCharCode;
+ default:
+ break;
+ }
+ return 0;
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetKeyCode(uint32_t* aKeyCode)
+{
+ NS_ENSURE_ARG_POINTER(aKeyCode);
+ *aKeyCode = KeyCode();
+ return NS_OK;
+}
+
+uint32_t
+KeyboardEvent::KeyCode()
+{
+ // If this event is initialized with ctor, we shouldn't check event type.
+ if (mInitializedByCtor) {
+ return mEvent->AsKeyboardEvent()->mKeyCode;
+ }
+
+ if (mEvent->HasKeyEventMessage()) {
+ return mEvent->AsKeyboardEvent()->mKeyCode;
+ }
+ return 0;
+}
+
+uint32_t
+KeyboardEvent::Which()
+{
+ // If this event is initialized with ctor, which can have independent value.
+ if (mInitializedByCtor) {
+ return mInitializedWhichValue;
+ }
+
+ switch (mEvent->mMessage) {
+ case eBeforeKeyDown:
+ case eKeyDown:
+ case eKeyDownOnPlugin:
+ case eAfterKeyDown:
+ case eBeforeKeyUp:
+ case eKeyUp:
+ case eKeyUpOnPlugin:
+ case eAfterKeyUp:
+ return KeyCode();
+ case eKeyPress:
+ //Special case for 4xp bug 62878. Try to make value of which
+ //more closely mirror the values that 4.x gave for RETURN and BACKSPACE
+ {
+ uint32_t keyCode = mEvent->AsKeyboardEvent()->mKeyCode;
+ if (keyCode == NS_VK_RETURN || keyCode == NS_VK_BACK) {
+ return keyCode;
+ }
+ return CharCode();
+ }
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+NS_IMETHODIMP
+KeyboardEvent::GetLocation(uint32_t* aLocation)
+{
+ NS_ENSURE_ARG_POINTER(aLocation);
+
+ *aLocation = Location();
+ return NS_OK;
+}
+
+uint32_t
+KeyboardEvent::Location()
+{
+ return mEvent->AsKeyboardEvent()->mLocation;
+}
+
+// static
+already_AddRefed<KeyboardEvent>
+KeyboardEvent::Constructor(const GlobalObject& aGlobal,
+ const nsAString& aType,
+ const KeyboardEventInit& aParam,
+ ErrorResult& aRv)
+{
+ nsCOMPtr<EventTarget> target = do_QueryInterface(aGlobal.GetAsSupports());
+ RefPtr<KeyboardEvent> newEvent =
+ new KeyboardEvent(target, nullptr, nullptr);
+ newEvent->InitWithKeyboardEventInit(target, aType, aParam, aRv);
+
+ return newEvent.forget();
+}
+
+void
+KeyboardEvent::InitWithKeyboardEventInit(EventTarget* aOwner,
+ const nsAString& aType,
+ const KeyboardEventInit& aParam,
+ ErrorResult& aRv)
+{
+ bool trusted = Init(aOwner);
+ InitKeyEvent(aType, aParam.mBubbles, aParam.mCancelable,
+ aParam.mView, false, false, false, false,
+ aParam.mKeyCode, aParam.mCharCode);
+ InitModifiers(aParam);
+ SetTrusted(trusted);
+ mDetail = aParam.mDetail;
+ mInitializedByCtor = true;
+ mInitializedWhichValue = aParam.mWhich;
+
+ WidgetKeyboardEvent* internalEvent = mEvent->AsKeyboardEvent();
+ internalEvent->mLocation = aParam.mLocation;
+ internalEvent->mIsRepeat = aParam.mRepeat;
+ internalEvent->mIsComposing = aParam.mIsComposing;
+ internalEvent->mKeyNameIndex =
+ WidgetKeyboardEvent::GetKeyNameIndex(aParam.mKey);
+ if (internalEvent->mKeyNameIndex == KEY_NAME_INDEX_USE_STRING) {
+ internalEvent->mKeyValue = aParam.mKey;
+ }
+ internalEvent->mCodeNameIndex =
+ WidgetKeyboardEvent::GetCodeNameIndex(aParam.mCode);
+ if (internalEvent->mCodeNameIndex == CODE_NAME_INDEX_USE_STRING) {
+ internalEvent->mCodeValue = aParam.mCode;
+ }
+}
+
+NS_IMETHODIMP
+KeyboardEvent::InitKeyEvent(const nsAString& aType,
+ bool aCanBubble,
+ bool aCancelable,
+ mozIDOMWindow* aView,
+ bool aCtrlKey,
+ bool aAltKey,
+ bool aShiftKey,
+ bool aMetaKey,
+ uint32_t aKeyCode,
+ uint32_t aCharCode)
+{
+ NS_ENSURE_TRUE(!mEvent->mFlags.mIsBeingDispatched, NS_OK);
+
+ UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, 0);
+
+ WidgetKeyboardEvent* keyEvent = mEvent->AsKeyboardEvent();
+ keyEvent->InitBasicModifiers(aCtrlKey, aAltKey, aShiftKey, aMetaKey);
+ keyEvent->mKeyCode = aKeyCode;
+ keyEvent->mCharCode = aCharCode;
+
+ return NS_OK;
+}
+
+} // namespace dom
+} // namespace mozilla
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+already_AddRefed<KeyboardEvent>
+NS_NewDOMKeyboardEvent(EventTarget* aOwner,
+ nsPresContext* aPresContext,
+ WidgetKeyboardEvent* aEvent)
+{
+ RefPtr<KeyboardEvent> it = new KeyboardEvent(aOwner, aPresContext, aEvent);
+ return it.forget();
+}