vimamsa 0.1.22 → 0.1.24

data/lib/vimamsa/gui_sourceview.rb

@@ -2,7 +2,6 @@
 class VSourceView < GtkSource::View
   attr_accessor :bufo, :autocp_active, :cpl_list
 
-
   # def initialize(title = nil,bufo=nil)
   def initialize(title, bufo)
     # super(:toplevel)
@@ -19,6 +18,7 @@ class VSourceView < GtkSource::View
     @tt = nil
 
     # 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")
       # handle_scrolling()
@@ -45,8 +45,90 @@ class VSourceView < GtkSource::View
     @curpos_mark = nil
   end
 
+  # Replace each character of every «word with * so the GTK buffer never
+  # exposes the real content. Length is preserved → buffer offsets stay valid.
+  def mask_for_display(str)
+    str.gsub(/(?<=«)\S+/) { |w| "*" * w.length }
+  end
+
   def set_content(str)
-    self.buffer.set_text(str)
+    if @bufo&.lang == "hyperplaintext"
+      self.buffer.set_text(mask_for_display(str))
+    else
+      self.buffer.set_text(str)
+    end
+  end
+
+  # Sync the GTK buffer to mask_for_display(@bufo.to_s).
+  # Handles both directions:
+  #   - masks unmasked «word regions (e.g. after typing a new «)
+  #   - unmasks orphaned *** spans left behind when « is deleted
+  def remask_gtk_buffer
+    return unless @bufo&.lang == "hyperplaintext"
+    ruby_text = @bufo.to_s
+    expected  = mask_for_display(ruby_text)
+    gtk_text  = buffer.text
+    return if expected == gtk_text
+    return if expected.length != gtk_text.length  # sanity check
+
+    # Find the smallest enclosing differing range and fix it in one edit.
+    i = 0
+    i += 1 while i < expected.length && expected[i] == gtk_text[i]
+    j = expected.length - 1
+    j -= 1 while j >= i && expected[j] == gtk_text[j]
+
+    s_iter = buffer.get_iter_at(:offset => i)
+    e_iter = buffer.get_iter_at(:offset => j + 1)
+    buffer.delete(s_iter, e_iter)
+    buffer.insert(buffer.get_iter_at(:offset => i), expected[i..j])
+  end
+
+  # Returns [word, word_start, word_end] if +pos+ (Ruby-buffer offset) is
+  # inside a «word region, nil otherwise.
+  def masked_word_at_cursor(pos)
+    text = @bufo.to_s
+    return nil unless text.include?("«")
+    text.scan(/«(\S+)/) do
+      word       = $1
+      word_start = $~.begin(0) + 1   # first char after «
+      word_end   = word_start + word.length
+      return [word, word_start, word_end] if pos >= word_start && pos <= word_end
+    end
+    nil
+  end
+
+  # Replace the masked (***) span with the real word from the Ruby buffer.
+  def unmask_gtk_region(word, word_start, word_end)
+    s_iter = buffer.get_iter_at(:offset => word_start)
+    e_iter = buffer.get_iter_at(:offset => word_end)
+    buffer.delete(s_iter, e_iter)
+    buffer.insert(buffer.get_iter_at(:offset => word_start), word)
+  end
+
+  # When in insert mode with cursor on a «word, expose the real text in the GTK
+  # buffer so the user can see/edit it. Re-mask when cursor leaves or mode changes.
+  def update_cursor_unmask
+    return unless @bufo&.lang == "hyperplaintext"
+    ctype = vma.kbd.get_cursor_type
+    pos   = @bufo.pos
+
+    if ctype == :insert
+      result = masked_word_at_cursor(pos)
+      if result
+        word, word_start, word_end = result
+        return if @unmasked_range == [word_start, word_end]  # already showing this word
+        remask_gtk_buffer if @unmasked_range                 # re-mask previous region
+        unmask_gtk_region(word, word_start, word_end)
+        @unmasked_range = [word_start, word_end]
+        return
+      end
+    end
+
+    # Not insert mode, or cursor is not over a masked word — ensure everything masked
+    if @unmasked_range
+      @unmasked_range = nil
+      remask_gtk_buffer
+    end
   end
 
   def gutter_width()
