vim-mode/vim_mode: beginnings of new input system starting to take shape -

following actual vim style of timeout/ttimeout[_len] flags and fields.

1 files changed, 398 insertions, 204 deletions

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 51094aa..963cd8f 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -587,16 +587,16 @@ Things we're not ever likely to do:
 
 use strict;
 use warnings;
-
+#use diagnostics;
 #TODO: Specify a minimum version of perl (5.8, probably?)
 #testing.
 # UTF-8 conversion functions.
 use Encode;
-use List::Util; # Not currently used.
+use List::Util;                 # Not currently used.
 
 use Irssi;
-use Irssi::TextUI; # statusbar handling.
-use Irssi::Irc;    # necessary for 0.8.14
+use Irssi::TextUI;              # statusbar handling.
+use Irssi::Irc;                 # necessary for 0.8.14
 
 
 
@@ -605,8 +605,8 @@ our %IRSSI   =
   (
    authors         => "Tom Feist (shabble), Simon Ruderich (rudi_s)",
    contact         => 'shabble+irssi@metavore.org, '
-                    . 'shabble@#irssi/Freenode, simon@ruderich.org'
-                    . 'rudi_s@#irssi/Freenode',
+   . 'shabble@#irssi/Freenode, simon@ruderich.org'
+   . 'rudi_s@#irssi/Freenode',
    name            => "vim_mode",
    description     => "Give Irssi Vim-like commands for editing the inputline",
    license         => "MIT",
@@ -655,13 +655,21 @@ sub S_STR  () { 2 }
 sub KEY_ESC () {  27 }
 sub KEY_RET () {  10 }
 sub KEY_TAB () {   9 }
-sub KEY_DEL () {   8 } # Ctrl-H
-sub KEY_BS  () { 127 } # Backspace (^? usually)
-sub KEY_C_C () {   3 } # Ctrl-C (all Ctrl-<x> are 0 + letter (from a=1 to 26))
+sub KEY_DEL () {   8 }   # Ctrl-H
+sub KEY_BS  () { 127 }   # Backspace (^? usually)
+sub KEY_C_C () {   3 }   # Ctrl-C (all Ctrl-<x> are 0 + letter (from a=1 to 26))
+
+
+sub SIG_STOP () { 1 }           # stop the signal from reaching other handlers.
+sub SIG_CONT () { 0 }           # allow it to continue
 
 
-sub SIG_STOP () { 1 } # stop the signal from reaching other handlers.
-sub SIG_CONT () { 0 } # allow it to continue
+# constants for determining how timeout and ttimeout settings are used.
+
+sub TIMEOUT_MODE_NONE () { 0 }
+sub TIMEOUT_MODE_BOTH () { 1 }
+sub TIMEOUT_MODE_CODE () { 2 }
+sub TIMEOUT_MODE_MAPS () { 3 }
 
 # word and non-word regex, keep in sync with setup_changed()!
 my $word     = qr/[\w_]/o;
@@ -689,8 +697,8 @@ my $commands
             repeatable => 1 },
 
      # arrow like movement
-      h     => { char => 'h',       func => \&cmd_h, type => C_NORMAL },
-      l     => { char => 'l',       func => \&cmd_l, type => C_NORMAL },
+     h     => { char => 'h',       func => \&cmd_h, type => C_NORMAL },
+     l     => { char => 'l',       func => \&cmd_l, type => C_NORMAL },
      "\x08" => { char => '<BS>',    func => \&cmd_h, type => C_NORMAL },
      "\x7F" => { char => '<BS>',    func => \&cmd_h, type => C_NORMAL },
      ' '    => { char => '<Space>', func => \&cmd_l, type => C_NORMAL },
@@ -710,8 +718,8 @@ my $commands
                  selection_needs_move_right => 1 },
      F      => { char => 'F', func => \&cmd_F, type => C_NEEDSKEY },
      T      => { char => 'T', func => \&cmd_T, type => C_NEEDSKEY },
-    ';'     => { char => ';', func => \&cmd_semicolon, type => C_NORMAL },
-    ','     => { char => ',', func => \&cmd_comma, type => C_NORMAL },
+     ';'     => { char => ';', func => \&cmd_semicolon, type => C_NORMAL },
+     ','     => { char => ',', func => \&cmd_comma, type => C_NORMAL },
      # word movement
      w      => { char => 'w',  func => \&cmd_w,  type => C_NORMAL },
      b      => { char => 'b',  func => \&cmd_b,  type => C_NORMAL },
@@ -738,10 +746,10 @@ my $commands
                  repeatable => 1, no_operator => 1 },
      X      => { char => 'X', func => \&cmd_X, type => C_NORMAL,
                  repeatable => 1, no_operator => 1 },
-               # C_NORMAL is correct, operator c takes care of insert mode
+     # C_NORMAL is correct, operator c takes care of insert mode
      s      => { char => 's', func => \&cmd_s, type => C_NORMAL,
                  repeatable => 1, no_operator => 1 },
-               # C_NORMAL is correct, operator c takes care of insert mode
+     # C_NORMAL is correct, operator c takes care of insert mode
      S      => { char => 'S', func => \&cmd_S, type => C_NORMAL,
                  repeatable => 1, no_operator => 1 },
      # insert mode
@@ -782,7 +790,7 @@ my $commands
      "\x06"  => { char => '<C-F>', func => \&cmd_ctrl_f, type => C_NORMAL,
                   no_operator => 1 },
      "\x02"  => { char => '<C-B>', func => \&cmd_ctrl_b, type => C_NORMAL,
-                 no_operator => 1 },
+                  no_operator => 1 },
      # window switching
      "\x17j" => { char => '<C-W>j', func => \&cmd_ctrl_wj, type => C_NORMAL,
                   no_operator => 1 },
