1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/* -*- 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/. */
#ifndef mozilla_GlobalKeyListener_h_
#define mozilla_GlobalKeyListener_h_
#include "mozilla/EventForwards.h"
#include "mozilla/layers/KeyboardMap.h"
#include "nsIDOMEventListener.h"
#include "nsIWeakReferenceUtils.h"
class nsAtom;
namespace mozilla {
class EventListenerManager;
class WidgetKeyboardEvent;
struct IgnoreModifierState;
namespace layers {
class KeyboardMap;
}
namespace dom {
class Element;
class EventTarget;
class KeyboardEvent;
} // namespace dom
class KeyEventHandler;
/**
* A generic listener for key events.
*
* Maintains a list of shortcut handlers and is registered as a listener for DOM
* key events from a target. Responsible for executing the appropriate handler
* when a keyboard event is received.
*/
class GlobalKeyListener : public nsIDOMEventListener {
public:
explicit GlobalKeyListener(dom::EventTarget* aTarget);
void InstallKeyboardEventListenersTo(
EventListenerManager* aEventListenerManager);
void RemoveKeyboardEventListenersFrom(
EventListenerManager* aEventListenerManager);
NS_DECL_ISUPPORTS
NS_DECL_NSIDOMEVENTLISTENER
protected:
virtual ~GlobalKeyListener() = default;
MOZ_CAN_RUN_SCRIPT
void WalkHandlers(dom::KeyboardEvent* aKeyEvent);
enum class Purpose {
ExecuteCommand,
LookForCommand,
};
struct MOZ_STACK_CLASS WalkHandlersResult {
// Set to true if it found a command matches with given keyboard event and
// it's available.
bool mMeaningfulHandlerFound = false;
// Set to true if the command which is found or executed is reserved for
// chrome.
bool mReservedHandlerForChromeFound = false;
// Set to true if found handler is disabled.
bool mDisabledHandlerFound = false;
// Set to true if a command is found but may correspond to a different type
// of keyboard event.
bool mRelevantHandlerFound = false;
};
// walk the handlers, looking for one to handle the event
MOZ_CAN_RUN_SCRIPT
WalkHandlersResult WalkHandlersInternal(Purpose aPurpose,
dom::KeyboardEvent* aKeyEvent);
// Walk the handlers for aEvent, aCharCode and aIgnoreModifierState.
MOZ_CAN_RUN_SCRIPT
WalkHandlersResult WalkHandlersAndExecute(
Purpose aPurpose, dom::KeyboardEvent* aKeyEvent, uint32_t aCharCode,
const IgnoreModifierState& aIgnoreModifierState);
// HandleEvent function for the capturing phase in the default event group.
MOZ_CAN_RUN_SCRIPT
void HandleEventOnCaptureInDefaultEventGroup(dom::KeyboardEvent* aEvent);
// HandleEvent function for the capturing phase in the system event group.
MOZ_CAN_RUN_SCRIPT
void HandleEventOnCaptureInSystemEventGroup(dom::KeyboardEvent* aEvent);
// Check if any handler would handle the given event. Optionally returns
// whether the command handler for the event is marked with the "reserved"
// attribute.
MOZ_CAN_RUN_SCRIPT
WalkHandlersResult HasHandlerForEvent(dom::KeyboardEvent* aEvent);
// Returns true if the key would be reserved for the given handler. A reserved
// key is not sent to a content process or single-process equivalent.
bool IsReservedKey(WidgetKeyboardEvent* aKeyEvent, KeyEventHandler* aHandler);
// lazily load the handlers. Overridden to handle being attached
// to a particular element rather than the document
virtual void EnsureHandlers() = 0;
virtual bool CanHandle(KeyEventHandler* aHandler, bool aWillExecute) const {
return true;
}
virtual bool IsDisabled() const { return false; }
virtual already_AddRefed<dom::EventTarget> GetHandlerTarget(
KeyEventHandler* aHandler) {
return do_AddRef(mTarget);
}
dom::EventTarget* mTarget; // weak ref;
KeyEventHandler* mHandler; // Linked list of event handlers.
};
/**
* A listener for shortcut keys defined in XUL keyset elements.
*
* Listens for keyboard events from the document object and triggers the
* appropriate XUL key elements.
*/
class XULKeySetGlobalKeyListener final : public GlobalKeyListener {
public:
explicit XULKeySetGlobalKeyListener(dom::Element* aElement,
dom::EventTarget* aTarget);
static void AttachKeyHandler(dom::Element* aElementTarget);
static void DetachKeyHandler(dom::Element* aElementTarget);
protected:
virtual ~XULKeySetGlobalKeyListener();
// Returns the element which was passed as a parameter to the constructor,
// unless the element has been removed from the document. Optionally returns
// whether the disabled attribute is set on the element (assuming the element
// is non-null).
dom::Element* GetElement(bool* aIsDisabled = nullptr) const;
virtual void EnsureHandlers() override;
virtual bool CanHandle(KeyEventHandler* aHandler,
bool aWillExecute) const override;
virtual bool IsDisabled() const override;
virtual already_AddRefed<dom::EventTarget> GetHandlerTarget(
KeyEventHandler* aHandler) override;
/**
* GetElementForHandler() retrieves an element for the handler. The element
* may be a command element or a key element.
*
* @param aHandler The handler.
* @param aElementForHandler Must not be nullptr. The element is returned to
* this.
* @return true if the handler is valid. Otherwise, false.
*/
bool GetElementForHandler(KeyEventHandler* aHandler,
dom::Element** aElementForHandler) const;
/**
* IsExecutableElement() returns true if aElement is executable.
* Otherwise, false. aElement should be a command element or a key element.
*/
bool IsExecutableElement(dom::Element* aElement) const;
// Using weak pointer to the DOM Element.
nsWeakPtr mWeakPtrForElement;
};
/**
* Listens for built-in shortcut keys.
*
* Listens to DOM keyboard events from the window or text input and runs the
* built-in shortcuts (see dom/events/keyevents) as necessary.
*/
class RootWindowGlobalKeyListener final : public GlobalKeyListener {
public:
explicit RootWindowGlobalKeyListener(dom::EventTarget* aTarget);
static void AttachKeyHandler(dom::EventTarget* aTarget);
static layers::KeyboardMap CollectKeyboardShortcuts();
protected:
// Is an HTML editable element focused
static bool IsHTMLEditorFocused();
virtual void EnsureHandlers() override;
};
} // namespace mozilla
#endif
|
