mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 05:15:09 +00:00
1253 lines
43 KiB
Objective-C
1253 lines
43 KiB
Objective-C
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 sw=2 et 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/. */
|
|
|
|
#ifndef TextInputHandler_h_
|
|
#define TextInputHandler_h_
|
|
|
|
#include "nsCocoaUtils.h"
|
|
|
|
#import <Carbon/Carbon.h>
|
|
#import <Cocoa/Cocoa.h>
|
|
#include "mozView.h"
|
|
#include "nsString.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsITimer.h"
|
|
#include "npapi.h"
|
|
#include "nsTArray.h"
|
|
#include "mozilla/EventForwards.h"
|
|
|
|
class nsChildView;
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
// Key code constants
|
|
enum
|
|
{
|
|
kVK_RightCommand = 0x36, // right command key
|
|
|
|
kVK_PC_PrintScreen = kVK_F13,
|
|
kVK_PC_ScrollLock = kVK_F14,
|
|
kVK_PC_Pause = kVK_F15,
|
|
|
|
kVK_PC_Insert = kVK_Help,
|
|
kVK_PC_Backspace = kVK_Delete,
|
|
kVK_PC_Delete = kVK_ForwardDelete,
|
|
|
|
kVK_PC_ContextMenu = 0x6E,
|
|
|
|
kVK_Powerbook_KeypadEnter = 0x34 // Enter on Powerbook's keyboard is different
|
|
};
|
|
|
|
/**
|
|
* TISInputSourceWrapper is a wrapper for the TISInputSourceRef. If we get the
|
|
* TISInputSourceRef from InputSourceID, we need to release the CFArray instance
|
|
* which is returned by TISCreateInputSourceList. However, when we release the
|
|
* list, we cannot access the TISInputSourceRef. So, it's not usable, and it
|
|
* may cause the memory leak bugs. nsTISInputSource automatically releases the
|
|
* list when the instance is destroyed.
|
|
*/
|
|
class TISInputSourceWrapper
|
|
{
|
|
public:
|
|
static TISInputSourceWrapper& CurrentInputSource();
|
|
|
|
TISInputSourceWrapper()
|
|
{
|
|
mInputSourceList = nullptr;
|
|
Clear();
|
|
}
|
|
|
|
TISInputSourceWrapper(const char* aID)
|
|
{
|
|
mInputSourceList = nullptr;
|
|
InitByInputSourceID(aID);
|
|
}
|
|
|
|
TISInputSourceWrapper(SInt32 aLayoutID)
|
|
{
|
|
mInputSourceList = nullptr;
|
|
InitByLayoutID(aLayoutID);
|
|
}
|
|
|
|
TISInputSourceWrapper(TISInputSourceRef aInputSource)
|
|
{
|
|
mInputSourceList = nullptr;
|
|
InitByTISInputSourceRef(aInputSource);
|
|
}
|
|
|
|
~TISInputSourceWrapper() { Clear(); }
|
|
|
|
void InitByInputSourceID(const char* aID);
|
|
void InitByInputSourceID(const nsAFlatString &aID);
|
|
void InitByInputSourceID(const CFStringRef aID);
|
|
/**
|
|
* InitByLayoutID() initializes the keyboard layout by the layout ID.
|
|
*
|
|
* @param aLayoutID An ID of keyboard layout.
|
|
* 0: US
|
|
* 1: Greek
|
|
* 2: German
|
|
* 3: Swedish-Pro
|
|
* 4: Dvorak-Qwerty Cmd
|
|
* 5: Thai
|
|
* 6: Arabic
|
|
* 7: French
|
|
* 8: Hebrew
|
|
* 9: Lithuanian
|
|
* 10: Norwegian
|
|
* 11: Spanish
|
|
* @param aOverrideKeyboard When testing set to TRUE, otherwise, set to
|
|
* FALSE. When TRUE, we use an ANSI keyboard
|
|
* instead of the actual keyboard.
|
|
*/
|
|
void InitByLayoutID(SInt32 aLayoutID, bool aOverrideKeyboard = false);
|
|
void InitByCurrentInputSource();
|
|
void InitByCurrentKeyboardLayout();
|
|
void InitByCurrentASCIICapableInputSource();
|
|
void InitByCurrentASCIICapableKeyboardLayout();
|
|
void InitByCurrentInputMethodKeyboardLayoutOverride();
|
|
void InitByTISInputSourceRef(TISInputSourceRef aInputSource);
|
|
void InitByLanguage(CFStringRef aLanguage);
|
|
|
|
/**
|
|
* If the instance is initialized with a keyboard layout input source,
|
|
* returns it.
|
|
* If the instance is initialized with an IME mode input source, the result
|
|
* references the keyboard layout for the IME mode. However, this can be
|
|
* initialized only when the IME mode is actually selected. I.e, if IME mode
|
|
* input source is initialized with LayoutID or SourceID, this returns null.
|
|
*/
|
|
TISInputSourceRef GetKeyboardLayoutInputSource() const
|
|
{
|
|
return mKeyboardLayout;
|
|
}
|
|
const UCKeyboardLayout* GetUCKeyboardLayout();
|
|
|
|
bool IsOpenedIMEMode();
|
|
bool IsIMEMode();
|
|
bool IsKeyboardLayout();
|
|
|
|
bool IsASCIICapable()
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetBoolProperty(kTISPropertyInputSourceIsASCIICapable);
|
|
}
|
|
|
|
bool IsEnabled()
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetBoolProperty(kTISPropertyInputSourceIsEnabled);
|
|
}
|
|
|
|
bool GetLanguageList(CFArrayRef &aLanguageList);
|
|
bool GetPrimaryLanguage(CFStringRef &aPrimaryLanguage);
|
|
bool GetPrimaryLanguage(nsAString &aPrimaryLanguage);
|
|
|
|
bool GetLocalizedName(CFStringRef &aName)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyLocalizedName, aName);
|
|
}
|
|
|
|
bool GetLocalizedName(nsAString &aName)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyLocalizedName, aName);
|
|
}
|
|
|
|
bool GetInputSourceID(CFStringRef &aID)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyInputSourceID, aID);
|
|
}
|
|
|
|
bool GetInputSourceID(nsAString &aID)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyInputSourceID, aID);
|
|
}
|
|
|
|
bool GetBundleID(CFStringRef &aBundleID)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyBundleID, aBundleID);
|
|
}
|
|
|
|
bool GetBundleID(nsAString &aBundleID)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyBundleID, aBundleID);
|
|
}
|
|
|
|
bool GetInputSourceType(CFStringRef &aType)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyInputSourceType, aType);
|
|
}
|
|
|
|
bool GetInputSourceType(nsAString &aType)
|
|
{
|
|
NS_ENSURE_TRUE(mInputSource, false);
|
|
return GetStringProperty(kTISPropertyInputSourceType, aType);
|
|
}
|
|
|
|
bool IsForRTLLanguage();
|
|
bool IsInitializedByCurrentInputSource();
|
|
|
|
enum {
|
|
// 40 is an actual result of the ::LMGetKbdType() when we connect an
|
|
// unknown keyboard and set the keyboard type to ANSI manually on the
|
|
// set up dialog.
|
|
eKbdType_ANSI = 40
|
|
};
|
|
|
|
void Select();
|
|
void Clear();
|
|
|
|
/**
|
|
* InitKeyEvent() initializes aKeyEvent for aNativeKeyEvent.
|
|
*
|
|
* @param aNativeKeyEvent A native key event for which you want to
|
|
* dispatch a Gecko key event.
|
|
* @param aKeyEvent The result -- a Gecko key event initialized
|
|
* from the native key event.
|
|
* @param aInsertString If caller expects that the event will cause
|
|
* a character to be input (say in an editor),
|
|
* the caller should set this. Otherwise,
|
|
* if caller sets null to this, this method will
|
|
* compute the character to be input from
|
|
* characters of aNativeKeyEvent.
|
|
*/
|
|
void InitKeyEvent(NSEvent *aNativeKeyEvent, WidgetKeyboardEvent& aKeyEvent,
|
|
const nsAString *aInsertString = nullptr);
|
|
|
|
/**
|
|
* ComputeGeckoKeyCode() returns Gecko keycode for aNativeKeyCode on current
|
|
* keyboard layout.
|
|
*
|
|
* @param aNativeKeyCode A native keycode.
|
|
* @param aKbType A native Keyboard Type value. Typically,
|
|
* this is a result of ::LMGetKbdType().
|
|
* @param aCmdIsPressed TRUE if Cmd key is pressed. Otherwise, FALSE.
|
|
* @return The computed Gecko keycode.
|
|
*/
|
|
uint32_t ComputeGeckoKeyCode(UInt32 aNativeKeyCode, UInt32 aKbType,
|
|
bool aCmdIsPressed);
|
|
|
|
/**
|
|
* ComputeGeckoKeyNameIndex() returns Gecko key name index for the key.
|
|
*
|
|
* @param aNativeKeyCode A native keycode.
|
|
*/
|
|
static KeyNameIndex ComputeGeckoKeyNameIndex(UInt32 aNativeKeyCode);
|
|
|
|
/**
|
|
* ComputeGeckoCodeNameIndex() returns Gecko code name index for the key.
|
|
*
|
|
* @param aNativeKeyCode A native keycode.
|
|
*/
|
|
static CodeNameIndex ComputeGeckoCodeNameIndex(UInt32 aNativeKeyCode);
|
|
|
|
protected:
|
|
/**
|
|
* TranslateToString() computes the inputted text from the native keyCode,
|
|
* modifier flags and keyboard type.
|
|
*
|
|
* @param aKeyCode A native keyCode.
|
|
* @param aModifiers Combination of native modifier flags.
|
|
* @param aKbType A native Keyboard Type value. Typically,
|
|
* this is a result of ::LMGetKbdType().
|
|
* @param aStr Result, i.e., inputted text.
|
|
* The result can be two or more characters.
|
|
* @return If succeeded, TRUE. Otherwise, FALSE.
|
|
* Even if TRUE, aStr can be empty string.
|
|
*/
|
|
bool TranslateToString(UInt32 aKeyCode, UInt32 aModifiers,
|
|
UInt32 aKbType, nsAString &aStr);
|
|
|
|
/**
|
|
* TranslateToChar() computes the inputted character from the native keyCode,
|
|
* modifier flags and keyboard type. If two or more characters would be
|
|
* input, this returns 0.
|
|
*
|
|
* @param aKeyCode A native keyCode.
|
|
* @param aModifiers Combination of native modifier flags.
|
|
* @param aKbType A native Keyboard Type value. Typically,
|
|
* this is a result of ::LMGetKbdType().
|
|
* @return If succeeded and the result is one character,
|
|
* returns the charCode of it. Otherwise,
|
|
* returns 0.
|
|
*/
|
|
uint32_t TranslateToChar(UInt32 aKeyCode, UInt32 aModifiers, UInt32 aKbType);
|
|
|
|
/**
|
|
* InitKeyPressEvent() initializes aKeyEvent for aNativeKeyEvent.
|
|
* Don't call this method when aKeyEvent isn't NS_KEY_PRESS.
|
|
*
|
|
* @param aNativeKeyEvent A native key event for which you want to
|
|
* dispatch a Gecko key event.
|
|
* @param aInsertChar A character to be input in an editor by the
|
|
* event.
|
|
* @param aKeyEvent The result -- a Gecko key event initialized
|
|
* from the native key event. This must be
|
|
* NS_KEY_PRESS event.
|
|
* @param aKbType A native Keyboard Type value. Typically,
|
|
* this is a result of ::LMGetKbdType().
|
|
*/
|
|
void InitKeyPressEvent(NSEvent *aNativeKeyEvent,
|
|
char16_t aInsertChar,
|
|
WidgetKeyboardEvent& aKeyEvent,
|
|
UInt32 aKbType);
|
|
|
|
bool GetBoolProperty(const CFStringRef aKey);
|
|
bool GetStringProperty(const CFStringRef aKey, CFStringRef &aStr);
|
|
bool GetStringProperty(const CFStringRef aKey, nsAString &aStr);
|
|
|
|
TISInputSourceRef mInputSource;
|
|
TISInputSourceRef mKeyboardLayout;
|
|
CFArrayRef mInputSourceList;
|
|
const UCKeyboardLayout* mUCKeyboardLayout;
|
|
int8_t mIsRTL;
|
|
|
|
bool mOverrideKeyboard;
|
|
};
|
|
|
|
/**
|
|
* TextInputHandlerBase is a base class of PluginTextInputHandler,
|
|
* IMEInputHandler and TextInputHandler. Utility methods should be implemented
|
|
* this level.
|
|
*/
|
|
|
|
class TextInputHandlerBase
|
|
{
|
|
public:
|
|
nsrefcnt AddRef()
|
|
{
|
|
NS_PRECONDITION(int32_t(mRefCnt) >= 0, "mRefCnt is negative");
|
|
++mRefCnt;
|
|
NS_LOG_ADDREF(this, mRefCnt, "TextInputHandlerBase", sizeof(*this));
|
|
return mRefCnt;
|
|
}
|
|
nsrefcnt Release()
|
|
{
|
|
NS_PRECONDITION(mRefCnt != 0, "mRefCnt is alrady zero");
|
|
--mRefCnt;
|
|
NS_LOG_RELEASE(this, mRefCnt, "TextInputHandlerBase");
|
|
if (mRefCnt == 0) {
|
|
mRefCnt = 1; /* stabilize */
|
|
delete this;
|
|
return 0;
|
|
}
|
|
return mRefCnt;
|
|
}
|
|
|
|
/**
|
|
* DispatchEvent() dispatches aEvent on mWidget.
|
|
*
|
|
* @param aEvent An event which you want to dispatch.
|
|
* @return TRUE if the event is consumed by web contents
|
|
* or chrome contents. Otherwise, FALSE.
|
|
*/
|
|
bool DispatchEvent(WidgetGUIEvent& aEvent);
|
|
|
|
/**
|
|
* SetSelection() dispatches NS_SELECTION_SET event for the aRange.
|
|
*
|
|
* @param aRange The range which will be selected.
|
|
* @return TRUE if setting selection is succeeded and
|
|
* the widget hasn't been destroyed.
|
|
* Otherwise, FALSE.
|
|
*/
|
|
bool SetSelection(NSRange& aRange);
|
|
|
|
/**
|
|
* InitKeyEvent() initializes aKeyEvent for aNativeKeyEvent.
|
|
*
|
|
* @param aNativeKeyEvent A native key event for which you want to
|
|
* dispatch a Gecko key event.
|
|
* @param aKeyEvent The result -- a Gecko key event initialized
|
|
* from the native key event.
|
|
* @param aInsertString If caller expects that the event will cause
|
|
* a character to be input (say in an editor),
|
|
* the caller should set this. Otherwise,
|
|
* if caller sets null to this, this method will
|
|
* compute the character to be input from
|
|
* characters of aNativeKeyEvent.
|
|
*/
|
|
void InitKeyEvent(NSEvent *aNativeKeyEvent, WidgetKeyboardEvent& aKeyEvent,
|
|
const nsAString *aInsertString = nullptr);
|
|
|
|
/**
|
|
* SynthesizeNativeKeyEvent() is an implementation of
|
|
* nsIWidget::SynthesizeNativeKeyEvent(). See the document in nsIWidget.h
|
|
* for the detail.
|
|
*/
|
|
nsresult SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
|
|
int32_t aNativeKeyCode,
|
|
uint32_t aModifierFlags,
|
|
const nsAString& aCharacters,
|
|
const nsAString& aUnmodifiedCharacters);
|
|
|
|
/**
|
|
* Utility method intended for testing. Attempts to construct a native key
|
|
* event that would have been generated during an actual key press. This
|
|
* *does not dispatch* the native event. Instead, it is attached to the
|
|
* |mNativeKeyEvent| field of the Gecko event that is passed in.
|
|
* @param aKeyEvent Gecko key event to attach the native event to
|
|
*/
|
|
NS_IMETHOD AttachNativeKeyEvent(WidgetKeyboardEvent& aKeyEvent);
|
|
|
|
/**
|
|
* GetWindowLevel() returns the window level of current focused (in Gecko)
|
|
* window. E.g., if an <input> element in XUL panel has focus, this returns
|
|
* the XUL panel's window level.
|
|
*/
|
|
NSInteger GetWindowLevel();
|
|
|
|
/**
|
|
* IsSpecialGeckoKey() checks whether aNativeKeyCode is mapped to a special
|
|
* Gecko keyCode. A key is "special" if it isn't used for text input.
|
|
*
|
|
* @param aNativeKeyCode A native keycode.
|
|
* @return If the keycode is mapped to a special key,
|
|
* TRUE. Otherwise, FALSE.
|
|
*/
|
|
static bool IsSpecialGeckoKey(UInt32 aNativeKeyCode);
|
|
|
|
|
|
/**
|
|
* EnableSecureEventInput() and DisableSecureEventInput() wrap the Carbon
|
|
* Event Manager APIs with the same names. In addition they keep track of
|
|
* how many times we've called them (in the same process) -- unlike the
|
|
* Carbon Event Manager APIs, which only keep track of how many times they've
|
|
* been called from any and all processes.
|
|
*
|
|
* The Carbon Event Manager's IsSecureEventInputEnabled() returns whether
|
|
* secure event input mode is enabled (in any process). This class's
|
|
* IsSecureEventInputEnabled() returns whether we've made any calls to
|
|
* EnableSecureEventInput() that are not (yet) offset by the calls we've
|
|
* made to DisableSecureEventInput().
|
|
*/
|
|
static void EnableSecureEventInput();
|
|
static void DisableSecureEventInput();
|
|
static bool IsSecureEventInputEnabled();
|
|
|
|
/**
|
|
* EnsureSecureEventInputDisabled() calls DisableSecureEventInput() until
|
|
* our call count becomes 0.
|
|
*/
|
|
static void EnsureSecureEventInputDisabled();
|
|
|
|
protected:
|
|
nsAutoRefCnt mRefCnt;
|
|
|
|
public:
|
|
/**
|
|
* mWidget must not be destroyed without OnDestroyWidget being called.
|
|
*
|
|
* @param aDestroyingWidget Destroying widget. This might not be mWidget.
|
|
* @return This result doesn't have any meaning for
|
|
* callers. When aDstroyingWidget isn't the same
|
|
* as mWidget, FALSE. Then, inherited methods in
|
|
* sub classes should return from this method
|
|
* without cleaning up.
|
|
*/
|
|
virtual bool OnDestroyWidget(nsChildView* aDestroyingWidget);
|
|
|
|
protected:
|
|
// The creater of this instance and client.
|
|
// This must not be null after initialized until OnDestroyWidget() is called.
|
|
nsChildView* mWidget; // [WEAK]
|
|
|
|
// The native view for mWidget.
|
|
// This view handles the actual text inputting.
|
|
NSView<mozView>* mView; // [STRONG]
|
|
|
|
TextInputHandlerBase(nsChildView* aWidget, NSView<mozView> *aNativeView);
|
|
virtual ~TextInputHandlerBase();
|
|
|
|
bool Destroyed() { return !mWidget; }
|
|
|
|
/**
|
|
* mCurrentKeyEvent indicates what key event we are handling. While
|
|
* handling a native keydown event, we need to store the event for insertText,
|
|
* doCommandBySelector and various action message handlers of NSResponder
|
|
* such as [NSResponder insertNewline:sender].
|
|
*/
|
|
struct KeyEventState
|
|
{
|
|
// Handling native key event
|
|
NSEvent* mKeyEvent;
|
|
// Whether keydown event was consumed by web contents or chrome contents.
|
|
bool mKeyDownHandled;
|
|
// Whether keypress event was dispatched for mKeyEvent.
|
|
bool mKeyPressDispatched;
|
|
// Whether keypress event was consumed by web contents or chrome contents.
|
|
bool mKeyPressHandled;
|
|
// Whether the key event causes other key events via IME or something.
|
|
bool mCausedOtherKeyEvents;
|
|
|
|
KeyEventState() : mKeyEvent(nullptr)
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
KeyEventState(NSEvent* aNativeKeyEvent) : mKeyEvent(nullptr)
|
|
{
|
|
Clear();
|
|
Set(aNativeKeyEvent);
|
|
}
|
|
|
|
KeyEventState(const KeyEventState &aOther) : mKeyEvent(nullptr)
|
|
{
|
|
Clear();
|
|
if (aOther.mKeyEvent) {
|
|
mKeyEvent = [aOther.mKeyEvent retain];
|
|
}
|
|
mKeyDownHandled = aOther.mKeyDownHandled;
|
|
mKeyPressDispatched = aOther.mKeyPressDispatched;
|
|
mKeyPressHandled = aOther.mKeyPressHandled;
|
|
mCausedOtherKeyEvents = aOther.mCausedOtherKeyEvents;
|
|
}
|
|
|
|
~KeyEventState()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void Set(NSEvent* aNativeKeyEvent)
|
|
{
|
|
NS_PRECONDITION(aNativeKeyEvent, "aNativeKeyEvent must not be NULL");
|
|
Clear();
|
|
mKeyEvent = [aNativeKeyEvent retain];
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
if (mKeyEvent) {
|
|
[mKeyEvent release];
|
|
mKeyEvent = nullptr;
|
|
}
|
|
mKeyDownHandled = false;
|
|
mKeyPressDispatched = false;
|
|
mKeyPressHandled = false;
|
|
mCausedOtherKeyEvents = false;
|
|
}
|
|
|
|
bool IsDefaultPrevented() const
|
|
{
|
|
return mKeyDownHandled || mKeyPressHandled || mCausedOtherKeyEvents;
|
|
}
|
|
|
|
bool CanDispatchKeyPressEvent() const
|
|
{
|
|
return !mKeyPressDispatched && !IsDefaultPrevented();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Helper class for guaranteeing cleaning mCurrentKeyEvent
|
|
*/
|
|
class AutoKeyEventStateCleaner
|
|
{
|
|
public:
|
|
AutoKeyEventStateCleaner(TextInputHandlerBase* aHandler) :
|
|
mHandler(aHandler)
|
|
{
|
|
}
|
|
|
|
~AutoKeyEventStateCleaner()
|
|
{
|
|
mHandler->RemoveCurrentKeyEvent();
|
|
}
|
|
private:
|
|
nsRefPtr<TextInputHandlerBase> mHandler;
|
|
};
|
|
|
|
/**
|
|
* mCurrentKeyEvents stores all key events which are being processed.
|
|
* When we call interpretKeyEvents, IME may generate other key events.
|
|
* mCurrentKeyEvents[0] is the latest key event.
|
|
*/
|
|
nsTArray<KeyEventState*> mCurrentKeyEvents;
|
|
|
|
/**
|
|
* mFirstKeyEvent must be used for first key event. This member prevents
|
|
* memory fragmentation for most key events.
|
|
*/
|
|
KeyEventState mFirstKeyEvent;
|
|
|
|
/**
|
|
* PushKeyEvent() adds the current key event to mCurrentKeyEvents.
|
|
*/
|
|
KeyEventState* PushKeyEvent(NSEvent* aNativeKeyEvent)
|
|
{
|
|
uint32_t nestCount = mCurrentKeyEvents.Length();
|
|
for (uint32_t i = 0; i < nestCount; i++) {
|
|
// When the key event is caused by another key event, all key events
|
|
// which are being handled should be marked as "consumed".
|
|
mCurrentKeyEvents[i]->mCausedOtherKeyEvents = true;
|
|
}
|
|
|
|
KeyEventState* keyEvent = nullptr;
|
|
if (nestCount == 0) {
|
|
mFirstKeyEvent.Set(aNativeKeyEvent);
|
|
keyEvent = &mFirstKeyEvent;
|
|
} else {
|
|
keyEvent = new KeyEventState(aNativeKeyEvent);
|
|
}
|
|
return *mCurrentKeyEvents.AppendElement(keyEvent);
|
|
}
|
|
|
|
/**
|
|
* RemoveCurrentKeyEvent() removes the current key event from
|
|
* mCurrentKeyEvents.
|
|
*/
|
|
void RemoveCurrentKeyEvent()
|
|
{
|
|
NS_ASSERTION(mCurrentKeyEvents.Length() > 0,
|
|
"RemoveCurrentKeyEvent() is called unexpectedly");
|
|
KeyEventState* keyEvent = GetCurrentKeyEvent();
|
|
mCurrentKeyEvents.RemoveElementAt(mCurrentKeyEvents.Length() - 1);
|
|
if (keyEvent == &mFirstKeyEvent) {
|
|
keyEvent->Clear();
|
|
} else {
|
|
delete keyEvent;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GetCurrentKeyEvent() returns current processing key event.
|
|
*/
|
|
KeyEventState* GetCurrentKeyEvent()
|
|
{
|
|
if (mCurrentKeyEvents.Length() == 0) {
|
|
return nullptr;
|
|
}
|
|
return mCurrentKeyEvents[mCurrentKeyEvents.Length() - 1];
|
|
}
|
|
|
|
/**
|
|
* IsPrintableChar() checks whether the unicode character is
|
|
* a non-printable ASCII character or not. Note that this returns
|
|
* TRUE even if aChar is a non-printable UNICODE character.
|
|
*
|
|
* @param aChar A unicode character.
|
|
* @return TRUE if aChar is a printable ASCII character
|
|
* or a unicode character. Otherwise, i.e,
|
|
* if aChar is a non-printable ASCII character,
|
|
* FALSE.
|
|
*/
|
|
static bool IsPrintableChar(char16_t aChar);
|
|
|
|
/**
|
|
* IsNormalCharInputtingEvent() checks whether aKeyEvent causes text input.
|
|
*
|
|
* @param aKeyEvent A key event.
|
|
* @return TRUE if the key event causes text input.
|
|
* Otherwise, FALSE.
|
|
*/
|
|
static bool IsNormalCharInputtingEvent(const WidgetKeyboardEvent& aKeyEvent);
|
|
|
|
/**
|
|
* IsModifierKey() checks whether the native keyCode is for a modifier key.
|
|
*
|
|
* @param aNativeKeyCode A native keyCode.
|
|
* @return TRUE if aNativeKeyCode is for a modifier key.
|
|
* Otherwise, FALSE.
|
|
*/
|
|
static bool IsModifierKey(UInt32 aNativeKeyCode);
|
|
|
|
private:
|
|
struct KeyboardLayoutOverride {
|
|
int32_t mKeyboardLayout;
|
|
bool mOverrideEnabled;
|
|
|
|
KeyboardLayoutOverride() :
|
|
mKeyboardLayout(0), mOverrideEnabled(false)
|
|
{
|
|
}
|
|
};
|
|
|
|
KeyboardLayoutOverride mKeyboardOverride;
|
|
|
|
static int32_t sSecureEventInputCount;
|
|
};
|
|
|
|
/**
|
|
* PluginTextInputHandler handles text input events for plugins.
|
|
*/
|
|
|
|
class PluginTextInputHandler : public TextInputHandlerBase
|
|
{
|
|
public:
|
|
|
|
/**
|
|
* When starting complex text input for current event on plugin, this is
|
|
* called. See also the comment of StartComplexTextInputForCurrentEvent() of
|
|
* nsIPluginWidget.
|
|
*/
|
|
nsresult StartComplexTextInputForCurrentEvent()
|
|
{
|
|
mPluginComplexTextInputRequested = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
/**
|
|
* HandleKeyDownEventForPlugin() handles aNativeKeyEvent.
|
|
*
|
|
* @param aNativeKeyEvent A native NSKeyDown event.
|
|
*/
|
|
void HandleKeyDownEventForPlugin(NSEvent* aNativeKeyEvent);
|
|
|
|
/**
|
|
* HandleKeyUpEventForPlugin() handles aNativeKeyEvent.
|
|
*
|
|
* @param aNativeKeyEvent A native NSKeyUp event.
|
|
*/
|
|
void HandleKeyUpEventForPlugin(NSEvent* aNativeKeyEvent);
|
|
|
|
/**
|
|
* ConvertCocoaKeyEventToNPCocoaEvent() converts aCocoaEvent to NPCocoaEvent.
|
|
*
|
|
* @param aCocoaEvent A native key event.
|
|
* @param aPluginEvent The result.
|
|
*/
|
|
static void ConvertCocoaKeyEventToNPCocoaEvent(NSEvent* aCocoaEvent,
|
|
NPCocoaEvent& aPluginEvent);
|
|
|
|
#ifndef __LP64__
|
|
|
|
/**
|
|
* InstallPluginKeyEventsHandler() is called when initializing process.
|
|
* RemovePluginKeyEventsHandler() is called when finalizing process.
|
|
* These methods initialize/finalize global resource for handling events for
|
|
* plugins.
|
|
*/
|
|
static void InstallPluginKeyEventsHandler();
|
|
static void RemovePluginKeyEventsHandler();
|
|
|
|
/**
|
|
* This must be called before first key/IME event for plugins.
|
|
* This method initializes IMKInputSession methods swizzling.
|
|
*/
|
|
static void SwizzleMethods();
|
|
|
|
/**
|
|
* When a composition starts or finishes, this is called.
|
|
*/
|
|
void SetPluginTSMInComposition(bool aInComposition)
|
|
{
|
|
mPluginTSMInComposition = aInComposition;
|
|
}
|
|
|
|
#endif // #ifndef __LP64__
|
|
|
|
protected:
|
|
bool mIgnoreNextKeyUpEvent;
|
|
|
|
PluginTextInputHandler(nsChildView* aWidget, NSView<mozView> *aNativeView);
|
|
~PluginTextInputHandler();
|
|
|
|
private:
|
|
|
|
#ifndef __LP64__
|
|
TSMDocumentID mPluginTSMDoc;
|
|
|
|
bool mPluginTSMInComposition;
|
|
#endif // #ifndef __LP64__
|
|
|
|
bool mPluginComplexTextInputRequested;
|
|
|
|
/**
|
|
* DispatchCocoaNPAPITextEvent() dispatches a text event for Cocoa plugin.
|
|
*
|
|
* @param aString A string inputted by the dispatching event.
|
|
* @return TRUE if the dispatched event was consumed.
|
|
* Otherwise, FALSE.
|
|
*/
|
|
bool DispatchCocoaNPAPITextEvent(NSString* aString);
|
|
|
|
/**
|
|
* Whether the plugin is in composition or not.
|
|
* On 32bit build, this returns the state of mPluginTSMInComposition.
|
|
* On 64bit build, this returns ComplexTextInputPanel's state.
|
|
*
|
|
* @return TRUE if plugin is in composition. Otherwise,
|
|
* FALSE.
|
|
*/
|
|
bool IsInPluginComposition();
|
|
|
|
#ifndef __LP64__
|
|
|
|
/**
|
|
* Create a TSM document for use with plugins, so that we can support IME in
|
|
* them. Once it's created, if need be (re)activate it. Some plugins (e.g.
|
|
* the Flash plugin running in Camino) don't create their own TSM document --
|
|
* without which IME can't work. Others (e.g. the Flash plugin running in
|
|
* Firefox) create a TSM document that (somehow) makes the input window behave
|
|
* badly when it contains more than one kind of input (say Hiragana and
|
|
* Romaji). (We can't just use the per-NSView TSM documents that Cocoa
|
|
* provides (those created and managed by the NSTSMInputContext class) -- for
|
|
* some reason TSMProcessRawKeyEvent() doesn't work with them.)
|
|
*/
|
|
void ActivatePluginTSMDocument();
|
|
|
|
/**
|
|
* HandleCarbonPluginKeyEvent() handles the aKeyEvent. This is called by
|
|
* PluginKeyEventsHandler().
|
|
*
|
|
* @param aKeyEvent A native Carbon event.
|
|
*/
|
|
void HandleCarbonPluginKeyEvent(EventRef aKeyEvent);
|
|
|
|
/**
|
|
* Target for text services events sent as the result of calls made to
|
|
* TSMProcessRawKeyEvent() in HandleKeyDownEventForPlugin() when a plugin has
|
|
* the focus. The calls to TSMProcessRawKeyEvent() short-circuit Cocoa-based
|
|
* IME (which would otherwise interfere with our efforts) and allow Carbon-
|
|
* based IME to work in plugins (via the NPAPI). This strategy doesn't cause
|
|
* trouble for plugins that (like the Java Embedding Plugin) bypass the NPAPI
|
|
* to get their keyboard events and do their own Cocoa-based IME.
|
|
*/
|
|
static OSStatus PluginKeyEventsHandler(EventHandlerCallRef aHandlerRef,
|
|
EventRef aEvent,
|
|
void *aUserData);
|
|
|
|
static EventHandlerRef sPluginKeyEventsHandler;
|
|
|
|
#endif // #ifndef __LP64__
|
|
};
|
|
|
|
/**
|
|
* IMEInputHandler manages:
|
|
* 1. The IME/keyboard layout statement of nsChildView.
|
|
* 2. The IME composition statement of nsChildView.
|
|
* And also provides the methods which controls the current IME transaction of
|
|
* the instance.
|
|
*
|
|
* Note that an nsChildView handles one or more NSView's events. E.g., even if
|
|
* a text editor on XUL panel element, the input events handled on the parent
|
|
* (or its ancestor) widget handles it (the native focus is set to it). The
|
|
* actual focused view is notified by OnFocusChangeInGecko.
|
|
*/
|
|
|
|
class IMEInputHandler : public PluginTextInputHandler
|
|
{
|
|
public:
|
|
virtual bool OnDestroyWidget(nsChildView* aDestroyingWidget);
|
|
|
|
virtual void OnFocusChangeInGecko(bool aFocus);
|
|
|
|
void OnSelectionChange() { mSelectedRange.location = NSNotFound; }
|
|
|
|
/**
|
|
* DispatchTextEvent() dispatches a text event on mWidget.
|
|
*
|
|
* @param aText User text input.
|
|
* @param aAttrString An NSAttributedString instance which indicates
|
|
* current composition string.
|
|
* @param aSelectedRange Current selected range (or caret position).
|
|
* @param aDoCommit TRUE if the composition string should be
|
|
* committed. Otherwise, FALSE.
|
|
*/
|
|
bool DispatchTextEvent(const nsString& aText,
|
|
NSAttributedString* aAttrString,
|
|
NSRange& aSelectedRange,
|
|
bool aDoCommit);
|
|
|
|
/**
|
|
* SetMarkedText() is a handler of setMarkedText of NSTextInput.
|
|
*
|
|
* @param aAttrString This mut be an instance of NSAttributedString.
|
|
* If the aString parameter to
|
|
* [ChildView setMarkedText:setSelectedRange:]
|
|
* isn't an instance of NSAttributedString,
|
|
* create an NSAttributedString from it and pass
|
|
* that instead.
|
|
* @param aSelectedRange Current selected range (or caret position).
|
|
* @param aReplacementRange The range which will be replaced with the
|
|
* aAttrString instead of current marked range.
|
|
*/
|
|
void SetMarkedText(NSAttributedString* aAttrString,
|
|
NSRange& aSelectedRange,
|
|
NSRange* aReplacementRange = nullptr);
|
|
|
|
/**
|
|
* ConversationIdentifier() returns an ID for the current editor. The ID is
|
|
* guaranteed to be unique among currently existing editors. But it might be
|
|
* the same as the ID of an editor that has already been destroyed.
|
|
*
|
|
* @return An identifier of current focused editor.
|
|
*/
|
|
NSInteger ConversationIdentifier();
|
|
|
|
/**
|
|
* GetAttributedSubstringFromRange() returns an NSAttributedString instance
|
|
* which is allocated as autorelease for aRange.
|
|
*
|
|
* @param aRange The range of string which you want.
|
|
* @param aActualRange The actual range of the result.
|
|
* @return The string in aRange. If the string is empty,
|
|
* this returns nil. If succeeded, this returns
|
|
* an instance which is allocated as autorelease.
|
|
* If this has some troubles, returns nil.
|
|
*/
|
|
NSAttributedString* GetAttributedSubstringFromRange(
|
|
NSRange& aRange,
|
|
NSRange* aActualRange = nullptr);
|
|
|
|
/**
|
|
* SelectedRange() returns current selected range.
|
|
*
|
|
* @return If an editor has focus, this returns selection
|
|
* range in the editor. Otherwise, this returns
|
|
* selection range in the focused document.
|
|
*/
|
|
NSRange SelectedRange();
|
|
|
|
/**
|
|
* FirstRectForCharacterRange() returns first *character* rect in the range.
|
|
* Cocoa needs the first line rect in the range, but we cannot compute it
|
|
* on current implementation.
|
|
*
|
|
* @param aRange A range of text to examine. Its position is
|
|
* an offset from the beginning of the focused
|
|
* editor or document.
|
|
* @param aActualRange If this is not null, this returns the actual
|
|
* range used for computing the result.
|
|
* @return An NSRect containing the first character in
|
|
* aRange, in screen coordinates.
|
|
* If the length of aRange is 0, the width will
|
|
* be 0.
|
|
*/
|
|
NSRect FirstRectForCharacterRange(NSRange& aRange,
|
|
NSRange* aActualRange = nullptr);
|
|
|
|
/**
|
|
* CharacterIndexForPoint() returns an offset of a character at aPoint.
|
|
* XXX This isn't implemented, always returns 0.
|
|
*
|
|
* @param The point in screen coordinates.
|
|
* @return The offset of the character at aPoint from
|
|
* the beginning of the focused editor or
|
|
* document.
|
|
*/
|
|
NSUInteger CharacterIndexForPoint(NSPoint& aPoint);
|
|
|
|
/**
|
|
* GetValidAttributesForMarkedText() returns attributes which we support.
|
|
*
|
|
* @return Always empty array for now.
|
|
*/
|
|
NSArray* GetValidAttributesForMarkedText();
|
|
|
|
bool HasMarkedText();
|
|
NSRange MarkedRange();
|
|
|
|
bool IsIMEComposing() { return mIsIMEComposing; }
|
|
bool IsIMEOpened();
|
|
bool IsIMEEnabled() { return mIsIMEEnabled; }
|
|
bool IsASCIICapableOnly() { return mIsASCIICapableOnly; }
|
|
bool IgnoreIMECommit() { return mIgnoreIMECommit; }
|
|
|
|
bool IgnoreIMEComposition()
|
|
{
|
|
// Ignore the IME composition events when we're pending to discard the
|
|
// composition and we are not to handle the IME composition now.
|
|
return (mPendingMethods & kDiscardIMEComposition) &&
|
|
(mIsInFocusProcessing || !IsFocused());
|
|
}
|
|
|
|
void CommitIMEComposition();
|
|
void CancelIMEComposition();
|
|
|
|
void EnableIME(bool aEnableIME);
|
|
void SetIMEOpenState(bool aOpen);
|
|
void SetASCIICapableOnly(bool aASCIICapableOnly);
|
|
|
|
bool IsFocused();
|
|
|
|
static CFArrayRef CreateAllIMEModeList();
|
|
static void DebugPrintAllIMEModes();
|
|
|
|
// Don't use ::TSMGetActiveDocument() API directly, the document may not
|
|
// be what you want.
|
|
static TSMDocumentID GetCurrentTSMDocumentID();
|
|
|
|
protected:
|
|
// We cannot do some jobs in the given stack by some reasons.
|
|
// Following flags and the timer provide the execution pending mechanism,
|
|
// See the comment in nsCocoaTextInputHandler.mm.
|
|
nsCOMPtr<nsITimer> mTimer;
|
|
enum {
|
|
kNotifyIMEOfFocusChangeInGecko = 1,
|
|
kDiscardIMEComposition = 2,
|
|
kSyncASCIICapableOnly = 4
|
|
};
|
|
uint32_t mPendingMethods;
|
|
|
|
IMEInputHandler(nsChildView* aWidget, NSView<mozView> *aNativeView);
|
|
virtual ~IMEInputHandler();
|
|
|
|
void ResetTimer();
|
|
|
|
virtual void ExecutePendingMethods();
|
|
|
|
/**
|
|
* InsertTextAsCommittingComposition() commits current composition. If there
|
|
* is no composition, this starts a composition and commits it immediately.
|
|
*
|
|
* @param aAttrString A string which is committed.
|
|
* @param aReplacementRange The range which will be replaced with the
|
|
* aAttrString instead of current selection.
|
|
*/
|
|
void InsertTextAsCommittingComposition(NSAttributedString* aAttrString,
|
|
NSRange* aReplacementRange);
|
|
|
|
private:
|
|
// If mIsIMEComposing is true, the composition string is stored here.
|
|
NSString* mIMECompositionString;
|
|
// mLastDispatchedCompositionString stores the lastest dispatched composition
|
|
// string by compositionupdate event.
|
|
nsString mLastDispatchedCompositionString;
|
|
|
|
NSRange mMarkedRange;
|
|
NSRange mSelectedRange;
|
|
|
|
bool mIsIMEComposing;
|
|
bool mIsIMEEnabled;
|
|
bool mIsASCIICapableOnly;
|
|
bool mIgnoreIMECommit;
|
|
// This flag is enabled by OnFocusChangeInGecko, and will be cleared by
|
|
// ExecutePendingMethods. When this is true, IsFocus() returns TRUE. At
|
|
// that time, the focus processing in Gecko might not be finished yet. So,
|
|
// you cannot use WidgetQueryContentEvent or something.
|
|
bool mIsInFocusProcessing;
|
|
bool mIMEHasFocus;
|
|
|
|
void KillIMEComposition();
|
|
void SendCommittedText(NSString *aString);
|
|
void OpenSystemPreferredLanguageIME();
|
|
|
|
// Pending methods
|
|
void NotifyIMEOfFocusChangeInGecko();
|
|
void DiscardIMEComposition();
|
|
void SyncASCIICapableOnly();
|
|
|
|
static bool sStaticMembersInitialized;
|
|
static CFStringRef sLatestIMEOpenedModeInputSourceID;
|
|
static void InitStaticMembers();
|
|
static void OnCurrentTextInputSourceChange(CFNotificationCenterRef aCenter,
|
|
void* aObserver,
|
|
CFStringRef aName,
|
|
const void* aObject,
|
|
CFDictionaryRef aUserInfo);
|
|
|
|
static void FlushPendingMethods(nsITimer* aTimer, void* aClosure);
|
|
|
|
/**
|
|
* ConvertToTextRangeStyle converts the given native underline style to
|
|
* our defined text range type.
|
|
*
|
|
* @param aUnderlineStyle NSUnderlineStyleSingle or
|
|
* NSUnderlineStyleThick.
|
|
* @param aSelectedRange Current selected range (or caret position).
|
|
* @return NS_TEXTRANGE_*.
|
|
*/
|
|
uint32_t ConvertToTextRangeType(uint32_t aUnderlineStyle,
|
|
NSRange& aSelectedRange);
|
|
|
|
/**
|
|
* GetRangeCount() computes the range count of aAttrString.
|
|
*
|
|
* @param aAttrString An NSAttributedString instance whose number of
|
|
* NSUnderlineStyleAttributeName ranges you with
|
|
* to know.
|
|
* @return The count of NSUnderlineStyleAttributeName
|
|
* ranges in aAttrString.
|
|
*/
|
|
uint32_t GetRangeCount(NSAttributedString *aString);
|
|
|
|
/**
|
|
* CreateTextRangeArray() returns text ranges for clauses and/or caret.
|
|
*
|
|
* @param aAttrString An NSAttributedString instance which indicates
|
|
* current composition string.
|
|
* @param aSelectedRange Current selected range (or caret position).
|
|
* @return The result is set to the
|
|
* NSUnderlineStyleAttributeName ranges in
|
|
* aAttrString.
|
|
*/
|
|
already_AddRefed<mozilla::TextRangeArray>
|
|
CreateTextRangeArray(NSAttributedString *aAttrString,
|
|
NSRange& aSelectedRange);
|
|
|
|
/**
|
|
* InitCompositionEvent() initializes aCompositionEvent.
|
|
*
|
|
* @param aCompositionEvent A composition event which you want to
|
|
* initialize.
|
|
*/
|
|
void InitCompositionEvent(WidgetCompositionEvent& aCompositionEvent);
|
|
|
|
/**
|
|
* When a composition starts, OnStartIMEComposition() is called.
|
|
*/
|
|
void OnStartIMEComposition();
|
|
|
|
/**
|
|
* When a composition is updated, OnUpdateIMEComposition() is called.
|
|
*/
|
|
void OnUpdateIMEComposition(NSString* aIMECompositionString);
|
|
|
|
/**
|
|
* When a composition is finished, OnEndIMEComposition() is called.
|
|
*/
|
|
void OnEndIMEComposition();
|
|
|
|
// The focused IME handler. Please note that the handler might lost the
|
|
// actual focus by deactivating the application. If we are active, this
|
|
// must have the actual focused handle.
|
|
// We cannot access to the NSInputManager during we aren't active, so, the
|
|
// focused handler can have an IME transaction even if we are deactive.
|
|
static IMEInputHandler* sFocusedIMEHandler;
|
|
};
|
|
|
|
/**
|
|
* TextInputHandler implements the NSTextInput protocol.
|
|
*/
|
|
class TextInputHandler : public IMEInputHandler
|
|
{
|
|
public:
|
|
static NSUInteger sLastModifierState;
|
|
|
|
static CFArrayRef CreateAllKeyboardLayoutList();
|
|
static void DebugPrintAllKeyboardLayouts();
|
|
|
|
TextInputHandler(nsChildView* aWidget, NSView<mozView> *aNativeView);
|
|
virtual ~TextInputHandler();
|
|
|
|
/**
|
|
* KeyDown event handler.
|
|
*
|
|
* @param aNativeEvent A native NSKeyDown event.
|
|
* @return TRUE if the event is consumed by web contents
|
|
* or chrome contents. Otherwise, FALSE.
|
|
*/
|
|
bool HandleKeyDownEvent(NSEvent* aNativeEvent);
|
|
|
|
/**
|
|
* KeyUp event handler.
|
|
*
|
|
* @param aNativeEvent A native NSKeyUp event.
|
|
*/
|
|
void HandleKeyUpEvent(NSEvent* aNativeEvent);
|
|
|
|
/**
|
|
* FlagsChanged event handler.
|
|
*
|
|
* @param aNativeEvent A native NSFlagsChanged event.
|
|
*/
|
|
void HandleFlagsChanged(NSEvent* aNativeEvent);
|
|
|
|
/**
|
|
* Insert the string to content. I.e., this is a text input event handler.
|
|
* If this is called during keydown event handling, this may dispatch a
|
|
* NS_KEY_PRESS event. If this is called during composition, this commits
|
|
* the composition by the aAttrString.
|
|
*
|
|
* @param aAttrString An inserted string.
|
|
* @param aReplacementRange The range which will be replaced with the
|
|
* aAttrString instead of current selection.
|
|
*/
|
|
void InsertText(NSAttributedString *aAttrString,
|
|
NSRange* aReplacementRange = nullptr);
|
|
|
|
/**
|
|
* doCommandBySelector event handler.
|
|
*
|
|
* @param aSelector A selector of the command.
|
|
* @return TRUE if the command is consumed. Otherwise,
|
|
* FALSE.
|
|
*/
|
|
bool DoCommandBySelector(const char* aSelector);
|
|
|
|
/**
|
|
* KeyPressWasHandled() checks whether keypress event was handled or not.
|
|
*
|
|
* @return TRUE if keypress event for latest native key
|
|
* event was handled. Otherwise, FALSE.
|
|
* If this handler isn't handling any key events,
|
|
* always returns FALSE.
|
|
*/
|
|
bool KeyPressWasHandled()
|
|
{
|
|
KeyEventState* currentKeyEvent = GetCurrentKeyEvent();
|
|
return currentKeyEvent && currentKeyEvent->mKeyPressHandled;
|
|
}
|
|
|
|
protected:
|
|
// Stores the association of device dependent modifier flags with a modifier
|
|
// keyCode. Being device dependent, this association may differ from one kind
|
|
// of hardware to the next.
|
|
struct ModifierKey
|
|
{
|
|
NSUInteger flags;
|
|
unsigned short keyCode;
|
|
|
|
ModifierKey(NSUInteger aFlags, unsigned short aKeyCode) :
|
|
flags(aFlags), keyCode(aKeyCode)
|
|
{
|
|
}
|
|
|
|
NSUInteger GetDeviceDependentFlags() const
|
|
{
|
|
return (flags & ~NSDeviceIndependentModifierFlagsMask);
|
|
}
|
|
|
|
NSUInteger GetDeviceIndependentFlags() const
|
|
{
|
|
return (flags & NSDeviceIndependentModifierFlagsMask);
|
|
}
|
|
};
|
|
typedef nsTArray<ModifierKey> ModifierKeyArray;
|
|
ModifierKeyArray mModifierKeys;
|
|
|
|
/**
|
|
* GetModifierKeyForNativeKeyCode() returns the stored ModifierKey for
|
|
* the key.
|
|
*/
|
|
const ModifierKey*
|
|
GetModifierKeyForNativeKeyCode(unsigned short aKeyCode) const;
|
|
|
|
/**
|
|
* GetModifierKeyForDeviceDependentFlags() returns the stored ModifierKey for
|
|
* the device dependent flags.
|
|
*/
|
|
const ModifierKey*
|
|
GetModifierKeyForDeviceDependentFlags(NSUInteger aFlags) const;
|
|
|
|
/**
|
|
* DispatchKeyEventForFlagsChanged() dispatches keydown event or keyup event
|
|
* for the aNativeEvent.
|
|
*
|
|
* @param aNativeEvent A native flagschanged event which you want to
|
|
* dispatch our key event for.
|
|
* @param aDispatchKeyDown TRUE if you want to dispatch a keydown event.
|
|
* Otherwise, i.e., to dispatch keyup event,
|
|
* FALSE.
|
|
*/
|
|
void DispatchKeyEventForFlagsChanged(NSEvent* aNativeEvent,
|
|
bool aDispatchKeyDown);
|
|
};
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|
|
|
|
#endif // TextInputHandler_h_
|