remapping Esc

[assemblical]

I remapped 'jk' and 'kj' to activate command mode.

'.editor.vim-mode:not(.command-mode)':
  'j k': 'vim-mode:activate-command-mode'
  'k j': 'vim-mode:activate-command-mode'

However if I just press 'k' or 'j' followed by another letter, the 'k' or 'j' doesn't appear. How can I overcome this problem?

[just-be-dev]

I've seen this as well. I usually map fj to escape in vim, however doing so in vim mode doesn't give the expected behavior. The first time 'f' is pressed, it always interprets it as a shortcut and waits on the rest to be entered. If something else is entered that isn't 'j' in this case then it just prints that out and continues on its marry way. In order to enter 'f' normally in my case I have to type it twice.

The vim style behavior is to have a short timeout in which, if the shortcut isn't completed the typed letters are printed. I have the feeling that this is more of an atom issue than a plugin issue though so I fear it'll be hard to change.

[garcg]

It seems the timeout after the first key press is there, it only needs a fallback to insert the text into the editor.

I've found a workaround adding the following to the user config.
This is for mapping j k as escape:

~/.atom/keymap.cson:

'.editor.vim-mode:not(.command-mode)':
  'j k': 'vim-mode:activate-command-mode'

'.editor.vim-mode.insert-mode':
  'j': 'insert-incomplete-keybinding'

~/.atom/init.coffee:

atom.workspaceView.command 'insert-incomplete-keybinding', (e)->
  if oe = e.originalEvent && e.originalEvent.originalEvent
    char = String.fromCharCode(oe.which)
    char = char.toLowerCase() unless oe.shift
    atom.workspace.activePaneItem.insertText(char)

Although, I don't know how this could be fixed in the vim package.

[just-be-dev]

It's good to know that it's doable though. I might explore a bit and see if I can come up with a solution.

[philk]

This completely worked for me when I thought based on #129 that it was still impossible in Atom. Only caveat was hitting jj was canceling visual mode, not just insert mode, but that was an easy fix.

'.editor.vim-mode.insert-mode':
  'j': 'insert-incomplete-keybinding'

'.vim-mode.insert-mode:not(.mini)':
  'j j': 'vim-mode:activate-command-mode'

Thanks, now I can use Atom without having to change my habits 😃

[BallisticPain]

I have been unable to get jj to work for typing "j" and also using "jj" to get me out of command mode. :(

I feel this shouldn't be so difficult. I have seen people reference a "timeout", but have been unable to find this anywhere in the settings for either Vim Mode nor Atom.

Edit: I just re-checked the init.coffee and noticed a misspelling... works now! Woohoo...

Thanks!
J

[pelachile]

@BallisticPain where did you find the misspelling? I have tried and tried and I can't get jj to work. It's the only thing that prevents me from using atom, I'm just to used to my vim settings. I'm on a OSX 10.10

[BallisticPain]

@pelachile, I'll copy and paste below what I have that's working. I use jj constantly and it was imperative that I got it working as well so I fully understand your frustration.

I personally mis-spelled a portion of the ~/.atom/init.coffee script. I didn't copy and paste, I just typed it in.

# Your init script
#
# Atom will evaluate this file each time a new window is opened. It is run
# after packages are loaded/activated and after the previous editor state
# has been restored.
#
# An example hack to make opened Markdown files always be soft wrapped:
#
# path = require 'path'
#
# atom.workspaceView.eachEditorView (editorView) ->
#   editor = editorView.getEditor()
#   if path.extname(editor.getPath()) is '.md'
#     editor.setSoftWrap(true)
#

atom.workspaceView.command 'insert-incomplete-keybinding', (e)->
    if oe = e.originalEvent && e.originalEvent.originalEvent
        char = String.fromCharCode(oe.which)
        char = char.toLowerCase() unless oe.shift
        atom.workspace.activePaneItem.insertText(char)

I misspelled the .workspace portion.

Here's my ~/.atom/keymap.cson (I was originally modifying the one in the package directly, and this wasn't working as well as modifying my home directory version)...

# Your keymap
#
# Atom keymaps work similarly to stylesheets. Just as stylesheets use selectors
# to apply styles to elements, Atom keymaps use selectors to associate
# keystrokes with events in specific contexts.
#
# You can create a new keybinding in this file by typing "key" and then hitting
# tab.
#
# Here's an example taken from Atom's built-in keymap:
#
# '.editor':
#   'enter': 'editor:newline'
#
# '.workspace':
#   'ctrl-P': 'core:move-up'
#   'ctrl-p': 'core:move-down'
#
'.editor.vim-mode.insert-mode':
    'j': 'insert-incomplete-keybinding'

