vimamsa 0.1.12 → 0.1.14

data/lib/vimamsa/gui_sourceview.rb

@@ -34,6 +34,7 @@ class VSourceView < GtkSource::View
     # puts "drag-data-received"
     # puts
     # if data.uris.size >= 1
+
     # imgpath = CGI.unescape(data.uris[0])
     # m = imgpath.match(/^file:\/\/(.*)/)
     # if m
@@ -46,8 +47,14 @@ class VSourceView < GtkSource::View
 
     # Mainly after page-up or page-down
     signal_connect("move-cursor") do |widget, event|
-      debug("MOVE-CURSOR", 2)
-      $update_cursor = true
+      if event.name == "GTK_MOVEMENT_PAGES" and (last_action == "page_up" or last_action == "page_down")
+        # Ripl.start :binding => binding
+
+        debug("MOVE-CURSOR", 2)
+        # $update_cursor = true
+        handle_scrolling()
+      end
+
       # handle_scrolling()
       # curpos = buffer.cursor_position
       # debug "MOVE CURSOR (sig): #{curpos}"
@@ -110,47 +117,116 @@ class VSourceView < GtkSource::View
   end
 
   def register_signals()
+    check_controllers
 
-    #TODO: Doesn't seem to catch "move-cursor" signal since upgrade to gtk4
-    # self.signal_connect("move-cursor") do |widget, event|
-    # $update_cursor = true
-    # false
-    # end
+    # Implement mouse selections using @cnt_mo and @cnt_drag
+    @cnt_mo = Gtk::EventControllerMotion.new
+    self.add_controller(@cnt_mo)
+    @cnt_mo.signal_connect "motion" do |gesture, x, y|
+      if !@range_start.nil? and !x.nil? and !y.nil? and buf.visual_mode?
+        i = coord_to_iter(x, y, true)
+        @bufo.set_pos(i) if !i.nil? and @last_iter != i
+        @last_iter = i
+      end
+    end
+
+    @last_coord = nil
+    @cnt_drag = Gtk::GestureDrag.new
+    self.add_controller(@cnt_drag)
+    @cnt_drag.signal_connect "drag-begin" do |gesture, x, y|
+      debug "drag-begin", 2
+      i = coord_to_iter(x, y, true)
+      pp i
+      @range_start = i
+      if !buf.visual_mode?
+        buf.start_visual_mode
+      end
+    end
+
+    @cnt_drag.signal_connect "drag-end" do |gesture, offsetx, offsety|
+      debug "drag-end", 2
+
+      # Not enough drag
+      if offsetx.abs < 5 and offsety.abs < 5
+        buf.end_visual_mode
+      end
+      @range_start = nil
+    end
 
-    check_controllers
     click = Gtk::GestureClick.new
     click.set_propagation_phase(Gtk::PropagationPhase::CAPTURE)
     self.add_controller(click)
     # Detect mouse click
     @click = click
+
+    @range_start = nil
     click.signal_connect "pressed" do |gesture, n_press, x, y, z|
-      debug "SourceView, GestureClick x=#{x} y=#{y}"
-      pp visible_rect
-      winw = width
-      view_width = visible_rect.width
-      gutter_width = winw - view_width
+      debug "SourceView, GestureClick released x=#{x} y=#{y}"
+
+      if buf.visual_mode?
+        buf.end_visual_mode
+      end
 
       xloc = (x - gutter_width).to_i
       yloc = (y + visible_rect.y).to_i
       debug "xloc=#{xloc} yloc=#{yloc}"
 
+      i = coord_to_iter(xloc, yloc)
+      # @range_start = i
+
       # This needs to happen after xloc calculation, otherwise xloc gets a wrong value (around 200 bigger)
       if vma.gui.current_view != self
         vma.gui.set_current_view(self)
       end
 
-      i = get_iter_at_location(xloc, yloc)
-      if !i.nil?
-        @bufo.set_pos(i.offset)
-      else
-        debug "iter nil"
-        #TODO: find correct line position some other way
+      @bufo.set_pos(i) if !i.nil?
+      true
+    end
+
+    click.signal_connect "released" do |gesture, n_press, x, y, z|
+      debug "SourceView, GestureClick released x=#{x} y=#{y}"
+
+      xloc = (x - gutter_width).to_i
+      yloc = (y + visible_rect.y).to_i
+      debug "xloc=#{xloc} yloc=#{yloc}"
+
+      # This needs to happen after xloc calculation, otherwise xloc gets a wrong value (around 200 bigger)
+      if vma.gui.current_view != self
+        vma.gui.set_current_view(self)
       end
 