@@ -174,9 +256,24 @@ class VSourceView < GtkSource::View
       i = coord_to_iter(x, y, true)
       pp i
       @range_start = i
+      @drag_start_x = x
+      @drag_start_y = y
       buf.start_selection
     end
 
+    @cnt_drag.signal_connect "drag-update" do |gesture, offset_x, offset_y|
+      next unless @range_start
+      cur_x = @drag_start_x + offset_x
+      cur_y = @drag_start_y + offset_y
+      debug "drag-update 2 #{cur_x} #{cur_y}"
+      i = coord_to_iter(cur_x, cur_y, true)
+      @bufo.set_pos(i) if !i.nil? and @last_iter != i
+      if !i.nil? and (@range_start - i).abs >= 2
+      vma.kbd.set_mode(:visual)
+      end
+      @last_iter = i
+    end
+
     @cnt_drag.signal_connect "drag-end" do |gesture, offsetx, offsety|
       debug "drag-end", 2
       if offsetx.abs < 5 and offsety.abs < 5
@@ -186,8 +283,7 @@ class VSourceView < GtkSource::View
       elsif vma.kbd.get_scope != :editor
         # Can't transition from editor wide mode to buffer specific mode
         vma.kbd.set_mode(:visual)
-      else
-        buf.end_selection
+      else # The normal case
       end
       @range_start = nil
     end
@@ -199,8 +295,22 @@ class VSourceView < GtkSource::View
     @click = click
 
     @range_start = nil
+
+    # Handle right click
+    rightclick = Gtk::GestureClick.new
+    rightclick.button = 3
+    self.add_controller(rightclick)
+    rightclick.signal_connect "pressed" do |gesture, n_press, x, y, z|
+      puts "SourceView, GestureClick rightclick released button=#{gesture.button} x=#{x} y=#{y}"
+      if gesture.button == 3
+        show_context_menu(x, y)
+        next true
+      end
+    end
+
     click.signal_connect "pressed" do |gesture, n_press, x, y, z|
       debug "SourceView, GestureClick released x=#{x} y=#{y}"
+      vma.gui.instance_variable_set(:@kbd_passthrough, false)
 
       if buf.visual_mode?
         buf.end_visual_mode
@@ -219,11 +329,19 @@ class VSourceView < GtkSource::View
       end
 
       @bufo.set_pos(i) if !i.nil?
+      if n_press == 2
+        #TODO: refactor to have one function for all line actions
+        if @bufo.module&.respond_to?(:select_line)
+          @bufo.module.select_line
+        else
+          @bufo.cur_nonwhitespace_word_action()
+        end
+      end
       true
     end
 
     click.signal_connect "released" do |gesture, n_press, x, y, z|
-      debug "SourceView, GestureClick released x=#{x} y=#{y}"
+      debug "SourceView, GestureClick released x=#{x} y=#{y} button=#{gesture.button}"
 
       xloc = (x - gutter_width).to_i
       yloc = (y + visible_rect.y).to_i
@@ -449,6 +567,7 @@ class VSourceView < GtkSource::View
       end
     end
     if any_change
+      remask_gtk_buffer
       #TODO: only when necessary
       self.set_cursor_pos(pos)
     end
@@ -573,7 +692,7 @@ class VSourceView < GtkSource::View
         self.style_context.add_provider(prov)
         @cursor_prov = prov
       end
-      @ctype == ctype
+      @ctype = ctype
     end
   end
 
@@ -587,7 +706,7 @@ class VSourceView < GtkSource::View
 
     mode = vma.kbd.get_mode
     ctype = vma.kbd.get_cursor_type
