vimamsa 0.1.4 → 0.1.7

data/lib/vimamsa/gui_sourceview.rb

@@ -0,0 +1,294 @@
+
+class VSourceView < GtkSource::View
+  def initialize(title = nil)
+    # super(:toplevel)
+    super()
+    puts "vsource init"
+    @last_keyval = nil
+    @last_event = [nil, nil]
+
+    signal_connect "button-press-event" do |_widget, event|
+      if event.button == Gdk::BUTTON_PRIMARY
+        # puts "Gdk::BUTTON_PRIMARY"
+        false
+      elsif event.button == Gdk::BUTTON_SECONDARY
+        # puts "Gdk::BUTTON_SECONDARY"
+        true
+      else
+        true
+      end
+    end
+
+    signal_connect("key_press_event") do |widget, event|
+      handle_key_event(event, :key_press_event)
+      true
+    end
+
+    signal_connect("key_release_event") do |widget, event|
+      handle_key_event(event, :key_release_event)
+      true
+    end
+
+    signal_connect("move-cursor") do |widget, event|
+      $update_cursor = true
+      false
+    end
+
+    signal_connect "button-release-event" do |widget, event|
+      $buffer.set_pos(buffer.cursor_position)
+      false
+    end
+    @curpos_mark = nil
+  end
+
+  def handle_key_event(event, sig)
+    if $update_cursor
+      curpos = buffer.cursor_position
+      puts "MOVE CURSOR: #{curpos}"
+      buf.set_pos(curpos)
+      $update_cursor = false
+    end
+    puts $view.visible_rect.inspect
+
+    puts "key event"
+    puts event
+
+    key_name = event.string
+    if event.state.control_mask?
+      key_name = Gdk::Keyval.to_name(event.keyval)
+      # Gdk::Keyval.to_name()
+    end
+
+    keyval_trans = {}
+    keyval_trans[Gdk::Keyval::KEY_Control_L] = "ctrl"
+    keyval_trans[Gdk::Keyval::KEY_Control_R] = "ctrl"
+
+    keyval_trans[Gdk::Keyval::KEY_Escape] = "esc"
+
+    keyval_trans[Gdk::Keyval::KEY_Return] = "enter"
+    keyval_trans[Gdk::Keyval::KEY_ISO_Enter] = "enter"
+    keyval_trans[Gdk::Keyval::KEY_KP_Enter] = "enter"
+    keyval_trans[Gdk::Keyval::KEY_Alt_L] = "alt"
+    keyval_trans[Gdk::Keyval::KEY_Alt_R] = "alt"
+
+    keyval_trans[Gdk::Keyval::KEY_BackSpace] = "backspace"
+    keyval_trans[Gdk::Keyval::KEY_KP_Page_Down] = "pagedown"
+    keyval_trans[Gdk::Keyval::KEY_KP_Page_Up] = "pageup"
+    keyval_trans[Gdk::Keyval::KEY_Page_Down] = "pagedown"
+    keyval_trans[Gdk::Keyval::KEY_Page_Up] = "pageup"
+    keyval_trans[Gdk::Keyval::KEY_Left] = "left"
+    keyval_trans[Gdk::Keyval::KEY_Right] = "right"
+    keyval_trans[Gdk::Keyval::KEY_Down] = "down"
+    keyval_trans[Gdk::Keyval::KEY_Up] = "up"
+    keyval_trans[Gdk::Keyval::KEY_space] = "space"
+
+    keyval_trans[Gdk::Keyval::KEY_Shift_L] = "shift"
+    keyval_trans[Gdk::Keyval::KEY_Shift_R] = "shift"
+    keyval_trans[Gdk::Keyval::KEY_Tab] = "tab"
+
+    key_trans = {}
+    key_trans["\e"] = "esc"
+    tk = keyval_trans[event.keyval]
+    key_name = tk if !tk.nil?
+
+    key_str_parts = []
+    key_str_parts << "ctrl" if event.state.control_mask? and key_name != "ctrl"
+    key_str_parts << "alt" if event.state.mod1_mask? and key_name != "alt"
+
+    key_str_parts << key_name
+    key_str = key_str_parts.join("-")
+    keynfo = { :key_str => key_str, :key_name => key_name, :keyval => event.keyval }
+    puts keynfo.inspect
+    # $kbd.match_key_conf(key_str, nil, :key_press)
+    # puts "key_str=#{key_str} key_"
+
+    if key_str != "" # or prefixed_key_str != ""
+      if sig == :key_release_event and event.keyval == @last_keyval
+        $kbd.match_key_conf(key_str + "!", nil, :key_release)
+        @last_event = [event, :key_release]
+      elsif sig == :key_press_event
+        $kbd.match_key_conf(key_str, nil, :key_press)
+        @last_event = [event, key_str, :key_press]
+      end
+      @last_keyval = event.keyval #TODO: outside if?
+    end
+
+    handle_deltas
+
+    # set_focus(5)
+    # false
+
+  end
+
+  def pos_to_coord(i)
+    b = buffer
+    iter = b.get_iter_at(:offset => i)
+    iterxy = get_iter_location(iter)
+    winw = parent_window.width
+    view_width = visible_rect.width
+    gutter_width = winw - view_width
+
+    x = iterxy.x + gutter_width
+    y = iterxy.y
+
+    # buffer_to_window_coords(Gtk::TextWindowType::TEXT, iterxy.x, iterxy.y).inspect
+    # puts buffer_to_window_coords(Gtk::TextWindowType::TEXT, x, y).inspect
+    (x, y) = buffer_to_window_coords(Gtk::TextWindowType::TEXT, x, y)
+    # Ripl.start :binding => binding
+
+    return [x, y]
+  end
+
+  def handle_deltas()
+    any_change = false
+    while d = buf.deltas.shift
+      any_change = true
+      pos = d[0]
+      op = d[1]
+      num = d[2]
+      txt = d[3]
+      if op == DELETE
+        startiter = buffer.get_iter_at(:offset => pos)
+        enditer = buffer.get_iter_at(:offset => pos + num)
+        buffer.delete(startiter, enditer)
+      elsif op == INSERT
+        startiter = buffer.get_iter_at(:offset => pos)
+        buffer.insert(startiter, txt)
+      end
+    end
+    if any_change
+      gui_set_cursor_pos($buffer.id, $buffer.pos) #TODO: only when necessary
+    end
+
+    # sanity_check #TODO
+  end
+
+  def sanity_check()
+    a = buffer.text
+    b = buf.to_s
+    # puts "===================="
+    # puts a.lines[0..10].join()
+    # puts "===================="
+    # puts b.lines[0..10].join()
+    # puts "===================="
+    if a == b
+      puts "Buffers match"
+    else
+      puts "ERROR: Buffer's don't match."
+    end
+  end
+
+  def set_cursor_pos(pos)
+    # return
+    itr = buffer.get_iter_at(:offset => pos)
+    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
+    yalign = 0.5
+
+    if @curpos_mark.nil?
+      @curpos_mark = buffer.create_mark("cursor", itr, false)
+    else
+      buffer.move_mark(@curpos_mark, itr)
+    end
+    scroll_to_mark(@curpos_mark, within_margin, use_align, xalign, yalign)
+    $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)
+    # Ripl.start :binding => binding
+    draw_cursor
+
+    return true
+  end
+
+  def cursor_visible_idle_func
+    puts "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)
+
+    sleep(0.01)
+    # intr = iterxy.intersect(vr)
+    if is_cursor_visible == false
+      # set_cursor_pos(buffer.cursor_position)
+
+      itr = buffer.get_iter_at(:offset => buffer.cursor_position)
+
+      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
+      yalign = 0.5
+
+      scroll_to_iter(itr, within_margin, use_align, xalign, yalign)
+
+      # return true # Call this func again
+    else
+      return false # Don't call this idle func again
+    end
+  end
+
+  def is_cursor_visible
+    vr = visible_rect
+    iter = buffer.get_iter_at(:offset => buffer.cursor_position)
+    iterxy = get_iter_location(iter)
+    iterxy.width = 1 if iterxy.width == 0
+    iterxy.height = 1 if iterxy.height == 0
+
+    intr = iterxy.intersect(vr)
+    if intr.nil?
+      puts iterxy.inspect
+      puts vr.inspect
+      # Ripl.start :binding => binding
+
+      # exit!
+      return false
+    else
+      return true
+    end
+  end
+
+  def ensure_cursor_visible
+    if is_cursor_visible == false
+      Thread.new {
+        sleep 0.01
+        GLib::Idle.add(proc { cursor_visible_idle_func })
+      }
+    end
+  end
+
+  def draw_cursor
+    if is_command_mode
+      itr = buffer.get_iter_at(:offset => buf.pos)
+      itr2 = buffer.get_iter_at(:offset => buf.pos + 1)
+      $view.buffer.select_range(itr, itr2)
+    elsif buf.visual_mode?
+      puts "VISUAL MODE"
+      (_start, _end) = buf.get_visual_mode_range2
+      puts "#{_start}, #{_end}"
+      itr = buffer.get_iter_at(:offset => _start)
+      itr2 = buffer.get_iter_at(:offset => _end + 1)
+      $view.buffer.select_range(itr, itr2)
+    else # Insert mode
+      itr = buffer.get_iter_at(:offset => buf.pos)
+      $view.buffer.select_range(itr, itr)
+      puts "INSERT MODE"
+    end
+  end
+
+  # def quit
+  # destroy
+  # true
+  # end
+end
+