@@ -896,13 +904,13 @@ my $commands_ex
 ################################################################
 
 # command mode mappings
-my $cmap = undef; # cmap still pending (contains first character entered)
+my $cmap = undef;        # cmap still pending (contains first character entered)
 my $cmaps = {};
 
 
 # insert-mode mappings
 
-my $imap = undef; # imap still pending (contains first character entered)
+my $imap = undef;        # imap still pending (contains first character entered)
 my $imaps
   = {
      # CTRL-R, insert register
@@ -970,7 +978,9 @@ my $should_ignore = 0;
 # buffer to keep track of the last N keystrokes, used for Esc detection and
 # insert mode mappings
 my @escape_buf;
-my $escape_buf_timer;
+my $escape_buf_timeout;
+my $escape_buf_ttimeout;
+
 my $escape_buf_enabled = 0;
 
 # mode-related input buffers
@@ -981,6 +991,9 @@ my @insert_mode_buf;
 my @cmd_mode_buf;
 my @ex_mode_buf;
 
+my $keycode_timeouts_active;
+my $mapping_timeouts_active;
+
 # Ex-mode related vars
 # --------------------
 
@@ -1017,7 +1030,7 @@ my $last
 # last ftFT movement, used by ; and ,
 my $last_ftFT
   = {
-     type => undef, # f, t, F or T
+     type => undef,             # f, t, F or T
      char => undef,
     };
 
@@ -1030,11 +1043,11 @@ my $register = '"';
 # vi registers
 my $registers
   = {
-     '"' => '', # default register
-     '0' => '', # yank register
-     '+' => '', # contains irssi's cut buffer
-     '*' => '', # same
-     '_' => '', # black hole register, always empty
+     '"' => '',                 # default register
+     '0' => '',                 # yank register
+     '+' => '',                 # contains irssi's cut buffer
+     '*' => '',                 # same
+     '_' => '',                 # black hole register, always empty
     };
 
 # (irssi) History related vars:
@@ -1102,7 +1115,7 @@ sub cmd_operator_c {
                        $move_cmd == $commands->{W})) {
         my $input = _input();
         if ($new_pos - $old_pos > 1 and
-                substr($input, $new_pos - 1, 1) =~ /\s/) {
+            substr($input, $new_pos - 1, 1) =~ /\s/) {
             $new_pos--;
         }
     }
