extension/lib/commands.coffee

   1 ###
   2 # Copyright Anton Khodakivskiy 2012, 2013, 2014.
   3 # Copyright Simon Lydell 2013, 2014.
   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 help  = require('./help')
  27 prefs = require('./prefs')
  28 utils = require('./utils')
  29
  30 commands = {}
  31
  32
  33
  34 commands.focus_location_bar = ({ vim }) ->
  35   # This function works even if the Address Bar has been removed.
  36   vim.window.focusAndSelectUrlBar()
  37
  38 commands.focus_search_bar = ({ vim, count }) ->
  39   # The `.webSearch()` method opens a search engine in a tab if the Search Bar
  40   # has been removed. Therefore we first check if it exists.
  41   if vim.window.BrowserSearch.searchBar
  42     vim.window.BrowserSearch.webSearch()
  43
  44 helper_paste_and_go = (event, { vim }) ->
  45   { gURLBar } = vim.window
  46   gURLBar.value = vim.window.readFromClipboard()
  47   gURLBar.handleCommand(event)
  48
  49 commands.paste_and_go = helper_paste_and_go.bind(null, null)
  50
  51 commands.paste_and_go_in_tab = helper_paste_and_go.bind(null, {altKey: true})
  52
  53 commands.copy_current_url = ({ vim }) ->
  54   utils.writeToClipboard(vim.window.gBrowser.currentURI.spec)
  55
  56 commands.go_up_path = ({ vim, count }) ->
  57   vim._run('go_up_path', {count})
  58
  59 # Go up to root of the URL hierarchy.
  60 commands.go_to_root = ({ vim }) ->
  61   vim._run('go_to_root')
  62
  63 commands.go_home = ({ vim }) ->
  64   vim.window.BrowserHome()
  65
  66 helper_go_history = (num, { vim, count = 1 }) ->
  67   { SessionStore, gBrowser } = vim.window
  68   SessionStore.getSessionHistory(gBrowser.selectedTab, (sessionHistory) ->
  69     { index } = sessionHistory
  70     newIndex = index + num * count
  71     newIndex = Math.max(newIndex, 0)
  72     newIndex = Math.min(newIndex, sessionHistory.entries.length - 1)
  73     gBrowser.gotoIndex(newIndex) unless newIndex == index
  74   )
  75
  76 commands.history_back    = helper_go_history.bind(null, -1)
  77
  78 commands.history_forward = helper_go_history.bind(null, +1)
  79
  80 commands.reload = ({ vim }) ->
  81   vim.window.BrowserReload()
  82
  83 commands.reload_force = ({ vim }) ->
  84   vim.window.BrowserReloadSkipCache()
  85
  86 commands.reload_all = ({ vim }) ->
  87   vim.window.gBrowser.reloadAllTabs()
  88
  89 commands.reload_all_force = ({ vim }) ->
  90   for tab in vim.window.gBrowser.visibleTabs
  91     gBrowser = tab.linkedBrowser
  92     consts = gBrowser.webNavigation
  93     flags = consts.LOAD_FLAGS_BYPASS_PROXY | consts.LOAD_FLAGS_BYPASS_CACHE
  94     gBrowser.reload(flags)
  95   return
  96
  97 commands.stop = ({ vim }) ->
  98   vim.window.BrowserStop()
  99
 100 commands.stop_all = ({ vim }) ->
 101   for tab in vim.window.gBrowser.visibleTabs
 102     tab.linkedBrowser.stop()
 103   return
 104
 105
 106
 107 helper_scroll = (vim, method, type, direction, amount, property = null) ->
 108   args = {
 109     method, type, direction, amount, property
 110     smooth: (prefs.root.get('general.smoothScroll') and
 111              prefs.root.get("general.smoothScroll.#{ type }"))
 112   }
 113   reset = prefs.root.tmp(
 114     'layout.css.scroll-behavior.spring-constant',
 115     vim.options["smoothScroll.#{ type }.spring-constant"]
 116   )
 117   vim._run('scroll', args, reset)
 118
 119 helper_scrollByLinesX = (amount, { vim, count = 1 }) ->
 120   distance = prefs.root.get('toolkit.scrollbox.horizontalScrollDistance')
 121   helper_scroll(vim, 'scrollBy', 'lines', 'left', amount * distance * count * 5)
 122
 123 helper_scrollByLinesY = (amount, { vim, count = 1 }) ->
 124   distance = prefs.root.get('toolkit.scrollbox.verticalScrollDistance')
 125   helper_scroll(vim, 'scrollBy', 'lines', 'top', amount * distance * count * 20)
 126
 127 helper_scrollByPagesY = (amount, { vim, count = 1 }) ->
 128   helper_scroll(vim, 'scrollBy', 'pages', 'top', amount * count, 'clientHeight')
 129
 130 helper_scrollToX = (amount, { vim }) ->
 131   helper_scroll(vim, 'scrollTo', 'other', 'left', amount, 'scrollLeftMax')
 132
 133 helper_scrollToY = (amount, { vim }) ->
 134   helper_scroll(vim, 'scrollTo', 'other', 'top', amount, 'scrollTopMax')
 135
 136 commands.scroll_left           = helper_scrollByLinesX.bind(null, -1)
 137 commands.scroll_right          = helper_scrollByLinesX.bind(null, +1)
 138 commands.scroll_down           = helper_scrollByLinesY.bind(null, +1)
 139 commands.scroll_up             = helper_scrollByLinesY.bind(null, -1)
 140 commands.scroll_page_down      = helper_scrollByPagesY.bind(null, +1)
 141 commands.scroll_page_up        = helper_scrollByPagesY.bind(null, -1)
 142 commands.scroll_half_page_down = helper_scrollByPagesY.bind(null, +0.5)
 143 commands.scroll_half_page_up   = helper_scrollByPagesY.bind(null, -0.5)
 144 commands.scroll_to_top         = helper_scrollToY.bind(null, 0)
 145 commands.scroll_to_bottom      = helper_scrollToY.bind(null, Infinity)
 146 commands.scroll_to_left        = helper_scrollToX.bind(null, 0)
 147 commands.scroll_to_right       = helper_scrollToX.bind(null, Infinity)
 148
 149
 150
 151 commands.tab_new = ({ vim }) ->
 152   vim.window.BrowserOpenTab()
 153
 154 commands.tab_duplicate = ({ vim }) ->
 155   { gBrowser } = vim.window
 156   gBrowser.duplicateTab(gBrowser.selectedTab)
 157
 158 absoluteTabIndex = (relativeIndex, gBrowser) ->
 159   tabs = gBrowser.visibleTabs
 160   { selectedTab } = gBrowser
 161
 162   currentIndex  = tabs.indexOf(selectedTab)
 163   absoluteIndex = currentIndex + relativeIndex
 164   numTabs       = tabs.length
 165
 166   wrap = (Math.abs(relativeIndex) == 1)
 167   if wrap
 168     absoluteIndex %%= numTabs
 169   else
 170     absoluteIndex = Math.max(0, absoluteIndex)
 171     absoluteIndex = Math.min(absoluteIndex, numTabs - 1)
 172
 173   return absoluteIndex
 174
 175 helper_switch_tab = (direction, { vim, count = 1 }) ->
 176   { gBrowser } = vim.window
 177   gBrowser.selectTabAtIndex(absoluteTabIndex(direction * count, gBrowser))
 178
 179 commands.tab_select_previous = helper_switch_tab.bind(null, -1)
 180
 181 commands.tab_select_next     = helper_switch_tab.bind(null, +1)
 182
 183 helper_move_tab = (direction, { vim, count = 1 }) ->
 184   { gBrowser }    = vim.window
 185   { selectedTab } = gBrowser
 186   { pinned }      = selectedTab
 187
 188   index = absoluteTabIndex(direction * count, gBrowser)
 189
 190   if index < gBrowser._numPinnedTabs
 191     gBrowser.pinTab(selectedTab) unless pinned
 192   else
 193     gBrowser.unpinTab(selectedTab) if pinned
 194
 195   gBrowser.moveTabTo(selectedTab, index)
 196
 197 commands.tab_move_backward = helper_move_tab.bind(null, -1)
 198
 199 commands.tab_move_forward  = helper_move_tab.bind(null, +1)
 200
 201 commands.tab_select_first = ({ vim }) ->
 202   vim.window.gBrowser.selectTabAtIndex(0)
 203
 204 commands.tab_select_first_non_pinned = ({ vim }) ->
 205   firstNonPinned = vim.window.gBrowser._numPinnedTabs
 206   vim.window.gBrowser.selectTabAtIndex(firstNonPinned)
 207
 208 commands.tab_select_last = ({ vim }) ->
 209   vim.window.gBrowser.selectTabAtIndex(-1)
 210
 211 commands.tab_toggle_pinned = ({ vim }) ->
 212   currentTab = vim.window.gBrowser.selectedTab
 213   if currentTab.pinned
 214     vim.window.gBrowser.unpinTab(currentTab)
 215   else
 216     vim.window.gBrowser.pinTab(currentTab)
 217
 218 commands.tab_close = ({ vim, count = 1}) ->
 219   { gBrowser } = vim.window
 220   return if gBrowser.selectedTab.pinned
 221   currentIndex = gBrowser.visibleTabs.indexOf(gBrowser.selectedTab)
 222   for tab in gBrowser.visibleTabs[currentIndex...(currentIndex + count)]
 223     gBrowser.removeTab(tab)
 224   return
 225
 226 commands.tab_restore = ({ vim, count = 1 }) ->
 227   vim.window.undoCloseTab() for [1..count] by 1
 228
 229 commands.tab_close_to_end = ({ vim }) ->
 230   { gBrowser } = vim.window
 231   gBrowser.removeTabsToTheEndFrom(gBrowser.selectedTab)
 232
 233 commands.tab_close_other = ({ vim }) ->
 234   { gBrowser } = vim.window
 235   gBrowser.removeAllTabsBut(gBrowser.selectedTab)
 236
 237
 238
 239 helper_follow = (name, vim, callback, count = null) ->
 240   vim._run(name, null, ({ wrappers, viewport }) ->
 241     vim.enterMode('hints', wrappers, viewport, callback, count)
 242   )
 243
 244 helper_follow_clickable = ({ inTab, inBackground }, { vim, count = 1 }) ->
 245   callback = (marker, timesLeft, keyStr) ->
 246     isLast = (timesLeft == 1)
 247     isLink = (marker.wrapper.type == 'link')
 248
 249     switch
 250       when keyStr.startsWith(vim.options.hints_toggle_in_tab)
 251         inTab = not inTab
 252       when keyStr.startsWith(vim.options.hints_toggle_in_background)
 253         inTab = true
 254         inBackground = not inBackground
 255       else
 256         unless isLast
 257           inTab = true
 258           inBackground = true
 259
 260     inTab = false unless isLink
 261
 262     if marker.type == 'text' or (isLink and not (inTab and inBackground))
 263       isLast = true
 264
 265     { elementIndex } = marker.wrapper
 266     vim._focusMarkerElement(elementIndex)
 267
 268     if inTab
 269       utils.openTab(vim.window, marker.wrapper.href, {
 270         inBackground
 271         relatedToCurrent: true
 272       })
 273     else
 274       vim._run('click_marker_element', {
 275         elementIndex
 276         preventTargetBlank: vim.options.prevent_target_blank
 277       })
 278
 279     return not isLast
 280
 281   name = if inTab then 'follow_in_tab' else 'follow'
 282   helper_follow(name, vim, callback, count)
 283
 284 # Follow links, focus text inputs and click buttons with hint markers.
 285 commands.follow =
 286   helper_follow_clickable.bind(null, {inTab: false, inBackground: true})
 287
 288 # Follow links in a new background tab with hint markers.
 289 commands.follow_in_tab =
 290   helper_follow_clickable.bind(null, {inTab: true, inBackground: true})
 291
 292 # Follow links in a new foreground tab with hint markers.
 293 commands.follow_in_focused_tab =
 294   helper_follow_clickable.bind(null, {inTab: true, inBackground: false})
 295
 296 # Like command_follow but multiple times.
 297 commands.follow_multiple = (args) ->
 298   args.count = Infinity
 299   commands.follow(args)
 300
 301 # Copy the URL or text of a markable element to the system clipboard.
 302 commands.follow_copy = ({ vim }) ->
 303   callback = (marker) ->
 304     { elementIndex } = marker.wrapper
 305     property = switch marker.wrapper.type
 306       when 'link'            then 'href'
 307       when 'textInput'       then 'value'
 308       when 'contenteditable' then 'textContent'
 309     vim._run('copy_marker_element', {elementIndex, property})
 310   helper_follow('follow_copy', vim, callback)
 311
 312 # Focus element with hint markers.
 313 commands.follow_focus = ({ vim }) ->
 314   callback = (marker) ->
 315     vim._focusMarkerElement(marker.wrapper.elementIndex, {select: true})
 316   return helper_follow('follow_focus', vim, callback)
 317
 318 helper_follow_pattern = (type, { vim }) ->
 319   options =
 320     pattern_selector: vim.options.pattern_selector
 321     pattern_attrs:    vim.options.pattern_attrs
 322     patterns:         vim.options["#{ type }_patterns"]
 323   vim._run('follow_pattern', {type, options})
 324
 325 commands.follow_previous = helper_follow_pattern.bind(null, 'prev')
 326
 327 commands.follow_next     = helper_follow_pattern.bind(null, 'next')
 328
 329 # Focus last focused or first text input.
 330 commands.focus_text_input = ({ vim, count }) ->
 331   vim._run('focus_text_input', {count})
 332
 333 # Switch between text inputs or simulate `<tab>`.
 334 helper_move_focus = (direction, { vim, _skipMoveFocus }) ->
 335   vim._run('move_focus', {direction, skip: _skipMoveFocus})
 336
 337 commands.focus_next     = helper_move_focus.bind(null, +1)
 338 commands.focus_previous = helper_move_focus.bind(null, -1)
 339
 340
 341
 342 findStorage = {lastSearchString: ''}
 343
 344 helper_find = (highlight, { vim }) ->
 345   findBar = vim.window.gBrowser.getFindBar()
 346
 347   findBar.onFindCommand()
 348   utils.focusElement(findBar._findField, {select: true})
 349
 350   return unless highlightButton = findBar.getElement('highlight')
 351   if highlightButton.checked != highlight
 352     highlightButton.click()
 353
 354 # Open the find bar, making sure that hightlighting is off.
 355 commands.find = helper_find.bind(null, false)
 356
 357 # Open the find bar, making sure that hightlighting is on.
 358 commands.find_highlight_all = helper_find.bind(null, true)
 359
 360 helper_find_again = (direction, { vim }) ->
 361   findBar = vim.window.gBrowser.getFindBar()
 362   if findStorage.lastSearchString.length > 0
 363     findBar._findField.value = findStorage.lastSearchString
 364     findBar.onFindAgainCommand(direction)
 365     message = findBar._findStatusDesc.textContent
 366     vim.notify(message) if message
 367
 368 commands.find_next     = helper_find_again.bind(null, false)
 369
 370 commands.find_previous = helper_find_again.bind(null, true)
 371
 372
 373
 374 commands.enter_mode_ignore = ({ vim }) ->
 375   vim.enterMode('ignore')
 376
 377 # Quote next keypress (pass it through to the page).
 378 commands.quote = ({ vim, count = 1 }) ->
 379   vim.enterMode('ignore', count)
 380
 381 # Display the Help Dialog.
 382 commands.help = ({ vim }) ->
 383   help.injectHelp(vim.window, vim._parent)
 384
 385 # Open and focus the Developer Toolbar.
 386 commands.dev = ({ vim }) ->
 387   vim.window.DeveloperToolbar.show(true) # `true` to focus.
 388
 389 commands.esc = ({ vim }) ->
 390   vim._run('esc')
 391   # Some browser UI elements, such as the web console, are not marked as
 392   # focusable, so we need to force the blur.
 393   utils.blurActiveElement(vim.window, {force: true})
 394   help.removeHelp(vim.window)
 395   vim.window.DeveloperToolbar.hide()
 396   vim.window.gBrowser.getFindBar().close()
 397   vim.window.TabView.hide()
 398
 399
 400
 401 module.exports = {
 402   commands
 403   findStorage
 404 }