data/lib/vimamsa/{default_key_bindings.rb → key_actions.rb}

@@ -1,4 +1,3 @@
-
 def e_move_forward_char
   buf.move(FORWARD_CHAR)
 end
@@ -29,249 +28,129 @@ def is_visual_mode()
   return 0
 end
 
-reg_act(:easy_jump, proc { easy_jump(:visible_area) }, "Easy jump")
-bindkey "VC s", :easy_jump
-
-reg_act(:savedebug, "savedebug", "Save debug info")
-
-# reg_act(:file_finder, "gui_file_finder", "Fuzzy file finder")
-
-reg_act(:open_file_dialog, "open_file_dialog", "Open file")
-reg_act(:create_new_file, "create_new_file", "Create new file")
-reg_act(:backup_all_buffers, "backup_all_buffers", "Backup all buffers")
-reg_act(:invoke_ack_search, "invoke_ack_search", "Invoke ack search")
-reg_act(:e_move_forward_char, "e_move_forward_char", "")
-reg_act(:e_move_backward_char, "e_move_backward_char", "")
-reg_act(:history_switch_backwards, "history_switch_backwards", "")
-reg_act(:history_switch_forwards, "history_switch_forwards", "")
-
-reg_act(:center_on_current_line, "center_on_current_line", "")
-
-# a = Action.new(:transform_upcase, "Transform selection upcase", proc{ buf.transform_selection(:upcase)  } , [:selection]) 
-
-reg_act(:run_last_macro, proc { $macro.run_last_macro }, "Run last recorded or executed macro")
-bindkey ["VCB M","B m"], :run_last_macro
-
-bindkey "VC , m f", [:find_macro_gui, proc{$macro.find_macro_gui}, "Find named macro"]
-bindkey "C , m n", [:gui_name_macro, proc{$macro.gui_name_macro}, "Name last macro"]
-
-
+reg_act(:easy_jump, proc { EasyJump.start }, "Easy jump")
+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 })
+reg_act(:backup_all_buffers, proc{backup_all_buffers}, "Backup all buffers", { :group => :file })
+reg_act(:e_move_forward_char, "e_move_forward_char", "", { :group => :move })
+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(: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 }, "")
-bindkey "C , j r", :jump_to_random
-
-reg_act(:insert_new_line, proc { buf.insert_new_line()}, "")
-bindkey "I enter", :insert_new_line
-
+reg_act(:insert_new_line, proc { buf.insert_new_line() }, "")
 reg_act(:show_key_bindings, proc { show_key_bindings }, "Show key bindings")
