]> git.gir.st - VimFx.git/blob - extension/lib/events.coffee
Fix `zF` crashing when devtools open in Firefox 49
[VimFx.git] / extension / lib / events.coffee
1 ###
2 # Copyright Anton Khodakivskiy 2012, 2013, 2014.
3 # Copyright Simon Lydell 2013, 2014, 2015, 2016.
4 #
5 # This file is part of VimFx.
6 #
7 # VimFx is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # VimFx is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License
18 # along with VimFx. If not, see <http://www.gnu.org/licenses/>.
19 ###
20
21 # This file sets up all event listeners needed to power VimFx: To know when to
22 # launch commands and to provide state to them. Events in web page content are
23 # listened for in events-frame.coffee.
24
25 button = require('./button')
26 messageManager = require('./message-manager')
27 prefs = require('./prefs')
28 utils = require('./utils')
29
30 HELD_MODIFIERS_ATTRIBUTE = 'vimfx-held-modifiers'
31
32 class UIEventManager
33 constructor: (@vimfx, @window) ->
34 @listen = utils.listen.bind(null, @window)
35 @listenOnce = utils.listenOnce.bind(null, @window)
36
37 # This flag controls whether to suppress the various key events or not.
38 @suppress = false
39
40 # If a matched shortcut has the `<late>` special key, this flag is set to
41 # `true`.
42 @late = false
43
44 # When a menu or panel is shown VimFx should temporarily stop processing
45 # keyboard input, allowing accesskeys to be used.
46 @popupPassthrough = false
47
48 @enteredKeys = new EnteredKeysManager(@window)
49
50 addListeners: ->
51 checkPassthrough = (value, event) =>
52 target = event.originalTarget
53 if target.localName in ['menupopup', 'panel'] and
54 # Don’t set `@popupPassthrough` to `false` if there actually are popups
55 # open. This is the case when a sub-menu closes.
56 (value or not @anyPopupsOpen())
57 @popupPassthrough = value
58
59 @listen('popupshown', checkPassthrough.bind(null, true))
60 @listen('popuphidden', checkPassthrough.bind(null, false))
61
62 @listen('keydown', (event) =>
63 # No matter what, always reset the `@suppress` flag, so we don't
64 # suppress more than intended.
65 @suppress = false
66
67 # Reset the `@late` flag, telling any late listeners for the previous
68 # event not to run. Also reset the `late` pref, telling frame scripts not
69 # to do synchronous message passing on every keydown.
70 @late = false
71 prefs.set('late', false)
72
73 if @popupPassthrough
74 # The `@popupPassthrough` flag is set a bit unreliably. Sometimes it
75 # can be stuck as `true` even though no popup is shown, effectively
76 # disabling the extension. Therefore we check if there actually _are_
77 # any open popups before stopping processing keyboard input. This is
78 # only done when popups (might) be open (not on every keystroke) for
79 # performance reasons.
80 return if @anyPopupsOpen()
81 @popupPassthrough = false # No popup was actually open.
82
83 return unless vim = @vimfx.getCurrentVim(@window)
84
85 @consumeKeyEvent(vim, event)
86 if @suppress
87 utils.suppressEvent(event) # This also suppresses the 'keypress' event.
88 else
89 # If this keydown event wasn’t suppressed, it’s an obvious interaction
90 # with the page. If it _was_ suppressed, though, it’s an interaction
91 # depending on the command triggered; if _it_ calls
92 # `vim.markPageInteraction()` or not.
93 vim.markPageInteraction() if vim.isUIEvent(event)
94 )
95
96 @listen('keyup', (event) =>
97 utils.suppressEvent(event) if @suppress
98 @setHeldModifiers(event, {filterCurrentOnly: true})
99 )
100
101 @listen('focus', => @setFocusType())
102 @listen('blur', =>
103 @window.setTimeout((=>
104 @setFocusType()
105 ), @vimfx.options.blur_timeout)
106 )
107
108 @listen('click', (event) =>
109 target = event.originalTarget
110 return unless vim = @vimfx.getCurrentVim(@window)
111
112 # In multi-process, clicks simulated by VimFx cannot be caught here. In
113 # non-multi-process, they unfortunately can. This hack should be
114 # sufficient for that case until non-multi-process is removed from
115 # Firefox.
116 isVimFxGeneratedEvent = (
117 event.layerX == 0 and event.layerY == 0 and
118 event.movementX == 0 and event.movementY == 0
119 )
120
121 # If the user clicks the reload button or a link when in hints mode, we’re
122 # going to end up in hints mode without any markers. Or if the user clicks
123 # a text input, then that input will be focused, but you can’t type in it
124 # (instead markers will be matched). So if the user clicks anything in
125 # hints mode it’s better to leave it.
126 if vim.mode == 'hints' and not isVimFxGeneratedEvent and
127 # Exclude the VimFx button, though, since clicking it returns to normal
128 # mode. Otherwise we’d first return to normal mode and then the button
129 # would open the help dialog.
130 target != button.getButton(@window)
131 vim.enterMode('normal')
132
133 vim._send('clearHover') unless isVimFxGeneratedEvent
134 )
135
136 @listen('overflow', (event) =>
137 target = event.originalTarget
138 return unless vim = @vimfx.getCurrentVim(@window)
139 if vim._isUIElement(target)
140 vim._state.scrollableElements.addChecked(target)
141 )
142
143 @listen('underflow', (event) =>
144 target = event.originalTarget
145 return unless vim = @vimfx.getCurrentVim(@window)
146 if vim._isUIElement(target)
147 vim._state.scrollableElements.deleteChecked(target)
148 )
149
150 @listen('TabSelect', (event) =>
151 target = event.originalTarget
152 target.setAttribute('VimFx-visited', 'true')
153 @vimfx.emit('TabSelect', {event})
154
155 return unless vim = @vimfx.getCurrentVim(@window)
156 vim.hideNotification()
157 @vimfx.emit('focusTypeChange', {vim})
158 )
159
160 @listen('TabClose', (event) =>
161 browser = @window.gBrowser.getBrowserForTab(event.originalTarget)
162 return unless vim = @vimfx.vims.get(browser)
163 # Note: `lastClosedVim` must be stored so that any window can access it.
164 @vimfx.lastClosedVim = vim
165 )
166
167 messageManager.listen('cachedPageshow', ((data, callback, browser) =>
168 [oldVim, @vimfx.lastClosedVim] = [@vimfx.lastClosedVim, null]
169 unless oldVim
170 callback(false)
171 return
172
173 if @vimfx.vims.has(browser)
174 vim = @vimfx.vims.get(browser)
175 if vim._messageManager == vim.browser.messageManager
176 callback(false)
177 return
178
179 # If we get here, it means that we’ve detected a tab dragged from one
180 # window to another. If so, the `vim` object from the last closed tab (the
181 # moved tab) should be re-used. See the commit message for commit bb70257d
182 # for more details.
183 oldVim._setBrowser(browser)
184 @vimfx.vims.set(browser, oldVim)
185 @vimfx.emit('modeChange', {vim: oldVim})
186 callback(true)
187 ), {messageManager: @window.messageManager})
188
189 setFocusType: ->
190 return unless vim = @vimfx.getCurrentVim(@window)
191
192 activeElement = utils.getActiveElement(@window)
193
194 if activeElement == @window.gBrowser.selectedBrowser
195 vim._send('checkFocusType')
196 return
197
198 focusType = utils.getFocusType(activeElement)
199 vim._setFocusType(focusType)
200
201 if focusType == 'editable' and vim.mode == 'caret'
202 vim.enterMode('normal')
203
204 consumeKeyEvent: (vim, event) ->
205 match = vim._consumeKeyEvent(event)
206
207 if match
208 if @vimfx.options.notify_entered_keys and vim.mode != 'ignore'
209 if match.type in ['none', 'full'] or match.likelyConflict
210 @enteredKeys.clear(vim)
211 else
212 @enteredKeys.push(vim, match.keyStr, @vimfx.options.timeout)
213 else
214 vim.hideNotification()
215
216 if match.specialKeys['<late>']
217 @suppress = false
218 @consumeLateKeydown(vim, event, match)
219 else
220 @suppress = vim._onInput(match, event)
221 else
222 @suppress = null
223 @setHeldModifiers(event)
224
225 consumeLateKeydown: (vim, event, match) ->
226 @late = true
227
228 # The passed in `event` is the regular non-late browser UI keydown event.
229 # It is only used to set held keys. This is easier than sending an event
230 # subset from frame scripts.
231 listener = ({defaultPrevented}) =>
232 # `@late` is reset on every keydown. If it is no longer `true`, it means
233 # that the page called `event.stopPropagation()`, which prevented this
234 # listener from running for that event.
235 return unless @late
236 @suppress =
237 if defaultPrevented
238 false
239 else
240 vim._onInput(match, event)
241 @setHeldModifiers(event)
242 return @suppress
243
244 if vim.isUIEvent(event)
245 @listenOnce('keydown', ((lateEvent) =>
246 listener(lateEvent)
247 if @suppress
248 utils.suppressEvent(lateEvent)
249 @listenOnce('keyup', utils.suppressEvent, false)
250 ), false)
251 else
252 # Hack to avoid synchronous messages on every keydown (see
253 # events-frame.coffee).
254 prefs.set('late', true)
255 vim._listenOnce('lateKeydown', listener)
256
257 setHeldModifiers: (event, {filterCurrentOnly = false} = {}) ->
258 mainWindow = @window.document.documentElement
259 modifiers =
260 if filterCurrentOnly
261 mainWindow.getAttribute(HELD_MODIFIERS_ATTRIBUTE)
262 else
263 if @suppress == null then 'alt ctrl meta shift' else ''
264 isHeld = (modifier) -> event["#{modifier}Key"]
265 mainWindow.setAttribute(
266 HELD_MODIFIERS_ATTRIBUTE, modifiers.split(' ').filter(isHeld).join(' ')
267 )
268
269 anyPopupsOpen: ->
270 # The autocomplete popup in text inputs (for example) is technically a
271 # panel, but it does not respond to key presses. Therefore
272 # `[ignorekeys="true"]` is excluded.
273 #
274 # coffeelint: disable=max_line_length
275 # <https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XUL/PopupGuide/PopupKeys#Ignoring_Keys>
276 # coffeelint: enable=max_line_length
277 popups = utils.querySelectorAllDeep(
278 @window, ':-moz-any(menupopup, panel):not([ignorekeys="true"])'
279 )
280 for popup in popups
281 return true if popup.state == 'open'
282 return false
283
284 class EnteredKeysManager
285 constructor: (@window) ->
286 @keys = []
287 @timeout = null
288
289 clear: (notifier) ->
290 @keys = []
291 @clearTimeout()
292 notifier.hideNotification()
293
294 push: (notifier, keyStr, duration) ->
295 @keys.push(keyStr)
296 @clearTimeout()
297 notifier.notify(@keys.join(''))
298 clear = @clear.bind(this)
299 @timeout = @window.setTimeout((-> clear(notifier)), duration)
300
301 clearTimeout: ->
302 @window.clearTimeout(@timeout) if @timeout?
303 @timeout = null
304
305 module.exports = UIEventManager
Imprint / Impressum