]> git.gir.st - VimFx.git/blob - extension/lib/events-frame.coffee
Fix missing hint markers when re-entering Hints mode quickly
[VimFx.git] / extension / lib / events-frame.coffee
1 ###
2 # Copyright Simon Lydell 2015, 2016.
3 #
4 # This file is part of VimFx.
5 #
6 # VimFx is free software: you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation, either version 3 of the License, or
9 # (at your option) any later version.
10 #
11 # VimFx is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License
17 # along with VimFx. If not, see <http://www.gnu.org/licenses/>.
18 ###
19
20 # This file is the equivalent to events.coffee, but for frame scripts.
21
22 notation = require('vim-like-key-notation')
23 commands = require('./commands-frame')
24 messageManager = require('./message-manager')
25 prefs = require('./prefs')
26 utils = require('./utils')
27
28 nsIFocusManager = Cc['@mozilla.org/focus-manager;1']
29 .getService(Ci.nsIFocusManager)
30
31 XULDocument = Ci.nsIDOMXULDocument
32
33 class FrameEventManager
34 constructor: (@vim) ->
35 @numFocusToSuppress = 0
36 @keepInputs = false
37 @currentUrl = false
38 @disconnectActiveElementObserver = null
39
40 listen: utils.listen.bind(null, FRAME_SCRIPT_ENVIRONMENT)
41 listenOnce: utils.listenOnce.bind(null, FRAME_SCRIPT_ENVIRONMENT)
42
43 addListeners: ->
44 # If the page already was loaded when VimFx was initialized, send the
45 # 'frameCanReceiveEvents' message straight away.
46 if @vim.content.document.readyState == 'complete'
47 messageManager.send('frameCanReceiveEvents', true)
48
49 @listen('readystatechange', (event) =>
50 target = event.originalTarget
51 topDocument = @vim.content.document
52 [oldUrl, @currentUrl] = [@currentUrl, @vim.content.location.href]
53
54 switch target.readyState
55 when 'interactive'
56 if target == topDocument or
57 # When loading the editor on codepen.io, a frame gets
58 # 'readystatechange' → 'interactive' quite a bit before the
59 # toplevel document does. Checking for this case lets us send
60 # 'locationChange' earlier, allowing to enter Ignore mode earlier,
61 # for example. Be careful not to trigger a 'locationChange' for
62 # frames loading _after_ the toplevel document, though. Finally,
63 # checking for 'uninitialized' is needed to be able to blacklist
64 # some XUL pages.
65 (topDocument.readyState in ['loading', 'uninitialized'] and
66 oldUrl == null)
67 messageManager.send('locationChange', @currentUrl)
68
69 when 'complete'
70 if target == topDocument
71 messageManager.send('frameCanReceiveEvents', true)
72 )
73
74 @listen('pageshow', (event) =>
75 [oldUrl, @currentUrl] = [@currentUrl, @vim.content.location.href]
76
77 # When navigating the history, `event.persisted` is `true` (meaning that
78 # the page loaded from cache) and 'readystatechange' won’t be fired, so
79 # send a 'locationChange' message to make sure that the blacklist is
80 # applied etc. The reason we don’t simply _always_ do this on the
81 # 'pageshow' event, is because it usually fires too late. However, it also
82 # fires after having moved a tab to another window. In that case it is
83 # _not_ a location change; the blacklist should not be applied.
84 if event.persisted
85 url = @vim.content.location.href
86 messageManager.send('cachedPageshow', null, (movedToNewTab) =>
87 if not movedToNewTab and oldUrl != @currentUrl
88 messageManager.send('locationChange', @currentUrl)
89 )
90 )
91
92 @listen('pagehide', (event) =>
93 target = event.originalTarget
94 @currentUrl = null
95
96 if target == @vim.content.document
97 messageManager.send('frameCanReceiveEvents', false)
98 @vim._enterMode('normal') if @vim.mode == 'hints'
99
100 # If the target isn’t the topmost document, it means that a frame has
101 # changed: It could have been removed or its `src` attribute could have
102 # been changed. If the frame contains other frames, 'pagehide' events have
103 # already been fired for them.
104 @vim.resetState(target)
105 )
106
107 messageManager.listen('getMarkableElementsMovements', (data, callback) =>
108 diffs = @vim.state.markerElements.map(({element, originalRect}) ->
109 newRect = element.getBoundingClientRect()
110 return {
111 dx: newRect.left - originalRect.left
112 dy: newRect.top - originalRect.top
113 }
114 )
115 callback(diffs)
116 )
117
118 @listen('overflow', (event) =>
119 target = event.originalTarget
120 @vim.state.scrollableElements.addChecked(target)
121 )
122
123 @listen('underflow', (event) =>
124 target = event.originalTarget
125 @vim.state.scrollableElements.deleteChecked(target)
126 )
127
128 @listen('submit', ((event) ->
129 return if event.defaultPrevented
130 target = event.originalTarget
131 {activeElement} = target.ownerDocument
132 if activeElement?.form == target and utils.isTypingElement(activeElement)
133 activeElement.blur()
134 ), false)
135
136 @listen('keydown', (event) =>
137 @keepInputs = false
138 )
139
140 @listen('keydown', ((event) =>
141 suppress = false
142
143 # This message _has_ to be synchronous so we can suppress the event if
144 # needed. To avoid sending a synchronous message on _every_ keydown, this
145 # hack of toggling a pref when a `<late>` shortcut is encountered is used.
146 if prefs.get('late')
147 suppress = messageManager.get('lateKeydown', {
148 defaultPrevented: event.defaultPrevented
149 })
150
151 if @vim.state.inputs and @vim.mode == 'normal' and not suppress and
152 not event.defaultPrevented
153 # There is no need to take `ignore_keyboard_layout` and `translations`
154 # into account here, since we want to override the _native_ `<tab>`
155 # behavior. Then, `event.key` is the way to go. (Unless the prefs are
156 # customized. YAGNI until requested.) Also, since 'keydown' is fired so
157 # often the options are read directly from the prefs system for
158 # performance. That means you can’t override them with
159 # `vimfx.addOptionOverrides`. YAGNI until requested.
160 keyStr = notation.stringify(event)
161 direction = switch keyStr
162 when ''
163 null
164 when prefs.get('focus_previous_key')
165 -1
166 when prefs.get('focus_next_key')
167 +1
168 else
169 null
170 if direction?
171 suppress = commands.move_focus({@vim, direction})
172 @keepInputs = true
173
174 if suppress
175 utils.suppressEvent(event)
176 @listenOnce('keyup', utils.suppressEvent, false)
177 ), false)
178
179 @listen('mousedown', (event) =>
180 # Allow clicking on another text input without exiting “gi mode”. Listen
181 # for 'mousedown' instead of 'click', because only the former runs before
182 # the 'blur' event. Also, `event.originalTarget` does _not_ work here.
183 @keepInputs = (@vim.state.inputs and event.target in @vim.state.inputs)
184
185 # Clicks are always counted as page interaction. Listen for 'mousedown'
186 # instead of 'click' to mark the interaction as soon as possible.
187 @vim.markPageInteraction()
188
189 @vim.hideNotification()
190 )
191
192 messageManager.listen('browserRefocus', =>
193 # Suppress the next two focus events (for `document` and `window`; see
194 # `blurActiveBrowserElement`).
195 @numFocusToSuppress = 2
196 )
197
198 @listen('focus', (event) =>
199 target = event.originalTarget
200
201 if @numFocusToSuppress > 0
202 utils.suppressEvent(event)
203 @numFocusToSuppress -= 1
204 return
205
206 @vim.state.explicitBodyFocus = (target == @vim.content.document.body)
207
208 @sendFocusType()
209
210 # Reset `hasInteraction` when (re-)selecting a tab, or coming back from
211 # another window, in order to prevent the common “automatically re-focus
212 # when switching back to the tab” behaviour many sites have, unless a text
213 # input _should_ be re-focused when coming back to the tab (see the 'blur'
214 # event below).
215 if target == @vim.content.document
216 if @vim.state.shouldRefocus
217 @vim.state.hasInteraction = true
218 @vim.state.shouldRefocus = false
219 else
220 @vim.state.hasInteraction = false
221 return
222
223 if utils.isTextInputElement(target)
224 # Save the last focused text input regardless of whether that input
225 # might be blurred because of autofocus prevention.
226 @vim.state.lastFocusedTextInput = target
227 @vim.state.hasFocusedTextInput = true
228
229 if @vim.mode == 'caret' and not utils.isContentEditable(target)
230 @vim._enterMode('normal')
231
232 # When moving a tab to another window, there is a short period of time
233 # when there’s no listener for this call.
234 return unless options = @vim.options(
235 ['prevent_autofocus', 'prevent_autofocus_modes']
236 )
237
238 # Blur the focus target, if autofocus prevention is enabled…
239 if options.prevent_autofocus and
240 @vim.mode in options.prevent_autofocus_modes and
241 # …and the user has interacted with the page…
242 not @vim.state.hasInteraction and
243 # …and the event is programmatic (not caused by clicks or keypresses)…
244 nsIFocusManager.getLastFocusMethod(null) == 0 and
245 # …and the target may steal most keystrokes…
246 utils.isTypingElement(target) and
247 # …and the page isn’t a Firefox internal page (like `about:config`).
248 @vim.content.document not instanceof XULDocument
249 # Some sites (such as icloud.com) re-focuses inputs if they are blurred,
250 # causing an infinite loop of autofocus prevention and re-focusing.
251 # Therefore, blur events that happen just after an autofocus prevention
252 # are suppressed.
253 @listenOnce('blur', utils.suppressEvent)
254 target.blur()
255 @vim.state.hasFocusedTextInput = false
256 )
257
258 @listen('blur', (event) =>
259 target = event.originalTarget
260
261 @vim.clearHover() if target == @vim.state.lastHoveredElement
262
263 @vim.content.setTimeout((=>
264 @sendFocusType()
265 ), prefs.get('blur_timeout'))
266
267 # If a text input is blurred immediately before the document loses focus,
268 # it most likely means that the user switched tab, for example by pressing
269 # `<c-tab>`, or switched to another window, while the text input was
270 # focused. In this case, when switching back to that tab, the text input
271 # will, and should, be re-focused (because it was focused when you left
272 # the tab). This case is kept track of so that the autofocus prevention
273 # does not catch it.
274 if utils.isTypingElement(target)
275 utils.nextTick(@vim.content, =>
276 @vim.state.shouldRefocus = not @vim.content.document.hasFocus()
277
278 # “gi mode” ends when blurring a text input, unless `<tab>` was just
279 # pressed.
280 unless @vim.state.shouldRefocus or @keepInputs
281 commands.clear_inputs({@vim})
282 )
283 )
284
285 messageManager.listen('checkFocusType', @sendFocusType.bind(this))
286
287 sendFocusType: ({ignore = []} = {}) ->
288 return unless activeElement = utils.getActiveElement(@vim.content)
289 focusType = utils.getFocusType(activeElement)
290 messageManager.send('focusType', focusType) unless focusType in ignore
291
292 # If a text input is removed from the DOM while it is focused, no 'focus'
293 # or 'blur' events will be fired, making VimFx think that the text input is
294 # still focused. Therefore we add a temporary observer for the currently
295 # focused element and re-send the focusType if it gets removed.
296 @disconnectActiveElementObserver?()
297 @disconnectActiveElementObserver =
298 if focusType == 'none'
299 null
300 else
301 utils.onRemoved(activeElement, @sendFocusType.bind(this))
302
303 module.exports = FrameEventManager
Imprint / Impressum