-bindkey "C , ; s k", :show_key_bindings #TODO: better binding
-
 reg_act(:put_file_path_to_clipboard, proc { buf.put_file_path_to_clipboard }, "Put file path of current file to clipboard")
-bindkey "C , , c b", :put_file_path_to_clipboard #TODO: better binding or remove?
-
 # reg_act(:encrypt_file, proc{buf.set_encrypted},"Set current file to encrypt on save")
 reg_act(:encrypt_file, proc { encrypt_cur_buffer }, "Set current file to encrypt on save")
-bindkey "C , , e", :encrypt_file #TODO: better binding
-
 reg_act(:set_unencrypted, proc { buf.set_unencrypted }, "Set current file to save unencrypted")
-bindkey "C , ; u", :set_unencrypted #TODO: better binding
-
-reg_act(:close_all_buffers, proc { bufs.close_all_buffers()  }, "Close all buffers")
-
+reg_act(:set_executable, proc { buf.set_executable }, "Set current file permissions to executable")
+reg_act(:close_all_buffers, proc { bufs.close_all_buffers() }, "Close all buffers")
 reg_act(:close_current_buffer, proc { bufs.close_current_buffer(true) }, "Close current buffer")
-bindkey "C , c b", :close_current_buffer
-
 reg_act(:comment_selection, proc { buf.comment_selection }, "")