-    ctype = :visual if vma.buf.selection_active?
+    ctype = :visual if @bufo.selection_active?
 
     if [:command, :replace, :browse].include?(ctype)
       set_cursor_color(ctype)
@@ -631,6 +750,75 @@ class VSourceView < GtkSource::View
       self.cursor_visible = false
       self.cursor_visible = true
     end
+
+    update_cursor_unmask
   end #end draw_cursor
-end
 
+  CONTEXT_MENU_ITEMS = [
+    ["Paste", :paste_after_cursor],
+    ["Previous buffer", :history_switch_backwards],
+  ]
+
+  CONTEXT_MENU_ITEMS_SELECTION = [
+    ["Copy", :copy_selection],
+    ["Cut", :cut_selection],
+  ]
+
+  def init_context_menu
+    all_items = CONTEXT_MENU_ITEMS + CONTEXT_MENU_ITEMS_SELECTION
+    all_items.each do |label, action_id|
+      actkey = "ctx_#{action_id}"
+      unless vma.gui.app.lookup_action(actkey)
+        act = Gio::SimpleAction.new(actkey)
+        vma.gui.app.add_action(act)
+        act.signal_connect("activate") do
+          call_action(action_id)
+          after_action
+        end
+      end
+    end
+
+    unless vma.gui.app.lookup_action("ctx_open_link")
+      act = Gio::SimpleAction.new("ctx_open_link")
+      vma.gui.app.add_action(act)
+      act.signal_connect("activate") do
+        next unless @context_link
+        if is_url(@context_link)
+          open_url(@context_link)
+        else
+          fn = hpt_check_cur_word(@context_link)
+          open_existing_file(fn) if fn
+        end
+      end
+    end
+
+    @context_menu = Gtk::PopoverMenu.new
+    @context_menu.set_parent(self)
+    @context_menu.has_arrow = false
+  end
+
+  def link_at(x, y)
+    bx, by = window_to_buffer_coords(:widget, x.to_i, y.to_i)
+    iter = get_iter_at_location(bx, by)
+    return nil unless iter
+    word, _range = @bufo.get_word_in_pos(iter.offset, boundary: :space)
+    return nil unless word
+    return word if is_url(word)
+    return word if word.match?(/⟦.+⟧/)
+    nil
+  end
+
+  def show_context_menu(x, y)
+    init_context_menu if @context_menu.nil?
+    menu = Gio::Menu.new
+    @context_link = link_at(x, y)
+    menu.append("Open link", "app.ctx_open_link") if @context_link
+    CONTEXT_MENU_ITEMS.each { |label, action_id| menu.append(label, "app.ctx_#{action_id}") }
+    if @bufo.selection_active?
+      CONTEXT_MENU_ITEMS_SELECTION.each { |label, action_id| menu.append(label, "app.ctx_#{action_id}") }
+    end
+    @context_menu.set_menu_model(menu)
+    @context_menu.set_pointing_to(Gdk::Rectangle.new(x.to_i, y.to_i, 1, 1))
+    @context_menu.popup
+  end
+end

data/lib/vimamsa/gui_text.rb

@@ -24,26 +24,4 @@ module Gui
       self.hilight_range(bf, r, tag: tag)
     }
   end
-
-  def self.highlight_match_old(bf, str, color: "#aa0000ff")
-    vbuf = bf.view.buffer
-    r = Regexp.new(Regexp.escape(str), Regexp::IGNORECASE)
-
-    hlparts = []
-
-    tt = vma.gui.view.buffer.tag_table.lookup("highlight_match_tag")
-    if tt.nil?
-      tt = vma.gui.view.buffer.create_tag("highlight_match_tag")
-    end
-
-    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

@@ -133,3 +133,4 @@ def hpt_scan_images(bf = nil)
 
   # vma.gui.delex.run #TODO:gtk4
 end
+

data/lib/vimamsa/key_actions.rb

