Added key modes and changed the command entry to use them.

Removed obsoleted `events.COMMAND_ENTRY_COMMAND`.

9 files changed, 337 insertions, 255 deletions

diff --git a/core/events.lua b/core/events.lua
index f7b2e997..6f755110 100644
--- a/core/events.lua
+++ b/core/events.lua
@@ -65,13 +65,6 @@ local M = {}
 --   Arguments:
 --
 --   * _`ch`_: The text character byte.
--- @field COMMAND_ENTRY_COMMAND (string)
---   Called to run the command entered into the Command Entry.
---   If any handler returns `true`, the Command Entry does not hide
---   automatically.
---   Arguments:
---
---   * _`command`_: The command text.
 -- @field COMMAND_ENTRY_KEYPRESS (string)
 --   Called when pressing a key in the Command Entry.
 --   If any handler returns `true`, the key is not inserted into the entry.
diff --git a/core/keys.lua b/core/keys.lua
index f1bfb7d1..794c3001 100644
--- a/core/keys.lua
+++ b/core/keys.lua
@@ -11,13 +11,15 @@ local M = {}
 -- Key bindings are defined in the global table `keys`. Each key-value pair in
 -- `keys` consists of either a string key sequence and its associated command,
 -- a string lexer language (from the *lexers/* directory) with a table of key
--- sequences and commands, or a key sequence with a table of more sequences and
--- commands. The latter is part of what is called a "key chain". When searching
--- for a command to run based on a key sequence, key bindings in the current
--- lexer have priority, followed by the ones in the global table. This means if
--- there are two commands with the same key sequence, the one specific to the
--- current lexer is run. However, if the command returns the boolean value
--- `false`, the lower-priority command is also run. (This is useful for
+-- sequences and commands, a string key mode with a table of key sequences and
+-- commands, or a key sequence with a table of more sequences and commands. The
+-- latter is part of what is called a "key chain", to be discussed below. When
+-- searching for a command to run based on a key sequence, key bindings in the
+-- current key mode have priority. If no key mode is active, key bindings in the
+-- current lexer have priority, followed by the ones in the global table. This
+-- means if there are two commands with the same key sequence, the one specific
+-- to the current lexer is run. However, if the command returns the boolean
+-- value `false`, the lower-priority command is also run. (This is useful for
 -- language-specific modules to override commands like Adeptsense
 -- autocompletion, but fall back to word autocompletion if the first command
 -- fails.)
@@ -52,18 +54,45 @@ local M = {}
 --
 -- ## Commands
 --
--- Commands associated with key sequences can be either Lua functions, or
--- tables containing Lua functions with a set of arguments to call the function
--- with. Examples are:
+-- Commands bound to key sequences can be either Lua functions, or tables
+-- containing Lua functions with a set of arguments to call the function with.
+-- Examples are:
 --
 --     keys['cn'] = new_buffer
 --     keys['cs'] = buffer.save
 --     keys['a('] = {_M.textadept.editing.enclose, '(', ')'}
+--     keys['cu'] = function() io.snapopen(_USERHOME) end
 --
--- Note that [`buffer`][] references are handled properly.
+-- (The function and function table syntax are functionally equivalent. You can
+-- use either.)
+--
+-- [`buffer`][] references are handled properly in static contexts.
 --
 -- [`buffer`]: buffer.html
 --
+-- ## Modes
+--
+-- Sets of key bindings can be grouped together into modes. When a key
+-- [mode](#MODE) is active, all key bindings defined outside the mode are
+-- ignored until the mode is unset. Here is a simple vi mode example:
+--
+--     keys.command_mode = {
+--       ['h'] = buffer.char_left,
+--       ['j'] = buffer.line_up,
+--       ['k'] = buffer.line_down,
+--       ['l'] = buffer.char_right,
+--       ['i'] = function()
+--         keys.MODE = nil
+--         gui.statusbar_text = 'INSERT MODE'
+--       end
+--     }
+--     keys['esc'] = function() keys.MODE = 'command_mode' end
+--     events.connect(events.UPDATE_UI, function()
+--       if keys.MODE == 'command_mode' then return end
+--       gui.statusbar_text = 'INSERT MODE'
+--     end)
+--     keys.MODE = 'command_mode' -- default mode
+--
 -- ## Key Chains
 --
 -- Key chains are a powerful concept. They allow multiple key bindings to be
@@ -86,6 +115,11 @@ local M = {}
 --   The starting key of the key chain reserved for language-specific modules.
 --   The default value is `'cl'` on platforms other than Mac OSX, `'ml'`
 --   otherwise. Equivalent to `Ctrl+L` (`⌘L` on Mac OSX | `M-L` in curses).
+-- @field MODE (string)
+--   The current key mode.
+--   When non-`nil`, all key bindings defined outside of `keys[MODE]` are
+--   ignored.
+--   The default value is `nil`.
 module('keys')]]
 
 local ADD = ''
@@ -112,9 +146,9 @@ local error = function(e) events.emit(events.ERROR, e) end
 -- @name KEYSYMS
 M.KEYSYMS = {
   -- From Scintilla.h and cdk/curdefs.h.
-  [7] = 'esc', [8] = '\b', [9] = '\t', [13] = '\n', [27] = 'esc', [127] = 'del',
+  [7] = 'esc',
   -- From curses.h.
-  [263] = '\b',
+  [263] = '\b', [343] = '\n',
   -- From Scintilla.h.
   [300] = 'down', [301] = 'up', [302] = 'left', [303] = 'right',
   [304] = 'home', [305] = 'end',
@@ -160,6 +194,8 @@ local function clear_key_sequence()
   -- Clearing a table is faster than re-creating one.
   if #keychain == 1 then keychain[1] = nil else keychain = {} end
 end
+-- Export for command_entry.lua without creating LuaDoc.
+if CURSES then M.clear_key_sequence = clear_key_sequence end
 
 -- Runs a given command.
 -- This is also used by *modules/textadept/menu.lua*.
@@ -185,36 +221,30 @@ local function run_command(command, command_type)
 end
 M.run_command = run_command -- export for menu.lua without creating LuaDoc
 
--- Return codes for `run_key_command()`.
+-- Return codes for `key_command()`.
 local INVALID, PROPAGATE, CHAIN, HALT = -1, 0, 1, 2
 
 -- Runs a key command associated with the current keychain.
--- @param lexer Optional lexer name for lexer-specific commands.
+-- @param prefix Optional prefix name for mode/lexer-specific commands.
 -- @return `INVALID`, `PROPAGATE`, `CHAIN`, or `HALT`.
-local function run_key_command(lexer)
-  local key, key_type = keys, type(keys)
-  if lexer and key_type == 'table' and key[lexer] then key = key[lexer] end
-  if type(key) ~= 'table' then return INVALID end
-
-  key = key[keychain[1]]
-  for i = 2, #keychain do
+local function key_command(prefix)
+  local key = not prefix and M or M[prefix]
+  for i = 1, #keychain do
     if type(key) ~= 'table' then return INVALID end
     key = key[keychain[i]]
   end
-  key_type = type(key)
-
+  local key_type = type(key)
   if key_type ~= 'function' and key_type ~= 'table' then return INVALID end
   if key_type == 'table' and #key == 0 and next(key) then
     gui.statusbar_text = _L['Keychain:']..' '..table.concat(keychain, ' ')
     return CHAIN
   end
-
   return run_command(key, key_type) == false and PROPAGATE or HALT
 end
 
 -- Handles Textadept keypresses.
--- It is called every time a key is pressed, and based on lexer, executes a
--- command. The command is looked up in the `_G.keys` table.
+-- It is called every time a key is pressed, and based on a mode or lexer,
+-- executes a command. The command is looked up in the `_G.keys` table.
 -- @param code The keycode.
 -- @param shift Whether or not the Shift modifier is pressed.
 -- @param control Whether or not the Control modifier is pressed.
@@ -222,40 +252,34 @@ end
 -- @param meta Whether or not the Command modifier on Mac OSX is pressed.
 -- @return `true` to stop handling the key; `nil` otherwise.
 local function keypress(code, shift, control, alt, meta)
-  local buffer = buffer
-  local key
   --print(code, M.KEYSYMS[code], shift, control, alt, meta)
-  if code < 256 then
-    key = (not CURSES or code ~= 7) and string_char(code) or M.KEYSYMS[code]
-    shift = shift and code < 32 -- for printable characters, key is upper case
-  else
-    key = M.KEYSYMS[code]
-    if not key then return end
-  end
+  local key = code < 256 and (not CURSES or code ~= 7) and string_char(code) or
+                                                           M.KEYSYMS[code]
+  if not key then return end
+  shift = shift and (code >= 256 or code == 9) -- printable chars are uppercased
   local key_seq = (control and CTRL or '')..(alt and ALT or '')..
                   (meta and OSX and META or '')..(shift and SHIFT or '')..key
   --print(key_seq)
 
   gui.statusbar_text = ''
   --if CURSES then gui.statusbar_text = '"'..key_seq..'"' end
-  if #keychain > 0 and key_seq == M.CLEAR then
+  local keychain_size = #keychain
+  if keychain_size > 0 and key_seq == M.CLEAR then
     clear_key_sequence()
     return true
   end
-  keychain[#keychain + 1] = key_seq
+  keychain[keychain_size + 1] = key_seq
 
-  local success
-  for i = 1, 2 do
-    local status = run_key_command(i == 1 and buffer:get_lexer(true))
-    if status > 0 then -- CHAIN or HALT
-      if status == HALT then clear_key_sequence() end
-      return true
-    end
-    success = success or status ~= -1
+  local status = PROPAGATE
+  if not M.MODE then
+    status = key_command(buffer:get_lexer(true))
+    if status <= PROPAGATE and not M.MODE then status = key_command() end
+  else
+    status = key_command(M.MODE)
   end
-  local size = #keychain
-  clear_key_sequence()
-  if not success and size > 1 then -- INVALID keychain sequence
+  if status ~= CHAIN then clear_key_sequence() end
+  if status > PROPAGATE then return true end -- CHAIN or HALT
+  if status == INVALID and keychain_size > 0 then
     gui.statusbar_text = _L['Invalid sequence']
     return true
   end
diff --git a/doc/14_Appendix.md b/doc/14_Appendix.md
index d24e8c4e..1e4fd663 100644
--- a/doc/14_Appendix.md
+++ b/doc/14_Appendix.md
@@ -104,7 +104,7 @@ As a special case, the empty capture `()` captures the current string position
 Textadept 5.5 beta introduced a curses version that can run in a terminal
 emulator. However, since curses is quite low-level in terms of graphics
 capability compared to GTK+, the curses version of Textadept lacks some features
-in its editing component Scintilla:
+in its editing component Scintilla and in general:
 
 * Any settings with alpha values are not supported.
 * Autocompletion lists cannot show images (pixmap surfaces are not supported).
diff --git a/modules/textadept/command_entry.lua b/modules/textadept/command_entry.lua
index 7e52282b..005af837 100644
--- a/modules/textadept/command_entry.lua
+++ b/modules/textadept/command_entry.lua
@@ -1,13 +1,79 @@
 -- Copyright 2007-2013 Mitchell mitchell.att.foicica.com. See LICENSE.
--- Modified by Jay Gould.
+-- Abbreviated environment and commands from Jay Gould.
+
+local M = gui.command_entry
 
 --[[ This comment is for LuaDoc.
 ---
 -- Textadept's Command Entry.
+--
+-- ## Modes
+--
+-- The command entry supports multiple [modes][] that have their own sets of key
+-- bindings stored in a separate table in `_G.keys` under a mode prefix key.
+-- Mode names are arbitrary, but cannot conflict with lexer names or key
+-- sequence strings (e.g. `'lua'` or `'send'`) due to the method used for
+-- looking up key bindings. An example mode is "lua_command" mode for executing
+-- Lua commands:
+--
+--     local gui_ce = gui.command_entry
+--     keys['ce'] = {gui_ce.enter_mode, 'lua_command'}
+--     keys.lua_command = {
+--       ['\t'] = gui_ce.complete_lua,
+--       ['\n'] = {gui_ce.finish_mode, gui_ce.execute_lua}
+--     }
+--
+-- In this case, `Ctrl+E` opens the command entry and enters "lua_command" key
+-- mode where the `Tab` and `Enter` keys have special, defined functionality.
+-- (By default, `Esc` is pre-defined to exit any command entry mode.) `Tab`
+-- shows a list of Lua completions for the entry text and `Enter` exits
+-- "lua_command" key mode and executes the entered code. All other keys are
+-- handled normally by the command entry.
+--
+-- It is important to note that while in any command entry key mode, all editor
+-- key bindings are ignored -- even if the editor, not the command entry, has
+-- focus. You must first exit the key mode by pressing `Esc` (or `Enter` in the
+-- case of the above "lua_command" key mode).
+--
+-- [modes]: keys.html#Modes
 -- @field entry_text (string)
 --   The text in the entry.
 module('gui.command_entry')]]
 
+---
+-- Opens the command entry in key mode *mode*.
+-- Key bindings will be looked up in `keys[mode]` instead of `keys`. The `Esc`
+-- (`⎋` on Mac OSX | `Esc` in curses) key exits the current mode, closes the
+-- command entry, and restores normal key lookup.
+-- This function is useful for binding keys to enter a command entry mode.
+-- @param mode The key mode to enter into, or `nil` to exit the current mode.
+-- @usage keys['ce'] = {gui.command_entry.enter_mode, 'command_entry'}
+-- @see _G.keys.MODE
+-- @name enter_mode
+function M.enter_mode(mode)
+  keys.MODE = mode
+  if mode then keys[mode]['esc'] = M.enter_mode end
+  -- In curses, M.focus() does not return immediately, so the key sequence that
+  -- called M.focus() is still on the keychain. Clear it.
+  if CURSES then keys.clear_key_sequence() end
+  M.focus()
+end
+
+---
+-- Exits the current key mode, closes the command entry, and calls function *f*
+-- with the command entry text as an argument.
+-- This is useful for binding keys to exit a command entry mode and perform an
+-- action with the entered text.
+-- @param f The function to call. It should accept the command entry text as an
+--   argument.
+-- @usage keys['\n'] = {gui.command_entry.finish_mode, gui.print}
+-- @name finish_mode
+function M.finish_mode(f)
+  M.enter_mode(nil)
+  f(M.entry_text)
+  if CURSES then return false end -- propagate to exit CDK entry on Enter
+end
+
 -- Environment for abbreviated commands.
 -- @class table
 -- @name env
@@ -29,71 +95,73 @@ local env = setmetatable({}, {
   end,
 })
 
-local events = events
-
--- Execute a Lua command.
-events.connect(events.COMMAND_ENTRY_COMMAND, function(command)
-  local f, err = load(command, nil, 'bt', env)
+---
+-- Executes string *code* as Lua code.
+-- Code is subject to an "abbreviated" environment where the `buffer`, `view`,
+-- and `gui` tables are also considered as globals.
+-- @param code The Lua code to execute.
+-- @name execute_lua
+function M.execute_lua(code)
+  local f, err = load(code, nil, 'bt', env)
   if err then error(err) end
-  if not CURSES then gui.command_entry.focus() end -- toggle focus to hide
   f()
   events.emit(events.UPDATE_UI)
-end)
+end
+args.register('-e', '--execute', 1, M.execute_lua, 'Execute Lua code')
 
-events.connect(events.COMMAND_ENTRY_KEYPRESS, function(code)
-  if keys.KEYSYMS[code] == 'esc' then
-    gui.command_entry.focus() -- toggle focus to hide
-  elseif keys.KEYSYMS[code] == '\t' then
-    local substring = gui.command_entry.entry_text:match('[%w_.:]+$') or ''
-    local path, o, prefix = substring:match('^([%w_.:]-)([.:]?)([%w_]*)$')
-    local f, err = load('return ('..path..')', nil, 'bt', env)
-    local ok, tbl = pcall(f)
-    local cmpls = {}
-    prefix = '^'..prefix
-    if not ok then -- shorthand notation
-      for _, t in ipairs{buffer, view, gui, _G} do
-        for k in pairs(t) do
-          if type(k) == 'string' and k:find(prefix) then
-            cmpls[#cmpls + 1] = k
-          end
-        end
+---
+-- Shows a set of Lua code completions for string *code* or `entry_text`.
+-- Completions are subject to an "abbreviated" environment where the `buffer`,
+-- `view`, and `gui` tables are also considered as globals.
+-- @param code The Lua code to complete. The default value is the value of
+--   `entry_text`.
+-- @name complete_lua
+function M.complete_lua(code)
+  local substring = (code or M.entry_text):match('[%w_.:]+$') or ''
+  local path, op, prefix = substring:match('^([%w_.:]-)([.:]?)([%w_]*)$')
+  local f, err = load('return ('..path..')', nil, 'bt', env)
+  local ok, tbl = pcall(f)
+  local cmpls = {}
+  prefix = '^'..prefix
+  if not ok then -- shorthand notation
+    for _, t in ipairs{buffer, view, gui, _G} do
+      for k in pairs(t) do
+        if type(k) == 'string' and k:find(prefix) then cmpls[#cmpls + 1] = k end
       end
+    end
+    for f in pairs(_SCINTILLA.functions) do
+      if f:find(prefix) then cmpls[#cmpls + 1] = f end
+    end
+    for p in pairs(_SCINTILLA.properties) do
+      if p:find(prefix) then cmpls[#cmpls + 1] = p end
+    end
+  else
+    if type(tbl) ~= 'table' then return end
+    for k in pairs(tbl) do
+      if type(k) == 'string' and k:find(prefix) then cmpls[#cmpls + 1] = k end
+    end
+    if path == 'buffer' and op == ':' then
       for f in pairs(_SCINTILLA.functions) do
         if f:find(prefix) then cmpls[#cmpls + 1] = f end
       end
+    elseif path == 'buffer' and op == '.' then
       for p in pairs(_SCINTILLA.properties) do
         if p:find(prefix) then cmpls[#cmpls + 1] = p end
       end
-    else
-      if type(tbl) ~= 'table' then return end
-      for k in pairs(tbl) do
-        if type(k) == 'string' and k:find(prefix) then cmpls[#cmpls + 1] = k end
-      end
-      if path == 'buffer' then
-        if o == ':' then
-          for f in pairs(_SCINTILLA.functions) do
-            if f:find(prefix) then cmpls[#cmpls + 1] = f end
-          end
-        else
-          for p in pairs(_SCINTILLA.properties) do
-            if p:find(prefix) then cmpls[#cmpls + 1] = p end
-          end
-        end
-      end
     end
-    table.sort(cmpls)
-    gui.command_entry.show_completions(cmpls)
-    return true
   end
-end)
-
--- Executes Lua code on startup.
-local function execute(command)
-  local f, err = load(command, nil, 'bt', env)
-  if err then error(err) end
-  f()
+  table.sort(cmpls)
+  M.show_completions(cmpls)
+  return true
 end
-args.register('-e', '--execute', 1, execute, 'Execute Lua code')
+
+local events = events
+-- Pass command entry keys to the default keypress handler.
+-- Since the command entry is designed to be modal, command entry key bindings
+-- should stay separate from editor key bindings.
+events.connect(events.COMMAND_ENTRY_KEYPRESS, function(...)
+  if keys.MODE then return events.emit(events.KEYPRESS, ...) end
+end)
 
 --[[ The function below is a Lua C function.
 
diff --git a/modules/textadept/filter_through.lua b/modules/textadept/filter_through.lua
index fbff074c..59cb77b0 100644
--- a/modules/textadept/filter_through.lua
+++ b/modules/textadept/filter_through.lua
@@ -9,11 +9,12 @@ module('_M.textadept.filter_through')]]
 
 local cat = not WIN32 and 'cat' or 'type'
 local tmpfile = _USERHOME..'/.ft'
-local filter_through_active = false
 
 ---
--- Prompts the user for a Linux, BSD, Mac OSX, or Windows shell command to
--- filter text through with standard input (stdin) as follows:
+-- Passes selected or all buffer text to string shell command *cmd* as standard
+-- input (stdin) and replaces the input text with the command's standard output
+-- (stdout).
+-- Standard input is as follows:
 --
 -- 1. If text is selected and spans multiple lines, all text on the lines
 -- containing the selection is used. However, if the end of the selection is at
@@ -22,57 +23,39 @@ local filter_through_active = false
 -- 2. If text is selected and spans a single line, only the selected text is
 -- used.
 -- 3. If no text is selected, the entire buffer is used.
---
--- The input text is replaced with the standard output (stdout) of the command.
+-- @param cmd The Linux, BSD, Mac OSX, or Windows shell command to filter text
+--   through.
 -- @name filter_through
-function M.filter_through()
-  filter_through_active = true
-  gui.command_entry.focus()
-end
-
-local events = events
-
-events.connect(events.COMMAND_ENTRY_KEYPRESS, function(code)
-  if filter_through_active and keys.KEYSYMS[code] == 'esc' then
-    filter_through_active = false
-  end
-end, 1) -- place before command_entry.lua's handler (if necessary)
-
--- Filter through.
-events.connect(events.COMMAND_ENTRY_COMMAND, function(text)
-  if filter_through_active then
-    local buffer = buffer
-    local s, e = buffer.selection_start, buffer.selection_end
-    local input
-    if s ~= e then -- use selected lines as input
-      local i, j = buffer:line_from_position(s), buffer:line_from_position(e)
-      if i < j then
-        s = buffer:position_from_line(i)
-        if buffer.column[e] > 0 then e = buffer:position_from_line(j + 1) end
-      end
-      input = buffer:text_range(s, e)
-    else -- use whole buffer as input
-      input = buffer:get_text()
-    end
-    local f = io.open(tmpfile, 'wb')
-    f:write(input)
-    f:close()
-    local cmd = cat..' "'..tmpfile..'" | '..text
-    if WIN32 then cmd = cmd:gsub('/', '\\') end
-    local p = io.popen(cmd)
-    if s ~= e then
-      buffer.target_start, buffer.target_end = s, e
-      buffer:replace_target(p:read('*all'))
-      buffer:set_sel(buffer.target_start, buffer.target_end)
-    else
-      buffer:set_text(p:read('*all'))
-      buffer:goto_pos(s)
+function M.filter_through(cmd)
+  local buffer = buffer
+  local s, e = buffer.selection_start, buffer.selection_end
+  local input
+  if s ~= e then -- use selected lines as input
+    local i, j = buffer:line_from_position(s), buffer:line_from_position(e)
+    if i < j then
+      s = buffer:position_from_line(i)
+      if buffer.column[e] > 0 then e = buffer:position_from_line(j + 1) end
     end
-    p:close()
-    os.remove(tmpfile)
-    filter_through_active = false
-    return true
+    input = buffer:text_range(s, e)
+  else -- use whole buffer as input
+    input = buffer:get_text()
   end
-end, 1) -- place before command_entry.lua's handler (if necessary)
+  local f = io.open(tmpfile, 'wb')
+  f:write(input)
+  f:close()
+  local cmd = cat..' "'..tmpfile..'" | '..cmd
+  if WIN32 then cmd = cmd:gsub('/', '\\') end
+  local p = io.popen(cmd)
+  if s ~= e then
+    buffer.target_start, buffer.target_end = s, e
+    buffer:replace_target(p:read('*all'))
+    buffer:set_sel(buffer.target_start, buffer.target_end)
+  else
+    buffer:set_text(p:read('*all'))
+    buffer:goto_pos(s)
+  end
+  p:close()
+  os.remove(tmpfile)
+end
 
 return M
diff --git a/modules/textadept/find.lua b/modules/textadept/find.lua
index d1105a7b..801c333f 100644
--- a/modules/textadept/find.lua
+++ b/modules/textadept/find.lua
@@ -1,6 +1,6 @@
 -- Copyright 2007-2013 Mitchell mitchell.att.foicica.com. See LICENSE.
 
-local find = gui.find
+local M = gui.find
 
 --[[ This comment is for LuaDoc.
 ---
@@ -60,17 +60,17 @@ local find = gui.find
 module('gui.find')]]
 
 local _L = _L
-find.find_label_text = not CURSES and _L['_Find:'] or _L['Find:']
-find.replace_label_text = not CURSES and _L['R_eplace:'] or _L['Replace:']
-find.find_next_button_text = not CURSES and _L['Find _Next'] or _L['[Next]']
-find.find_prev_button_text = not CURSES and _L['Find _Prev'] or _L['[Prev]']
-find.replace_button_text = not CURSES and _L['_Replace'] or _L['[Replace]']
-find.replace_all_button_text = not CURSES and _L['Replace _All'] or _L['[All]']
-find.match_case_label_text = not CURSES and _L['_Match case'] or _L['Case(F1)']
-find.whole_word_label_text = not CURSES and _L['_Whole word'] or _L['Word(F2)']
-find.lua_pattern_label_text = not CURSES and _L['_Lua pattern'] or
-                              _L['Pattern(F3)']
-find.in_files_label_text = not CURSES and _L['_In files'] or _L['Files(F4)']
+M.find_label_text = not CURSES and _L['_Find:'] or _L['Find:']
+M.replace_label_text = not CURSES and _L['R_eplace:'] or _L['Replace:']
+M.find_next_button_text = not CURSES and _L['Find _Next'] or _L['[Next]']
+M.find_prev_button_text = not CURSES and _L['Find _Prev'] or _L['[Prev]']
+M.replace_button_text = not CURSES and _L['_Replace'] or _L['[Replace]']
+M.replace_all_button_text = not CURSES and _L['Replace _All'] or _L['[All]']
+M.match_case_label_text = not CURSES and _L['_Match case'] or _L['Case(F1)']
+M.whole_word_label_text = not CURSES and _L['_Whole word'] or _L['Word(F2)']
+M.lua_pattern_label_text = not CURSES and _L['_Lua pattern'] or
+                           _L['Pattern(F3)']
+M.in_files_label_text = not CURSES and _L['_In files'] or _L['Files(F4)']
 
 -- Events.
 local events, events_connect = events, events.connect
@@ -94,7 +94,7 @@ local preferred_view
 -- @see find_in_files
 -- @class table
 -- @name FILTER
-find.FILTER = lfs.FILTER
+M.FILTER = lfs.FILTER
 
 -- Text escape sequences with their associated characters.
 -- @class table
@@ -114,7 +114,7 @@ local escapes = {
 --   the user is prompted for one.
 -- @see FILTER
 -- @name find_in_files
-function find.find_in_files(utf8_dir)
+function M.find_in_files(utf8_dir)
   if not utf8_dir then
     utf8_dir = gui.dialog('fileselect',
                           '--title', _L['Find in Files'],
@@ -125,13 +125,13 @@ function find.find_in_files(utf8_dir)
   end
   if utf8_dir == '' then return end
 
-  local text = find.find_entry_text
-  if not find.lua then text = text:gsub('([().*+?^$%%[%]-])', '%%%1') end
-  if not find.match_case then text = text:lower() end
-  if find.whole_word then text = '%f[%w_]'..text..'%f[^%w_]' end
+  local text = M.find_entry_text
+  if not M.lua then text = text:gsub('([().*+?^$%%[%]-])', '%%%1') end
+  if not M.match_case then text = text:lower() end
+  if M.whole_word then text = '%f[%w_]'..text..'%f[^%w_]' end
   local matches = {_L['Find:']..' '..text}
   lfs.dir_foreach(utf8_dir, function(file)
-    local match_case = find.match_case
+    local match_case = M.match_case
     local line_num = 1
     for line in io.lines(file) do
       if (match_case and line or line:lower()):find(text) then
@@ -140,7 +140,7 @@ function find.find_in_files(utf8_dir)
       end
       line_num = line_num + 1
     end
-  end, find.FILTER, true)
+  end, M.FILTER, true)
   if #matches == 1 then matches[2] = _L['No results found'] end
   matches[#matches + 1] = ''
   if buffer._type ~= _L['[Files Found Buffer]'] then preferred_view = view end
@@ -174,14 +174,14 @@ local function find_(text, next, flags, nowrap, wrapped)
 
   if not flags then
     flags = 0
-    if find.match_case then flags = flags + c.SCFIND_MATCHCASE end
-    if find.whole_word then flags = flags + c.SCFIND_WHOLEWORD end
-    if find.lua then flags = flags + 8 end
-    if find.in_files then flags = flags + 16 end
+    if M.match_case then flags = flags + c.SCFIND_MATCHCASE end
+    if M.whole_word then flags = flags + c.SCFIND_WHOLEWORD end
+    if M.lua then flags = flags + 8 end
+    if M.in_files then flags = flags + 16 end
   end
 
   local result
-  find.captures = nil
+  M.captures = nil
 
   if flags < 8 then
     buffer:goto_pos(buffer[next and 'current_pos' or 'anchor'] + increment)
@@ -193,12 +193,12 @@ local function find_(text, next, flags, nowrap, wrapped)
     local buffer_text = buffer:get_text(buffer.length)
     local results = {buffer_text:find(text, buffer.anchor + increment + 1)}
     if #results > 0 then
-      find.captures = {table.unpack(results, 3)}
+      M.captures = {table.unpack(results, 3)}
       buffer:set_sel(results[2], results[1] - 1)
     end
     result = results[1] or -1
   else -- find in files
-    find.find_in_files()
+    M.find_in_files()
     return
   end
 
@@ -222,47 +222,52 @@ local function find_(text, next, flags, nowrap, wrapped)
 end
 events_connect(events.FIND, find_)
 
--- Finds and selects text incrementally in the current buffer from a start
--- point.
+-- Finds and selects text incrementally in the current buffer from a starting
+-- position.
 -- Flags other than `SCFIND_MATCHCASE` are ignored.
 -- @param text The text to find.
-local function find_incremental(text)
-  local flags = find.match_case and c.SCFIND_MATCHCASE or 0
-  buffer:goto_pos(find.incremental_start or 0)
-  find_(text, true, flags)
+-- @param next Flag indicating whether or not the search direction is forward.
+local function find_incremental(text, next)
+  buffer:goto_pos(M.incremental_start or 0)
+  find_(text, next, M.match_case and c.SCFIND_MATCHCASE or 0)
 end
 
 ---
--- Begins an incremental find using the command entry.
+-- Begins an incremental search using the command entry if *text* is `nil`;
+-- otherwise continues an incremental search by searching for the next instance
+-- of string *text*.
 -- Only the `match_case` find option is recognized. Normal command entry
--- functionality will be unavailable until the search is finished by pressing
--- `Esc` (`⎋` on Mac OSX | `Esc` in curses).
+-- functionality is unavailable until the search is finished by pressing `Esc`
+-- (`⎋` on Mac OSX | `Esc` in curses).
+-- @param text The text to incrementally search for, or `nil` to begin an
+--   incremental search.
 -- @name find_incremental
-function find.find_incremental()
-  find.incremental, find.incremental_start = true, buffer.current_pos
+function M.find_incremental(text)
+  if text then find_incremental(text, true) return end
+  M.incremental_start = buffer.current_pos
   gui.command_entry.entry_text = ''
-  gui.command_entry.focus()
+  gui.command_entry.enter_mode('find_incremental')
 end
 
-events_connect(events.COMMAND_ENTRY_KEYPRESS, function(code)
-  if not find.incremental then return end
-  if keys.KEYSYMS[code] == 'esc' then
-    find.incremental = nil
-  elseif keys.KEYSYMS[code] == '\b' then
-    find_incremental(gui.command_entry.entry_text:sub(1, -2))
-  elseif code < 256 then
-    find_incremental(gui.command_entry.entry_text..string.char(code))
-  end
-end, 1) -- place before command_entry.lua's handler (if necessary)
-
--- "Find next" for incremental search.
-events_connect(events.COMMAND_ENTRY_COMMAND, function(text)
-  if find.incremental then
-    find.incremental_start = buffer.current_pos + 1
-    find_incremental(text)
-    return true
-  end
-end, 1) -- place before command_entry.lua's handler (if necessary)
+---
+-- Continues an incremental search by searching for the next match starting from
+-- the current position.
+-- @see find_incremental
+-- @name find_incremental_next
+function M.find_incremental_next()
+  M.incremental_start = buffer.current_pos + 1
+  find_incremental(gui.command_entry.entry_text, true)
+end
+
+---
+-- Continues an incremental search by searching for the previous match starting
+-- from the current position.
+-- @see find_incremental
+-- @name find_incremental_prev
+function M.find_incremental_prev()
+  M.incremental_start = buffer.current_pos - 1
+  find_incremental(gui.command_entry.entry_text, false)
+end
 
 -- Optimize for speed.
 local load, pcall = load, pcall
@@ -295,11 +300,11 @@ end
 -- @see find
 local function replace(rtext)
   if buffer:get_sel_text() == '' then return end
-  if find.in_files then find.in_files = false end
+  if M.in_files then M.in_files = false end
   local buffer = buffer
   buffer:target_from_selection()
   rtext = rtext:gsub('%%%%', '\\037') -- escape '%%'
-  local captures = find.captures
+  local captures = M.captures
   if captures then
     for i = 1, #captures do
       rtext = rtext:gsub('%%'..i, (captures[i]:gsub('%%', '%%%%')))
@@ -326,7 +331,7 @@ events_connect(events.REPLACE, replace)
 -- @see find
 local function replace_all(ftext, rtext)
   if ftext == '' then return end
-  if find.in_files then find.in_files = false end
+  if M.in_files then M.in_files = false end
   local buffer = buffer
   buffer:begin_undo_action()
   local count = 0
@@ -389,7 +394,7 @@ events_connect(events.DOUBLE_CLICK, goto_file)
 -- @param next Optional flag indicating whether or not to go to the next file.
 --   The default value is `false`.
 -- @name goto_file_in_list
-function find.goto_file_in_list(next)
+function M.goto_file_in_list(next)
   local orig_view = _VIEWS[view]
   for _, buffer in ipairs(_BUFFERS) do
     if buffer._type == _L['[Files Found Buffer]'] then
diff --git a/modules/textadept/keys.lua b/modules/textadept/keys.lua
index 8fa15a19..e2d41770 100644
--- a/modules/textadept/keys.lua
+++ b/modules/textadept/keys.lua
@@ -298,7 +298,8 @@ events.connect(events.BUFFER_NEW, constantize_menu_buffer_functions)
 if not RESETTING then constantize_menu_buffer_functions() end
 
 local keys = keys
-local io, gui, gui_find, buffer, view = io, gui, gui.find, buffer, view
+local io, gui, gui_find, gui_ce = io, gui, gui.find, gui.command_entry
+local buffer, view = buffer, view
 local m_textadept, m_editing = _M.textadept, _M.textadept.editing
 local m_bookmarks, m_snippets = m_textadept.bookmarks, m_textadept.snippets
 local OSX, c = OSX, _SCINTILLA.constants
@@ -466,13 +467,13 @@ keys[not OSX and 'cj' or 'mj'] = m_editing.goto_line
 
 -- Tools.
 keys[not OSX and (not CURSES and 'ce' or 'mc')
-             or 'me'] = gui.command_entry.focus
+             or 'me'] = {gui_ce.enter_mode, 'lua_command'}
 keys[not OSX and (not CURSES and 'cE' or 'mC') or 'mE'] = utils.select_command
 keys[not OSX and 'cr' or 'mr'] = m_textadept.run.run
 keys[not OSX and (not CURSES and 'cR' or 'cmr')
              or 'mR'] = m_textadept.run.compile
 keys[not OSX and (not CURSES and 'c|' or 'c\\')
-             or 'm|'] = m_textadept.filter_through.filter_through
+             or 'm|'] = {gui_ce.enter_mode, 'filter_through'}
 -- Adeptsense.
 keys[not OSX and (not CURSES and 'c ' or 'c@')
              or 'aesc'] = m_textadept.adeptsense.complete
@@ -594,4 +595,25 @@ elseif CURSES then
   keys.ck = utils.cut_to_eol
 end
 
+-- Modes.
+keys.lua_command = {
+  ['\t'] = gui_ce.complete_lua,
+  ['\n'] = {gui_ce.finish_mode, gui_ce.execute_lua}
+}
+keys.filter_through = {
+  ['\n'] = {gui_ce.finish_mode, m_textadept.filter_through.filter_through},
+}
+keys.find_incremental = {
+  ['\n'] = gui_find.find_incremental_next,
+  ['cr'] = gui_find.find_incremental_prev,
+  ['\b'] = function()
+    gui_find.find_incremental(gui_ce.entry_text:sub(1, -2))
+    return false -- propagate
+  end
+}
+setmetatable(keys.find_incremental, {__index = function(t, k)
+               if #k > 1 and k:find('^[cams]*.+$') then return end
+               gui_find.find_incremental(gui_ce.entry_text..k)
+             end})
+
 return M
diff --git a/modules/textadept/menu.lua b/modules/textadept/menu.lua
index f4784b5d..583b3f46 100644
--- a/modules/textadept/menu.lua
+++ b/modules/textadept/menu.lua
@@ -119,12 +119,12 @@ M.menubar = {
     {_L['_Jump to'], m_editing.goto_line},
   },
   { title = _L['_Tools'],
-    {_L['Command _Entry'], gui.command_entry.focus},
+    {_L['Command _Entry'], {gui.command_entry.enter_mode, 'lua_command'}},
     {_L['Select Co_mmand'], utils.select_command},
     SEPARATOR,
     {_L['_Run'], m_textadept.run.run},
     {_L['_Compile'], m_textadept.run.compile},
-    {_L['_Filter Through'], _M.textadept.filter_through.filter_through},
+    {_L['_Filter Through'], {gui.command_entry.enter_mode, 'filter_through'}},
     SEPARATOR,
     { title = _L['_Adeptsense'],
       {_L['_Complete Symbol'], m_textadept.adeptsense.complete},
diff --git a/src/textadept.c b/src/textadept.c
index 1e913aae..301c061d 100644
--- a/src/textadept.c
+++ b/src/textadept.c
@@ -549,33 +549,24 @@ static int lfind__newindex(lua_State *L) {
  * As a PROCESSFN, returns `TRUE` to continue key propagation.
  */
 static int c_keypress(EObjectType _, void *object, void *data, chtype key) {
-  if (data && (key == KEY_ENTER || key == KEY_TAB)) return TRUE;
-  int ret = TRUE;
-  if (key == KEY_ENTER) {
-    fcopy(&command_text, getCDKEntryValue((CDKENTRY *)object));
-    ret = lL_event(lua, "command_entry_command", LUA_TSTRING, command_text, -1);
-  } else {
-    int ctrl = key < 0x20 && key != 9 && key != 10 && key != 13 && key != 27;
-    if (ctrl) key = tolower(key ^ 0x40);
-    // TODO: F1-F12.
-    ret = !lL_event(lua, "command_entry_keypress", LUA_TNUMBER, key,
-                    LUA_TBOOLEAN, FALSE, LUA_TBOOLEAN, ctrl, -1);
-  }
+  if (!data && key == KEY_TAB) return TRUE; // do not exit on Tab
+  int ctrl = key < 0x20 && key != 9 && key != 27;
+  if (ctrl) key = tolower(key ^ 0x40);
+  if (key == 27) key = SCK_ESCAPE;
+  int halt = lL_event(lua, "command_entry_keypress", LUA_TNUMBER, key,
+                      LUA_TBOOLEAN, FALSE, LUA_TBOOLEAN, ctrl, -1);
   scintilla_refresh(focused_view), drawCDKEntry((CDKENTRY *)object, FALSE);
-  return key == KEY_TAB || ret;
+  return !halt || key == SCK_ESCAPE;
 }
 #endif
 
 /** `command_entry.focus()` Lua function. */
 static int lce_focus(lua_State *L) {
 #if GTK
-  if (!gtk_widget_has_focus(command_entry)) {
-    gtk_widget_show(command_entry);
-    gtk_widget_grab_focus(command_entry);
-  } else {
-    gtk_widget_hide(command_entry);
-    gtk_widget_grab_focus(focused_view);
-  }
+  if (!gtk_widget_get_visible(command_entry))
+    gtk_widget_show(command_entry), gtk_widget_grab_focus(command_entry);
+  else
+    gtk_widget_hide(command_entry), gtk_widget_grab_focus(focused_view);
 #elif CURSES
   if (command_entry) return 0; // already active
   CDKSCREEN *screen = initCDKScreen(newwin(1, 0, LINES - 2, 0));
@@ -585,7 +576,6 @@ static int lce_focus(lua_State *L) {
   command_entry = newCDKEntry(screen, LEFT, TOP, NULL, NULL, A_NORMAL, '_',
                               vMIXED, 0, 0, 256, FALSE, FALSE);
   bindCDKObject(vENTRY, command_entry, KEY_TAB, c_keypress, NULL);
-  bindCDKObject(vENTRY, command_entry, KEY_ENTER, c_keypress, NULL);
   setCDKEntryPreProcess(command_entry, c_keypress, "");
   setCDKEntryValue(command_entry, command_text);
   char *clipboard = get_clipboard();
@@ -607,12 +597,15 @@ static int lce_show_completions(lua_State *L) {
   luaL_checktype(L, 1, LUA_TTABLE);
   int len = lua_rawlen(L, 1);
 #if GTK
+  if (!gtk_widget_get_visible(command_entry))
+    luaL_error(L, "command entry inactive");
   GtkEntryCompletion *completion = gtk_entry_get_completion(
                                    GTK_ENTRY(command_entry));
   GtkListStore *store = GTK_LIST_STORE(
                         gtk_entry_completion_get_model(completion));
   gtk_list_store_clear(store);
 #elif CURSES
+  if (!command_entry) luaL_error(L, "command entry inactive");
   const char **items = malloc(len * sizeof(const char *));
   int width = 0;
 #endif
@@ -2073,11 +2066,6 @@ static GtkWidget *new_findbox() {
   return findbox;
 }
 
-/** Signal for the 'enter' key being pressed in the Command Entry. */
-static void c_activate(GtkWidget*_, void*__) {
-  lL_event(lua, "command_entry_command", LUA_TSTRING, command_text, -1);
-}
-
 /** Signal for a keypress inside the Command Entry. */
 static int c_keypress(GtkWidget*_, GdkEventKey *event, void*__) {
   return lL_event(lua, "command_entry_keypress", LUA_TNUMBER, event->keyval,
@@ -2167,7 +2155,6 @@ static void new_window() {
   gtk_box_pack_start(GTK_BOX(vbox), new_findbox(), FALSE, FALSE, 5);
 
   command_entry = gtk_entry_new();
-  signal(command_entry, "activate", c_activate);
   signal(command_entry, "key-press-event", c_keypress);
   gtk_box_pack_start(GTK_BOX(vbox), command_entry, FALSE, FALSE, 0);