-bindkey "V ctrl-c", :comment_selection
-
 reg_act(:delete_char_forward, proc { buf.delete(CURRENT_CHAR_FORWARD) }, "Delete char forward")
-bindkey "C x", :delete_char_forward
-
 reg_act(:load_theme, proc { load_theme }, "Load theme")
-bindkey "C , , l t", :load_theme
-
 reg_act(:gui_file_finder, proc { vma.FileFinder.start_gui }, "Fuzzy file finder")
-bindkey "C , f", :gui_file_finder
-
-
 reg_act(:gui_file_history_finder, proc { vma.FileHistory.start_gui }, "Fuzzy file history finder")
-bindkey "C , h", :gui_file_history_finder
-
-
 reg_act(:gui_search_replace, proc { gui_search_replace }, "Search and replace")
-bindkey "C , r r", :gui_search_replace
-bindkey "V , r r", :gui_search_replace
-
 reg_act(:set_style_bold, proc { buf.style_transform(:bold) }, "Set text weight to bold")
-bindkey "V , t b", :set_style_bold
-
 reg_act(:set_style_link, proc { buf.style_transform(:link) }, "Set text as link")
-bindkey "V , t l", :set_style_link
-
 reg_act(:V_join_lines, proc { vma.buf.convert_selected_text(:joinlines) }, "Join lines")
-bindkey "V J", :V_join_lines
-
-
 reg_act(:clear_formats, proc { buf.style_transform(:clear) }, "Clear style formats")
-bindkey "V , t c", :clear_formats
-
 reg_act(:set_line_style_heading, proc { buf.set_line_style(:heading) }, "Set style of current line as heading")
-bindkey "C , t h", :set_line_style_heading
-
 reg_act(:set_line_style_h1, proc { buf.set_line_style(:h1) }, "Set cur line as Heading 1")
-bindkey "C , t 1", :set_line_style_h1
 reg_act(:set_line_style_h2, proc { buf.set_line_style(:h2) }, "Set cur line as Heading 1")
-bindkey "C , t 2", :set_line_style_h2
 reg_act(:set_line_style_h3, proc { buf.set_line_style(:h3) }, "Set cur line as Heading 1")
-bindkey "C , t 3", :set_line_style_h3
 reg_act(:set_line_style_h4, proc { buf.set_line_style(:h4) }, "Set cur line as Heading 1")
-bindkey "C , t 4", :set_line_style_h4
-
-
 reg_act(:set_line_style_bold, proc { buf.set_line_style(:bold) }, "Set style of current line as bold")
-bindkey "C , t b", :set_line_style_bold
-
 reg_act(:set_line_style_title, proc { buf.set_line_style(:title) }, "Set style of current line as title")
-bindkey "C , t t", :set_line_style_title
-
 reg_act(:clear_line_styles, proc { buf.set_line_style(:clear) }, "Clear styles of current line")
-bindkey "C , t c", :clear_line_styles
-
 reg_act(:gui_select_buffer, proc { $kbd.set_mode("S"); gui_select_buffer }, "Select buffer")
