vimamsa 0.1.10 → 0.1.12

data/lib/vimamsa/gui_sourceview.rb

@@ -1,73 +1,68 @@
-
-
 # class VSourceView < Gtk::TextView
 class VSourceView < GtkSource::View
-  attr_accessor :bufo 
+  attr_accessor :bufo
   # :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)
+  def initialize(title, bufo)
     # super(:toplevel)
     @highlight_matching_brackets = true
+    @idle_func_running = false
     super()
     @bufo = bufo #object of Buffer class buffer.rb
     debug "vsource init"
     @last_keyval = nil
     @last_event = [nil, nil]
-    self.drag_dest_add_image_targets
-    self.drag_dest_add_uri_targets
-
-    signal_connect "button-press-event" do |_widget, event|
-      if event.button == Gdk::BUTTON_PRIMARY
-        # debug "Gdk::BUTTON_PRIMARY"
-        false
-      elsif event.button == Gdk::BUTTON_SECONDARY
-        # debug "Gdk::BUTTON_SECONDARY"
-        true
-      else
-        true
-      end
-    end
-
-    signal_connect("drag-data-received") do |widget, event, x, y, data, info, time|
-      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("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
-
+    @removed_controllers = []
+    self.highlight_current_line = true
+
+    @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
+
+    # Mainly after page-up or page-down
     signal_connect("move-cursor") do |widget, event|
+      debug("MOVE-CURSOR", 2)
       $update_cursor = true
+      # handle_scrolling()
+      # curpos = buffer.cursor_position
+      # debug "MOVE CURSOR (sig): #{curpos}"
+
+      # run_as_idle proc {
+      # curpos = buffer.cursor_position
+      # debug "MOVE CURSOR (sig2): #{curpos}"
+      # }
+
       false
     end
 
+    return
+
+    #TODO:gtk4
     signal_connect "button-release-event" do |widget, event|
       vma.buf.set_pos(buffer.cursor_position)
       false
@@ -75,23 +70,129 @@ class VSourceView < GtkSource::View
     @curpos_mark = nil
   end
 
-  def handle_key_event(event, sig)
-    if $update_cursor
-      curpos = buffer.cursor_position
-      debug "MOVE CURSOR: #{curpos}"
-      buf.set_pos(curpos)
+  def gutter_width()
+    winwidth = width
+    view_width = visible_rect.width
+    gutter_width = winwidth - view_width
+  end
+
+  def show_controllers
+    clist = self.observe_controllers
+    (0..(clist.n_items - 1)).each { |x|
+      ctr = clist.get_item(x)
+      pp ctr
+    }
+  end
+
+  def check_controllers
+    clist = self.observe_controllers
+    to_remove = []
+    (0..(clist.n_items - 1)).each { |x|
+      ctr = clist.get_item(x)
+      # Sometimes a GestureClick EventController appears from somewhere
+      # not initiated from this file.
+
+      # if ctr.class == Gtk::EventControllerKey or ctr.class == Gtk::GestureClick
+      if ctr != @click
+        # to_remove << ctr if ctr.class != Gtk::GestureDrag
+        to_remove << ctr
+      end
+    }
+    if to_remove.size > 0
+      debug "Removing controllers:"
+      pp to_remove
+      to_remove.each { |x|
+        # To avoid GC. https://github.com/ruby-gnome/ruby-gnome/issues/15790
+        @removed_controllers << x
+        self.remove_controller(x)
+      }
+    end
+  end
+
+  def register_signals()
+
+    #TODO: Doesn't seem to catch "move-cursor" signal since upgrade to gtk4
+    # self.signal_connect("move-cursor") do |widget, event|
+    # $update_cursor = true
+    # false
+    # end
+
+    check_controllers
+    click = Gtk::GestureClick.new
+    click.set_propagation_phase(Gtk::PropagationPhase::CAPTURE)
+    self.add_controller(click)
+    # Detect mouse click
+    @click = click
+    click.signal_connect "pressed" do |gesture, n_press, x, y, z|
+      debug "SourceView, GestureClick x=#{x} y=#{y}"
+      pp visible_rect
+      winw = width
+      view_width = visible_rect.width
+      gutter_width = winw - view_width
+
+      xloc = (x - gutter_width).to_i
+      yloc = (y + visible_rect.y).to_i
+      debug "xloc=#{xloc} yloc=#{yloc}"
+
+      # This needs to happen after xloc calculation, otherwise xloc gets a wrong value (around 200 bigger)
+      if vma.gui.current_view != self
+        vma.gui.set_current_view(self)
+      end
+
+      i = get_iter_at_location(xloc, yloc)
+      if !i.nil?
+        @bufo.set_pos(i.offset)
+      else
+        debug "iter nil"
+        #TODO: find correct line position some other way
+      end
+
+      true
+    end
+  end
+
+  def handle_scrolling()
+    delete_cursorchar
+    # curpos = buffer.cursor_position
+    # debug "MOVE CURSOR: #{curpos}"
+    return nil if vma.gui.nil?
+    return nil if @bufo.nil?
+    vma.gui.run_after_scrolling proc {
+      delete_cursorchar
+      bc = window_to_buffer_coords(Gtk::TextWindowType::WIDGET, gutter_width + 2, 60)
+      if !bc.nil?
+        # Try to get exact character position
+        i = get_iter_at_location(bc[0], bc[1])
+        if i.nil?
+          # If doesn't work, at least get the start of correct line
+          i = get_line_at_y(bc[1])
+          i = i[0]
+        end
+        if !i.nil?
+          @bufo.set_pos(i.offset)
+        end
+      end
       $update_cursor = false
+    }
+  end
+
+  # def handle_key_event(event, sig)
+  def handle_key_event(keyval, keyname, sig)
+    delete_cursorchar
+    if $update_cursor
+      handle_scrolling
     end
     debug $view.visible_rect.inspect
 
     debug "key event"
-    debug event
+    # debug event
 
-    key_name = event.string
-    if event.state.control_mask?
-      key_name = Gdk::Keyval.to_name(event.keyval)
-      # Gdk::Keyval.to_name()
-    end
+    # key_name = event.string
+    #TODO:??
+    # 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"
@@ -122,29 +223,48 @@ class VSourceView < GtkSource::View
 
     key_trans = {}
     key_trans["\e"] = "esc"
-    tk = keyval_trans[event.keyval]
-    key_name = tk if !tk.nil?
+    tk = keyval_trans[keyval]
+    keyname = 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 << "ctrl" if vma.kbd.modifiers[:ctrl]
+    key_str_parts << "alt" if vma.kbd.modifiers[:alt]
+    key_str_parts << "shift" if vma.kbd.modifiers[:shift]
+    key_str_parts << "meta" if vma.kbd.modifiers[:meta]
+    key_str_parts << "super" if vma.kbd.modifiers[:super]
+    key_str_parts << keyname
+
+    if key_str_parts[0] == key_str_parts[1]
+      # We don't want "ctrl-ctrl" or "alt-alt"
+      # TODO:There should be a better way to do this
+      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)
+    end
 
