vimamsa 0.1.21 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b44f279b048a7cd7baba9e21e70dc9666a251f9608466f9e4bd38094c486738
-  data.tar.gz: ef57b1ad00c480d30720ec8d272df38ec289640c7951b8a04a070837e43a261a
+  metadata.gz: 3eba5b3c9a7821e14802295825b32369ff9440046b91b065ca2b1e82e44cc444
+  data.tar.gz: 16bd4a94226c3b07cb5d40cb6e395a09f8fbbb4e96e164af19b05415048a9812
 SHA512:
-  metadata.gz: 756f7c861bff64427fac5e397f8e0b4d539f46dd9d72edf39ddbc190eefff09cb86c0107ec38664ee9a1c450c2de9912f6960aee7c990c8b99c4c914cf0f5a56
-  data.tar.gz: 15a6b06c01f13435a154a2b64c544e8d5b14f253bed3e4b65e845dc510f591fcd77c1e9c278d4cf7b67699205c97952ad6ab8042fffe222260d972b88db42bee
+  metadata.gz: f74f902af54d82002d4b0d814e80cafc5326bfb712c0cd124c39be0bb2bf3f70d1eaabe6c2f05de619ee9e9ac4cf12a10a4350c568ca1b815129904b40797c48
+  data.tar.gz: a01c59f8358904e1ad511c4608de70bc31ac8bc8ccbbfa240eb897240a68f7673b7ae1bc124dcf312b94a6c7f12834d33dba692e6795713f083a5b2736ac6291

data/README.md

@@ -18,15 +18,21 @@ Vi/Vim -inspired experimental GUI-oriented text editor written with Ruby and GTK
  - Ruby 3.0+
  - GTK 4
 
+
 ## Installation
 
 
-On Ubuntu:
+On Ubuntu (22.04):
 ```
-sudo apt install ruby-dev
+sudo apt install ruby-dev build-essential
 sudo gem install vimamsa
 ```
 
+Run:
+```
+vimamsa
+```
+
 ### Other install options
 
 Install from sources:
@@ -51,7 +57,6 @@ vimamsa
 Install packages for optional features:
 ```
 sudo apt install ack-grep clang-format
-gem install ripl ripl-multi_line differ parallel listen rufo language_server-protocol
 ```
 
 For customization, edit ~/.vimamsa/custom.rb
@@ -63,7 +68,7 @@ For customization, edit ~/.vimamsa/custom.rb
 
 ## Key bindings
 
-Key bindings are very much like in VIm. For details, see file lib/vimamsa/key_bindings.rb and lib/vimamsa/key_bindings_vimlike.rb
+Key bindings are very much like in VIm. For details, see menu item "Help -> Show key bindings" and file lib/vimamsa/key_bindings_vimlike.rb
 
 Keys that work somewhat similarly as in Vim:
 
@@ -81,8 +86,9 @@ d y gU gu
 Keys that work differently to Vim are documented in the tables below
 
 Syntax:  
-ctrl! means press and immediate release of ctrl key. Triggered by key up event.  
-ctrl-x means press and hold ctrl key, press x  
+
+ - ctrl! means press and immediate release of ctrl key. Triggered by key up event when no other keys were pressed between key down and key up events.
+ - ctrl-x means press and hold ctrl key, press x  
 
 <table>
 <colgroup>

data/install.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+gem build vimamsa.gemspec 
+sudo gem uninstall vimamsa
+sudo gem install --local $(ls -1tr *gem |head -n 1)

data/lib/vimamsa/buffer_cursor.rb

@@ -141,7 +141,7 @@ class Buffer < String
   end
 
   def jump_to_next_instance_of_word()
-    if $kbd.last_action == $kbd.cur_action and @current_word != nil
+    if vma.kbd.last_action == vma.kbd.cur_action and @current_word != nil
       # debug "REPEATING *"
     else
       start_search = [@pos - 150, 0].max

data/lib/vimamsa/buffer_list.rb

@@ -180,7 +180,7 @@ class BufferList
   end
 
   def get_last_dir
-    return @last_dir
+    return File.expand_path(@last_dir)
   end
 
   def reset_navigation

data/lib/vimamsa/editor.rb

@@ -74,7 +74,7 @@ class Editor
 
     # build_key_bindings_tree
     @kbd = KeyBindingTree.new()
-    $kbd = @kbd
+    $kbd = @kbd #TODO: remove global
     require "vimamsa/key_bindings_vimlike"
 
     $buffers = BufferList.new
@@ -261,6 +261,9 @@ class Editor
     if p and !@file_content_search_paths.include?(p)
       r.insert(0, p)
     end
+    
+    # Ensure that paths are in correct format
+    r = r.map{|x|File.expand_path(x)}
 
     return r
   end
@@ -365,21 +368,6 @@ def start_minibuffer_cmd(bufname, bufstr, cmd)
   $minibuffer.call_func = method(cmd)
 end
 
-def show_key_bindings()
-  kbd_s = "❙Key bindings❙\n"
-  kbd_s << "\n⦁[Mode] keys : action⦁\n"
-
-  kbd_s << "[B]=Browse, [C]=Command, [I]=Insert, [V]=Visual\n"
-  kbd_s << "key!: Press key once, release before pressing any other keys\n"
-
-  kbd_s << "===============================================\n"
-  kbd_s << vma.kbd.to_s
-  kbd_s << "\n"
-  kbd_s << "===============================================\n"
-  b = create_new_buffer(kbd_s, "key-bindings")
-  gui_set_file_lang(b.id, "hyperplaintext")
-  #
-end
 
 def diff_buffer()
   bufstr = ""
@@ -412,14 +400,14 @@ end
 
 def minibuffer_end()
   debug "minibuffer_end"
-  $kbd.set_mode(:command)
+  vma.kbd.set_mode(:command)
   minibuffer_input = $minibuffer.to_s[0..-2]
   return $minibuffer.call_func.call(minibuffer_input)
 end
 
 def minibuffer_cancel()
   debug "minibuffer_cancel"
-  $kbd.set_mode(:command)
+  vma.kbd.set_mode(:command)
   minibuffer_input = $minibuffer.to_s[0..-2]
   # $minibuffer.call_func.call('')
 end

data/lib/vimamsa/file_manager.rb

@@ -18,7 +18,7 @@ class FileManager
   end
 
   def self.init()
-    reg_act(:start_file_selector, proc { FileManager.new.run; vma.kbd.set_mode(:file_exp); }, "File selector")
+    reg_act(:start_file_selector, proc { FileManager.new.run; vma.kbd.set_mode(:file_exp) }, "File selector")
 
     reg_act(:fexp_chdir_parent, proc { FileManager.chdir_parent }, "File selector")
     reg_act(:fexp_select, proc { buf.module.select_line }, "")
