extension/lib/commands.coffee

   1 ###
   2 # Copyright Anton Khodakivskiy 2012, 2013, 2014.
   3 # Copyright Simon Lydell 2013, 2014, 2015, 2016.
   4 # Copyright Wang Zhuochun 2013, 2014.
   5 #
   6 # This file is part of VimFx.
   7 #
   8 # VimFx is free software: you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation, either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # VimFx is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with VimFx.  If not, see <http://www.gnu.org/licenses/>.
  20 ###
  21
  22 # This file defines all Normal mode commands. Commands that need to interact
  23 # with web page content do so by running `vim._run(name)`, which invokes `name`
  24 # in commands-frame.coffee.
  25
  26 # NOTE: Most tab related commands need to do their actual tab manipulations in
  27 # the next tick (`utils.nextTick`) to work around bug 1200334.
  28
  29 config = require('./config')
  30 help = require('./help')
  31 hints = require('./hints')
  32 prefs = require('./prefs')
  33 translate = require('./l10n')
  34 utils = require('./utils')
  35
  36 commands = {}
  37
  38
  39
  40 commands.focus_location_bar = ({vim}) ->
  41   vim.window.focusAndSelectUrlBar()
  42
  43 commands.focus_search_bar = ({vim, count}) ->
  44   # The `.webSearch()` method opens a search engine in a tab if the search bar
  45   # has been removed. Therefore we first check if it exists.
  46   if vim.window.BrowserSearch.searchBar
  47     vim.window.BrowserSearch.webSearch()
  48
  49 helper_paste_and_go = (props, {vim}) ->
  50   {gURLBar} = vim.window
  51   gURLBar.value = vim.window.readFromClipboard()
  52   gURLBar.handleCommand(new vim.window.KeyboardEvent('keydown', props))
  53
  54 commands.paste_and_go = helper_paste_and_go.bind(null, null)
  55
  56 commands.paste_and_go_in_tab = helper_paste_and_go.bind(null, {altKey: true})
  57
  58 commands.copy_current_url = ({vim}) ->
  59   utils.writeToClipboard(vim.window.gBrowser.currentURI.spec)
  60   vim.notify(translate('notification.copy_current_url'))
  61
  62 commands.go_up_path = ({vim, count}) ->
  63   vim._run('go_up_path', {count})
  64
  65 commands.go_to_root = ({vim}) ->
  66   vim._run('go_to_root')
  67
  68 commands.go_home = ({vim}) ->
  69   vim.window.BrowserHome()
  70
  71 helper_go_history = (direction, {vim, count = 1}) ->
  72   {window} = vim
  73   {SessionStore, gBrowser} = window
  74
  75   if (direction == 'back'    and not gBrowser.canGoBack) or
  76      (direction == 'forward' and not gBrowser.canGoForward)
  77     vim.notify(translate("notification.history_#{direction}.limit"))
  78     return
  79
  80   # `SessionStore.getSessionHistory()` (used below to support counts) starts
  81   # lots of asynchronous tasks internally, which is a bit unreliable, it has
  82   # turned out. The primary use of the `history_back` and `history_forward`
  83   # commands is to go _one_ step back or forward, though, so those cases are
  84   # optimized to use more reliable ways of going back and forward. Also, some
  85   # extensions override the following functions, so calling them also gives
  86   # better interoperability.
  87   if count == 1
  88     if direction == 'back'
  89       window.BrowserBack()
  90     else
  91       window.BrowserForward()
  92     return
  93
  94   SessionStore.getSessionHistory(gBrowser.selectedTab, (sessionHistory) ->
  95     {index} = sessionHistory
  96     newIndex = index + count * (if direction == 'back' then -1 else 1)
  97     newIndex = Math.max(newIndex, 0)
  98     newIndex = Math.min(newIndex, sessionHistory.entries.length - 1)
  99     gBrowser.gotoIndex(newIndex)
 100   )
 101
 102 commands.history_back    = helper_go_history.bind(null, 'back')
 103
 104 commands.history_forward = helper_go_history.bind(null, 'forward')
 105
 106 commands.history_list = ({vim}) ->
 107   menu = vim.window.document.getElementById('backForwardMenu')
 108   utils.openPopup(menu)
 109   if menu.childElementCount == 0
 110     vim.notify(translate('notification.history_list.none'))
 111
 112 commands.reload = ({vim}) ->
 113   vim.window.BrowserReload()
 114
 115 commands.reload_force = ({vim}) ->
 116   vim.window.BrowserReloadSkipCache()
 117
 118 commands.reload_all = ({vim}) ->
 119   vim.window.gBrowser.reloadAllTabs()
 120
 121 commands.reload_all_force = ({vim}) ->
 122   for tab in vim.window.gBrowser.visibleTabs
 123     gBrowser = tab.linkedBrowser
 124     consts = gBrowser.webNavigation
 125     flags = consts.LOAD_FLAGS_BYPASS_PROXY | consts.LOAD_FLAGS_BYPASS_CACHE
 126     gBrowser.reload(flags)
 127   return
 128
 129 commands.stop = ({vim}) ->
 130   vim.window.BrowserStop()
 131
 132 commands.stop_all = ({vim}) ->
 133   for tab in vim.window.gBrowser.visibleTabs
 134     tab.linkedBrowser.stop()
 135   return
 136
 137
 138
 139 helper_scroll = (vim, uiEvent, args...) ->
 140   [
 141     method, type, directions, amounts
 142     properties = null, adjustment = 0, name = 'scroll'
 143   ] = args
 144   options = {
 145     method, type, directions, amounts, properties, adjustment
 146     smooth: (prefs.root.get('general.smoothScroll') and
 147              prefs.root.get("general.smoothScroll.#{type}"))
 148   }
 149   reset = prefs.root.tmp(
 150     'layout.css.scroll-behavior.spring-constant',
 151     vim.options["smoothScroll.#{type}.spring-constant"]
 152   )
 153
 154   helpScroll = help.getHelp(vim.window)?.querySelector('.wrapper')
 155   if uiEvent or helpScroll
 156     activeElement = helpScroll or utils.getActiveElement(vim.window)
 157     if vim._state.scrollableElements.has(activeElement) or helpScroll
 158       utils.scroll(activeElement, options)
 159       reset()
 160       return
 161
 162   vim._run(name, options, reset)
 163
 164
 165 helper_scrollByLinesX = (amount, {vim, uiEvent, count = 1}) ->
 166   distance = prefs.root.get('toolkit.scrollbox.horizontalScrollDistance')
 167   helper_scroll(vim, uiEvent, 'scrollBy', 'lines', ['left'],
 168                 [amount * distance * count * 5])
 169
 170 helper_scrollByLinesY = (amount, {vim, uiEvent, count = 1}) ->
 171   distance = prefs.root.get('toolkit.scrollbox.verticalScrollDistance')
 172   helper_scroll(vim, uiEvent, 'scrollBy', 'lines', ['top'],
 173                 [amount * distance * count * 20])
 174
 175 helper_scrollByPagesY = (amount, type, {vim, uiEvent, count = 1}) ->
 176   adjustment = vim.options["scroll.#{type}_page_adjustment"]
 177   helper_scroll(vim, uiEvent, 'scrollBy', 'pages', ['top'],
 178                 [amount * count], ['clientHeight'], adjustment)
 179
 180 helper_scrollToX = (amount, {vim, uiEvent}) ->
 181   helper_scroll(vim, uiEvent, 'scrollTo', 'other', ['left'],
 182                 [amount], ['scrollLeftMax'])
 183   helper_mark_last_scroll_position(vim)
 184
 185 helper_scrollToY = (amount, {vim, uiEvent}) ->
 186   helper_scroll(vim, uiEvent, 'scrollTo', 'other', ['top'],
 187                 [amount], ['scrollTopMax'])
 188   helper_mark_last_scroll_position(vim)
 189
 190 commands.scroll_left           = helper_scrollByLinesX.bind(null, -1)
 191 commands.scroll_right          = helper_scrollByLinesX.bind(null, +1)
 192 commands.scroll_down           = helper_scrollByLinesY.bind(null, +1)
 193 commands.scroll_up             = helper_scrollByLinesY.bind(null, -1)
 194 commands.scroll_page_down      = helper_scrollByPagesY.bind(null, +1,   'full')
 195 commands.scroll_page_up        = helper_scrollByPagesY.bind(null, -1,   'full')
 196 commands.scroll_half_page_down = helper_scrollByPagesY.bind(null, +0.5, 'half')
 197 commands.scroll_half_page_up   = helper_scrollByPagesY.bind(null, -0.5, 'half')
 198 commands.scroll_to_top         = helper_scrollToY.bind(null, 0)
 199 commands.scroll_to_bottom      = helper_scrollToY.bind(null, Infinity)
 200 commands.scroll_to_left        = helper_scrollToX.bind(null, 0)
 201 commands.scroll_to_right       = helper_scrollToX.bind(null, Infinity)
 202
 203 helper_mark_last_scroll_position = (vim) ->
 204   keyStr = vim.options['scroll.last_position_mark']
 205   vim._run('mark_scroll_position', {keyStr, notify: false})
 206
 207 commands.mark_scroll_position = ({vim}) ->
 208   vim.enterMode('marks', (keyStr) -> vim._run('mark_scroll_position', {keyStr}))
 209
 210 commands.scroll_to_mark = ({vim}) ->
 211   vim.enterMode('marks', (keyStr) ->
 212     unless keyStr == vim.options['scroll.last_position_mark']
 213       helper_mark_last_scroll_position(vim)
 214     helper_scroll(vim, null, 'scrollTo', 'other', ['top', 'left'], keyStr,
 215                   ['scrollTopMax', 'scrollLeftMax'], 0, 'scroll_to_mark')
 216   )
 217
 218
 219
 220 commands.tab_new = ({vim}) ->
 221   utils.nextTick(vim.window, ->
 222     vim.window.BrowserOpenTab()
 223   )
 224
 225 commands.tab_duplicate = ({vim}) ->
 226   {gBrowser} = vim.window
 227   utils.nextTick(vim.window, ->
 228     gBrowser.duplicateTab(gBrowser.selectedTab)
 229   )
 230
 231 absoluteTabIndex = (relativeIndex, gBrowser, {pinnedSeparate}) ->
 232   tabs = gBrowser.visibleTabs
 233   {selectedTab} = gBrowser
 234
 235   currentIndex = tabs.indexOf(selectedTab)
 236   absoluteIndex = currentIndex + relativeIndex
 237   numTabsTotal = tabs.length
 238   numPinnedTabs = gBrowser._numPinnedTabs
 239
 240   [numTabs, min] = switch
 241     when not pinnedSeparate
 242       [numTabsTotal,  0]
 243     when selectedTab.pinned
 244       [numPinnedTabs, 0]
 245     else
 246       [numTabsTotal - numPinnedTabs, numPinnedTabs]
 247
 248   # Wrap _once_ if at one of the ends of the tab bar and cannot move in the
 249   # current direction.
 250   if (relativeIndex < 0 and currentIndex == min) or
 251      (relativeIndex > 0 and currentIndex == min + numTabs - 1)
 252     if absoluteIndex < min
 253       absoluteIndex += numTabs
 254     else if absoluteIndex >= min + numTabs
 255       absoluteIndex -= numTabs
 256
 257   absoluteIndex = Math.max(min, absoluteIndex)
 258   absoluteIndex = Math.min(absoluteIndex, min + numTabs - 1)
 259
 260   return absoluteIndex
 261
 262 helper_switch_tab = (direction, {vim, count = 1}) ->
 263   {gBrowser} = vim.window
 264   index = absoluteTabIndex(direction * count, gBrowser, {pinnedSeparate: false})
 265   utils.nextTick(vim.window, ->
 266     gBrowser.selectTabAtIndex(index)
 267   )
 268
 269 commands.tab_select_previous = helper_switch_tab.bind(null, -1)
 270
 271 commands.tab_select_next     = helper_switch_tab.bind(null, +1)
 272
 273 commands.tab_select_most_recent = ({vim, count = 1}) ->
 274   {gBrowser} = vim.window
 275   tabsSorted =
 276     Array.filter(
 277       gBrowser.tabs,
 278       (tab) -> not tab.closing and not tab.getAttribute('unread')
 279     ).sort((a, b) -> b.lastAccessed - a.lastAccessed)[1..] # Remove current tab.
 280   tab = tabsSorted[Math.min(count - 1, tabsSorted.length - 1)]
 281   if tab
 282     gBrowser.selectedTab = tab
 283   else
 284     vim.notify(translate('notification.tab_select_most_recent.none'))
 285
 286 commands.tab_select_oldest_unread = ({vim, count = 1}) ->
 287   {gBrowser} = vim.window
 288   tabsSorted =
 289     Array.filter(
 290       gBrowser.tabs,
 291       (tab) -> not tab.closing and tab.getAttribute('unread')
 292     ).sort((a, b) -> a.lastAccessed - b.lastAccessed)
 293   tab = tabsSorted[Math.min(count - 1, tabsSorted.length - 1)]
 294   if tab
 295     gBrowser.selectedTab = tab
 296   else
 297     vim.notify(translate('notification.tab_select_oldest_unread.none'))
 298
 299 helper_move_tab = (direction, {vim, count = 1}) ->
 300   {gBrowser} = vim.window
 301   index = absoluteTabIndex(direction * count, gBrowser, {pinnedSeparate: true})
 302   utils.nextTick(vim.window, ->
 303     gBrowser.moveTabTo(gBrowser.selectedTab, index)
 304   )
 305
 306 commands.tab_move_backward = helper_move_tab.bind(null, -1)
 307
 308 commands.tab_move_forward  = helper_move_tab.bind(null, +1)
 309
 310 commands.tab_move_to_window = ({vim}) ->
 311   {gBrowser} = vim.window
 312   gBrowser.replaceTabWithWindow(gBrowser.selectedTab)
 313
 314 commands.tab_select_first = ({vim, count = 1}) ->
 315   utils.nextTick(vim.window, ->
 316     vim.window.gBrowser.selectTabAtIndex(count - 1)
 317   )
 318
 319 commands.tab_select_first_non_pinned = ({vim, count = 1}) ->
 320   firstNonPinned = vim.window.gBrowser._numPinnedTabs
 321   utils.nextTick(vim.window, ->
 322     vim.window.gBrowser.selectTabAtIndex(firstNonPinned + count - 1)
 323   )
 324
 325 commands.tab_select_last = ({vim, count = 1}) ->
 326   utils.nextTick(vim.window, ->
 327     vim.window.gBrowser.selectTabAtIndex(-count)
 328   )
 329
 330 commands.tab_toggle_pinned = ({vim}) ->
 331   currentTab = vim.window.gBrowser.selectedTab
 332   if currentTab.pinned
 333     vim.window.gBrowser.unpinTab(currentTab)
 334   else
 335     vim.window.gBrowser.pinTab(currentTab)
 336
 337 commands.tab_close = ({vim, count = 1}) ->
 338   {gBrowser} = vim.window
 339   return if gBrowser.selectedTab.pinned
 340   currentIndex = gBrowser.visibleTabs.indexOf(gBrowser.selectedTab)
 341   utils.nextTick(vim.window, ->
 342     for tab in gBrowser.visibleTabs[currentIndex...(currentIndex + count)]
 343       gBrowser.removeTab(tab)
 344     return
 345   )
 346
 347 commands.tab_restore = ({vim, count = 1}) ->
 348   utils.nextTick(vim.window, ->
 349     for index in [0...count] by 1
 350       restoredTab = vim.window.undoCloseTab()
 351       if not restoredTab and index == 0
 352         vim.notify(translate('notification.tab_restore.none'))
 353         break
 354     return
 355   )
 356
 357 commands.tab_restore_list = ({vim}) ->
 358   {window} = vim
 359   fragment = window.RecentlyClosedTabsAndWindowsMenuUtils.getTabsFragment(
 360     window, 'menuitem'
 361   )
 362   if fragment.childElementCount == 0
 363     vim.notify(translate('notification.tab_restore.none'))
 364   else
 365     utils.openPopup(utils.injectTemporaryPopup(window.document, fragment))
 366
 367 commands.tab_close_to_end = ({vim}) ->
 368   {gBrowser} = vim.window
 369   gBrowser.removeTabsToTheEndFrom(gBrowser.selectedTab)
 370
 371 commands.tab_close_other = ({vim}) ->
 372   {gBrowser} = vim.window
 373   gBrowser.removeAllTabsBut(gBrowser.selectedTab)
 374
 375
 376
 377 helper_follow = (name, vim, callback, count = null) ->
 378   vim.markPageInteraction()
 379   help.removeHelp(vim.window)
 380
 381   # Enter hints mode immediately, with an empty set of markers. The user might
 382   # press keys before the `vim._run` callback is invoked. Those key presses
 383   # should be handled in hints mode, not normal mode.
 384   initialMarkers = []
 385   storage = vim.enterMode('hints', initialMarkers, callback, count,
 386                           vim.options.hints_sleep)
 387
 388   vim._run(name, null, ({wrappers, viewport}) ->
 389     # The user might have exited hints mode (and perhaps even entered it again)
 390     # before this callback is invoked. If so, `storage.markers` has been
 391     # cleared, or set to a new value. Only proceed if it is unchanged.
 392     return unless storage.markers == initialMarkers
 393
 394     if wrappers.length > 0
 395       {markers, markerMap} = hints.injectHints(vim.window, wrappers, viewport,
 396                                                vim.options)
 397       storage.markers = markers
 398       storage.markerMap = markerMap
 399     else
 400       vim.notify(translate('notification.follow.none'))
 401       vim.enterMode('normal')
 402   )
 403
 404 helper_follow_clickable = ({inTab, inBackground}, {vim, count = 1}) ->
 405   callback = (marker, timesLeft, keyStr) ->
 406     {type, elementIndex} = marker.wrapper
 407     isLast = (timesLeft == 1)
 408     isLink = (type == 'link')
 409
 410     switch
 411       when keyStr.startsWith(vim.options.hints_toggle_in_tab)
 412         inTab = not inTab
 413       when keyStr.startsWith(vim.options.hints_toggle_in_background)
 414         inTab = true
 415         inBackground = not inBackground
 416       else
 417         unless isLast
 418           inTab = true
 419           inBackground = true
 420
 421     inTab = false unless isLink
 422
 423     if type == 'text' or (isLink and not (inTab and inBackground))
 424       isLast = true
 425
 426     vim._focusMarkerElement(elementIndex)
 427
 428     if inTab
 429       utils.nextTick(vim.window, ->
 430         utils.openTab(vim.window, marker.wrapper.href, {
 431           inBackground
 432           relatedToCurrent: true
 433         })
 434       )
 435     else
 436       vim._run('click_marker_element', {
 437         elementIndex, type
 438         preventTargetBlank: vim.options.prevent_target_blank
 439       })
 440
 441     return not isLast
 442
 443   name = if inTab then 'follow_in_tab' else 'follow'
 444   helper_follow(name, vim, callback, count)
 445
 446 commands.follow =
 447   helper_follow_clickable.bind(null, {inTab: false, inBackground: true})
 448
 449 commands.follow_in_tab =
 450   helper_follow_clickable.bind(null, {inTab: true, inBackground: true})
 451
 452 commands.follow_in_focused_tab =
 453   helper_follow_clickable.bind(null, {inTab: true, inBackground: false})
 454
 455 commands.follow_in_window = ({vim}) ->
 456   callback = (marker) ->
 457     vim._focusMarkerElement(marker.wrapper.elementIndex)
 458     vim.window.openLinkIn(marker.wrapper.href, 'window', {})
 459   helper_follow('follow_in_tab', vim, callback)
 460
 461 commands.follow_multiple = (args) ->
 462   args.count = Infinity
 463   commands.follow(args)
 464
 465 commands.follow_copy = ({vim}) ->
 466   callback = (marker) ->
 467     {elementIndex} = marker.wrapper
 468     property = switch marker.wrapper.type
 469       when 'link'
 470         'href'
 471       when 'text'
 472         'value'
 473       when 'contenteditable'
 474         'textContent'
 475     vim._run('copy_marker_element', {elementIndex, property})
 476   helper_follow('follow_copy', vim, callback)
 477
 478 commands.follow_focus = ({vim}) ->
 479   callback = (marker) ->
 480     vim._focusMarkerElement(marker.wrapper.elementIndex, {select: true})
 481   return helper_follow('follow_focus', vim, callback)
 482
 483 commands.click_browser_element = ({vim}) ->
 484   markerElements = []
 485
 486   filter = (element, getElementShape) ->
 487     document = element.ownerDocument
 488     type = switch
 489       when vim._state.scrollableElements.has(element)
 490         'scrollable'
 491       when (element.tabIndex > -1 and
 492             not (element.localName?.endsWith('box') and
 493                  element.localName != 'checkbox') and
 494             element.localName not in ['tabs', 'menuitem', 'menuseparator']) or
 495            element.onclick
 496         'clickable'
 497     return unless type
 498     return unless shape = getElementShape(element)
 499     length = markerElements.push(element)
 500     return {type, semantic: true, shape, elementIndex: length - 1}
 501
 502   callback = (marker) ->
 503     element = markerElements[marker.wrapper.elementIndex]
 504     switch marker.wrapper.type
 505       when 'scrollable'
 506         utils.focusElement(element, {flag: 'FLAG_BYKEY'})
 507       when 'clickable'
 508         utils.focusElement(element)
 509         utils.simulateMouseEvents(element, 'click')
 510
 511   {wrappers, viewport} =
 512     hints.getMarkableElementsAndViewport(vim.window, filter)
 513
 514   if wrappers.length > 0
 515     {markers} = hints.injectHints(vim.window, wrappers, viewport, {
 516       hint_chars: vim.options.hint_chars
 517       ui: true
 518     })
 519     vim.enterMode('hints', markers, callback)
 520   else
 521     vim.notify(translate('notification.follow.none'))
 522
 523 helper_follow_pattern = (type, {vim}) ->
 524   options = {
 525     pattern_selector: vim.options.pattern_selector
 526     pattern_attrs: vim.options.pattern_attrs
 527     patterns: vim.options["#{type}_patterns"]
 528   }
 529   vim._run('follow_pattern', {type, options})
 530
 531 commands.follow_previous = helper_follow_pattern.bind(null, 'prev')
 532
 533 commands.follow_next     = helper_follow_pattern.bind(null, 'next')
 534
 535 commands.focus_text_input = ({vim, count}) ->
 536   vim.markPageInteraction()
 537   vim._run('focus_text_input', {count})
 538
 539
 540
 541 findStorage = {lastSearchString: ''}
 542
 543 helper_find = ({highlight, linksOnly = false}, {vim}) ->
 544   helpSearchInput = help.getSearchInput(vim.window)
 545   if helpSearchInput
 546     helpSearchInput.select()
 547     return
 548
 549   helper_mark_last_scroll_position(vim)
 550   findBar = vim.window.gBrowser.getFindBar()
 551
 552   mode = if linksOnly then findBar.FIND_LINKS else findBar.FIND_NORMAL
 553   findBar.startFind(mode)
 554   utils.focusElement(findBar._findField, {select: true})
 555
 556   return if linksOnly
 557   return unless highlightButton = findBar.getElement('highlight')
 558   if highlightButton.checked != highlight
 559     highlightButton.click()
 560
 561 commands.find = helper_find.bind(null, {highlight: false})
 562
 563 commands.find_highlight_all = helper_find.bind(null, {highlight: true})
 564
 565 commands.find_links_only = helper_find.bind(null, {linksOnly: true})
 566
 567 helper_find_again = (direction, {vim}) ->
 568   findBar = vim.window.gBrowser.getFindBar()
 569   if findStorage.lastSearchString.length == 0
 570     vim.notify(translate('notification.find_again.none'))
 571     return
 572   helper_mark_last_scroll_position(vim)
 573   findBar._findField.value = findStorage.lastSearchString
 574   findBar.onFindAgainCommand(direction)
 575   message = findBar._findStatusDesc.textContent
 576   vim.notify(message) if message
 577
 578 commands.find_next     = helper_find_again.bind(null, false)
 579
 580 commands.find_previous = helper_find_again.bind(null, true)
 581
 582
 583
 584 commands.window_new = ({vim}) ->
 585   vim.window.OpenBrowserWindow()
 586
 587 commands.window_new_private = ({vim}) ->
 588   vim.window.OpenBrowserWindow({private: true})
 589
 590 commands.enter_mode_ignore = ({vim}) ->
 591   vim.enterMode('ignore', {type: 'explicit'})
 592
 593 # Quote next keypress (pass it through to the page).
 594 commands.quote = ({vim, count = 1}) ->
 595   vim.enterMode('ignore', {type: 'explicit', count})
 596
 597 commands.enter_reader_view = ({vim}) ->
 598   button = vim.window.document.getElementById('reader-mode-button')
 599   if not button?.hidden
 600     button.click()
 601   else
 602     vim.notify(translate('notification.enter_reader_view.none'))
 603
 604 commands.reload_config_file = ({vim}) ->
 605   vim._parent.emit('shutdown')
 606   config.load(vim._parent, (status) -> switch status
 607     when null
 608       vim.notify(translate('notification.reload_config_file.none'))
 609     when true
 610       vim.notify(translate('notification.reload_config_file.success'))
 611     else
 612       vim.notify(translate('notification.reload_config_file.failure'))
 613   )
 614
 615 commands.help = ({vim}) ->
 616   help.injectHelp(vim.window, vim._parent)
 617
 618 commands.dev = ({vim}) ->
 619   vim.window.DeveloperToolbar.show(true) # `true` to focus.
 620
 621 commands.esc = ({vim}) ->
 622   vim._run('esc')
 623   utils.blurActiveBrowserElement(vim)
 624   vim.window.DeveloperToolbar.hide()
 625   vim.window.gBrowser.getFindBar().close()
 626   # TODO: Remove when Tab Groups have been removed.
 627   vim.window.TabView?.hide()
 628   hints.removeHints(vim.window) # Better safe than sorry.
 629
 630   unless help.getSearchInput(vim.window)?.getAttribute('focused')
 631     help.removeHelp(vim.window)
 632
 633
 634
 635 module.exports = {
 636   commands
 637   findStorage
 638 }