-    key_str_parts << key_name
     key_str = key_str_parts.join("-")
-    keynfo = { :key_str => key_str, :key_name => key_name, :keyval => event.keyval }
+    if key_str == "\u0000"
+      key_str = ""
+    end
+
+    keynfo = { :key_str => key_str, :key_name => keyname, :keyval => keyval }
     debug keynfo.inspect
     # $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_event and event.keyval == @last_keyval
+      if sig == :key_release and keyval == @last_keyval
         $kbd.match_key_conf(key_str + "!", nil, :key_release)
-        @last_event = [event, :key_release]
-      elsif sig == :key_press_event
+        @last_event = [keynfo, :key_release]
+      elsif sig == :key_press
         $kbd.match_key_conf(key_str, nil, :key_press)
-        @last_event = [event, key_str, :key_press]
+        @last_event = [keynfo, key_str, :key_press]
       end
-      @last_keyval = event.keyval #TODO: outside if?
+      @last_keyval = keyval #TODO: outside if?
     end
 
     handle_deltas
@@ -152,15 +272,17 @@ class VSourceView < GtkSource::View
     # set_focus(5)
     # false
 
+    draw_cursor #TODO: only when needed
   end
 
   def pos_to_coord(i)
     b = buffer
     iter = b.get_iter_at(:offset => i)
     iterxy = get_iter_location(iter)
-    winw = parent_window.width
+    winw = width #TODO
+
     view_width = visible_rect.width
-    gutter_width = winw - view_width
+    gutter_width = winw - view_width #TODO
 
     x = iterxy.x + gutter_width
     y = iterxy.y
@@ -168,12 +290,12 @@ class VSourceView < GtkSource::View
     # buffer_to_window_coords(Gtk::TextWindowType::TEXT, iterxy.x, iterxy.y).inspect
     # debug 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()
+    delete_cursorchar
     any_change = false
     while d = @bufo.deltas.shift
       any_change = true