@@ -162,13 +162,14 @@ class FileManager
     #TODO:
   end
 
+  # Main inteface, show contents of current dir
   def dir_to_buf(dirpath, b = nil)
     # File.stat("testfile").mtime
 
     debug "last file: #{vma.buffers.last_file}", 2
     lastf = vma.buffers.last_file
     jumpto = nil
-    if File.dirname(lastf) == dirpath
+    if !lastf.nil? and File.dirname(lastf) == dirpath
       jumpto = File.basename(lastf)
     end
     vma.buffers.last_dir = dirpath
@@ -231,6 +232,13 @@ class FileManager
     else
       @buf.set_line_and_column_pos(@header.size, 0)
     end
+
+    if @cdirs.size > 0
+      r = vma.buf.line_range(2, @cdirs.size+1)
+      
+      # Hilight works only if done after buffer is drawn
+      run_as_idle proc { Gui.hilight_range(vma.buf, r, color: "#4488ffff") }
+    end
   end
 
   def fullp(fn)
@@ -267,7 +275,6 @@ class FileManager
       jump_to_file(fn)
       # vma.buffers.set_current_buffer(idx)
       vma.buffers.close_other_buffer(@buf.id)
-
     else
       open_with_default_program(fn)
     end

data/lib/vimamsa/gui.rb

@@ -348,7 +348,7 @@ class VMAgui
     sw.set_child(view)
   end
 
-    #TODO: implement in gtk4
+  #TODO: implement in gtk4
   def init_header_bar()
     header = Gtk::HeaderBar.new
     @header = header
@@ -577,17 +577,36 @@ class VMAgui
 
       reset_controllers
 
+      focus_controller = Gtk::EventControllerFocus.new
+
+      focus_controller.signal_connect("enter") do
+        debug "Gained focus"
+        draw_cursor_bug_workaround
+      end
+      @window.add_controller(focus_controller)
+
+      motion_controller = Gtk::EventControllerMotion.new
+      motion_controller.signal_connect("motion") do |controller, x, y|
+        # label.set_text("Mouse at: (%.1f, %.1f)" % [x, y])
+        # puts "MOVE #{x} #{y}"
+        
+        # Cursor vanishes when hovering over menubar
+        draw_cursor_bug_workaround if y < 30 
+        @last_cursor = [x, y]
+        @cursor_move_time = Time.now
+      end
+      @window.add_controller(motion_controller)
+
       @windows[1] = new_window(1)
 
       @last_adj_time = Time.now
 
-
       # To show keyboard key binding state
       @statnfo = Gtk::Label.new
-      
+
       # To show e.g. current folder
       @subtitle = Gtk::Label.new("")
-      
+
       @statbox = Gtk::Box.new(:horizontal, 2)
       @statnfo.set_size_request(150, 10)
       @statbox.append(@subtitle)
@@ -618,6 +637,12 @@ class VMAgui
 
       @window.show
 
+      surface = @window.native.surface
+      tt = Time.now
+      surface.signal_connect("layout") do
+        # puts "Window resized or moved, other redraw."
+      end
+
       run_as_idle proc { idle_set_size }
 
       prov = Gtk::CssProvider.new
@@ -666,9 +691,9 @@ class VMAgui
     return true if Time.now - @monitor_time < 0.2
     # Detect element resize
     if swa.width != @sw_width
-      # puts "@sw.width=#{@sw.width}"
+      debug "Width change sw_width #{@sw_width}"
       @sw_width = swa.width
-      DelayExecutioner.exec(id: :scale_images, wait: 0.7, callable: proc { vma.gui.scale_all_images })
+      DelayExecutioner.exec(id: :scale_images, wait: 0.7, callable: proc { debug ":scale_images"; vma.gui.scale_all_images })
     end
     @monitor_time = Time.now
     return true

data/lib/vimamsa/gui_sourceview.rb

@@ -1,16 +1,7 @@
 # class VSourceView < Gtk::TextView
 class VSourceView < GtkSource::View
   attr_accessor :bufo, :autocp_active, :cpl_list
-  # :highlight_matching_brackets
 
-  # def set_highlight_current_line(vbool)
-  # end
-
-  # def set_show_line_numbers(vbool)
-  # end
-
-  # def highlight_matching_brackets=(vbool)
-  # end
 
   # def initialize(title = nil,bufo=nil)
   def initialize(title, bufo)
@@ -27,29 +18,6 @@ class VSourceView < GtkSource::View
 
     @tt = nil
 
-    #    self.drag_dest_add_image_targets #TODO:gtk4
-    #    self.drag_dest_add_uri_targets #TODO:gtk4
-
-    #    signal_connect("drag-data-received") do |widget, event, x, y, data, info, time| #TODO:gtk4
-    # puts "drag-data-received"
-    # puts
-    # if data.uris.size >= 1
-
-    # imgpath = CGI.unescape(data.uris[0])
-    # m = imgpath.match(/^file:\/\/(.*)/)
-    # if m
-    # fp = m[1]
-    # handle_drag_and_drop(fp)
-    # end
-    # end
-    # true
-    # end
-
-    # signal_connect("show-completion") do |x, y, z|
-    # debug "SHOW-COMPLETION", 2
-    # false
-    # end
-
     # Mainly after page-up or page-down
     signal_connect("move-cursor") do |widget, event|
       # if event.name == "GTK_MOVEMENT_PAGES" and (vma.actions.last_action == "page_up" or vma.actions.last_action == "page_down")
@@ -70,7 +38,6 @@ class VSourceView < GtkSource::View
 
     return
 
-    #TODO:gtk4
     signal_connect "button-release-event" do |widget, event|
       vma.buf.set_pos(buffer.cursor_position)
       false
@@ -115,7 +82,7 @@ class VSourceView < GtkSource::View
       # Gtk::GestureDrag
       # Gtk::ShortcutController
 
-      if ctr != @click and [Gtk::DropControllerMotion, Gtk::DropTarget, Gtk::GestureDrag, Gtk::GestureClick, Gtk::EventControllerKey].include?(ctr.class)
+      if ![@click, @dt].include?(ctr) and [Gtk::DropControllerMotion, Gtk::DropTarget, Gtk::GestureDrag, Gtk::GestureClick, Gtk::EventControllerKey].include?(ctr.class)
         to_remove << ctr
       end
     }