+      i = coord_to_iter(xloc, yloc)
+
+      # if i != @range_start
+      # debug "RANGE #{[@range_start, i]}", 2
+      # end
+
+      @bufo.set_pos(i) if !i.nil?
+      # @range_start = nil
       true
     end
   end
 
+  def coord_to_iter(xloc, yloc, transform_coord = false)
+    if transform_coord
+      xloc = (xloc - gutter_width).to_i
+      yloc = (yloc + visible_rect.y).to_i
+    end
+
+    # Try to get exact character position
+    i = get_iter_at_location(xloc, yloc)
+
+    # If doesn't work, at least get the start of correct line
+    # TODO: sometimes end of line is better choice
+    if i.nil?
+      r = get_line_at_y(yloc)
+      i = r[0] if !r.nil?
+    end
+
+    return i.offset if !i.nil?
+    return nil
+  end
+
   def handle_scrolling()
     delete_cursorchar
     # curpos = buffer.cursor_position
@@ -158,18 +234,13 @@ class VSourceView < GtkSource::View
     return nil if vma.gui.nil?
     return nil if @bufo.nil?
     vma.gui.run_after_scrolling proc {
+      debug "START UPDATE POS AFTER SCROLLING", 2
       delete_cursorchar
       bc = window_to_buffer_coords(Gtk::TextWindowType::WIDGET, gutter_width + 2, 60)
       if !bc.nil?
-        # Try to get exact character position
-        i = get_iter_at_location(bc[0], bc[1])
-        if i.nil?
-          # If doesn't work, at least get the start of correct line
-          i = get_line_at_y(bc[1])
-          i = i[0]
-        end
+        i = coord_to_iter(bc[0], bc[1])
         if !i.nil?
-          @bufo.set_pos(i.offset)
+          @bufo.set_pos(i)
         end
       end
       $update_cursor = false
@@ -220,6 +291,7 @@ class VSourceView < GtkSource::View
     keyval_trans[Gdk::Keyval::KEY_Shift_L] = "shift"
     keyval_trans[Gdk::Keyval::KEY_Shift_R] = "shift"
     keyval_trans[Gdk::Keyval::KEY_Tab] = "tab"
+    keyval_trans[Gdk::Keyval::GDK_KEY_ISO_Left_Tab] = "tab"
 
     key_trans = {}
     key_trans["\e"] = "esc"
@@ -240,10 +312,12 @@ class VSourceView < GtkSource::View
       key_str_parts.delete_at(0)
     end
 
-    if key_str_parts[0] == "shift" and key_str_parts[1].class == String
-      #"shift-P" to just "P"
-      # key_str_parts.delete_at(0) if key_str_parts[1].match(/^[[:upper:]]$/)
-      key_str_parts.delete_at(0)
+    if key_str_parts[0] == "shift" and key_str_parts.size == 2
+      if key_str_parts[1].size == 1 # and key_str_parts[1].match(/^[[:upper:]]$/)
+        #"shift-P" to just "P" etc.
+        # but keep shift-tab as is
+        key_str_parts.delete_at(0)
+      end
     end
 
     key_str = key_str_parts.join("-")
@@ -342,8 +416,6 @@ class VSourceView < GtkSource::View
     itr2 = buffer.get_iter_at(:offset => pos + 1)
     buffer.place_cursor(itr)
 
-    # $view.signal_emit("extend-selection", Gtk::MovementStep.new(:PAGES), -1, false)
-
     within_margin = 0.075 #margin as a [0.0,0.5) fraction of screen size
     use_align = false
     xalign = 0.5 #0.0=top 1.0=bottom, 0.5=center
@@ -358,22 +430,15 @@ class VSourceView < GtkSource::View
     $idle_scroll_to_mark = true
     ensure_cursor_visible
 
-    # scroll_to_iter(itr, within_margin, use_align, xalign, yalign)
-
-    # $view.signal_emit("extend-selection", Gtk::TextExtendSelection.new, itr,itr,itr2)
     draw_cursor
 
     return true
   end
 
   def cursor_visible_idle_func
+    return false
     debug "cursor_visible_idle_func"
     # From https://picheta.me/articles/2013/08/gtk-plus--a-method-to-guarantee-scrolling.html
-    # vr = visible_rect
-
-    # b = $view.buffer
-    # iter = buffer.get_iter_at(:offset => buffer.cursor_position)
-    # iterxy = get_iter_location(iter)
 
     # This is not the current buffer
     return false if vma.gui.view != self
@@ -417,16 +482,13 @@ class VSourceView < GtkSource::View
   end
 
   def ensure_cursor_visible
-    return #TODO:gtk4
+    # return
     debug "@idle_func_running=#{@idle_func_running}"
     return if @idle_func_running
     if is_cursor_visible == false
       @idle_func_running = true
       debug "Starting idle func"
-      Thread.new {
-        sleep 0.01
-        GLib::Idle.add(proc { cursor_visible_idle_func })
-      }
+      GLib::Idle.add(proc { cursor_visible_idle_func })
     end
   end
 
@@ -477,9 +539,9 @@ class VSourceView < GtkSource::View
       end
       # elsif @bufo.visual_mode?
     elsif ctype == :visual
-      debug "VISUAL MODE"
+      # debug "VISUAL MODE"
       (_start, _end) = @bufo.get_visual_mode_range2
-      debug "#{_start}, #{_end}"
+      # debug "#{_start}, #{_end}"
       itr = buffer.get_iter_at(:offset => _start)
       itr2 = buffer.get_iter_at(:offset => _end + 1)
       # Pango-CRITICAL **: pango_layout_get_cursor_pos: assertion 'index >= 0 && index <= layout->length' failed

data/lib/vimamsa/gui_text.rb

@@ -0,0 +1,19 @@
+module Gui
+  def self.highlight_match(bf, str, color: "#aa0000ff")
+    vbuf = bf.view.buffer
+    r = Regexp.new(Regexp.escape(str), Regexp::IGNORECASE)
+
+    hlparts = []
+
+    tt = vma.gui.view.buffer.create_tag("highlight_match_tag")
+    tt.weight = 650
+    tt.foreground = color
+
+    ind = scan_indexes(bf, r)
+    ind.each { |x|
+      itr = vbuf.get_iter_at(:offset => x)
+      itr2 = vbuf.get_iter_at(:offset => x + str.size)
+      vbuf.apply_tag(tt, itr, itr2)
+    }
+  end
+end

data/lib/vimamsa/hyper_plain_text.rb

@@ -1,8 +1,8 @@
 def hpt_check_cur_word(w)
   debug "check_cur_word(w)"
-  m = w.match(/⟦(.*)⟧/)
+  m = w.match(/⟦((audio|img):)?(.*)⟧/)
   if m
-    fpfx = m[1]
+    fpfx = m[3]
     if vma.buf.fname
       dn = File.dirname(vma.buf.fname)
 
@@ -15,16 +15,26 @@ def hpt_check_cur_word(w)
       fcands << File.expand_path("#{fpfx}.txt")
 
       fn = nil
+
       for fc in fcands
-        if File.exists?(fc)
+        if File.exist?(fc)
           fn = fc
           break
         end
       end
 
       if fn
-        message "HPT opening file #{fn}"
-        return fn
+        if m[2] == "audio"
+          # Thread.new { Audio.play(fn) }
+          Audio.play(fn)
+        else
+          if !file_is_text_file(fn)
+            message "Not text file #{fn}"
+            return nil
+          end
+          message "HPT opening file #{fn}"
+          return fn
+        end
         # open_existing_file(fn)
         # return true
       else

data/lib/vimamsa/key_actions.rb

@@ -31,10 +31,15 @@ end
 reg_act(:lsp_debug, proc { vma.buf.lsp_get_def }, "LSP get definition")
 reg_act(:lsp_jump_to_definition, proc { vma.buf.lsp_jump_to_def }, "LSP jump to definition")
 
-reg_act(:enable_debug, proc { $debug = true }, "Enable debug")
-reg_act(:disable_debug, proc { $debug = false }, "Disable debug")
+reg_act(:enable_debug, proc { cnf.debug = true }, "Enable debug")
+reg_act(:disable_debug, proc { cnf.debug = false }, "Disable debug")
 
 reg_act(:easy_jump, proc { EasyJump.start }, "Easy jump")
+reg_act(:gui_ensure_cursor_visible, proc { vma.gui.view.ensure_cursor_visible }, "Scroll to current cursor position")
+reg_act(:gui_refresh_cursor, proc { vma.buf.refresh_cursor }, "Refresh cursor")
+
+
+
 reg_act(:savedebug, "savedebug", "Save debug info", { :group => :debug })
 reg_act(:open_file_dialog, "open_file_dialog", "Open file", { :group => :file })
 reg_act(:create_new_file, "create_new_file", "Create new file", { :group => :file })
@@ -44,7 +49,7 @@ reg_act(:e_move_backward_char, "e_move_backward_char", "", { :group => [:move, :
 reg_act(:history_switch_backwards, "history_switch_backwards", "", { :group => :file })
 reg_act(:history_switch_forwards, "history_switch_forwards", "", { :group => :file })
 reg_act(:center_on_current_line, "center_on_current_line", "", { :group => :view })
-reg_act(:run_last_macro, proc { $macro.run_last_macro }, "Run last recorded or executed macro", { :group => :macro })
+reg_act(:run_last_macro, proc { vma.macro.run_last_macro }, "Run last recorded or executed macro", { :group => :macro })
 reg_act(:jump_to_next_edit, "jump_to_next_edit", "")
 reg_act(:jump_to_last_edit, proc { buf.jump_to_last_edit }, "")
 reg_act(:jump_to_random, proc { buf.jump_to_random_pos }, "")
@@ -91,7 +96,9 @@ reg_act :delete_to_next_word_start, proc { buf.delete2(:to_next_word) }, "Delete
 reg_act :delete_to_line_start, proc { buf.delete2(:to_line_start) }, "Delete to line start", { :group => [:edit, :basic] }
 reg_act :start_browse_mode, proc { $kbd.set_mode(:browse); $kbd.set_default_mode(:browse) }, "Start browse mode"
 reg_act :exit_browse_mode, proc {
-  bufs.add_current_buf_to_history(); $kbd.set_mode(:command); $kbd.set_default_mode(:command)
+  bufs.add_current_buf_to_history; 
+  vma.kbd.set_mode_stack([vma.buf.default_mode])
+  vma.kbd.set_mode_to_default
 }, "Exit browse mode"
 
 reg_act :page_down, proc { page_down }, "Page down", :group => [:move, :basic]
@@ -104,6 +111,8 @@ reg_act(:execute_current_line_in_terminal_autoclose, proc { buf.execute_current_
 reg_act(:show_images, proc { hpt_scan_images() }, "Show images inserted with ⟦img:file.png⟧ syntax")
 reg_act(:delete_current_file, proc { bufs.delete_current_buffer() }, "Delete current file")
 
+reg_act(:audio_stop, proc { Audio.stop }, "Stop audio playback")
+
 act_list = {
   # File handling
   :buf_save => { :proc => proc { buf.save },
@@ -164,199 +173,14 @@ act_list = {
   :quit => { :proc => proc { _quit },
              :desc => "Quit", :group => :app },
 
+  :run_tests => { :proc => proc { run_tests },
+                  :desc => "Run tests" },
+
+  :debug_buf_hex => { :proc => proc { puts "SHA256: " + (Digest::SHA2.hexdigest vma.buf.to_s) },
+                      :desc => "Output SHA256 hex digest of curent buffer" },
+
 }
 
 for k, v in act_list
   reg_act(k, v[:proc], v[:desc])
 end
-
-act_list_todo = {
-
-  # Buffer handling
-  # : =>  {proc => proc {bufs.switch}, :desc => "", :group => :},
-  :buf_switch_to_last => { :proc => proc { bufs.switch_to_last_buf },
-                           :desc => "", :group => :file },
-  #    'C , s'=> 'gui_select_buffer',
-  :buf_revert => { :proc => proc { buf.revert },
-                   :desc => "Reload/revert file from disk", :group => :file },
-  :buf_close => { :proc => proc { bufs.close_current_buffer },
-                  :desc => "Close current file", :group => :file },
-  #"C , b" => '$kbd.set_mode("S");gui_select_buffer',
-
-  # MOVING
-  #    'VC h' => 'buf.move(BACKWARD_CHAR)',
-  :m_forward_char => { :proc => proc { buf.move(FORWARD_CHAR) },
-                       :desc => "Move cursor one char forward",
-                       :group => :move },
-  # "VC j" => "buf.move(FORWARD_LINE)",
-  # "VC k" => "buf.move(BACKWARD_LINE)",
-
-  "VC pagedown" => "page_down",
-  "VC pageup" => "page_up",
-
-  "VCI left" => "buf.move(BACKWARD_CHAR)",
-  "VCI right" => "buf.move(FORWARD_CHAR)",
-  "VCI down" => "buf.move(FORWARD_LINE)",
-  "VCI up" => "buf.move(BACKWARD_LINE)",
-
-  "VC w" => "buf.jump_word(FORWARD,WORD_START)",
-  "VC b" => "buf.jump_word(BACKWARD,WORD_START)",
-  "VC e" => "buf.jump_word(FORWARD,WORD_END)",
-  #    'C '=> 'buf.jump_word(BACKWARD,END)',#TODO
-  "VC f <char>" => "buf.jump_to_next_instance_of_char(<char>)",
-  "VC F <char>" => "buf.jump_to_next_instance_of_char(<char>,BACKWARD)",
-  "VC f space" => "buf.jump_to_next_instance_of_char(' ')",
-  "VC F space" => "buf.jump_to_next_instance_of_char(' ',BACKWARD)",
-
-  "VC /[1-9]/" => "set_next_command_count(<char>)",
-  #    'VC number=/[0-9]/+ g'=> 'jump_to_line(<number>)',
-  #    'VC X=/[0-9]/+ * Y=/[0-9]/+ '=> 'x_times_y(<X>,<Y>)',
-  "VC ^" => "buf.jump(BEGINNING_OF_LINE)",
-  "VC G($next_command_count!=nil)" => "buf.jump_to_line()",
-  "VC 0($next_command_count!=nil)" => "set_next_command_count(<char>)",
-  "VC 0($next_command_count==nil)" => "buf.jump(BEGINNING_OF_LINE)",
-  # 'C 0'=> 'buf.jump(BEGINNING_OF_LINE)',
-  "VC g g" => "buf.jump(START_OF_BUFFER)",
-  "VC g ;" => "buf.jump_to_last_edit",
-  "VC G" => "buf.jump(END_OF_BUFFER)",
-  #    'VC z z' => 'center_on_current_line',
-  "VC *" => "buf.jump_to_next_instance_of_word",
-
-  # MINIBUFFER bindings
-  "VC /" => "invoke_search",
-  # 'VC :' => 'invoke_command', #TODO
-  "C , e" => "invoke_command", # Currently eval
-  "M enter" => "minibuffer_end()",
-  # "M return" => "minibuffer_end()",
-  "M esc" => "minibuffer_cancel()",
-  "M backspace" => "minibuffer_delete()",
-  "M <char>" => "minibuffer_new_char(<char>)",
-  "M ctrl-v" => "$minibuffer.paste(BEFORE)",
-
-  # READCHAR bindings
-
-  "R <char>" => "readchar_new_char(<char>)",
-
-  "C n" => "$search.jump_to_next()",
-  "C N" => "$search.jump_to_previous()",
-
-  # Debug
-  "C , d r p" => "start_ripl",
-  "C , D" => "debug_print_buffer",
-  "C , c s" => "bufs.close_scrap_buffers",
-  "C , d b" => "debug_print_buffer",
-  "C , d c" => "debug_dump_clipboard",
-  "C , d d" => "debug_dump_deltas",
-  "VC O" => "buf.jump(END_OF_LINE)",
-  "VC $" => "buf.jump(END_OF_LINE)",
-
-  "C o" => 'buf.jump(END_OF_LINE);buf.insert_txt("\n");$kbd.set_mode(:insert)',
-  "C X" => 'buf.jump(END_OF_LINE);buf.insert_txt("\n");',
-  "C A" => "buf.jump(END_OF_LINE);$kbd.set_mode(:insert)",
-  "C I" => "buf.jump(FIRST_NON_WHITESPACE);$kbd.set_mode(:insert)",
-  "C a" => "buf.move(FORWARD_CHAR);$kbd.set_mode(:insert)",
-  "C J" => "buf.join_lines()",
-  "C u" => "buf.undo()",
-
-  "C ^" => "buf.jump(BEGINNING_OF_LINE)",
-  "C /[1-9]/" => "set_next_command_count(<char>)",
-
-  # Command mode only:
-  "C R" => "buf.redo()",
-  "C v" => "buf.start_visual_mode",
-  "C P" => "buf.paste(BEFORE)", # TODO: implement as replace for visual mode
-  "C space <char>" => "buf.insert_txt(<char>)",
-  "C space space" => "buf.insert_txt(' ')",
-  "C y y" => "buf.copy_line",
-  "C y O" => "buf.copy(:to_line_end)",
-  "C y 0" => "buf.copy(:to_line_start)",
-  "C y e" => "buf.copy(:to_word_end)", # TODO
-  #### Deleting
-  "C x" => "buf.delete(CURRENT_CHAR_FORWARD)",
-  # 'C d k'=> 'delete_line(BACKWARD)', #TODO
-  # 'C d j'=> 'delete_line(FORWARD)', #TODO
-  # 'C d d'=> 'buf.delete_cur_line',
-  "C d e" => "buf.delete2(:to_word_end)",
-  "C d O" => "buf.delete2(:to_line_end)",
-  "C d $" => "buf.delete2(:to_line_end)",
-  #    'C d e'=> 'buf.delete_to_next_word_end',
-  "C d <num> e" => "delete_next_word",
-  "C r <char>" => "buf.replace_with_char(<char>)", # TODO
-  "C , l b" => "load_buffer_list",
-  "C , l l" => "save_buffer_list",
-  "C , r <char>" => "set_register(<char>)", # TODO
-  "C , p <char>" => "buf.paste(BEFORE,<char>)", # TODO
-
-  "C ctrl-c" => "buf.comment_line()",
-  "C ctrl-x" => "buf.comment_line(:uncomment)",
-
-  # 'C 0($next_command_count==nil)'=> 'jump_to_beginning_of_line',
-
-  # Visual mode only:
-  "V esc" => "buf.end_visual_mode",
-  "V ctrl!" => "buf.end_visual_mode",
-  "V y" => "buf.copy_active_selection(:foo)",
-  "V g U" => "buf.transform_selection(:upcase)",
-  "V g u" => "buf.transform_selection(:downcase)",
-  "V g c" => "buf.transform_selection(:capitalize)",
-  "V g s" => "buf.transform_selection(:swapcase)",
-  "V g r" => "buf.transform_selection(:reverse)",
-
-  "V x" => "buf.delete(SELECTION)",
-  # "V ctrl-c" => "buf.comment_selection",
-  "V ctrl-x" => "buf.comment_selection(:uncomment)",
-
-  "CI ctrl-v" => "buf.paste(BEFORE)",
-  "CI backspace" => "buf.delete(BACKWARD_CHAR)",
-
-  # Marks
-  "CV m <char>" => "buf.mark_current_position(<char>)",
-  'CV \' <char>' => "buf.jump_to_mark(<char>)",
-  # "CV ''" =>'jump_to_mark(NEXT_MARK)', #TODO
-
-  "C i" => "$kbd.set_mode(:insert)",
-  "C ctrl!" => "$kbd.set_mode(:insert)",
-
-  # Macros
-  # (experimental, may not work correctly)
-  # "C q a" => '$macro.start_recording("a")',
-  "VC q <char>" => "$macro.start_recording(<char>)",
-  "VC q($macro.is_recording==true) " => "$macro.end_recording", # TODO
-  # 'C q'=> '$macro.end_recording', #TODO
-  "C q v" => "$macro.end_recording",
-  # 'C v'=> '$macro.end_recording',
-  # "C M" => '$macro.run_last_macro',
-  "C @ <char>" => "$macro.run_macro(<char>)",
-  "C , m S" => '$macro.save_macro("a")',
-  "C , m s" => "$macro.save",
-  "C , t r" => "run_tests()",
-
-  "C ." => "repeat_last_action", # TODO
-  "VC ;" => "repeat_last_find",
-  "CV ctrl-q" => "_quit",
-  "CV , R" => "restart_application",
-  "I ctrl!" => "$kbd.set_mode(:command)",
-  "C shift!" => "buf.save",
-  "I <char>" => "buf.insert_txt(<char>)",
-  "I esc" => "$kbd.set_mode(:command)",
-
-  "I ctrl-d" => "buf.delete2(:to_word_end)",
-
-  # INSERT MODE: Moving
-  "I ctrl-a" => "buf.jump(BEGINNING_OF_LINE)",
-  "I ctrl-b" => "buf.move(BACKWARD_CHAR)",
-  "I ctrl-f" => "buf.move(FORWARD_CHAR)",
-  "I ctrl-n" => "buf.move(FORWARD_LINE)",
-  "I ctrl-p" => "buf.move(BACKWARD_LINE)",
-  "I ctrl-e" => "buf.jump(END_OF_LINE)", # context: mode:I, buttons down: {C}
-  "I alt-f" => "buf.jump_word(FORWARD,WORD_START)",
-  "I alt-b" => "buf.jump_word(BACKWARD,WORD_START)",
-
-  "I tab" => 'buf.insert_txt("	")',
-  "I space" => 'buf.insert_txt(" ")',
-#  "I return" => 'buf.insert_new_line()',
-}
-
-# default_keys.each { |key, value|
-# bindkey(key, value)
-# }