@@ -18,15 +18,6 @@ def jump_to_next_edit
   buf.jump_to_next_edit
 end
 
-def is_command_mode()
-  return true if vma.kbd.mode_root_state.to_s() == "C"
-  return false
-end
-
-def is_visual_mode()
-  return 1 if vma.kbd.mode_root_state.to_s() == "V"
-  return 0
-end
 
 reg_act(:command_to_buf, proc { command_to_buf }, "Execute command, output to buffer")
 
@@ -35,9 +26,19 @@ reg_act(:lsp_jump_to_definition, proc { vma.buf.lsp_jump_to_def }, "LSP jump to
 
 reg_act(:eval_buf, proc { vma.buf.eval_whole_buf }, "Eval whole current buffer as ruby code (DANGEROUS)")
 
+reg_act(:show_settings, proc { show_settings_dialog }, "Show settings")
+reg_act(:cut_selection, proc { buf.delete(SELECTION) }, "Cut selection to clipboard")
+
+reg_act(:insert_backspace, proc { buf.selection_active? ? buf.delete(SELECTION) : buf.delete(BACKWARD_CHAR) }, "Delete backwards")
+reg_act(:insert_select_up, proc { insert_select_move(BACKWARD_LINE) }, "Select texte upwards")
+reg_act(:insert_select_down, proc { insert_select_move(FORWARD_LINE) }, "Select text downwards")
+
+reg_act(:copy_selection, proc { buf.copy_active_selection }, "Copy selection to clipboard")
 reg_act(:enable_debug, proc { cnf.debug = true }, "Enable debug")
 reg_act(:disable_debug, proc { cnf.debug = false }, "Disable debug")
 
+reg_act(:experimental_eval, proc { bindkey "V , e", "vma.buf.convert_selected_text(:eval)" }, "Enable key binding:\"[VISUAL] , e:\" Eval selected text")
+
 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")
@@ -46,18 +47,20 @@ 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, :basic] })
-reg_act(:e_move_backward_char, "e_move_backward_char", "", { :group => [:move, :basic] })
+reg_act(:e_move_forward_char, "e_move_forward_char", "Move forward", { :group => [:move, :basic] })
+reg_act(:e_move_backward_char, "e_move_backward_char", "Move forward", { :group => [:move, :basic] })
 # reg_act(:history_switch_backwards, proc{bufs.history_switch_backwards}, "", { :group => :file })
-reg_act(:history_switch_backwards, proc{bufs.history_switch(-1)}, "", { :group => :file })
-reg_act(:history_switch_forwards, proc{bufs.history_switch(+1)}, "", { :group => :file })
+reg_act(:history_switch_backwards, proc { bufs.history_switch(-1) }, "Prev buffer", { :group => :file })
+reg_act(:history_switch_forwards, proc { bufs.history_switch(+1) }, "Next buffer", { :group => :file })
+reg_act(:print_buffer_access_list, proc { bufs.print_by_access_time }, "Print buffers by access time", { :group => :file })
 reg_act(:center_on_current_line, "center_on_current_line", "", { :group => :view })
 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_next_edit, "jump_to_next_edit", "Jump to next edit pos")
+reg_act(:jump_to_last_edit, proc { buf.jump_to_last_edit }, "Jump to last edit pos")
 reg_act(:jump_to_random, proc { buf.jump_to_random_pos }, "")
-reg_act(:insert_new_line, proc { buf.insert_new_line() }, "")
+reg_act(:insert_new_line, proc { buf.insert_new_line() }, "Insert new line")
 reg_act(:show_key_bindings, proc { show_key_bindings }, "Show key bindings")
+reg_act(:show_free_key_bindings, proc { show_free_key_bindings }, "Show available (unbound) key binding slots")
 reg_act(:put_file_path_to_clipboard, proc { buf.put_file_path_to_clipboard }, "Put file path of current file to clipboard")
 reg_act(:put_file_ref_to_clipboard, proc { buf.put_file_ref_to_clipboard }, "Put file ref of current file to clipboard")
 