@@ -191,7 +313,8 @@ class VSourceView < GtkSource::View
       end
     end
     if any_change
-      gui_set_cursor_pos(@bufo.id, @bufo.pos) #TODO: only when necessary
+      #TODO: only when necessary
+      self.set_cursor_pos(pos)
     end
 
     # sanity_check #TODO
@@ -213,6 +336,7 @@ class VSourceView < GtkSource::View
   end
 
   def set_cursor_pos(pos)
+    delete_cursorchar
     # return
     itr = buffer.get_iter_at(:offset => pos)
     itr2 = buffer.get_iter_at(:offset => pos + 1)
@@ -237,7 +361,6 @@ class VSourceView < GtkSource::View
     # 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
@@ -252,6 +375,9 @@ class VSourceView < GtkSource::View
     # 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
+
     sleep(0.01)
     # intr = iterxy.intersect(vr)
     if is_cursor_visible == false
@@ -266,8 +392,9 @@ class VSourceView < GtkSource::View
 
       scroll_to_iter(itr, within_margin, use_align, xalign, yalign)
 
-      # return true # Call this func again
+      return true # Call this func again
     else
+      @idle_func_running = false
       return false # Don't call this idle func again
     end
   end
@@ -283,9 +410,6 @@ class VSourceView < GtkSource::View
     if intr.nil?
       debug iterxy.inspect
       debug vr.inspect
-      # Ripl.start :binding => binding
-
-      # exit!
       return false
     else
       return true
@@ -293,7 +417,12 @@ class VSourceView < GtkSource::View
   end
 
   def ensure_cursor_visible
+    return #TODO:gtk4
+    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 })
@@ -301,22 +430,71 @@ class VSourceView < GtkSource::View
     end
   end
 
+  # Delete the extra char added to buffer to represent the cursor
+  def delete_cursorchar
+    if !@cursorchar.nil?
+      itr = buffer.get_iter_at(:offset => @cursorchar)
+      itr2 = buffer.get_iter_at(:offset => @cursorchar + 1)
+      buffer.delete(itr, itr2)
+      @cursorchar = nil
+    end
+  end
+
   def draw_cursor
-    if is_command_mode
-      itr = buffer.get_iter_at(:offset => @bufo.pos)
-      itr2 = buffer.get_iter_at(:offset => @bufo.pos + 1)
-      $view.buffer.select_range(itr, itr2)
-    elsif @bufo.visual_mode?
+    # if @tt.nil?
+    # @tt = buffer.create_tag("font_tag")
+    # @tt.font = "Arial"
+    # end
+
+    mode = vma.kbd.get_mode
+    ctype = vma.kbd.get_cursor_type
+    delete_cursorchar
+    vma.gui.remove_overlay_cursor
+    if ctype == :command
+      if @bufo[@bufo.pos] == "\n"
+        # If we are at end of line, it's not possible to draw the cursor by making a selection. I tried to do this by drawing an overlay, but that generates issues. If moving the cursor causes the ScrolledWindow to be scrolled, these errors randomly appear and the whole view shows blank:
+        # (ruby:21016): Gtk-WARNING **: 19:52:23.181: Trying to snapshot GtkSourceView 0x55a97524c8c0 without a current allocation
+        # (ruby:21016): Gtk-WARNING **: 19:52:23.181: Trying to snapshot GtkGizmo 0x55a9727d2580 without a current allocation
+        # (ruby:21016): Gtk-WARNING **: 19:52:23.243: Trying to snapshot GtkSourceView 0x55a97524c8c0 without a current allocation
+        # vma.gui.overlay_draw_cursor(@bufo.pos)
+
+        # Current workaround is to add an empty space to the place where the cursor is and then remove this whenever we get any kind of event that might cause this class to be accessed.
+        itr = buffer.get_iter_at(:offset => @bufo.pos)
+        buffer.insert(itr, " ") # normal space
+        # buffer.insert(itr, " ") # thin space (U+2009)
+        # buffer.insert(itr, "l")
+        @cursorchar = @bufo.pos
+
+        # Apparently we need to redo this after buffer.insert:
+        itr = buffer.get_iter_at(:offset => @bufo.pos)
+        itr2 = buffer.get_iter_at(:offset => @bufo.pos + 1)
+        # buffer.apply_tag(@tt, itr, itr2)
+        buffer.select_range(itr, itr2)
+      else
+        itr = buffer.get_iter_at(:offset => @bufo.pos)
+        itr2 = buffer.get_iter_at(:offset => @bufo.pos + 1)
+        buffer.select_range(itr, itr2)
+      end
+      # elsif @bufo.visual_mode?
+    elsif ctype == :visual
       debug "VISUAL MODE"
       (_start, _end) = @bufo.get_visual_mode_range2
       debug "#{_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