-bindkey "C , b", :gui_select_buffer
-
 reg_act :open_file_dialog, "open_file_dialog", "Open file"
-# bindkey "C , f o", :open_file_dialog
-bindkey "CI ctrl-o", :open_file_dialog
-
 reg_act :minibuffer_end, proc { minibuffer_end }
-bindkey "M enter", :minibuffer_end
-
 reg_act(:invoke_replace, "invoke_replace", "")
 reg_act(:diff_buffer, "diff_buffer", "")
-
 # reg_act(:invoke_grep_search, proc{invoke_grep_search}, "")
 reg_act(:invoke_grep_search, proc { gui_grep }, "Grep current buffer")
-
-
 reg_act(:ack_search, proc { gui_ack }, "") #invoke_ack_search
-bindkey "C , a", :ack_search
-
 reg_act :update_file_index, proc { update_file_index }, "Update file index"
-
-
 reg_act :delete_to_word_end, proc { buf.delete2(:to_word_end) }, "Delete to file end"
-bindkey  "C d w", :delete_to_word_end
-
 reg_act :delete_to_line_start, proc { buf.delete2(:to_line_start) }, "Delete to line 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
-bindkey "B z", "center_on_current_line();call(:exit_browse_mode)"
-
 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)
+reg_act :exit_browse_mode, proc {
+  bufs.add_current_buf_to_history(); $kbd.set_mode(:command); $kbd.set_default_mode(:command)
 }, "Exit browse mode"
-#TODO: Need to deside which of these is best:
-bindkey "B enter || B return || B esc || B j || B ctrl!", :exit_browse_mode
-
-reg_act :page_down, proc {page_down}
-reg_act :page_up, proc {page_up}
-bindkey "B s", :page_up
-bindkey "B d", :page_down
-bindkey "B s", :page_up
-bindkey "B d", :page_down
-
-reg_act :jump_to_start_of_buffer, proc{buf.jump(START_OF_BUFFER)}, "Jump to start of buffer"
-reg_act :jump_to_end_of_buffer, proc{buf.jump(END_OF_BUFFER)}, "Jump to end of buffer"
-
-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", :invoke_grep_search
-#bindkey 'C , g', proc{invoke_grep_search}
 
+reg_act :page_down, proc { page_down }
+reg_act :page_up, proc { page_up }
+reg_act :jump_to_start_of_buffer, proc { buf.jump(START_OF_BUFFER) }, "Jump to start of buffer"
+reg_act :jump_to_end_of_buffer, proc { buf.jump(END_OF_BUFFER) }, "Jump to end of buffer"
 reg_act(:auto_indent_buffer, proc { buf.indent }, "Auto format buffer")
-bindkey "C , v", :auto_indent_buffer
-bindkey "C , , d", :savedebug
-bindkey "C , , u", :update_file_index
-
-bindkey "C , s a", "buf.save_as()"
-
-
-
-reg_act(:execute_current_line_in_terminal, proc { buf.execute_current_line_in_terminal }, "Execute current line in terminal")
-
+reg_act(:execute_current_line_in_terminal, proc { buf.execute_current_line_in_terminal }, "Execute current line in terminalL")
+reg_act(:execute_current_line_in_terminal_autoclose, proc { buf.execute_current_line_in_terminal(true) }, "Execute current line in terminal. Close after execution.")
 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")
 
+act_list = {
+  # File handling
+  :buf_save => { :proc => proc { buf.save },
+                 :desc => "Save buffer", :group => :file },
 
-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)},""]
+  :buf_save_as => { :proc => proc { buf.save_as },
+                    :desc => "Save file as", :group => :file },
+  :buf_new => { :proc => proc { create_new_file() }, :desc => "Create a new file", :group => :file },
+  :buf_revert => { :proc => proc { buf.revert },
+                   :desc => "Reload file from disk", :group => :file },
+  :buf_backup => { :proc => proc { buf.backup() }, :desc => "Backup current file", :group => :file },
 
+  :edit_redo => { :proc => proc { buf.redo },
+                  :desc => "Redo edit", :group => :edit },
 
