The Tor Browser: widget/gtk/nsGtkKeyUtils.h@ac0c01689b40 (annotated)

widget/gtk/nsGtkKeyUtils.h@ac0c01689b40 (annotated)

widget/gtk/nsGtkKeyUtils.h

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim:expandtab:shiftwidth=4:tabstop=4:
  */
 /* 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/. */
 #ifndef __nsGdkKeyUtils_h__
 #define __nsGdkKeyUtils_h__
 #include "nsTArray.h"
 #include "mozilla/EventForwards.h"
 #include <gdk/gdk.h>
 #include <X11/XKBlib.h>
 namespace mozilla {
 namespace widget {
 /**
  *  KeymapWrapper is a wrapper class of GdkKeymap.  GdkKeymap doesn't support
  *  all our needs, therefore, we need to access lower level APIs.
  *  But such code is usually complex and might be slow.  Against such issues,
  *  we should cache some information.
  *
  *  This class provides only static methods.  The methods is using internal
  *  singleton instance which is initialized by default GdkKeymap.  When the
  *  GdkKeymap is destroyed, the singleton instance will be destroyed.
  */
 class KeymapWrapper
 {
 public:
     /**
      * Compute an our DOM keycode from a GDK keyval.
      */
     static uint32_t ComputeDOMKeyCode(const GdkEventKey* aGdkKeyEvent);
     /**
      * Compute a DOM key name index from aGdkKeyEvent.
      */
     KeyNameIndex ComputeDOMKeyNameIndex(const GdkEventKey* aGdkKeyEvent);
     /**
      * Modifier is list of modifiers which we support in widget level.
      */
     enum Modifier {
         NOT_MODIFIER       = 0x0000,
         CAPS_LOCK          = 0x0001,
         NUM_LOCK           = 0x0002,
         SCROLL_LOCK        = 0x0004,
         SHIFT              = 0x0008,
         CTRL               = 0x0010,
         ALT                = 0x0020,
         META               = 0x0040,
         SUPER              = 0x0080,
         HYPER              = 0x0100,
         LEVEL3             = 0x0200,
         LEVEL5             = 0x0400
     };
     /**
      * Modifiers is used for combination of Modifier.
      * E.g., |Modifiers modifiers = (SHIFT | CTRL);| means Shift and Ctrl.
      */
     typedef uint32_t Modifiers;
     /**
      * GetCurrentModifierState() returns current modifier key state.
      * The "current" means actual state of hardware keyboard when this is
      * called.  I.e., if some key events are not still dispatched by GDK,
      * the state may mismatch with GdkEventKey::state.
      *
      * @return                  Current modifier key state.
      */
     static guint GetCurrentModifierState();
     /**
      * AreModifiersCurrentlyActive() checks the "current" modifier state
      * on aGdkWindow with the keymap of the singleton instance.
      *
      * @param aModifiers        One or more of Modifier values except
      *                          NOT_MODIFIER.
      * @return                  TRUE if all of modifieres in aModifiers are
      *                          active.  Otherwise, FALSE.
      */
     static bool AreModifiersCurrentlyActive(Modifiers aModifiers);
     /**
      * AreModifiersActive() just checks whether aModifierState indicates
      * all modifiers in aModifiers are active or not.
      *
      * @param aModifiers        One or more of Modifier values except
      *                          NOT_MODIFIER.
      * @param aModifierState    GDK's modifier states.
      * @return                  TRUE if aGdkModifierType indecates all of
      *                          modifiers in aModifier are active.
      *                          Otherwise, FALSE.
      */
     static bool AreModifiersActive(Modifiers aModifiers,
                                    guint aModifierState);
     /**
      * InitInputEvent() initializes the aInputEvent with aModifierState.
      */
     static void InitInputEvent(WidgetInputEvent& aInputEvent,
                                guint aModifierState);
     /**
      * InitKeyEvent() intializes aKeyEvent's modifier key related members
      * and keycode related values.
      *
      * @param aKeyEvent         It's an WidgetKeyboardEvent which needs to be
      *                          initialized.
      * @param aGdkKeyEvent      A native GDK key event.
      */
     static void InitKeyEvent(WidgetKeyboardEvent& aKeyEvent,
                              GdkEventKey* aGdkKeyEvent);
     /**
      * IsKeyPressEventNecessary() returns TRUE when aGdkKeyEvent should cause
      * a DOM keypress event.  Otherwise, FALSE.
      */
     static bool IsKeyPressEventNecessary(GdkEventKey* aGdkKeyEvent);
 protected:
     /**
      * GetInstance() returns a KeymapWrapper instance.
      *
      * @return                  A singleton instance of KeymapWrapper.
      */
     static KeymapWrapper* GetInstance();
     KeymapWrapper();
     ~KeymapWrapper();
     bool mInitialized;
     /**
      * Initializing methods.
      */
     void Init();
     void InitXKBExtension();
     void InitBySystemSettings();
     /**
      * mModifierKeys stores each hardware key information.
      */
     struct ModifierKey {
         guint mHardwareKeycode;
         guint mMask;
         ModifierKey(guint aHardwareKeycode) :
           mHardwareKeycode(aHardwareKeycode), mMask(0)
         {
         }
     };
     nsTArray<ModifierKey> mModifierKeys;
     /**
      * GetModifierKey() returns modifier key information of the hardware
      * keycode.  If the key isn't a modifier key, returns nullptr.
      */
     ModifierKey* GetModifierKey(guint aHardwareKeycode);
     /**
      * mModifierMasks is bit masks for each modifier.  The index should be one
      * of ModifierIndex values.
      */
     enum ModifierIndex {
         INDEX_NUM_LOCK,
         INDEX_SCROLL_LOCK,
         INDEX_ALT,
         INDEX_META,
         INDEX_SUPER,
         INDEX_HYPER,
         INDEX_LEVEL3,
         INDEX_LEVEL5,
         COUNT_OF_MODIFIER_INDEX
     };
     guint mModifierMasks[COUNT_OF_MODIFIER_INDEX];
     guint GetModifierMask(Modifier aModifier) const;
     /**
      * @param aGdkKeyval        A GDK defined modifier key value such as
      *                          GDK_Shift_L.
      * @return                  Returns Modifier values for aGdkKeyval.
      *                          If the given key code isn't a modifier key,
      *                          returns NOT_MODIFIER.
      */
     static Modifier GetModifierForGDKKeyval(guint aGdkKeyval);
 #ifdef PR_LOGGING
     static const char* GetModifierName(Modifier aModifier);
 #endif // PR_LOGGING
     /**
      * mGdkKeymap is a wrapped instance by this class.
      */
     GdkKeymap* mGdkKeymap;
     /**
      * The base event code of XKB extension.
      */
     int mXKBBaseEventCode;
     /**
      * Only auto_repeats[] stores valid value.  If you need to use other
      * members, you need to listen notification events for them.
      * See a call of XkbSelectEventDetails() with XkbControlsNotify in
      * InitXKBExtension().
      */
     XKeyboardState mKeyboardState;
     /**
      * Pointer of the singleton instance.
      */
     static KeymapWrapper* sInstance;
     /**
      * Auto key repeat management.
      */
     static guint sLastRepeatableHardwareKeyCode;
     enum RepeatState
     {
         NOT_PRESSED,
         FIRST_PRESS,
         REPEATING
     };
     static RepeatState sRepeatState;
     /**
      * IsAutoRepeatableKey() returns true if the key supports auto repeat.
      * Otherwise, false.
      */
     bool IsAutoRepeatableKey(guint aHardwareKeyCode);
     /**
      * Signal handlers.
      */
     static void OnKeysChanged(GdkKeymap* aKeymap, KeymapWrapper* aKeymapWrapper);
     static void OnDestroyKeymap(KeymapWrapper* aKeymapWrapper,
                                 GdkKeymap *aGdkKeymap);
     /**
      * GetCharCodeFor() Computes what character is inputted by the key event
      * with aModifierState and aGroup.
      *
      * @param aGdkKeyEvent      Native key event, must not be nullptr.
      * @param aModifierState    Combination of GdkModifierType which you
      *                          want to test with aGdkKeyEvent.
      * @param aGroup            Set group in the mGdkKeymap.
      * @return                  charCode which is inputted by aGdkKeyEvent.
      *                          If failed, this returns 0.
      */
     static uint32_t GetCharCodeFor(const GdkEventKey *aGdkKeyEvent);
     uint32_t GetCharCodeFor(const GdkEventKey *aGdkKeyEvent,
                             guint aModifierState,
                             gint aGroup);
     /**
      * GetUnmodifiedCharCodeFor() computes what character is inputted by the
      * key event without Ctrl/Alt/Meta/Super/Hyper modifiers.
      * If Level3 or Level5 Shift causes no character input, this also ignores
      * them.
      *
      * @param aGdkKeyEvent      Native key event, must not be nullptr.
      * @return                  charCode which is computed without modifiers
      *                          which prevent text input.
      */
     uint32_t GetUnmodifiedCharCodeFor(const GdkEventKey* aGdkKeyEvent);
     /**
      * GetKeyLevel() returns level of the aGdkKeyEvent in mGdkKeymap.
      *
      * @param aGdkKeyEvent      Native key event, must not be nullptr.
      * @return                  Using level.  Typically, this is 0 or 1.
      *                          If failed, this returns -1.
      */
     gint GetKeyLevel(GdkEventKey *aGdkKeyEvent);
     /**
      * GetFirstLatinGroup() returns group of mGdkKeymap which can input an
      * ASCII character by GDK_A.
      *
      * @return                  group value of GdkEventKey.
      */
     gint GetFirstLatinGroup();
     /**
      * IsLatinGroup() checkes whether the keyboard layout of aGroup is
      * ASCII alphabet inputtable or not.
      *
      * @param aGroup            The group value of GdkEventKey.
      * @return                  TRUE if the keyboard layout can input
      *                          ASCII alphabet.  Otherwise, FALSE.
      */
     bool IsLatinGroup(guint8 aGroup);
     /**
      * IsBasicLatinLetterOrNumeral() Checks whether the aCharCode is an
      * alphabet or a numeric character in ASCII.
      *
      * @param aCharCode         Charcode which you want to test.
      * @return                  TRUE if aCharCode is an alphabet or a numeric
      *                          in ASCII range.  Otherwise, FALSE.
      */
     static bool IsBasicLatinLetterOrNumeral(uint32_t aCharCode);
     /**
      * GetGDKKeyvalWithoutModifier() returns the keyval for aGdkKeyEvent when
      * ignoring the modifier state except NumLock. (NumLock is a key to change
      * some key's meaning.)
      */
     static guint GetGDKKeyvalWithoutModifier(const GdkEventKey *aGdkKeyEvent);
     /**
      * GetDOMKeyCodeFromKeyPairs() returns DOM keycode for aGdkKeyval if
      * it's in KeyPair table.
      */
     static uint32_t GetDOMKeyCodeFromKeyPairs(guint aGdkKeyval);
     /**
      * InitKeypressEvent() intializes keyCode, charCode and
      * alternativeCharCodes of keypress event.
      *
      * @param aKeyEvent         An NS_KEY_PRESS event, must not be nullptr.
      *                          The modifier related members and keyCode must
      *                          be initialized already.
      * @param aGdkKeyEvent      A native key event which causes dispatching
      *                          aKeyEvent.
      */
     void InitKeypressEvent(WidgetKeyboardEvent& aKeyEvent,
                            GdkEventKey* aGdkKeyEvent);
     /**
      * FilterEvents() listens all events on all our windows.
      * Be careful, this may make damage to performance if you add expensive
      * code in this method.
      */
     static GdkFilterReturn FilterEvents(GdkXEvent* aXEvent,
                                         GdkEvent* aGdkEvent,
                                         gpointer aData);
 };
 } // namespace widget
 } // namespace mozilla
 #endif /* __nsGdkKeyUtils_h__ */

The Tor Browser / annotate

widget/gtk/nsGtkKeyUtils.h@ac0c01689b40 (annotated)

widget/gtk/nsGtkKeyUtils.h