'.vim-mode.insert-mode:not(.mini)':
  'j j': 'vim-mode:activate-command-mode'

One thing I will also note here is that I believe the order of these two insertions matters. The other note is that if you want to type a 'j' while in insert mode, type it and then the next letter and they'll both appear. Otherwise you must wait for the timeout to occur to see the 'j' appear.

I hope this helps,
Jarvis

[JacobHTran]

Atom seems to have a new process to add custom commands. I have been playing with atom for all of 10 mins, but in order to achieve this functionality without using the deprecated atom.workspaceView.command I implement the insert-incomplete-keybinding as such:

atom.commands.add 'atom-text-editor', 'insert-incomplete-keybinding', (e)->
  oe = e.originalEvent
  char = String.fromCharCode(oe.which)
  char = char.toLowerCase() unless oe.shift
  atom.workspace.activePaneItem.insertText(char)

[rdlugosz]

I was still seeing odd delays with the methods described above and so I implemented things in a slightly different way. Note that I prefer to use kj to exit insert mode rather than jk or jj, but you should be able to modify this for your own approach.

#keymap.cson
'atom-text-editor.vim-mode.insert-mode':
  'j': 'exit-insert-mode-if-preceded-by-k'

#init.coffee
atom.commands.add 'atom-text-editor', 'exit-insert-mode-if-preceded-by-k': (e) ->
  editor = @getModel()
  pos = editor.getCursorBufferPosition()
  range = [pos.traverse([0,-1]), pos]
  lastChar = editor.getTextInBufferRange(range)
  if lastChar != "k"
    e.abortKeyBinding()
  else
    editor.backspace()
    atom.commands.dispatch(e.currentTarget, 'vim-mode:activate-normal-mode')

While this isn't quite as flexible (in terms of being able to map different keys without changing the command that's executed), there are no "timeout" related issues or visual delays in not having the j (or in my case, k) char appear on the screen until the next keypress. This also avoids issues related to Atom "eating" the first char of your mapping, which can happen with other approaches.

Note that using the event.abortKeyBinding() is the preferred way to jump out of your key bindings and let the keystroke pass through to the editor (see: https://atom.io/docs/api/v0.187.0/KeymapManager).

edit: the word should have been "preceded" not "proceeded".
edit2: changed .editor to atom-text-editor to resolve Atom 1.0 deprecation warning
edit3: 22July2015 - Changed vim-mode:activate-command-mode to vim-mode:activate-normal-mode for compatibility with v.56+

[Robert-Wett]

+1 @rdlugosz - working great for me, using jk to exit insert mode. For the lazy:

#keymap.cson
'atom-text-editor.vim-mode.insert-mode':
  'k': 'exit-insert-mode-if-proceeded-by-j'

#init.coffee
atom.commands.add 'atom-text-editor', 'exit-insert-mode-if-proceeded-by-j': (e) ->
  editor = @getModel()
  pos = editor.getCursorBufferPosition()
  range = [pos.traverse([0,-1]), pos]
  lastChar = editor.getTextInBufferRange(range)
  if lastChar != "j"
    e.abortKeyBinding()
  else
    editor.backspace()
    atom.commands.dispatch(e.currentTarget, 'vim-mode:activate-normal-mode')

[jesseleite]

It should be as easy as:

'atom-text-editor.vim-mode':
  'j k': 'vim-mode:reset-command-mode'

Unfortunately, it's not. Small things like this keep me using Sublime. I'm excited about Atom's future though.

[ahmadseleem]

The best and simplest until this is supported natively by Atom:
Is the one by: @Robert-Wett
because the the one by @garcg doesn't work if yo wanna map escape to something like =>

 , ,

So, the final solution is as @Robert-Wett except he didn't add escape for visual mode in the mapping:

#keymap.cson

#................................................
# Escape
#................................................
'atom-text-editor.editor.vim-mode.insert-mode':
  ',': 'exit-insert-mode-if-proceeded-by-j'

'atom-text-editor.vim-mode.visual-mode:not(.mini)':
  ', ,': 'vim-mode:activate-command-mode'
  'v': 'vim-mode:activate-command-mode'

It's still not perfect because it just wait for the second letter for ever....!!!
it should be just a half a second or so then inserts the char and return...

[ahmadseleem]

Like:

 setTimeout(doStuff, 50); //wait 50 millisecnds then recheck
 return;

I know it's extremely rare that you would need to type jj or jk or ,, or whatever alike.
But, just incase

[bronson]

Is this a dupe of #221?