@@ -1225,10 +1238,10 @@ sub cmd_j {
     if (defined $history_index) {
         $history_index += $count;
         print "History Index: $history_index" if DEBUG;
-    # Prevent destroying the current input when pressing j after entering
-    # command mode. Not exactly like in default irssi, but simplest solution
-    # (and S can be used to clear the input line fast, which is what <down>
-    # does in plain irssi).
+        # Prevent destroying the current input when pressing j after entering
+        # command mode. Not exactly like in default irssi, but simplest solution
+        # (and S can be used to clear the input line fast, which is what <down>
+        # does in plain irssi).
     } else {
         return (undef, undef);
     }
@@ -1393,8 +1406,8 @@ sub cmd_semicolon {
     return (undef, undef) if not defined $last_ftFT->{type};
 
     (undef, $pos)
-        = $commands->{$last_ftFT->{type}}
-                   ->{func}($count, $pos, $repeat, $last_ftFT->{char});
+      = $commands->{$last_ftFT->{type}}
+      ->{func}($count, $pos, $repeat, $last_ftFT->{char});
     return (undef, $pos);
 }
 
@@ -1409,8 +1422,8 @@ sub cmd_comma {
     $type =~ tr/ftFT/FTft/;
 
     (undef, $pos)
-        = $commands->{$type}
-                   ->{func}($count, $pos, $repeat, $last_ftFT->{char});
+      = $commands->{$type}
+      ->{func}($count, $pos, $repeat, $last_ftFT->{char});
     # Restore type as the move functions overwrites it.
     $last_ftFT->{type} = $save;
     return (undef, $pos);
@@ -1492,8 +1505,7 @@ sub _end_of_word {
         if (substr($input, $pos + 1) =~ /^\s+/) {
             $pos += $+[0] + 1;
             $skipped = 1;
-        }
-        elsif (substr($input, $pos) =~ /^\s+/) {
+        } elsif (substr($input, $pos) =~ /^\s+/) {
             $pos += $+[0];
             $skipped = 1;
         }
@@ -1501,9 +1513,9 @@ sub _end_of_word {
         if (substr($input, $pos) =~ /^$word{2,}/ or
             substr($input, $pos) =~ /^$non_word{2,}/) {
             $pos += $+[0] - 1;
-        # We are the border of word/non-word. Skip to the end of the next one.
-        # But not if we've already jumped over whitespace because there could
-        # be only one word/non-word char after the whitespace.
+            # We are the border of word/non-word. Skip to the end of the next one.
+            # But not if we've already jumped over whitespace because there could
+            # be only one word/non-word char after the whitespace.
         } elsif (!$skipped and (substr($input, $pos) =~ /^$word($non_word+)/ or
                                 substr($input, $pos) =~ /^$non_word($word+)/)) {
             $pos += $+[0] - 1;
@@ -1643,7 +1655,7 @@ sub cmd__a {
                     } else {
                         $pos = length($input);
                     }
-                # WORD
+                    # WORD
                 } else {
                     if (substr($input, $pos + 1) =~ /\s/) {
                         $pos += $-[0] + 1;
@@ -1652,7 +1664,7 @@ sub cmd__a {
                     }
                 }
 
-            # word
+                # word
             } elsif ($char eq 'w') {
                 # Start at the beginning of this WORD.
                 if (not defined $cur_pos and $pos > 0
@@ -1694,11 +1706,11 @@ sub cmd__a {
                     }
                 }
 
-            # WORD
+                # WORD
             } else {
                 # Start at the beginning of this WORD.
                 if (not defined $cur_pos and $pos > 0 and
-                        substr($input, $pos - 1, 1) !~ /\s/) {
+                    substr($input, $pos - 1, 1) !~ /\s/) {
                     $cur_pos = _find_regex_before($input, '\s', $pos - 1, 0);
                     if ($cur_pos < 0) {
                         $cur_pos = 0;
@@ -1756,10 +1768,10 @@ sub cmd_caret {
     # No whitespace at all.
     if ($input !~ m/^\s/) {
         $pos = 0;
-    # Some non-whitespace, go to first one.
+        # Some non-whitespace, go to first one.
     } elsif ($input =~ m/[^\s]/) {
         $pos = $-[0];
-    # Only whitespace, go to the end.
+        # Only whitespace, go to the end.
     } else {
         $pos = _fix_input_pos(length $input, length $input);
     }
@@ -2039,7 +2051,7 @@ sub cmd_undo {
         $undo_index++;
         _restore_undo_entry($undo_index);
         print "Undoing entry index: $undo_index of " . scalar(@undo_buffer)
-            if DEBUG;
+          if DEBUG;
     } else {
         print "No further undo." if DEBUG;
     }
@@ -2052,7 +2064,7 @@ sub cmd_redo {
     if ($undo_index != 0) {
         $undo_index--;
         print "Undoing entry index: $undo_index of " . scalar(@undo_buffer)
-            if DEBUG;
+          if DEBUG;
         _restore_undo_entry($undo_index);
     } else {
         print "No further Redo." if DEBUG;
@@ -2068,7 +2080,7 @@ sub _fix_input_pos {
     # correct handling of last character in line.
     if ($operator) {
         $pos = $length if $pos > $length;
-    # Otherwise forbid it.
+        # Otherwise forbid it.
     } else {
         $pos = $length - 1 if $pos > $length - 1;
     }
@@ -2097,7 +2109,7 @@ sub cmd_ex_command {
 
     # add this item to the ex mode history
     ex_history_add($arg_str);
-    $ex_history_index = 0; # and reset the history position.
+    $ex_history_index = 0;      # and reset the history position.
 
     my $count = $1;
     if ($count eq '') {
@@ -2205,13 +2217,13 @@ sub ex_buffer {
         # :[N]:b[uffer]
         if (defined $count) {
             $window = Irssi::window_find_refnum($count);
-        # Go to window number.
+            # Go to window number.
         } elsif ($buffer =~ /^[0-9]+$/) {
             $window = Irssi::window_find_refnum($buffer);
-        # Go to previous window.
+            # Go to previous window.
         } elsif ($buffer eq '#') {
             Irssi::command('window last');
-        # Go to best regex matching window.
+            # Go to best regex matching window.
         } else {
             eval {
                 my $matches = _matching_windows($buffer);
@@ -2416,19 +2428,19 @@ sub ex_map {
                              type => C_EX,
                            };
             }
-        # Irssi command
+            # Irssi command
         } elsif (index($rhs, '/') == 0) {
             $command = { char => $rhs,
                          func => substr($rhs, 1),
                          type => C_IRSSI,
                        };
-        # <Nop> does nothing
+            # <Nop> does nothing
         } elsif (lc $rhs eq '<nop>') {
             $command = { char => '<Nop>',
                          func => undef,
                          type => C_NOP,
                        };
-        # command-mode command
+            # command-mode command
         } else {
             $rhs = _parse_mapping($2);
             if (not defined $rhs) {
@@ -2441,7 +2453,7 @@ sub ex_map {
         }
         add_map($lhs, $command);
 
-    # :map [lhs]
+        # :map [lhs]
     } elsif ($arg_str =~ m/^map\s*$/ or $arg_str =~ m/^map (\S+)$/) {
         # Necessary for case insensitive matchings. lc alone won't work.
         my $search = $1;
@@ -2458,7 +2470,7 @@ sub ex_map {
                 next if $map->{char} eq '<C-H>' and $cmd->{char} eq '<BS>';
                 next if $map->{char} !~ /^\Q$search\E/; # skip non-matches
                 $active_window->print(sprintf "%-15s %s", $map->{char},
-                                                          $cmd->{char});
+                                      $cmd->{char});
             }
         }
     } else {
@@ -2476,7 +2488,7 @@ sub ex_unmap {
     my $lhs = _parse_mapping($1);
     if (not defined $lhs) {
         return _warn_ex('unmap', 'invalid {lhs}');
-    # Prevent unmapping of unknown or default mappings.
+        # Prevent unmapping of unknown or default mappings.
     } elsif (not exists $cmaps->{$lhs} or not defined $cmaps->{$lhs}->{cmd} or
              ($commands->{$lhs} and $cmaps->{$lhs}->{cmd} == $commands->{$lhs})) {
         return _warn_ex('unmap', "$1 not found");
@@ -2502,21 +2514,21 @@ sub _parse_mapping_bracket {
     # <C-X>, get corresponding CTRL char.
     if ($string =~ /^c-([a-z])$/i) {
         $string = chr(ord($1) - 96);
-    # <C-6> and <C-^>
+        # <C-6> and <C-^>
     } elsif ($string =~ /^c-[6^]$/i) {
         $string = chr(30);
-    # <Space>
+        # <Space>
     } elsif ($string eq 'space') {
         $string = ' ';
-    # <CR>
+        # <CR>
     } elsif ($string eq 'cr') {
         $string = "\n";
-    # <BS>
+        # <BS>
     } elsif ($string eq 'bs') {
         $string = chr(127);
     } elsif ($string eq 'leader') {
         $string = $settings->{map_leader}->{value};
-    # Invalid char, return special string to recognize the error.
+        # Invalid char, return special string to recognize the error.
     } else {
         $string = '<invalid>';
     }
@@ -2630,7 +2642,7 @@ sub ex_set {
             _setting_set($name, $value);
             setup_changed();
 
-        # :se[t] [option]
+            # :se[t] [option]
         } else {
             my $search = defined $1 ? $1 : '';
             my $active_window = Irssi::active_win();
@@ -2752,7 +2764,7 @@ sub _set_prompt {
     my $msg = shift;
 
     # add a leading space unless we're trying to clear it entirely.
-    if  (length($msg) and $settings->{prompt_leading_space}->{value}) {
+    if (length($msg) and $settings->{prompt_leading_space}->{value}) {
         $msg = ' ' . $msg;
     }
 
@@ -2825,16 +2837,16 @@ sub _matching_windows {
         if ($window->{name} =~ /$buffer/i) {
             my $win_ratio = ($+[0] - $-[0]) / length($window->{name});
             push @matches, { window => $window,
-                               item => undef,
-                              ratio => $win_ratio,
-                               text => $window->{name} };
+                             item => undef,
+                             ratio => $win_ratio,
+                             text => $window->{name} };
             print ":b $window->{name}: $win_ratio" if DEBUG;
         }
         # Matching Window item names (= channels).
         foreach my $item ($window->items()) {
             # Wrong server.
             if ($server and (!$item->{server} or
-                              $item->{server}->{chatnet} !~ /^$server/i)) {
+                             $item->{server}->{chatnet} !~ /^$server/i)) {
                 next;
             }
             if ($item->{name} =~ /$buffer/i) {
@@ -2842,9 +2854,9 @@ sub _matching_windows {
                 $length-- if index($item->{name}, '#') == 0;
                 my $item_ratio = ($+[0] - $-[0]) / $length;
                 push @matches, { window => $window,
-                                   item => $item,
-                                  ratio => $item_ratio,
-                                   text => $item->{name} };
+                                 item => $item,
+                                 ratio => $item_ratio,
+                                 text => $item->{name} };
                 print ":b $window->{name} $item->{name}: $item_ratio" if DEBUG;
             }
         }
@@ -2992,7 +3004,7 @@ sub vim_mode_init {
 
     # Add all default mappings.
     foreach my $char (keys %$commands) {
-        next if $char =~ /^_/; # skip private commands (text-objects for now)
+        next if $char =~ /^_/;  # skip private commands (text-objects for now)
         add_map($char, $commands->{$char});
     }
 
@@ -3149,8 +3161,8 @@ sub add_map {
         if (not exists $cmaps->{$tmp}) {
             $cmaps->{$tmp} = { char => _parse_mapping_reverse($tmp),
                                cmd => undef,
-                              maps => {}
-                            };
+                               maps => {}
+                             };
         }
         if (not exists $cmaps->{$tmp}->{maps}->{$tmp . $map}) {
             $cmaps->{$tmp}->{maps}->{$tmp . $map} = undef;
@@ -3160,8 +3172,8 @@ sub add_map {
     if (not exists $cmaps->{$keys}) {
         $cmaps->{$keys} = { char => undef,
                             cmd => undef,
-                           maps => {}
-                         };
+                            maps => {}
+                          };
     }
     $cmaps->{$keys}->{char} = _parse_mapping_reverse($keys);
     $cmaps->{$keys}->{cmd} = $command;
@@ -3224,9 +3236,9 @@ sub _update_mode {
             _input_pos($pos);
             $numeric_prefix = undef;
 
-        # In insert mode we are "between" characters, in command mode "on top"
-        # of keys. When leaving insert mode we have to move on key left to
-        # accomplish that.
+            # In insert mode we are "between" characters, in command mode "on top"
+            # of keys. When leaving insert mode we have to move on key left to
+            # accomplish that.
         } else {
             $pos = _input_pos();
             if ($pos != 0) {
@@ -3236,12 +3248,12 @@ sub _update_mode {
         # Store current line to allow undo of i/a/I/A.
         _add_undo_entry(_input(), _input_pos());
 
-    # Change mode to i to support insert mode repetition. This doesn't affect
-    # commands like i/a/I/A because handle_command_cmd() sets $last->{cmd}.
-    # It's necessary when pressing enter so the next line can be repeated.
+        # Change mode to i to support insert mode repetition. This doesn't affect
+        # commands like i/a/I/A because handle_command_cmd() sets $last->{cmd}.
+        # It's necessary when pressing enter so the next line can be repeated.
     } elsif ($mode == M_CMD and $new_mode == M_INS) {
         $last->{cmd} = $commands->{i};
-    # Make sure prompt is cleared when leaving ex mode.
+        # Make sure prompt is cleared when leaving ex mode.
     } elsif ($mode == M_EX and $new_mode != M_EX) {
         _set_prompt('');
     }
@@ -3251,8 +3263,8 @@ sub _update_mode {
         $history_index = undef;
         $register = '"';
         @insert_mode_buf = ();
-    # Reset every command mode related status as a fallback in case something
-    # goes wrong.
+        # Reset every command mode related status as a fallback in case something
+        # goes wrong.
     } elsif ($mode == M_CMD) {
         $numeric_prefix = undef;
         $operator = undef;
@@ -3362,7 +3374,7 @@ sub ex_history_add {
     unshift @ex_history, $line;
 
     if ($settings->{ex_history_size}->{value} < @ex_history) {
-        pop @ex_history; # junk the last entry if we've hit the max.
+        pop @ex_history;        # junk the last entry if we've hit the max.
     }
 }
 
@@ -3444,97 +3456,279 @@ sub sig_gui_keypress {
 sub process_input_key {
     my ($key, $char) = @_;
 
-    # no matter what mode we're in, we need to deal with escape (and escape
-    # sequences) specially. So do them first.
+    my ($timeout, $ttimeout)
+      = ($settings->{timeout}->{value},
+         $settings->{ttimeout}->{value});
+
+    my ($timeout_len, $ttimeout_len)
+      = ($settings->{timeoutlen}->{value},
+         $settings->{ttimeoutlen}->{value});
 
-    # First,
-    if ($key == KEY_ESC) {
-        _debug("Escape seen, beginning escape_buf collection");
-        $escape_buf_enabled = 1;
+    _append_to_mode_buffer($key);
 
-        push @escape_buf, $key;
+    if ((not $timeout) and (not $ttimeout)) {
+        # wait forever
+        _debug("process_keys_timeout none");
 
-        # NOTE: this timeout might be too low on laggy systems, but
-        # it comes at the cost of keystroke latency for things that
-        # contain escape sequences (arrow keys, etc)
-        my $esc_buf_timeout = $settings->{esc_buf_timeout}->{value};
+        return if $keycode_timeouts_active or $mapping_timeouts_active;
 
-        $escape_buf_timer =
-          Irssi::timeout_add_once($esc_buf_timeout,
-                                  \&escape_buffer_timeout, undef);
+        process_keys_timeout(TIMEOUT_MODE_NONE); # make these constants.
+    } elsif ($timeout) {
+        _debug("process_keys_timeout both");
 
-        _debug("Buffer Timer tag: $escape_buf_timer");
+        # timeout on both mappings and keycodes
+        process_keys_timeout(TIMEOUT_MODE_BOTH, $timeout_len, $ttimeout_len);
+    } elsif ((not $timeout) and $ttimeout) {
+        # timeout on codes (but not mappings?
+        _debug("process_keys_timeout code");
 
-    } elsif ($escape_buf_enabled) {
-        attempt_escape_buffer_parse($key, $char);
-        # we can check at this point if we recognise the sequence, and cancel
-        # the timeout if we do.
+        return if $keycode_timeouts_active;
+
+        process_keys_timeout(TIMEOUT_MODE_CODE, $timeout_len, $ttimeout_len);
+    } else {
+        _debug("What the buggery, shouldn't happen: T: $timeout, TT: $ttimeout");
     }
+
 }
-sub attempt_escape_buffer_parse {
-    my ($key, $char) = @_;
+#     if ($key == KEY_ESC) {
+#         _debug("Escape seen, beginning escape_buf collection");
+#         $escape_buf_enabled = 1;
 
-    if ($char eq '[') {
-        _debug("Spotted CSI");
-    } elsif ($char eq ']') {
-        _debug ("Spotted OSC");
-    } else {
-        push @escape_buf, $key;
+#         push @escape_buf, $key;
+
+#         # NOTE: this timeout might be too low on laggy systems, but
+#         # it comes at the cost of keystroke latency for things that
+#         # contain escape sequences (arrow keys, etc)
+#         my $esc_buf_timeout = $settings->{esc_buf_timeout}->{value};
+
+#         $escape_buf_timer =
+#           Irssi::timeout_add_once($esc_buf_timeout,
+#                                   \&escape_buffer_timeout, undef);
+
+#         _debug("Buffer Timer tag: $escape_buf_timer");
+
+#     } elsif ($escape_buf_enabled) {
+#         attempt_escape_buffer_parse($key, $char);
+#         # we can check at this point if we recognise the sequence, and cancel
+#         # the timeout if we do.
+#     }
+# }
+
+
+sub process_keys_timeout 
+{
+    my ($timeout_mode, $timeout_len, $ttimeout_len) = @_;
+
+    if ($timeout_mode eq TIMEOUT_MODE_NONE) {
+
+        _try_process_keycode();
+        _try_process_mapping();
+
+    } elsif ($timeout_mode eq TIMEOUT_MODE_BOTH) {
+
+        my ($keycode_delay, $mapping_delay);
+
+        if ($ttimeout_len == 0) {
+            return if $keycode_timeouts_active;
+            _try_process_keycode();
+
+        } elsif ($ttimeout_len > 0 and $ttimeout_len < 10) {
+            $mapping_delay = 10; # minimum irssi timeout.
+        } else {
+
+            $timeout_len   = $timeout_len < 10 ? 10 : $timeout_len;
+            $mapping_delay = $keycode_delay = $timeout_len;
+        }
+
+        if (not $mapping_timeouts_active) {
+
+            _debug("Setting mapping delay to %d", $mapping_delay);
+            $escape_buf_ttimeout
+              = Irssi::timeout_add_once($mapping_delay,
+                                        \&_try_process_mapping, 1);
+              $mapping_timeouts_active = 1;
+
+        } else {
+            _debug ("Not adding new mapping timeout");
+        }
+
+        if (not $keycode_timeouts_active) {
+
+            _debug("Setting keycode delay to %d", $keycode_delay);
+            $escape_buf_timeout
+              = Irssi::timeout_add_once($keycode_delay,
+                                        \&_try_process_keycode, 1);
+            $keycode_timeouts_active = 1;
+
+        } else {
+            _debug ("Not adding new keycode timeout");
+        }
+
+    } elsif ($timeout_mode eq TIMEOUT_MODE_CODE) {
+
+        $keycode_timeouts_active = 1;
+
+        _try_process_mapping();
+        $escape_buf_timeout
+          = Irssi::timeout_add_once($timeout_len,
+                                    \&_try_process_keycode, 1);
     }
 }
 
-sub escape_buffer_timeout {
+sub _try_process_mapping {
+    my ($from_timer) = @_;
 
-    $escape_buf_timer = undef;
-    $escape_buf_enabled = 0;
+    my @buf = _get_mode_buffer();
+    _debug("process mapping: '%s'", _buf_to_str(@buf));
 
-    _debug("Escape buffer contains: ", join(", ", @escape_buf));
+    $mapping_timeouts_active = 0 if $from_timer;
+}
 
-    if (@escape_buf == 1 && $escape_buf[0] == KEY_ESC) {
+sub _try_process_keycode {
+    my ($from_timer) = @_;
 
-        _debug("escape only, Enter Command Mode");
+    my @buf = _get_mode_buffer();
+    _debug("keycode mapping: '%s'", _buf_to_str(@buf));
+    if (@buf == 1 and $buf[0] == KEY_ESC) {
+        _debug ("Buf contains ESC!");
         _update_mode(M_CMD);
+    } elsif (@buf == 1 and $buf[0] == ord('i')) {
+        _debug ("Buf contains i!");
+        _update_mode(M_INS);
+    } else {
+        _debug("buf contains: '%s'", _buf_to_hex_str(@buf));
+    }
+
+    _reset_mode_buffer($_) for (M_CMD, M_INS, M_EX);
+    $keycode_timeouts_active = 0 if $from_timer;
+}
 
+
+################################################################
+#                    INPUT BUFFER MODEL                        #
+################################################################
+
+sub _append_to_mode_buffer {
+    my ($keycode) = @_;
+    my $char = chr $keycode;
+    if ($mode == M_CMD) {
+        _debug("Appending %s to CMD buf",  $char);
+        push @cmd_mode_buf, $keycode;
+    } elsif ($mode == M_EX) {
+        _debug("Appending %s to EX buf",  $char);
+
+        push @ex_mode_buf, $keycode;
     } else {
-        # we have more than a single esc, implying an escape sequence
-        # (meta-* or esc-*)
-
-        # currently, we only extract escape sequences if:
-        # a) we're in ex mode
-        # b) they're arrow keys (for history control)
-
-        if ($mode == M_EX) {
-            # ex mode
-            my $key_str = join '', map { chr } @escape_buf;
-            if ($key_str =~ m/^\e\[([ABCD])/) {
-                my $arrow = $1;
-                _debug( "Arrow key: $arrow");
-                if ($arrow eq 'A') { # up
-                    ex_history_back();
-                } elsif ($arrow eq 'B') { # down
-                    ex_history_fwd();
-                } else {
-                    $arrow =~ s/C/right/;
-                    $arrow =~ s/D/left/;
-                    _debug("Arrow key $arrow not supported");
-                }
-            }
-        } else {
-            # otherwise, we just forward them to irssi.
-            _emulate_keystrokes(@escape_buf);
-        }
+        _debug("Appending %s to INS buf",  $char);
 
-        # Clear insert buffer, pressing "special" keys (like arrow keys)
-        # resets it.
-        @escape_buf = ();
+        push @insert_mode_buf, $keycode;
     }
+}
 
-    @escape_buf = ();
-    $escape_buf_enabled = 0;
+sub _get_mode_buffer {
+    if ($mode == M_CMD) {
+        return @cmd_mode_buf;
+    } elsif ($mode == M_EX) {
+        return @ex_mode_buf;
+    } else {
+        return @insert_mode_buf;
+    }
 }
 
+sub _reset_mode_buffer {
+    my ($override_mode) = @_;
+
+    if (not defined $override_mode) {
+        $override_mode = $mode;
+    }
+
+    if ($override_mode == M_CMD) {
+        _debug("Resetting CMD buffer");
+        @cmd_mode_buf = ();
+    } elsif ($override_mode == M_EX) {
+        _debug("Resetting EX buffer");
+        @ex_mode_buf = ();
+    } elsif ($override_mode == M_INS) {
+        _debug("Resetting INS buffer");
+        @insert_mode_buf = ();
+    } else {
+        _warn("Reset mode buffer: Unknown mode: $override_mode");
+    }
+}
 
+sub _buf_to_str {
+    return join '', map { chr } @_;
+}
 
+sub _buf_to_hex_str {
+    my @list;
+    foreach my $key (@_) {
+        push @list, sprintf('0x%02x', $key);
+    }
+    return '[' . join(' ', @list) . ']';
+}
+
+# sub attempt_escape_buffer_parse {
+#     my ($key, $char) = @_;
+
+#     if ($char eq '[') {
+#         _debug("Spotted CSI");
+#     } elsif ($char eq ']') {
+#         _debug ("Spotted OSC");
+#     } else {
+#         push @escape_buf, $key;
+#     }
+# }
+
+# sub escape_buffer_timeout {
+
+#     $escape_buf_timer = undef;
+#     $escape_buf_enabled = 0;
+
+#     _debug("Escape buffer contains: ", join(", ", @escape_buf));
+
+#     if (@escape_buf == 1 && $escape_buf[0] == KEY_ESC) {
+
+#         _debug("escape only, Enter Command Mode");
+#         _update_mode(M_CMD);
+
+#     } else {
+#         # we have more than a single esc, implying an escape sequence
+#         # (meta-* or esc-*)
+
+#         # currently, we only extract escape sequences if:
+#         # a) we're in ex mode
+#         # b) they're arrow keys (for history control)
+
+#         if ($mode == M_EX) {
+#             # ex mode
+#             my $key_str = join '', map { chr } @escape_buf;
+#             if ($key_str =~ m/^\e\[([ABCD])/) {
+#                 my $arrow = $1;
+#                 _debug( "Arrow key: $arrow");
+#                 if ($arrow eq 'A') { # up
+#                     ex_history_back();
+#                 } elsif ($arrow eq 'B') { # down
+#                     ex_history_fwd();
+#                 } else {
+#                     $arrow =~ s/C/right/;
+#                     $arrow =~ s/D/left/;
+#                     _debug("Arrow key $arrow not supported");
+#                 }
+#             }
+#         } else {
+#             # otherwise, we just forward them to irssi.
+#             _emulate_keystrokes(@escape_buf);
+#         }
+
+#         # Clear insert buffer, pressing "special" keys (like arrow keys)
+#         # resets it.
+#         @escape_buf = ();
+#     }
+
+#     @escape_buf = ();
+#     $escape_buf_enabled = 0;
+# }
 
 
 # work slowly incorporating stuff back in.
@@ -3627,35 +3821,35 @@ sub escape_buffer_timeout {
 # TODO: merge this with 'flush_input_buffer' below.
 
 
-sub flush_input_buffer {
-    Irssi::timeout_remove($escape_buf_timer) if defined $escape_buf_timer;
-    $escape_buf_timer = undef;
-    # see what we've collected.
-    _debug("Escape buffer flushed");
+# sub flush_input_buffer {
+#     Irssi::timeout_remove($escape_buf_timer) if defined $escape_buf_timer;
+#     $escape_buf_timer = undef;
+#     # see what we've collected.
+#     _debug("Escape buffer flushed");
 
-    # Add the characters to @escape_buf so they can be repeated.
-    push @escape_buf, map chr, @escape_buf;
+#     # Add the characters to @escape_buf so they can be repeated.
+#     push @escape_buf, map chr, @escape_buf;
 
-    _emulate_keystrokes(@escape_buf);
+#     _emulate_keystrokes(@escape_buf);
 
-    @escape_buf = ();
-    $escape_buf_enabled = 0;
+#     @escape_buf = ();
+#     $escape_buf_enabled = 0;
 
-    $imap = undef;
-}
+#     $imap = undef;
+# }
 
-sub flush_pending_map {
-    my ($old_pending_map) = @_;
+# sub flush_pending_map {
+#     my ($old_pending_map) = @_;
 
-    print "flush_pending_map(): ", $pending_map, ' ', $old_pending_map
-        if DEBUG;
+#     print "flush_pending_map(): ", $pending_map, ' ', $old_pending_map
+#         if DEBUG;
 
-    return if not defined $pending_map or
-              $pending_map ne $old_pending_map;
+#     return if not defined $pending_map or
+#               $pending_map ne $old_pending_map;
 
-    handle_command_cmd(undef);
-    Irssi::statusbar_items_redraw("vim_mode");
-}
+#     handle_command_cmd(undef);
+#     Irssi::statusbar_items_redraw("vim_mode");
+# }
 
 
 
@@ -3683,7 +3877,7 @@ sub handle_command_cmd {
     my $char;
     if (defined $key) {
         $char = chr($key);
-    # We were called from flush_pending_map().
+        # We were called from flush_pending_map().
     } else {
         $char = $pending_map;
         $key = 0;
@@ -3695,7 +3889,7 @@ sub handle_command_cmd {
         ($char =~ m/[1-9]/ or ($numeric_prefix && $char =~ m/[0-9]/))) {
         print "Processing numeric prefix: $char" if DEBUG;
         handle_numeric_prefix($char);
-        return 1; # call _stop()
+        return 1;               # call _stop()
     }
 
     if (defined $pending_map and not $pending_map_flushed) {
@@ -3723,16 +3917,16 @@ sub handle_command_cmd {
             # after a timeout.
             if (defined $map->{cmd}) {
                 Irssi::timeout_add_once(1000, \&flush_pending_map,
-                                              $pending_map);
+                                        $pending_map);
             }
-            return 1; # call _stop()
+            return 1;           # call _stop()
         }
 
     } else {
         print "No mapping found for $char" if DEBUG;
         $pending_map = undef;
         $numeric_prefix = undef;
-        return 1; # call _stop()
+        return 1;               # call _stop()
     }
 
     $pending_map = undef;
@@ -3742,7 +3936,7 @@ sub handle_command_cmd {
     # Make sure we have a valid $cmd.
     if (not defined $cmd) {
         print "Bug in pending_map_flushed() $map->{char}" if DEBUG;
-        return 1; # call _stop()
+        return 1;               # call _stop()
     }
 
     # Ex-mode commands can also be bound in command mode.
@@ -3752,21 +3946,21 @@ sub handle_command_cmd {
         $cmd->{func}->(substr($cmd->{char}, 1), $numeric_prefix);
         $numeric_prefix = undef;
 
-        return 1; # call _stop()
-    # As can irssi commands.
+        return 1;               # call _stop()
+        # As can irssi commands.
     } elsif ($cmd->{type} == C_IRSSI) {
         print "Processing irssi-command: $map->{char} ($cmd->{char})" if DEBUG;
 
         _command_with_context($cmd->{func});
 
         $numeric_prefix = undef;
-        return 1; # call _stop();
-    # <Nop> does nothing.
+        return 1;               # call _stop();
+        # <Nop> does nothing.
     } elsif ($cmd->{type} == C_NOP) {
         print "Processing <Nop>: $map->{char}" if DEBUG;
 
         $numeric_prefix = undef;
-        return 1; # call _stop();
+        return 1;               # call _stop();
     }
 
     # text-objects (i a) are simulated with $movement
@@ -3790,14 +3984,14 @@ sub handle_command_cmd {
                 print "Processing line operator: ",
                   $map->{char}, " (",
                   $cmd->{char} ,")"
-                    if DEBUG;
+                  if DEBUG;
 
                 my $pos = _input_pos();
                 $cmd->{func}->(0, _input_len(), undef, 0);
                 # Restore position for yy.
                 if ($cmd == $commands->{y}) {
                     _input_pos($pos);
-                # And save undo for other operators.
+                    # And save undo for other operators.
                 } else {
                     _add_undo_entry(_input(), _input_pos());
                 }
@@ -3809,26 +4003,26 @@ sub handle_command_cmd {
             $numeric_prefix = undef;
             $operator = undef;
             $movement = undef;
-        # Set new operator.
+            # Set new operator.
         } else {
             $operator = $cmd;
         }
 
-    # Start Ex mode.
+        # Start Ex mode.
     } elsif ($cmd == $commands->{':'}) {
 
         if (not script_is_loaded('uberprompt')) {
             _warn("Warning: Ex mode requires the 'uberprompt' script. " .
-                    "Please load it and try again.");
+                  "Please load it and try again.");
         } else {
             _update_mode(M_EX);
             _set_prompt(':');
         }
 
-    # Enter key sends the current input line in command mode as well.
+        # Enter key sends the current input line in command mode as well.
     } elsif ($key == 10) {
         _commit_line();
-        return 0; # don't call _stop()
+        return 0;               # don't call _stop()
 
     } else {
         print "Processing command: $map->{char} ($cmd->{char})" if DEBUG;
@@ -3858,7 +4052,7 @@ sub handle_command_cmd {
         # Ignore invalid operator/command combinations.
         if ($operator and $cmd->{no_operator}) {
             print "Invalid operator/command: $operator->{char} $cmd->{char}"
-                if DEBUG;
+              if DEBUG;
             $skip = 1;
         }
 
@@ -3880,11 +4074,11 @@ sub handle_command_cmd {
             # Execute the movement (multiple times).
             if (not $movement) {
                 ($old_pos, $new_pos)
-                    = $cmd->{func}->($numeric_prefix, $cur_pos, $repeat);
+                  = $cmd->{func}->($numeric_prefix, $cur_pos, $repeat);
             } else {
                 ($old_pos, $new_pos)
-                    = $cmd->{func}->($numeric_prefix, $cur_pos, $repeat,
-                                     $char);
+                  = $cmd->{func}->($numeric_prefix, $cur_pos, $repeat,
+                                   $char);
             }
             if (defined $old_pos) {
                 print "Changing \$cur_pos from $cur_pos to $old_pos" if DEBUG;
@@ -3902,7 +4096,7 @@ sub handle_command_cmd {
                 ((defined $operator and $operator == $commands->{d}) or
                  $cmd->{repeatable})) {
                 print "Updating history position: $undo_buffer[0]->[0]"
-                    if DEBUG;
+                  if DEBUG;
                 $undo_buffer[0]->[1] = $cur_pos;
             }
 
@@ -3951,7 +4145,7 @@ sub handle_command_cmd {
 
     }
 
-    return 1; # call _stop()
+    return 1;                   # call _stop()
 }
 
 sub handle_command_ex {
@@ -3963,18 +4157,18 @@ sub handle_command_ex {
         if (@ex_mode_buf > 0) {
             pop @ex_mode_buf;
             _set_prompt(':' . join '', @ex_mode_buf);
-        # Backspacing over : exits ex-mode.
+            # Backspacing over : exits ex-mode.
         } else {
             _update_mode(M_CMD);
         }
 
-    # Return key - execute command
+        # Return key - execute command
     } elsif ($key == 10) {
         print "Run ex-mode command" if DEBUG;
         cmd_ex_command();
         _update_mode(M_CMD);
 
-    } elsif ($key == 9) { # TAB
+    } elsif ($key == 9) {       # TAB
         print "Tab pressed" if DEBUG;
         print "Ex buf contains: " . join('', @ex_mode_buf) if DEBUG;
         @tab_candidates = _tab_complete(join('', @ex_mode_buf), [keys %$commands_ex]);
@@ -3983,11 +4177,11 @@ sub handle_command_ex {
             @ex_mode_buf = ( split('', $tab_candidates[0]), ' ');
             _set_prompt(':' . join '', @ex_mode_buf);
         }
-    # Ignore control characters for now.
+        # Ignore control characters for now.
     } elsif ($key > 0 && $key < 32) {
         # TODO: use them later, e.g. completion
 
-    # Append entered key
+        # Append entered key
     } else {
         if ($key != -1) {
             # check we're not called from an ex_history_* function