@@ -67,11 +70,19 @@ reg_act(:set_unencrypted, proc { buf.set_unencrypted }, "Set current file to sav
 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")
-reg_act(:comment_selection, proc { buf.comment_selection }, "")
+reg_act(:toggle_file_panel, proc { vma.gui.toggle_file_panel }, "Toggle file panel")
+reg_act(:show_message_history, proc { vma.gui.show_message_history }, "Show message history")
+reg_act(:toggle_func_panel, proc { vma.gui.toggle_func_panel }, "Toggle LSP function panel")
+reg_act(:refresh_func_panel, proc { vma.gui.func_panel_refresh }, "Refresh LSP function panel")
+reg_act(:git_diff_w, proc { git_diff_w }, "Show git diff -w for whole repository")
+reg_act(:lsp_print_functions, proc { lsp_print_functions }, "LSP print functions in current file")
+reg_act(:comment_selection, proc { buf.comment_selection }, "Comment selection")
 reg_act(:delete_char_forward, proc { buf.delete(CURRENT_CHAR_FORWARD) }, "Delete char forward", { :group => [:edit, :basic] })
 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")
+reg_act(:find_next, proc { $search.jump_to_next() }, "Find next")
+
 reg_act(:set_style_bold, proc { buf.style_transform(:bold) }, "Set text weight to bold")
 reg_act(:set_style_link, proc { buf.style_transform(:link) }, "Set text as link")
 reg_act(:V_join_lines, proc { vma.buf.convert_selected_text(:joinlines) }, "Join lines")
@@ -87,8 +98,10 @@ reg_act(:clear_line_styles, proc { buf.set_line_style(:clear) }, "Clear styles o
 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", "")
+reg_act(:invoke_replace, "invoke_replace", "Invoke replace")
 reg_act(:diff_buffer, "diff_buffer", "")
+reg_act(:git_diff_buffer, proc { git_diff_buffer }, "Show git diff of current file")
+reg_act(:diff_buffer_jump_to_source, proc { diff_buffer_jump_to_source }, "Jump to corresponding line in source from 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
@@ -97,35 +110,42 @@ 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 }, "Ack")
 
-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(: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(:paste_over_after, proc { buf.paste_over(AFTER) }, "Paste over selection or after cursor")
+reg_act(:paste_over_before, proc { buf.paste_over(BEFORE) }, "Paste over selection or before 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_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(: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(: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(:install_demo_files, proc { install_demo_files }, "Install and show Demo")
+reg_act(:reload_customrb, proc { reload_customrb }, "Reload custom.rb")
 
 reg_act :start_browse_mode, proc {
   vma.kbd.set_mode(:browse)
   bufs.reset_navigation
 }, "Start browse mode"
 reg_act :kbd_dump_state, proc { vma.kbd.dump_state }, "Dump keyboard tree state"
+reg_act :toggle_kbd_passthrough, proc {
+  vma.gui.instance_variable_set(:@kbd_passthrough, !vma.gui.instance_variable_get(:@kbd_passthrough))
+  state = vma.gui.instance_variable_get(:@kbd_passthrough) ? "ON" : "OFF"
+  message("Keyboard passthrough: #{state}")
+}, "Toggle keyboard event passthrough (allow other widgets to receive key events)"
 
 reg_act :exit_browse_mode, proc {
   bufs.add_current_buf_to_history
@@ -189,6 +209,9 @@ act_list = {
   :backward_line => { :proc => proc { buf.move(BACKWARD_LINE) },
                       :desc => "Move one line backward", :group => [:move, :basic] },
 
+  :increment_word => { :proc => proc { buf.increment_current_word },
+                       :desc => "Increment word", :group => [:edit, :extra] },
+
   # { :proc => proc {  },
   # :desc => "", :group => : },