+      # Pango-CRITICAL **: pango_layout_get_cursor_pos: assertion 'index >= 0 && index <= layout->length' failed
+      buffer.select_range(itr, itr2)
+    elsif ctype == :insert
+      # Not sure why this is needed
       itr = buffer.get_iter_at(:offset => @bufo.pos)
-      $view.buffer.select_range(itr, itr)
+      buffer.select_range(itr, itr)
+
+      # Via trial and error, this combination is only thing that seems to work:
+      vma.gui.sw.child.toggle_cursor_visible
+      vma.gui.sw.child.cursor_visible = true
+
       debug "INSERT MODE"
+    else # TODO
     end
   end
 end

data/lib/vimamsa/hyper_plain_text.rb

@@ -51,6 +51,35 @@ def translate_path(fn, bf)
   return outfn
 end
 
+# Scan audio files inserted with ⟦audio:filepath⟧ syntax
+#TODO: merge code with hpt_scan_images
+def hpt_scan_audio(bf = nil)
+  bf = buf() if bf.nil?
+  return if bf.nil?
+  return if !bf.fname
+  return if !bf.fname.match(/.*txt$/)
+  imgpos = scan_indexes(bf, /⟦audio:.+?⟧/)
+  imgtags = bf.scan(/(⟦audio:(.+?)⟧)/)
+  c = 0
+  imgpos.each.with_index { |x, i|
+    a = imgpos[i]
+    t = imgtags[i]
+    insert_pos = a + t[0].size + c
+    fn = t[1]
+    imgfn = translate_path(fn, bf)
+    next if !File.exist?(imgfn)
+    # Show as image in gui, handle as empty space in txt file
+
+    if bf[insert_pos..(insert_pos + 2)] != "\n \n"
+      bf.insert_txt_at("\n \n", insert_pos)
+      bf.view.handle_deltas
+      c += 3
+    end
+    bf.add_audio(imgfn, insert_pos + 1)
+  }
+  # vma.gui.delex.run #TODO:gtk4
+end
+
 # Scan images inserted with ⟦img:filepath⟧ syntax
 def hpt_scan_images(bf = nil)
   bf = buf() if bf.nil?
@@ -76,5 +105,9 @@ def hpt_scan_images(bf = nil)
     end
     bf.add_image(imgfn, insert_pos + 1)
   }
-  vma.gui.delex.run
+
+  # Need to scale after buffer loaded
+  GLib::Idle.add(proc { vma.gui.scale_all_images })
+
+  # vma.gui.delex.run #TODO:gtk4
 end

data/lib/vimamsa/key_actions.rb

@@ -28,6 +28,9 @@ def is_visual_mode()
   return 0
 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")
 
@@ -48,6 +51,8 @@ reg_act(:jump_to_random, proc { buf.jump_to_random_pos }, "")
 reg_act(:insert_new_line, proc { buf.insert_new_line() }, "")
 reg_act(:show_key_bindings, proc { show_key_bindings }, "Show key bindings")
 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")
+
 # 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")
 reg_act(:set_unencrypted, proc { buf.set_unencrypted }, "Set current file to save unencrypted")
@@ -80,8 +85,9 @@ 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
-reg_act :update_file_index, proc { update_file_index }, "Update file index"
+reg_act :update_file_index, proc { FileFinder.update_index }, "Update file index"
 reg_act :delete_to_word_end, proc { buf.delete2(:to_word_end) }, "Delete to file end", { :group => [:edit, :basic] }
+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 :start_browse_mode, proc { $kbd.set_mode(:browse); $kbd.set_default_mode(:browse) }, "Start browse mode"
 reg_act :exit_browse_mode, proc {
@@ -146,6 +152,12 @@ act_list = {
   :search_actions => { :proc => proc { search_actions },
                        :desc => "Search actions", :group => :search },
 
+  :toggle_active_window => { :proc => proc { vma.gui.toggle_active_window },
+                             :desc => "Toggle active window", :group => :search },
+
+  :toggle_two_column => { :proc => proc { vma.gui.set_two_column },
+                          :desc => "Set two column mode", :group => :search },
+
   :content_search => { :proc => proc { FileContentSearch.start_gui },
                        :desc => "Search content of files", :group => :search },