-# reg_act(:start_file_selector, proc { FileSelector.new.run; $kbd.set_mode(:file_exp) }, "File selector")
-# bindkey "C , j f", :start_file_selector
-# bindkey "C , f", :start_file_selector
+  :edit_undo => { :proc => proc { buf.undo },
+                  :desc => "Undo edit", :group => :edit },
 
-# $kbd.add_minor_mode('fexp', :file_exp, :command)
+  :find_in_buffer => { :proc => proc { invoke_search },
+                  :desc => "Find", :group => :edit },
 
-# bindkey  "fexp l" , [:fexp_right,proc{puts "==fexp_right=="},""]
-# bindkey  "fexp esc" , [:fexp_quit,proc{$kbd.set_mode(:command)},""]
-# bindkey  "fexp enter" , [:fexp_select,proc{buf.module.select_line},""]
 
-# bindkey "C , j j", [:mode_file_exp, proc{$kbd.set_mode(:file_exp)}, "fexp"]
+  # { :proc => proc {  },
+  # :desc => "", :group => : },
 
-#bindkey 'C z h', :history_switch_backwards
-#bindkey 'C z l', :history_switch_forwards
+  :search_actions => { :proc => proc { search_actions },
+                       :desc => "Search actions", :group => :search },
 
+  :quit => { :proc => proc { _quit },
+             :desc => "Quit", :group => :app },
 
-#TODO: Change these evals into  proc{}'s
-default_keys = {
+}
 
-  # File handling
-  "C ctrl-s" => "buf.save",
-  "C W" => "buf.save",
+for k, v in act_list
+  reg_act(k, v[:proc], v[:desc])
+end
+
+act_list_todo = {
 
   # Buffer handling
-  "C B" => "bufs.switch",
-  "C tab" => "bufs.switch_to_last_buf",
+  # : =>  {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',
-  "C , r v b" => "buf.revert",
-  "C , c b" => "bufs.close_current_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',
-  "C , n b" => "create_new_file()",
-  "C , ." => "buf.backup()",
-  # "C , , ." => "backup_all_buffers()",
-  "VC , , s" => "search_actions()",
 
 
   # MOVING
   #    'VC h' => 'buf.move(BACKWARD_CHAR)',
-  "VC l" => "buf.move(FORWARD_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)",
 
@@ -289,6 +168,9 @@ default_keys = {
   #    '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>)',
@@ -343,7 +225,6 @@ default_keys = {
   "C /[1-9]/" => "set_next_command_count(<char>)",
 
   # Command mode only:
-  "C ctrl-r" => "buf.redo()", # TODO:???
   "C R" => "buf.redo()",
   "C v" => "buf.start_visual_mode",
   "C P" => "buf.paste(BEFORE)", # TODO: implement as replace for visual mode
@@ -377,7 +258,7 @@ default_keys = {
   # Visual mode only:
   "V esc" => "buf.end_visual_mode",
   "V ctrl!" => "buf.end_visual_mode",
-  "V y" => "buf.copy_active_selection",
+  "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)",
@@ -402,20 +283,19 @@ default_keys = {
   # Macros
   # (experimental, may not work correctly)
   # "C q a" => '$macro.start_recording("a")',
-  "VC q <char>" => '$macro.start_recording(<char>)',
+  "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 @ <char>" => "$macro.run_macro(<char>)",
   "C , m S" => '$macro.save_macro("a")',
-  "C , m s" => '$macro.save',
+  "C , m s" => "$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!" => "$kbd.set_mode(:command)",
@@ -435,11 +315,11 @@ default_keys = {
   "I alt-f" => "buf.jump_word(FORWARD,WORD_START)",
   "I alt-b" => "buf.jump_word(BACKWARD,WORD_START)",
 
-  "I tab" => 'buf.insert_txt("  ")',
+  "I tab" => 'buf.insert_txt("	")',
   "I space" => 'buf.insert_txt(" ")',
 #  "I return" => 'buf.insert_new_line()',
 }
 
-default_keys.each { |key, value|
-  bindkey(key, value)
-}
+# default_keys.each { |key, value|
+# bindkey(key, value)
+# }