@@ -157,11 +124,8 @@ class VSourceView < GtkSource::View
         uri = v.value.gsub(/\r\n$/, "")
       end
       debug "dt,drop #{v.value},#{x},#{y}", 2
-      begin
-        fp = URI(uri).path
-        buf.handle_drag_and_drop(fp)
-      rescue URI::InvalidURIError
-      end
+      fp = uri_to_path(uri)
+      buf.handle_drag_and_drop(fp) if !fp.nil?
       true
     end
 
@@ -422,15 +386,15 @@ class VSourceView < GtkSource::View
 
     keynfo = { :key_str => key_str, :key_name => keyname, :keyval => keyval }
     debug keynfo.inspect
-    # $kbd.match_key_conf(key_str, nil, :key_press)
+    # vma.kbd.match_key_conf(key_str, nil, :key_press)
     # debug "key_str=#{key_str} key_"
 
     if key_str != "" # or prefixed_key_str != ""
       if sig == :key_release and keyval == @last_keyval
-        $kbd.match_key_conf(key_str + "!", nil, :key_release)
+        vma.kbd.match_key_conf(key_str + "!", nil, :key_release)
         @last_event = [keynfo, :key_release]
       elsif sig == :key_press
-        $kbd.match_key_conf(key_str, nil, :key_press)
+        vma.kbd.match_key_conf(key_str, nil, :key_press)
         @last_event = [keynfo, key_str, :key_press]
       end
     end
@@ -669,3 +633,4 @@ class VSourceView < GtkSource::View
     end
   end #end draw_cursor
 end
+

data/lib/vimamsa/key_actions.rb

@@ -19,12 +19,12 @@ def jump_to_next_edit
 end
 
 def is_command_mode()
-  return true if $kbd.mode_root_state.to_s() == "C"
+  return true if vma.kbd.mode_root_state.to_s() == "C"
   return false
 end
 
 def is_visual_mode()
-  return 1 if $kbd.mode_root_state.to_s() == "V"
+  return 1 if vma.kbd.mode_root_state.to_s() == "V"
   return 0
 end
 
