vimamsa 0.1.13 → 0.1.14

data/lib/vimamsa/gui.rb

@@ -6,7 +6,6 @@ def gui_open_file_dialog(dirpath)
                                       :buttons => [["Open", :accept],
                                                    ["Cancel", :cancel]])
   dialog.set_current_folder(Gio::File.new_for_path(dirpath))
-  # dialog.set_current_folder(Gio::File.new_for_path("/tmp"))
 
   dialog.signal_connect("response") do |dialog, response_id|
     if response_id == Gtk::ResponseType::ACCEPT
@@ -24,7 +23,7 @@ def gui_file_saveas(dirpath)
                                       :action => :save,
                                       :buttons => [["Save", :accept],
                                                    ["Cancel", :cancel]])
-  # dialog.set_current_folder(dirpath) #TODO:gtk4
+  dialog.set_current_folder(Gio::File.new_for_path(dirpath))
   dialog.signal_connect("response") do |dialog, response_id|
     if response_id == Gtk::ResponseType::ACCEPT
       file_saveas(dialog.file.parse_name)
@@ -36,32 +35,6 @@ def gui_file_saveas(dirpath)
   dialog.show
 end
 
-def idle_func
-  # debug "IDLEFUNC"
-  if $idle_scroll_to_mark
-    # $view.get_visible_rect
-    vr = $view.visible_rect
-
-    # iter = b.get_iter_at(:offset => i)
-
-    b = $view.buffer
-    iter = b.get_iter_at(:offset => b.cursor_position)
-    iterxy = $view.get_iter_location(iter)
-    # debug "ITERXY" + iterxy.inspect
-
-    intr = iterxy.intersect(vr)
-    if intr.nil?
-      $view.set_cursor_pos($view.buffer.cursor_position)
-    else
-      $idle_scroll_to_mark = false
-    end
-
-    sleep(0.1)
-  end
-  sleep(0.01)
-  return true
-end
-
 def center_on_current_line()
   b = $view.buffer
   iter = b.get_iter_at(:offset => b.cursor_position)
@@ -91,9 +64,6 @@ def page_down
 end
 
 
-def set_system_clipboard(arg)
-  vma.gui.window.display.clipboard.set(arg)
-end
 
 def gui_create_buffer(id, bufo)
   debug "gui_create_buffer(#{id})"
@@ -101,7 +71,7 @@ def gui_create_buffer(id, bufo)
   view = VSourceView.new(nil, bufo)
 
   view.register_signals()
-  $debug = true
+  cnf.debug = true
 
   ssm = GtkSource::StyleSchemeManager.new
   ssm.set_search_path(ssm.search_path << ppath("styles/"))
@@ -118,6 +88,7 @@ def gui_create_buffer(id, bufo)
   provider.load(data: "textview { font-family: Monospace; font-size: 11pt; }")
   view.style_context.add_provider(provider)
   view.wrap_mode = :char
+  pp $cnf
   view.set_tab_width(conf(:tab_width))
 
   $vmag.buffers[id] = view

data/lib/vimamsa/gui_dialog.rb

@@ -0,0 +1,113 @@
+module Gui
+  def self.confirm(title, callback)
+    params = {}
+    params["title"] = title
+    params["inputs"] = {}
+    params["inputs"]["yes_btn"] = { :label => "Yes", :type => :button, :default_focus => true }
+    params[:callback] = callback
+    PopupFormGenerator.new(params).run
+  end
+end
+
+module Gtk
+  class Frame
+    def margin=(a)
+      self.margin_bottom = a
+      self.margin_top = a
+      self.margin_end = a
+      self.margin_start = a
+    end
+  end
+
+  class Box
+    def margin=(a)
+      self.margin_bottom = a
+      self.margin_top = a
+      self.margin_end = a
+      self.margin_start = a
+    end
+  end
+end
+
+def set_margin_all(widget, m)
+  widget.margin_bottom = m
+  widget.margin_top = m
+  widget.margin_end = m
+  widget.margin_start = m
+end
+
+class OneInputAction
+  def initialize(main_window, title, field_label, button_title, callback, opt = {})
+    @window = Gtk::Window.new()
+    # @window.screen = main_window.screen
+    # @window.title = title
+    @window.title = ""
+
+    frame = Gtk::Frame.new()
+    # frame.margin = 20
+    @window.set_child(frame)
+
+    infolabel = Gtk::Label.new
+    infolabel.markup = title
+
+    vbox = Gtk::Box.new(:vertical, 8)
+    vbox.margin = 10
+    frame.set_child(vbox)
+
+    hbox = Gtk::Box.new(:horizontal, 8)
+    # @window.add(hbox)
+    vbox.pack_end(infolabel, :expand => false, :fill => false, :padding => 0)
+    vbox.pack_end(hbox, :expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => button_title)
+    cancel_button = Gtk::Button.new(:label => "Cancel")
+
+    label = Gtk::Label.new(field_label)
+
+    @entry1 = Gtk::Entry.new
+
+    if opt[:hide]
+      @entry1.visibility = false
+    end
+
+    button.signal_connect "clicked" do
+      callback.call(@entry1.text)
+      @window.destroy
+    end
+
+    cancel_button.signal_connect "clicked" do
+      @window.destroy
+    end
+
+    press = Gtk::EventControllerKey.new
+    press.set_propagation_phase(Gtk::PropagationPhase::CAPTURE)
+    @window.add_controller(press)
+    press.signal_connect "key-pressed" do |gesture, keyval, keycode, y|
+      if keyval == Gdk::Keyval::KEY_Return
+        callback.call(@entry1.text)
+        @window.destroy
+        true
+      elsif keyval == Gdk::Keyval::KEY_Escape
+        @window.destroy
+        true
+      else
+        false
+      end
+    end
+
+    hbox.pack_end(label, :expand => false, :fill => false, :padding => 0)
+    hbox.pack_end(@entry1, :expand => false, :fill => false, :padding => 0)
+    hbox.pack_end(button, :expand => false, :fill => false, :padding => 0)
+    hbox.pack_end(cancel_button, :expand => false, :fill => false, :padding => 0)
+    return
+  end
+
+  def run
+    if !@window.visible?
+      @window.show
+    else
+      @window.destroy
+    end
+    @window
+  end
+end

data/lib/vimamsa/gui_sourceview.rb

@@ -291,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"
@@ -311,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("-")
@@ -433,13 +436,9 @@ class VSourceView < GtkSource::View
   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
@@ -483,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
 

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,9 +1,7 @@
 def hpt_check_cur_word(w)
   debug "check_cur_word(w)"
-  m = w.match(/⟦((audio|img):)(.*)⟧/)
+  m = w.match(/⟦((audio|img):)?(.*)⟧/)
   if m
-    # Ripl.start :binding => binding
-
     fpfx = m[3]
     if vma.buf.fname
       dn = File.dirname(vma.buf.fname)
@@ -17,8 +15,9 @@ 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
@@ -27,8 +26,12 @@ def hpt_check_cur_word(w)
       if fn
         if m[2] == "audio"
           # Thread.new { Audio.play(fn) }
-          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

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,10 +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 },
@@ -168,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)
-# }