dom/events/KeyboardEvent.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_KeyboardEvent_h_
   8 #define mozilla_dom_KeyboardEvent_h_
   9
  10 #include "mozilla/dom/UIEvent.h"
  11 #include "mozilla/dom/KeyboardEventBinding.h"
  12 #include "mozilla/EventForwards.h"
  13
  14 namespace mozilla::dom {
  15
  16 class KeyboardEvent : public UIEvent {
  17  public:
  18   KeyboardEvent(EventTarget* aOwner, nsPresContext* aPresContext,
  19                 WidgetKeyboardEvent* aEvent);
  20
  21   NS_INLINE_DECL_REFCOUNTING_INHERITED(KeyboardEvent, UIEvent)
  22
  23   virtual KeyboardEvent* AsKeyboardEvent() override { return this; }
  24
  25   static already_AddRefed<KeyboardEvent> ConstructorJS(
  26       const GlobalObject& aGlobal, const nsAString& aType,
  27       const KeyboardEventInit& aParam);
  28
  29   virtual JSObject* WrapObjectInternal(
  30       JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override {
  31     return KeyboardEvent_Binding::Wrap(aCx, this, aGivenProto);
  32   }
  33
  34   bool AltKey(CallerType aCallerType = CallerType::System);
  35   bool CtrlKey(CallerType aCallerType = CallerType::System);
  36   bool ShiftKey(CallerType aCallerType = CallerType::System);
  37   bool MetaKey();
  38
  39   // Returns true if the modifier state of the event matches the modifier state
  40   // of access key.
  41   bool IsMenuAccessKeyPressed() const;
  42   Modifiers GetModifiersForMenuAccessKey() const;
  43
  44   bool GetModifierState(const nsAString& aKey,
  45                         CallerType aCallerType = CallerType::System) {
  46     bool modifierState = GetModifierStateInternal(aKey);
  47
  48     if (!ShouldResistFingerprinting(aCallerType)) {
  49       return modifierState;
  50     }
  51
  52     Modifiers modifier = WidgetInputEvent::GetModifier(aKey);
  53     return GetSpoofedModifierStates(modifier, modifierState);
  54   }
  55
  56   bool Repeat();
  57   bool IsComposing();
  58   void GetKey(nsAString& aKey) const;
  59   uint32_t CharCode(CallerType aCallerType = CallerType::System);
  60   uint32_t KeyCode(CallerType aCallerType = CallerType::System);
  61   virtual uint32_t Which(CallerType aCallerType = CallerType::System) override;
  62   uint32_t Location();
  63
  64   void GetCode(nsAString& aCode, CallerType aCallerType = CallerType::System);
  65   void GetInitDict(KeyboardEventInit& aParam);
  66
  67   void InitKeyEventJS(const nsAString& aType, bool aCanBubble, bool aCancelable,
  68                       nsGlobalWindowInner* aView, bool aCtrlKey, bool aAltKey,
  69                       bool aShiftKey, bool aMetaKey, uint32_t aKeyCode,
  70                       uint32_t aCharCode);
  71   static bool IsInitKeyEventAvailable(JSContext*, JSObject*);
  72
  73   void InitKeyboardEventJS(const nsAString& aType, bool aCanBubble,
  74                            bool aCancelable, nsGlobalWindowInner* aView,
  75                            const nsAString& aKey, uint32_t aLocation,
  76                            bool aCtrlKey, bool aAltKey, bool aShiftKey,
  77                            bool aMetaKey);
  78
  79  protected:
  80   ~KeyboardEvent() = default;
  81
  82   void InitWithKeyboardEventInit(EventTarget* aOwner, const nsAString& aType,
  83                                  const KeyboardEventInit& aParam);
  84
  85  private:
  86   // True, if the instance is initialized by JS.
  87   bool mInitializedByJS;
  88   // True, if the instance is initialized by Ctor.
  89   bool mInitializedByCtor;
  90
  91   // If the instance is created with Constructor(), which may have independent
  92   // value.  mInitializedWhichValue stores it.  I.e., this is invalid when
  93   // mInitializedByCtor is false.
  94   uint32_t mInitializedWhichValue;
  95
  96   // This method returns the boolean to indicate whether spoofing keyboard
  97   // event for fingerprinting resistance. It will return true when pref
  98   // 'privacy.resistFingerprinting' is true and the event target is content.
  99   // Otherwise, it will return false.
 100   bool ShouldResistFingerprinting(CallerType aCallerType);
 101
 102   // This method returns the spoofed modifier state of the given modifier key
 103   // for fingerprinting resistance.
 104   bool GetSpoofedModifierStates(const Modifiers aModifierKey,
 105                                 const bool aRawModifierState);
 106
 107   /**
 108    * ComputeTraditionalKeyCode() computes traditional keyCode value.  I.e.,
 109    * returns 0 if this event should return non-zero from CharCode().
 110    * In spite of the name containing "traditional", this computes spoof
 111    * keyCode value if user wants it.
 112    *
 113    * @param aKeyboardEvent  Should be |*mEvent->AsKeyboardEvent()|.
 114    * @param aCallerType     Set caller type of KeyCode() or CharCode().
 115    * @return                If traditional charCode value is 0, returns
 116    *                        the raw keyCode value or spoof keyCode value.
 117    *                        Otherwise, 0.
 118    */
 119   uint32_t ComputeTraditionalKeyCode(WidgetKeyboardEvent& aKeyboardEvent,
 120                                      CallerType aCallerType);
 121   /**
 122    * ShouldUseSameValueForCharCodeAndKeyCode() returns true if KeyCode() and
 123    * CharCode() should return same value.
 124    */
 125   bool ShouldUseSameValueForCharCodeAndKeyCode(
 126       const WidgetKeyboardEvent& aKeyboardEvent, CallerType aCallerType) const;
 127 };
 128
 129 }  // namespace mozilla::dom
 130
 131 already_AddRefed<mozilla::dom::KeyboardEvent> NS_NewDOMKeyboardEvent(
 132     mozilla::dom::EventTarget* aOwner, nsPresContext* aPresContext,
 133     mozilla::WidgetKeyboardEvent* aEvent);
 134
 135 #endif  // mozilla_dom_KeyboardEvent_h_