@@ -69,7 +69,6 @@ reg_act(:set_executable, proc { buf.set_executable }, "Set current file permissi
 reg_act(:close_current_buffer, proc { bufs.close_current_buffer(true) }, "Close current buffer")
 reg_act(:comment_selection, proc { buf.comment_selection }, "")
 reg_act(:delete_char_forward, proc { buf.delete(CURRENT_CHAR_FORWARD) }, "Delete char forward", { :group => [:edit, :basic] })
-reg_act(:load_theme, proc { load_theme }, "Load theme")
 reg_act(:gui_file_finder, proc { vma.FileFinder.start_gui }, "Fuzzy file finder")
 reg_act(:gui_file_history_finder, proc { vma.FileHistory.start_gui }, "Fuzzy file history finder")
 reg_act(:gui_search_replace, proc { gui_search_replace }, "Search and replace")
@@ -85,7 +84,7 @@ reg_act(:set_line_style_h4, proc { buf.set_line_style(:h4) }, "Set cur line as H
 reg_act(:set_line_style_bold, proc { buf.set_line_style(:bold) }, "Set style of current line as bold")
 reg_act(:set_line_style_title, proc { buf.set_line_style(:title) }, "Set style of current line as title")
 reg_act(:clear_line_styles, proc { buf.set_line_style(:clear) }, "Clear styles of current line")
-reg_act(:gui_select_buffer, proc { $kbd.set_mode("S"); gui_select_buffer }, "Select buffer")
+reg_act(:gui_select_buffer, proc { vma.kbd.set_mode("S"); gui_select_buffer }, "Select buffer")
 reg_act :open_file_dialog, "open_file_dialog", "Open file"
 reg_act :minibuffer_end, proc { minibuffer_end }
 reg_act(:invoke_replace, "invoke_replace", "")
@@ -98,6 +97,30 @@ reg_act :delete_to_word_end, proc { buf.delete2(:to_word_end) }, "Delete to file
 reg_act :delete_to_next_word_start, proc { buf.delete2(:to_next_word) }, "Delete to start of next word", { :group => [:edit, :basic] }
 reg_act :delete_to_line_start, proc { buf.delete2(:to_line_start) }, "Delete to line start", { :group => [:edit, :basic] }
 
+
+reg_act(:ack_search, proc { gui_ack }, "") 
+
+reg_act(:copy_cur_line, proc {buf.copy_line}, "Copy the current line") 
+reg_act(:paste_before_cursor, proc {buf.paste(BEFORE)}, "Paste text before the cursor") 
+reg_act(:paste_after_cursor, proc {buf.paste(AFTER)}, "Paste text after the cursor") 
+reg_act(:redo, proc {buf.redo()}, "Redo the last undone action")
+reg_act(:undo, proc {buf.undo()}, "Undo the last action")
+reg_act(:jump_end_of_line, proc { buf.jump(END_OF_LINE) }, "Move to the end of the current line")
+reg_act(:jump_end_of_buffer, proc {buf.jump(END_OF_BUFFER)}, "Move to the end of the buffer")
+reg_act(:jump_start_of_buffer, proc { buf.jump(START_OF_BUFFER) }, "Move to the start of the buffer")
+reg_act(:jump_beginning_of_line, proc { buf.jump(BEGINNING_OF_LINE) }, "Move to the beginning of the current line")
+reg_act(:jump_next_word_end, proc { buf.jump_word(FORWARD,WORD_END) }, "Jump to the end of the next word")
+reg_act(:jump_prev_word_start, proc { buf.jump_word(BACKWARD,WORD_START) }, "Jump to the start of the previous word")
+reg_act(:jump_next_word_start, proc { buf.jump_word(FORWARD,WORD_START) }, "Jump to the start of the next word")
+reg_act(:insert_mode, proc { vma.kbd.set_mode(:insert) }, "Switch to INSERT mode")
+reg_act(:prev_mode, proc { vma.kbd.to_previous_mode }, "Return to the previous mode")
+reg_act(:move_prev_line, proc { buf.move(BACKWARD_LINE) }, "Move the cursor to the previous line")
+reg_act(:move_next_line, proc { buf.move(FORWARD_LINE) }, "Move the cursor to the next line")
+reg_act(:move_backward_char, proc { buf.move(BACKWARD_CHAR) }, "Move one character backward")
+reg_act(:start_visual_mode, proc { buf.start_selection;vma.kbd.set_mode(:visual) }, "Enter VISUAL mode (for selections)") 
+reg_act(:jump_last_edit, proc { buf.jump_to_last_edit }, "Jump to the last edit location")
+
+
 reg_act :start_browse_mode, proc {
   vma.kbd.set_mode(:browse)
   bufs.reset_navigation

data/lib/vimamsa/key_binding_tree.rb

@@ -7,8 +7,8 @@
 #
 # Change mode from INSERT into COMMAND when ctrl key is released immediately
 # after it has been pressed (there are no other key events between key press and key release).
-#        'I ctrl!'=> '$kbd.set_mode(:command)',
-#        'C ctrl!'=> '$kbd.set_mode(:insert)',
+#        'I ctrl!'=> 'vma.kbd.set_mode(:command)',
+#        'C ctrl!'=> 'vma.kbd.set_mode(:insert)',
 
 #
 # In command mode: press keys "," "r" "v" and "b" sequentially.
@@ -18,9 +18,8 @@
 # 'I ctrl-a'=> 'vma.buf.jump(BEGINNING_OF_LINE)',
 #
 
-
 class State
-  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level, :cursor_type
+  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level, :cursor_type, :keywords
   attr_reader :cur_mode, :scope
 
   def initialize(key_name, eval_rule = "", ctype = :command, scope: :buffer)
@@ -29,6 +28,7 @@ class State
     @children = []
     @scope = scope
     @major_modes = []
+    @keywords = []
     @action = nil
     @level = 0
     @cursor_type = ctype
@@ -86,7 +86,7 @@ class KeyBindingTree
 
   def set_mode_stack(ms)
     debug "set_mode_stack(#{ms})", 2
-    show_caller if cnf.debug? # TODO: remove 
+    show_caller if cnf.debug? # TODO: remove
     @default_mode_stack = ms
     label = @default_mode_stack[-1]
     @match_state = [@modes[label]]
@@ -110,7 +110,7 @@ class KeyBindingTree
   end
 
   def to_previous_mode()
-    debug "to_previous_mode",2
+    debug "to_previous_mode", 2
     debug @default_mode_stack
     if @default_mode_stack.size > 1
       @default_mode_stack.pop
@@ -135,7 +135,6 @@ class KeyBindingTree
     @modes[label] = mode
     if @root.nil?
       show_caller
-      Ripl.start :binding => binding
     end
     @root.children << mode
     mode.major_modes << major_mode_label
@@ -165,6 +164,7 @@ class KeyBindingTree
 
   def match(key_name)
     new_state = []
+    debug = false
     @match_state.each { |parent|
       parent.children.each { |c|
         # printf(" KEY MATCH: ")
@@ -174,6 +174,9 @@ class KeyBindingTree
         elsif c.key_name == key_name and c.eval_rule != ""
           debug "CHECK EVAL: #{c.eval_rule}"
           if eval(c.eval_rule)
+            # if eval_rule.match(/macro/)
+            debug = true
+            # end
             new_state << c
             debug "EVAL TRUE"
           else
@@ -183,6 +186,10 @@ class KeyBindingTree
       }
     }
 
+    if debug
+      # require "pry"; binding.pry
+    end
+
     if new_state.any? # Match found
       @match_state = new_state
       return new_state
@@ -262,14 +269,66 @@ class KeyBindingTree
     @state_trail = [@mode_root_state]
   end
 
+  def get_by_keywords(modes: [], keywords: [])
+    s = ""
+    stack = [[@root, ""]]
+    lines = []
+
+    # Traverse the tree (class State objects) using a stack
+    while stack.any?
+      t, p = *stack.pop # t = current state, p = current path
+      if t.children.any?
+        t.children.reverse.each { |c|
+
+          # Restrict by modes if specified
+          if c.level == 1 and !modes.empty?
+            next if !modes.include?(c.key_name)
+          end
+
+          if c.eval_rule.size > 0
+            new_p = "#{p} #{c.key_name}(#{c.eval_rule})"
+          else
+            if c.level == 1
+              new_p = "#{p} [#{c.key_name}]"
+            else
+              new_p = "#{p} #{c.key_name}"
+            end
+          end
+          stack << [c, new_p]
+        }
+        # stack.concat[t.children]
+
+      else
+        method_desc = t.action
+        if t.action.class == Symbol
+          if vma.actions.include?(t.action)
+            a = vma.actions[t.action].method_name
+            if !a.nil? and !a.empty?
+              method_desc = a
+            end
+          end
+        end
+
+        if (keywords - t.keywords).empty? # All keywords are present
+          kw = ""
+          # kw = ", [#{t.keywords.join(",")}]" if !t.keywords.empty?
+          lines << p + " : #{method_desc}#{kw}"
+        end
+      end
+    end
+    s = lines.sort.join("\n")
+    return s
+  end
+
   # Print key bindings to show as documentation or for debugging
   def to_s()
-    # return self.class.to_s
+    return self.class.to_s
     s = ""
     # @cur_state = @root
     stack = [[@root, ""]]
     lines = []
 
+    # Traverse the tree (class State objects) using a stack
     while stack.any?
       t, p = *stack.pop # t = current state, p = current path
       if t.children.any?
@@ -297,7 +356,9 @@ class KeyBindingTree
           end
         end
 
-        lines << p + " : #{method_desc}"
+        kw = ""
+        # kw = ", " + t.keywords.join(",") if !t.keywords.empty?
+        lines << p + " : #{method_desc}#{kw}"
       end
     end
     s = lines.sort.join("\n")
@@ -426,11 +487,15 @@ class KeyBindingTree
     else
 
       # Don't execute action if one of the states has children
+      # TODO: why?
       state_with_children = new_state.select { |s| s.children.any? }
       s_act = new_state.select { |s| s.action != nil }
 
-      if s_act.any? and !state_with_children.any?
+      if s_act.any? #and !state_with_children.any?
         eval_s = s_act.first.action if eval_s == nil
+        # if eval_s.to_s.match(/end_recording/)
+        # require "pry"; binding.pry
+        # end
         debug "FOUND MATCH:#{eval_s}"
         debug "CHAR: #{c}"
         c.gsub!("\\", %q{\\\\} * 4) # Escape \ -chars
@@ -449,7 +514,12 @@ class KeyBindingTree
     return true
   end
 
-  def bindkey(key, action)
+  def bindkey(key, action, keywords: "")
+    # puts "keywords #{keywords}" if !keywords.empty?
+    if keywords.class == String
+      keywords = keywords.split(" ")
+    end
+    # puts "keywords #{keywords}" if !keywords.empty?
     if key.class != Array
       # Handle syntax like :
       # "X esc || X ctrl!" => "vma.kbd.to_previous_mode",
@@ -464,10 +534,10 @@ class KeyBindingTree
       msg = action[2]
       reg_act(label, proc, msg)
     end
-    key.each { |k| _bindkey(k, a) }
+    key.each { |k| _bindkey(k, a, keywords: keywords) }
   end
 
-  def _bindkey(key, action)
+  def _bindkey(key, action, keywords: [])
     key.strip!
     key.gsub!(/\s+/, " ")
 
@@ -502,15 +572,18 @@ class KeyBindingTree
       fatal_error("Error in keydef #{key.inspect}")
     end
 
+    # puts "keywords #{keywords}"
     modes.each { |mode_id|
-      mode_bind_key(mode_id, keydef, action)
+      mode_bind_key(mode_id, keydef, action, keywords: keywords)
+
+      # Map froma actions to keybindings (e.g. to show bindings in menu)
       @act_bindings[mode_id][action] = keydef
     }
   end
 
   # Binds a keyboard key combination to an action,
   # for a given keyboard mode like insert ("I") or command ("C")
-  def mode_bind_key(mode_id, keydef, action)
+  def mode_bind_key(mode_id, keydef, action, keywords: [])
     # debug "mode_bind_key #{mode_id.inspect}, #{keydef.inspect}, #{action.inspect}", 2
     # Example:
     # bindkey "C , f", :gui_file_finder
@@ -520,7 +593,7 @@ class KeyBindingTree
     set_state(mode_id, "") # TODO: check is ok?
     start_state = @cur_state
 
-    k_arr = keydef.split
+    k_arr = keydef.split #e.g. definition: "C y e" = > ["C", "y", "e"]
 
     prev_state = nil
     s1 = start_state
@@ -561,6 +634,7 @@ class KeyBindingTree
     else
       @cur_state.action = action
     end
+    @cur_state.keywords = keywords
     @cur_state = @root
   end
 
@@ -614,13 +688,19 @@ class KeyBindingTree
   end
 end
 
-def bindkey(key, action)
-  $kbd.bindkey(key, action)
+def bindkey(key, action, keywords: "")
+  vma.kbd.bindkey(key, action, keywords: keywords)
+end
+
+def add_keys(keywords, to_add)
+  to_add.each { |key, value|
+    bindkey(key, value, keywords: keywords)
+  }
 end
 
 def exec_action(action)
-  $kbd.last_action = $kbd.cur_action
-  $kbd.cur_action = action
+  vma.kbd.last_action = vma.kbd.cur_action
+  vma.kbd.cur_action = action
   if action.class == Symbol
     return call_action(action)
   elsif action.class == Proc
@@ -630,14 +710,70 @@ def exec_action(action)
   end
 end
 
+def show_key_bindings()
+  kbd_s = "❙Key bindings❙\n"
+  kbd_s << "\n⦁[Mode] <keys> : <action>⦁\n"
+  done = []
+
+  kbd_s << "[B]=Browse, [C]=Command, [I]=Insert, [V]=Visual\n"
+  kbd_s << "<key>!: Press <key> once, release before pressing any other keys\n"
+  kbd_s << "===============================================\n"
+  kbd_s << "◼ Basic\n"
+  kbd_s << "◼◼ Command mode\n"
+
+  x = vma.kbd.get_by_keywords(modes: ["C"], keywords: ["intro"])
+  done.concat(x.lines); kbd_s << x
+
+  kbd_s << "\n"
+  kbd_s << "◼◼ Insert mode\n"
+  x = vma.kbd.get_by_keywords(modes: ["I"], keywords: ["intro"])
+  done.concat(x.lines); kbd_s << x
+  kbd_s << "\n"
+  kbd_s << "◼◼ Visual mode\n"
+  x = vma.kbd.get_by_keywords(modes: ["V"], keywords: ["intro"])
+  done.concat(x.lines); kbd_s << x
+  kbd_s << "\n"
+
+  kbd_s << "◼ Core\n"
+  x = vma.kbd.get_by_keywords(modes: [], keywords: ["core"])
+  x << vma.kbd.get_by_keywords(modes: ["X"], keywords: ["intro"])
+
+  done.concat(x.lines); kbd_s << x
+  kbd_s << "\n"
+
+  kbd_s << "◼ Debug / Experimental\n"
+  x = vma.kbd.get_by_keywords(modes: [], keywords: ["experimental"])
+  done.concat(x.lines); kbd_s << x
+  kbd_s << "\n"
+
+  kbd_s << "◼ Others\n"
+  # x = vma.kbd.get_by_keywords(modes: [], keywords:["experimental"])
+  # x = vma.kbd.to_s
+  x = vma.kbd.get_by_keywords(modes: [], keywords: [])
+  done << x.lines - done
+  kbd_s << (x.lines - done).join
+  kbd_s << "\n"
+
+  kbd_s << "===============================================\n"
+  # x = vma.kbd.to_s
+  # # require "pry"; binding.pry
+  # done << x.lines - done
+  # kbd_s << (x.lines - done).join
+  # kbd_s << "\n"
+  # kbd_s << "===============================================\n"
+  b = create_new_buffer(kbd_s, "key-bindings")
+  gui_set_file_lang(b.id, "hyperplaintext")
+  #
+end
+
 # Try to clear modifiers when program loses focus
 # e.g. after alt-tab
 # TODO
 # def focus_out
-  # debug "RB Clear modifiers"
-  # $kbd.clear_modifiers()
+# debug "RB Clear modifiers"
+# vma.kbd.clear_modifiers()
 # end
 
 # def handle_key_event(event)
-  # $kbd.handle_key_event(event)
+# vma.kbd.handle_key_event(event)
 # end

data/lib/vimamsa/key_bindings_vimlike.rb

@@ -4,6 +4,7 @@ vma.kbd.add_mode("V", :visual, :visual)
 vma.kbd.add_mode("M", :minibuffer) #TODO: needed?
 vma.kbd.add_mode("R", :readchar)
 vma.kbd.add_minor_mode("audio", :audio, :command)
+vma.kbd.add_minor_mode("macro", :macro, :command)
 vma.kbd.add_mode("B", :browse, :browse, scope: :editor)
 vma.kbd.add_mode("X", :replace, :replace, name: "Replace")
 vma.kbd.set_default_mode(:command)
@@ -40,95 +41,44 @@ def insert_move(op)
   _insert_move(op)
 end
 
-bindkey ["VCB M", "B m"], :run_last_macro
-
-bindkey "VC s", :easy_jump
-bindkey "I alt-s", :easy_jump
-bindkey "VC , m f", [:find_macro_gui, proc { vma.macro.find_macro_gui }, "Find named macro"]
-bindkey "C , m n", [:gui_name_macro, proc { vma.macro.gui_name_macro }, "Name last macro"]
-bindkey "C , j r", :jump_to_random
-bindkey "C , ; s k", :show_key_bindings #TODO: better binding
-bindkey "C , , c b", :put_file_path_to_clipboard #TODO: better binding or remove?
-bindkey "C , , e", :encrypt_file #TODO: better binding
-bindkey "C , ; u", :set_unencrypted #TODO: better binding
-bindkey "C , c b", :close_current_buffer
-bindkey "V ctrl-c", :comment_selection
-bindkey "C x", :delete_char_forward
-bindkey "C , , l t", :load_theme
-bindkey "C , f", :gui_file_finder
-bindkey "C , h", :gui_file_history_finder
-bindkey "C , z", :gui_file_finder
-
-bindkey "C ` k", :lsp_debug
-bindkey "C ` j", :lsp_jump_to_definition
-
-bindkey "C , r r", :gui_search_replace
-bindkey "V , r r", :gui_search_replace
-bindkey "V , t b", :set_style_bold
-bindkey "V , t l", :set_style_link
-bindkey "V J", :V_join_lines
-bindkey "V , t c", :clear_formats
-bindkey "C , t h", :set_line_style_heading
-bindkey "C , t 1", :set_line_style_h1
-bindkey "C , t 2", :set_line_style_h2
-bindkey "C , t 3", :set_line_style_h3
-bindkey "C , t 4", :set_line_style_h4
-bindkey "C , t b", :set_line_style_bold
-bindkey "C , t t", :set_line_style_title
-bindkey "C , t c", :clear_line_styles
-bindkey "C , b", :start_buf_manager
-bindkey "C , w", :toggle_active_window
-bindkey "C , , w", :toggle_two_column
-
-bindkey "C , u s", :audio_stop
-bindkey "C , m a", "vma.kbd.set_mode(:audio)"
-bindkey "audio s", :audio_stop
-bindkey "audio f || audio right", [:audio_forward, proc { Audio.seek_forward }, "Seek forward in audio stream"]
-bindkey "audio left", [:audio_backward, proc { Audio.seek_forward(-5.0) }, "Seek backward in audio stream"]
-
-bindkey "audio space", :audio_stop
-bindkey "audio q || audio esc", "vma.kbd.to_previous_mode"
+add_keys "intro", {
+  "C y y" => :copy_cur_line,
+  "C P" => :paste_before_cursor,
+  "C p" => :paste_after_cursor,
+  "C v" => :start_visual_mode,
+  "C ctrl-r" => :redo,
+  "C u" => :undo,
+  "VC O" => :jump_end_of_line,
+  # NOTE: "G(condition)" need to be defined before "G"
+  "VC G(vma.kbd.next_command_count!=nil)" => "buf.jump_to_line()",
+  "VC G" => :jump_end_of_buffer,
+  "VC g ;" => :jump_last_edit,
+  "VC g g" => :jump_start_of_buffer,
+  "VC e" => :jump_next_word_end,
+  "VC b" => :jump_prev_word_start,
+  "VC w" => :jump_next_word_start,
+  "V esc" => "buf.end_visual_mode",
+  "V ctrl!" => "buf.end_visual_mode", 
+  
+  "C ctrl!" => :insert_mode,
+  "C i" => :insert_mode,
+  "I esc || I ctrl!" => :prev_mode,
+  "IX alt-b" => :jump_prev_word_start,
+  "IX alt-f" => :jump_next_word_start,
+  "IX ctrl-e" => :jump_end_of_line,
+  "IX ctrl-p" => :move_prev_line,
+  "IX ctrl-n" => :move_next_line,
+  "IX ctrl-b" => :move_backward_char,
+  "IX ctrl-a" => :jump_beginning_of_line,
+}
 
-# bindkey "C , f o", :open_file_dialog
-bindkey "CI ctrl-o", :open_file_dialog
-# bindkey "M enter", :minibuffer_end
-bindkey "C , a", :ack_search
-bindkey "C d w", :delete_to_next_word_start
-
-bindkey "C d 0", :delete_to_line_start
-bindkey "C , , f", :file_finder
-bindkey "VC h", :e_move_backward_char
-bindkey "C , , .", :backup_all_buffers
-bindkey "C z ", :start_browse_mode
-bindkey "B h", :history_switch_backwards
-bindkey "B l", :history_switch_forwards
-bindkey "B z", "center_on_current_line();call_action(:exit_browse_mode)"
-bindkey "B enter || B return || B esc || B j || B ctrl!", :exit_browse_mode
-bindkey "B s", :page_up
-bindkey "B d", :page_down
-bindkey "B r", proc { vma.gui.page_down(multip: 0.25) }
-bindkey "B e", proc { vma.gui.page_up(multip: 0.25) }
-
-bindkey "B i", :jump_to_start_of_buffer
-bindkey "B o", :jump_to_end_of_buffer
-bindkey "B c", :close_current_buffer
-bindkey "B ;", "buf.jump_to_last_edit"
-bindkey "B q", :jump_to_last_edit
-bindkey "B w", :jump_to_next_edit
-# bindkey "C , d", :diff_buffer
-#bindkey 'C , g', proc{invoke_grep_search}
-bindkey "C , v", :auto_indent_buffer
-bindkey "C , , d", :savedebug
-bindkey "C , , u", :update_file_index
-bindkey "C , s a", :buf_save_as
-bindkey "C d d", [:delete_line, proc { buf.delete_line }, "Delete current line"]
-bindkey "C enter || C return", [:line_action, proc { buf.handle_line_action() }, "Line action"]
-bindkey "C p", [:paste_after, proc { buf.paste(AFTER) }, ""] # TODO: implement as replace for visual mode
-bindkey "V d", [:delete_selection, proc { buf.delete(SELECTION) }, ""]
-bindkey "V a d", [:delete_append_selection, proc { buf.delete(SELECTION, :append) }, "Delete and append selection"]
+add_keys "intro delete", {
+  "C x" => :delete_char_forward,
+  "C d d" => [:delete_line, proc { buf.delete_line }, "Delete current line"]
+}
 
 
-default_keys = {
+add_keys "core", {
 
   # File handling
   "C ctrl-s" => :buf_save,
@@ -185,9 +135,6 @@ default_keys = {
   "VCX down" => "buf.move(FORWARD_LINE)",
   "VCX 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)",
@@ -197,14 +144,10 @@ default_keys = {
   "VC /[1-9]/" => "vma.kbd.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 G(vma.kbd.next_command_count!=nil)" => "buf.jump_to_line()",
   "VC 0(vma.kbd.next_command_count!=nil)" => "set_next_command_count(<char>)",
   "VC 0(vma.kbd.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 ^" => "buf.jump(BEGINNING_OF_LINE)",
-  "VC G" => "buf.jump(END_OF_BUFFER)",
   #    'VC z z' => 'center_on_current_line',
   "VC *" => "buf.jump_to_next_instance_of_word",
 
@@ -221,17 +164,8 @@ default_keys = {
 
   "C C" => :content_search,
 
-  # Debug
-  "C , d r p" => "start_ripl",
-  "C , d o" => "vma.gui.clear_overlay",
-  "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",
-  "C , d m" => :kbd_dump_state,
 
-  "VC O" => "buf.jump(END_OF_LINE)",
   "VC $" => "buf.jump(END_OF_LINE)",
 
   "C o" => 'buf.jump(END_OF_LINE);buf.insert_txt("\n");vma.kbd.set_mode(:insert)',
@@ -240,23 +174,18 @@ default_keys = {
   "C I" => "buf.jump(FIRST_NON_WHITESPACE);vma.kbd.set_mode(:insert)",
   "C a" => "buf.move(FORWARD_CHAR);vma.kbd.set_mode(:insert)",
   "C J" => "buf.join_lines()",
-  "C u" => "buf.undo()",
 
   "C ^" => "buf.jump(BEGINNING_OF_LINE)",
   # "C /[1-9]/" => "vma.kbd.set_next_command_count(<char>)",
 
   # Command mode only:
-  "C ctrl-r" => "buf.redo()", # TODO:???
-  "C v" => "buf.start_selection;vma.kbd.set_mode(:visual)",
-  "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 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',
@@ -279,8 +208,7 @@ default_keys = {
   # '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()",
   "V a y" => "buf.copy_active_selection(:append)",
   "V g U" => :selection_upcase,
@@ -305,9 +233,7 @@ default_keys = {
   # "CV ''" =>'jump_to_mark(NEXT_MARK)', #TODO
 
   # Switch to another mode
-  "C i" => "vma.kbd.set_mode(:insert)",
   "C R" => "vma.kbd.set_mode(:replace)",
-  "C ctrl!" => "vma.kbd.set_mode(:insert)",
 
   # Replace mode
   "X esc || X ctrl!" => "vma.kbd.to_previous_mode",
@@ -316,49 +242,140 @@ default_keys = {
   # Macros
   # (experimental, may not work correctly)
   # "C q a" => 'vma.macro.start_recording("a")',
-  "VC q <char>" => "vma.macro.start_recording(<char>)",
-  "VC q(vma.macro.is_recording==true) " => "$macro.end_recording", # TODO
+  
+  "macro q" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
+  "macro q z" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
+  
+  # "VC q(vma.macro.is_recording==true)" => "vma.macro.end_recording", # TODO: does not work
+  # "VC o(vma.macro.is_recording==true)" => "vma.macro.end_recording", # TODO: does not work
+  # "VC q q(vma.macro.is_recording==true)" => "vma.macro.end_recording",
+  "VC q <char>" => "vma.kbd.set_mode(:macro);vma.macro.start_recording(<char>)",
   # 'C q'=> 'vma.macro.end_recording', #TODO
-  "C q v" => "vma.macro.end_recording",
+  "C q v" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
   # 'C v'=> 'vma.macro.end_recording',
   # "C M" => 'vma.macro.run_last_macro',
   "C @ <char>" => "vma.macro.run_macro(<char>)",
   "C , m S" => 'vma.macro.save_macro("a")',
   "C , m s" => "vma.macro.save",
-  "C , t r" => "run_tests()",
 
   # "C ." => "repeat_last_action", # TODO
   "VC ;" => "repeat_last_find",
   # "CV Q" => :quit,
   "CV ctrl-q" => :quit,
-  "CV , R" => "restart_application",
   # "I ctrl!" => "vma.kbd.to_previous_mode",
   "C shift! s" => "buf.save",
   "I ctrl-s" => "buf.save",
   "I <char>" => "buf.insert_txt(<char>)",
-  "I esc || I ctrl!" => "vma.kbd.to_previous_mode",
 
   "I ctrl-d" => "buf.delete2(:to_word_end)",
 
   # Insert and Replace modes: Moving
-  "IX ctrl-a" => "buf.jump(BEGINNING_OF_LINE)",
-  "IX ctrl-b" => "buf.move(BACKWARD_CHAR)",
   "IX ctrl-f" => "buf.move(FORWARD_CHAR)",
-  "IX ctrl-n" => "buf.move(FORWARD_LINE)",
-  "IX ctrl-p" => "buf.move(BACKWARD_LINE)",
-  "IX ctrl-e" => "buf.jump(END_OF_LINE)", # context: mode:I, buttons down: {C}
-  "IX alt-f" => "buf.jump_word(FORWARD,WORD_START)",
-  "IX alt-b" => "buf.jump_word(BACKWARD,WORD_START)",
 
-  "I ctrl-h" => :show_autocomplete,
   "I ctrl-j" => "vma.buf.view.hide_completions",
 
   "I space" => 'buf.insert_txt(" ")',
 #  "I return" => 'buf.insert_new_line()',
+
+ "CI ctrl-o" => :open_file_dialog,
+ "C , a" => :ack_search,
+ "C d w" => :delete_to_next_word_start,
+
+ "C d 0" => :delete_to_line_start,
+ "C , , f" => :file_finder,
+ "VC h" => :e_move_backward_char,
+ "C , , ." => :backup_all_buffers,
+ "C z " => :start_browse_mode,
+ "B h" => :history_switch_backwards,
+ "B l" => :history_switch_forwards,
+ "B z" => "center_on_current_line();call_action(:exit_browse_mode)",
+ "B enter || B return || B esc || B j || B ctrl!" => :exit_browse_mode,
+ "B s" => :page_up,
+ "B d" => :page_down,
+ "B r" => proc { vma.gui.page_down(multip: 0.25) },
+ "B e" => proc { vma.gui.page_up(multip: 0.25) },
+
+ "B i" => :jump_to_start_of_buffer,
+ "B o" => :jump_to_end_of_buffer,
+ "B c" => :close_current_buffer,
+ "B ;" => :jump_last_edit,
+ "B q" => :jump_to_last_edit,
+ "B w" => :jump_to_next_edit,
+ "C , v" => :auto_indent_buffer,
+ "C , , u" => :update_file_index,
+ "C , s a" => :buf_save_as,
+ "VC , r r" => :gui_search_replace,
+ "V , t b" => :set_style_bold,
+ "V , t l" => :set_style_link,
+ "V J" => :V_join_lines,
+ "V , t c" => :clear_formats,
+ "C , t h" => :set_line_style_heading,
+ "C , t 1" => :set_line_style_h1,
+ "C , t 2" => :set_line_style_h2,
+ "C , t 3" => :set_line_style_h3,
+ "C , t 4" => :set_line_style_h4,
+ "C , t b" => :set_line_style_bold,
+ "C , t t" => :set_line_style_title,
+ "C , t c" => :clear_line_styles,
+ "C , b" => :start_buf_manager,
+ "C , w" => :toggle_active_window,
+ "C , , w" => :toggle_two_column,
+
+ "VC s" => :easy_jump,
+ "I alt-s" => :easy_jump,
+ "VC , m f" => [:find_macro_gui, proc { vma.macro.find_macro_gui }, "Find named macro"],
+ "C , m n" => [:gui_name_macro, proc { vma.macro.gui_name_macro }, "Name last macro"],
+ "C , j r" => :jump_to_random,
+ "C , ; s k" => :show_key_bindings, #TODO: better binding,
+ "C , , c b" => :put_file_path_to_clipboard, #TODO: better binding or remove?,
+ "C , , e" => :encrypt_file, #TODO: better binding,
+ "C , ; u" => :set_unencrypted, #TODO: better binding,
+ "C , c b" => :close_current_buffer,
+ "V ctrl-c" => :comment_selection,
+ "C , f" => :gui_file_finder,
+ "C , h" => :gui_file_history_finder,
+ "C , z" => :gui_file_finder,
+
+ "C enter || C return" => [:line_action, proc { buf.handle_line_action() }, "Line action"],
+ "V d" => [:delete_selection, proc { buf.delete(SELECTION) }, ""],
+ "V a d" => [:delete_append_selection, proc { buf.delete(SELECTION, :append) }, "Delete and append selection"]
 }
 
-bindkey "C , i p", "generate_password_to_buf(15)"
+bindkey ["VCB M", "B m"], :run_last_macro
+
+add_keys "experimental", {
+ "C ` k" => :lsp_debug,
+ "C ` j" => :lsp_jump_to_definition,
+ "C , u s" => :audio_stop,
 
-default_keys.each { |key, value|
-  bindkey(key, value)
+  "C , t r" => "run_tests()",
+  # "CV , R" => "restart_application", #TODO: does not work
+  "I ctrl-h" => :show_autocomplete, #TODO: does not work
+  "C , d m" => :kbd_dump_state,
+  "C , d d" => "debug_dump_deltas",
+  "C , d c" => "debug_dump_clipboard",
+  "C , d b" => "debug_print_buffer",
+  "C , D" => "debug_print_buffer",
+  "C , d o" => "vma.gui.clear_overlay",
+  # Debug
+  "C , d r p" => 'require "pry"; binding.pry', #TODO
+#bindkey 'C , g', proc{invoke_grep_search}
+# bindkey "C , d", :diff_buffer
+ "C , , d" => :savedebug,
+ "C , m a" => "vma.kbd.set_mode(:audio)",
+ "audio s" => :audio_stop,
 }
+
+
+bindkey "audio f || audio right", [:audio_forward, proc { Audio.seek_forward }, "Seek forward in audio stream"]
+bindkey "audio left", [:audio_backward, proc { Audio.seek_forward(-5.0) }, "Seek backward in audio stream"]
+
+bindkey "audio space", :audio_stop
+bindkey "audio q || audio esc", "vma.kbd.to_previous_mode"
+
+
+bindkey "C , i p", "generate_password_to_buf(15)"
+
+# default_keys.each { |key, value|
+  # bindkey(key, value)
+# }

data/lib/vimamsa/util.rb

@@ -3,6 +3,10 @@ require "open3"
 VOWELS = %w(a e i o u)
 CONSONANTS = %w(b c d f g h j k l m n p q r s t v w x y z)
 
+def draw_cursor_bug_workaround()
+  DelayExecutioner.exec(id: :bug_workaround_draw_cursor, wait: 1.0, callable: proc { vma.gui.view.draw_cursor(); debug ":bug_workaround_draw_cursor"; false })
+end
+
 def running_wayland?
   sess = ENV["DESKTOP_SESSION"]
   sess ||= ENV["XDG_SESSION_DESKTOP"]
@@ -218,7 +222,7 @@ end
 # Used for image scaling after window resize
 
 class DelayExecutioner
-
+  attr_accessor :last_run, :wait_before_next
   # Run 'callable.call' if 'wait' time elapsed from last exec call for this id
   def self.exec(id:, wait:, callable:)
     @@h ||= {}
@@ -226,6 +230,12 @@ class DelayExecutioner
     if h[id].nil?
       h[id] = DelayExecutioner.new(wait, callable)
     end
+    o = h[id]
+    if !o.last_run.nil?
+      # if Time.now - o.last_run < o.wait_before_next
+      # return
+      # end
+    end
     h[id].run
   end
 
@@ -234,6 +244,8 @@ class DelayExecutioner
     @proc = _proc
     @lastt = Time.now
     @thread_running = false
+    @last_run = nil
+    @wait_before_next = 0
   end
 
   def start_thread
@@ -242,6 +254,7 @@ class DelayExecutioner
         sleep 0.1
         if Time.now - @lastt > @wait_time
           @proc.call
+          @last_run = Time.now
           @thread_running = false
           break
         end
@@ -344,6 +357,17 @@ def is_existing_file(s)
   return false
 end
 
+def uri_to_path(uri)
+  fp = nil
+  begin
+    x = URI::DEFAULT_PARSER.unescape(URI(uri).path)
+  rescue URI::InvalidURIError
+  else
+    fp = x # only if no exception
+  end
+  return fp
+end
+
 def is_image_file(fpath)
   return false if !File.exist?(fpath)
   # return false if !fpath.match(/.(jpg|jpeg|png)$/i)

data/lib/vimamsa/version.rb

@@ -1,3 +1,3 @@
 module Vimamsa
-  VERSION = "0.1.21"
+  VERSION = "0.1.22"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vimamsa
 version: !ruby/object:Gem::Version
-  version: 0.1.21
+  version: 0.1.22
 platform: ruby
 authors:
 - Sami Sieranoja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-21 00:00:00.000000000 Z
+date: 2025-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -241,6 +241,7 @@ files:
 - exe/vimamsa
 - ext/vmaext/extconf.rb
 - ext/vmaext/vmaext.c
+- install.sh
 - lang/hyperplaintext.lang
 - lib/vimamsa.rb
 - lib/vimamsa/ack.rb