vimamsa 0.1.23 → 0.1.25

data/lib/vimamsa/gui_select_window.rb

@@ -30,14 +30,14 @@ class SelectUpdateWindow
   end
 
   def set_selected_row(rownum)
+    count = @model.count
+    return if count == 0
     rownum = 0 if rownum < 0
+    rownum = count - 1 if rownum >= count
     @selected_row = rownum
-
-    if @model.count > 0
-      path = Gtk::TreePath.new(@selected_row.to_s)
-      iter = @model.get_iter(path)
-      @tv.selection.select_iter(iter)
-    end
+    path = Gtk::TreePath.new(@selected_row.to_s)
+    iter = @model.get_iter(path)
+    @tv.selection.select_iter(iter)
   end
 
   def initialize(main_window, item_list, jump_keys, select_callback, update_callback, opt = {})
@@ -126,6 +126,17 @@ class SelectUpdateWindow
         @window.destroy
         # debug iter[1].inspect
         true
+      elsif keyval == Gdk::Keyval::KEY_Delete && @opt[:delete_callback]
+        path = Gtk::TreePath.new(@selected_row.to_s)
+        iter = @model.get_iter(path)
+        next false unless iter
+        name = iter[COLUMN_DESCRIPTION]
+        refresh = proc {
+          update_item_list(@update_callback.call(@entry.text))
+          @window.present
+        }
+        @opt[:delete_callback].call(name, refresh)
+        true
       elsif keyval == Gdk::Keyval::KEY_Escape
         @window.destroy
         true

data/lib/vimamsa/gui_settings.rb

@@ -19,6 +19,14 @@ SETTINGS_DEFS = [
     :settings => [
       { :key => [:match, :highlight, :color], :label => "Search highlight color", :type => :string },
       { :key => [:kbd, :show_prev_action], :label => "Show previous action in toolbar", :type => :bool },
+      { :key => [:style_scheme], :label => "Color scheme", :type => :select,
+        :options => proc {
+          ssm = GtkSource::StyleSchemeManager.new
+          ssm.set_search_path(ssm.search_path << ppath("styles/"))
+          ssm.scheme_ids.reject { |id| [VIMAMSA_OVERLAY_SCHEME_ID, VIMAMSA_CONTRAST_SCHEME_ID].include?(id) }.sort
+        } },
+      { :key => [:color_contrast],   :label => "Color scheme contrast (1.0 = original)",  :type => :float, :min => 0.5, :max => 2.0, :step => 0.05 },
+      { :key => [:color_brightness], :label => "Color scheme brightness (0.0 = original)", :type => :float, :min => -0.5, :max => 0.5, :step => 0.01 },
     ],
   },
   {
@@ -27,10 +35,40 @@ SETTINGS_DEFS = [
       { :key => [:lsp, :enabled], :label => "Enable LSP (Language Server)", :type => :bool },
       { :key => [:experimental], :label => "Enable experimental features", :type => :bool },
       { :key => [:macro, :animation_delay], :label => "Macro animation delay (sec)", :type => :float, :min => 0.0, :max => 2.0, :step => 0.0001 },
+      { :key => [:paste, :cursor_at_start], :label => "Leave cursor at start of pasted text", :type => :bool },
+    ],
+  },
+  {
+    :label => "Files",
+    :settings => [
+      { :key => ["search_dirs"], :label => "Search directories (one per line)", :type => :string_list },
     ],
   },
 ]
 
+# Build the full settings definition list, appending a Modules section
+# dynamically from whatever subdirectories exist in modules/.
+def all_settings_defs
+  # Build one settings entry per module found in modules/*/.
+  # Each module may provide a <name>_info.rb file that defines <name>_info,
+  # returning a hash with :name (display label) and :no_restart (bool).
+  # Modules without an info file fall back to a capitalized directory name
+  # and require a restart to activate.
+  module_settings = Dir.glob(ppath("modules/*/")).sort.map do |mod_dir|
+    mod_name = File.basename(mod_dir)
+    info_file = File.join(mod_dir, "#{mod_name}_info.rb")
+    load info_file if File.exist?(info_file)
+    info_fn = "#{mod_name}_info"
+    info = respond_to?(info_fn, true) ? send(info_fn) : {}
+    label = info[:name] || mod_name.split(/[_\-]/).map(&:capitalize).join(" ")
+    no_restart = info[:no_restart] || false
+    restart_note = no_restart ? "" : " (requires restart)"
+    { :key => [:modules, mod_name.to_sym, :enabled], :label => "#{label}#{restart_note}", :type => :bool, :no_restart => no_restart }
+  end
+  return SETTINGS_DEFS unless module_settings.any?
+  SETTINGS_DEFS + [{ :label => "Modules", :settings => module_settings }]
+end
+
 class SettingsDialog
   def initialize
     @widgets = {}
@@ -47,7 +85,7 @@ class SettingsDialog
     notebook = Gtk::Notebook.new
     outer.append(notebook)
 
-    SETTINGS_DEFS.each do |section|
+    all_settings_defs.each do |section|
       grid = Gtk::Grid.new
       grid.row_spacing = 10
       grid.column_spacing = 16
@@ -56,16 +94,28 @@ class SettingsDialog
       grid.margin_start = 12
       grid.margin_end = 12
 
-      section[:settings].each_with_index do |s, row|
+      grid_row = 0
+      section[:settings].each do |s|
         label = Gtk::Label.new(s[:label])
         label.halign = :start
         label.hexpand = true
 
-        widget = make_widget(s)
-        @widgets[s[:key]] = { :widget => widget, :type => s[:type] }
-
-        grid.attach(label, 0, row, 1, 1)
-        grid.attach(widget, 1, row, 1, 1)
+        if s[:type] == :string_list
+          # Label spans both columns; editor on the next row spanning both columns
+          grid.attach(label, 0, grid_row, 2, 1)
+          grid_row += 1
+          cur = get(s[:key])
+          container, get_value = build_string_list_editor(cur.is_a?(Array) ? cur : [])
+          @widgets[s[:key]] = { :widget => container, :type => s[:type], :get_value => get_value }
+          grid.attach(container, 0, grid_row, 2, 1)
+        else
+          widget = make_widget(s)
+          # Store prev_value so save_and_close can detect newly-enabled modules.
+          @widgets[s[:key]] = { :widget => widget, :type => s[:type], :no_restart => s[:no_restart], :prev_value => cnf_get(s[:key]) }
+          grid.attach(label, 0, grid_row, 1, 1)
+          grid.attach(widget, 1, grid_row, 1, 1)
+        end
+        grid_row += 1
       end
 
       notebook.append_page(grid, Gtk::Label.new(section[:label]))
@@ -97,7 +147,7 @@ class SettingsDialog
   end
 
   def make_widget(s)
-    cur = get(s[:key])
+    cur = cnf_get(s[:key])
     case s[:type]
     when :bool
       w = Gtk::Switch.new
@@ -116,24 +166,122 @@ class SettingsDialog
       w = Gtk::Entry.new
       w.text = cur.to_s
       w
+    when :select
+      options = s[:options].is_a?(Proc) ? s[:options].call : s[:options]
+      cur = cnf_get(s[:key]).to_s
+      string_list = Gtk::StringList.new(options)
+      w = Gtk::DropDown.new(string_list, nil)
+      w.selected = [options.index(cur) || 0, 0].max
+      w
+    end
+  end
+
+  def build_string_list_editor(paths)
+    store = Gtk::ListStore.new(String)
+    paths.each { |p| store.append[0] = p }
+
+    tv = Gtk::TreeView.new(store)
+    tv.headers_visible = false
+    renderer = Gtk::CellRendererText.new
+    renderer.ellipsize = Pango::EllipsizeMode::START
+    col = Gtk::TreeViewColumn.new("", renderer, text: 0)
+    col.expand = true
+    tv.append_column(col)
+
+    sw = Gtk::ScrolledWindow.new
+    sw.set_policy(:automatic, :automatic)
+    sw.set_child(tv)
+    sw.set_size_request(-1, 120)
+    sw.vexpand = true
+
+    add_btn = Gtk::Button.new(label: "Add…")
+    add_btn.signal_connect("clicked") do
+      chooser = Gtk::FileChooserDialog.new(
+        :title => "Select directory",
+        :action => :select_folder,
+        :buttons => [["Select", :accept], ["Cancel", :cancel]],
+      )
+      chooser.set_transient_for(@window)
+      chooser.modal = true
+      chooser.signal_connect("response") do |dlg, resp|
+        if resp == Gtk::ResponseType::ACCEPT
+          iter = store.append
+          iter[0] = dlg.file.path
+        end
+        dlg.destroy
+      end
+      chooser.show
+    end
+
+    remove_btn = Gtk::Button.new(label: "Remove")
+    remove_btn.signal_connect("clicked") do
+      sel = tv.selection.selected
+      store.remove(sel) if sel
     end
+
+    btn_box = Gtk::Box.new(:horizontal, 6)
+    btn_box.append(add_btn)
+    btn_box.append(remove_btn)
+
+    container = Gtk::Box.new(:vertical, 4)
+    container.vexpand = true
+    container.append(sw)
+    container.append(btn_box)
+
+    get_value = proc {
+      result = []
+      store.each { |_m, _path, iter| result << iter[0] }
+      result
+    }
+
+    [container, get_value]
   end
 
   def save_and_close
     @widgets.each do |key, info|
       val = case info[:type]
-            when :bool   then info[:widget].active?
-            when :int    then info[:widget].value.to_i
-            when :float  then info[:widget].value.to_f
-            when :string then info[:widget].text
+            when :bool        then info[:widget].active?
+            when :int         then info[:widget].value.to_i
+            when :float       then info[:widget].value.to_f
+            when :string      then info[:widget].text
+            when :string_list then info[:get_value].call
+            when :select      then info[:widget].selected_item&.string
             end
-      set(key, val)
+      cnf_set(key, val) unless val.nil?
     end
     save_settings_to_file
     gui_refresh_font
+    gui_refresh_style_scheme
+    activate_no_restart_modules
     @window.destroy
   end
 
+  # For modules that support live activation (no_restart: true), apply enable
+  # and disable transitions immediately without requiring a restart.
+  # Modules that were already in the target state when the dialog opened are
+  # skipped (prev_value matches new value), so we never double-init or double-disable.
+  def activate_no_restart_modules
+    @widgets.each do |key, info|
+      next unless key.is_a?(Array) && key[0] == :modules && key[2] == :enabled
+      next unless info[:no_restart]  # module requires restart — skip
+      mod_name = key[1].to_s
+      was_enabled = info[:prev_value]
+      now_enabled = cnf_get(key)
+      if !was_enabled && now_enabled
+        # Toggled on: load the module file and call <name>_init.
+        main_file = ppath("modules/#{mod_name}/#{mod_name}.rb")
+        next unless File.exist?(main_file)
+        load main_file
+        init_fn = "#{mod_name}_init"
+        send(init_fn) if respond_to?(init_fn, true)
+      elsif was_enabled && !now_enabled
+        # Toggled off: call <name>_disable to unregister actions and bindings.
+        disable_fn = "#{mod_name}_disable"
+        send(disable_fn) if respond_to?(disable_fn, true)
+      end
+    end
+  end
+
   def run
     @window.show
   end
@@ -143,6 +291,192 @@ def show_settings_dialog
   SettingsDialog.new.run
 end
 
+VIMAMSA_OVERLAY_SCHEME_ID  = "vimamsa_overlay"
+VIMAMSA_CONTRAST_SCHEME_ID = "vimamsa_contrast"
+
+# ── Color utilities ────────────────────────────────────────────────────────────
+
+def hex_to_rgb(hex)
+  hex = hex.delete("#")
+  hex = hex.chars.map { |c| c * 2 }.join if hex.length == 3
+  [hex[0, 2].to_i(16), hex[2, 2].to_i(16), hex[4, 2].to_i(16)]
+end
+
+def rgb_to_hsl(r, g, b)
+  r, g, b = r / 255.0, g / 255.0, b / 255.0
+  max, min = [r, g, b].max, [r, g, b].min
+  l = (max + min) / 2.0
+  if max == min
+    [0.0, 0.0, l]
+  else
+    d = max - min
+    s = l > 0.5 ? d / (2.0 - max - min) : d / (max + min)
+    h = case max
+        when r then ((g - b) / d + (g < b ? 6 : 0)) / 6.0
+        when g then ((b - r) / d + 2) / 6.0
+        else        ((r - g) / d + 4) / 6.0
+        end
+    [h, s, l]
+  end
+end
+
+def hsl_to_rgb(h, s, l)
+  return Array.new(3, (l * 255).round) if s == 0
+  q = l < 0.5 ? l * (1 + s) : l + s - l * s
+  p = 2 * l - q
+  [h + 1 / 3.0, h, h - 1 / 3.0].map do |t|
+    t += 1 if t < 0; t -= 1 if t > 1
+    v = if    t < 1 / 6.0 then p + (q - p) * 6 * t
+         elsif t < 1 / 2.0 then q
+         elsif t < 2 / 3.0 then p + (q - p) * (2 / 3.0 - t) * 6
+         else p
+         end
+    (v * 255).round.clamp(0, 255)
+  end
+end
+
+# Adjust contrast and brightness of a hex color.
+# contrast: scales lightness around 0.5 (>1 increases separation, <1 reduces it).
+# brightness: fixed lightness offset applied after contrast (-1.0..1.0, 0 = no change).
+# Chroma is preserved by rescaling saturation to compensate for gamut narrowing at
+# extreme lightness values, preventing warm colors from washing out.
+def adjust_hex_color(hex, contrast, brightness)
+  r, g, b = hex_to_rgb(hex)
+  h, s, l = rgb_to_hsl(r, g, b)
+  new_l = (0.5 + (l - 0.5) * contrast + brightness).clamp(0.0, 1.0)
+  old_chroma = s * [l, 1.0 - l].min * 2.0
+  max_new_chroma = [new_l, 1.0 - new_l].min * 2.0
+  new_s = max_new_chroma > 0 ? [old_chroma / max_new_chroma, 1.0].min : 0.0
+  nr, ng, nb = hsl_to_rgb(h, new_s, new_l)
+  "#%02X%02X%02X" % [nr, ng, nb]
+end
+
+# ── Scheme XML processing ──────────────────────────────────────────────────────
+
+# Find the XML file on disk for a given scheme id.
+def find_scheme_xml_path(scheme_id)
+  ssm = GtkSource::StyleSchemeManager.new
+  ssm.set_search_path(ssm.search_path << ppath("styles/"))
+  ssm.search_path.each do |dir|
+    next unless Dir.exist?(dir)
+    Dir[File.join(dir, "*.xml")].each do |f|
+      return f if File.read(f).include?("id=\"#{scheme_id}\"")
+    rescue StandardError
+    end
+  end
+  nil
+end
+
+# Apply contrast and brightness to every hex color value in an XML string.
+def apply_contrast_to_xml(xml, contrast, brightness)
+  xml.gsub(/#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}\b/) do |hex|
+    adjust_hex_color(hex, contrast, brightness)
+  end
+end
+
+# If contrast != 1.0, generate a contrast-adjusted copy of base_scheme_id and
+# return its scheme id. Otherwise return base_scheme_id unchanged.
+def apply_contrast_transformation(base_scheme_id, contrast, brightness)
+  return base_scheme_id if contrast == 1.0 && brightness == 0.0
+  xml_path = find_scheme_xml_path(base_scheme_id)
+  return base_scheme_id if xml_path.nil?
+
+  adjusted = apply_contrast_to_xml(IO.read(xml_path), contrast, brightness)
+  adjusted = adjusted.sub(/(<style-scheme\b[^>]*)id="[^"]*"/, "\\1id=\"#{VIMAMSA_CONTRAST_SCHEME_ID}\"")
+  adjusted = adjusted.sub(/(<style-scheme\b[^>]*)name="[^"]*"/, "\\1name=\"#{VIMAMSA_CONTRAST_SCHEME_ID}\"")
+  adjusted = adjusted.sub(/\s*parent-scheme="[^"]*"/, "")  # avoid inheritance chains
+  IO.write(ppath("styles/_vimamsa_contrast.xml"), adjusted)
+  VIMAMSA_CONTRAST_SCHEME_ID
+end
+
+# ── Overlay scheme ─────────────────────────────────────────────────────────────
+
+# Return foreground attribute XML fragment for a style name from a scheme object.
+# Falls back to default_fg if the scheme doesn't define it.
+def style_fg_attr(sty, style_name, default_fg = nil)
+  fg = sty&.get_style(style_name)&.foreground
+  fg = default_fg if fg.nil? || fg.empty?
+  fg ? " foreground=\"#{fg}\"" : ""
+end
+
+# Generate a GtkSourceView style scheme that inherits from base_scheme_id
+# (optionally contrast-adjusted) and overlays Vimamsa-specific heading/
+# hyperlink styles on top. Written to styles/_vimamsa_overlay.xml.
+# Foreground colors are read from the parent scheme so they are preserved.
+def generate_vimamsa_overlay(base_scheme_id)
+  contrast   = (cnf_get([:color_contrast])   || 1.0).to_f
+  brightness = (cnf_get([:color_brightness]) || 0.0).to_f
+  parent_id  = apply_contrast_transformation(base_scheme_id, contrast, brightness)
+
+  # Load the parent scheme to read existing foreground colors for headings/links
+  ssm = GtkSource::StyleSchemeManager.new
+  ssm.set_search_path(ssm.search_path << ppath("styles/"))
+  parent_sty = ssm.get_scheme(parent_id)
+
+  xml = <<~XML
+    <?xml version="1.0"?>
+    <style-scheme id="#{VIMAMSA_OVERLAY_SCHEME_ID}" name="#{VIMAMSA_OVERLAY_SCHEME_ID}" version="1.0" parent-scheme="#{parent_id}">
+      <style name="def:title"     scale="2.0"   bold="true"#{style_fg_attr(parent_sty, "def:title")}/>
+      <style name="def:hyperlink" bold="true"#{style_fg_attr(parent_sty, "def:hyperlink", "#4FC3F7")}/>
+      <style name="def:heading0"  scale="2.0"   bold="true"#{style_fg_attr(parent_sty, "def:heading0")}/>
+      <style name="def:heading1"  scale="1.75"  bold="true"#{style_fg_attr(parent_sty, "def:heading1")}/>
+      <style name="def:heading2"  scale="1.5"   bold="true"#{style_fg_attr(parent_sty, "def:heading2")}/>
+      <style name="def:heading3"  scale="1.25"  bold="true"#{style_fg_attr(parent_sty, "def:heading3")}/>
+      <style name="def:heading4"  scale="1.175" bold="true"#{style_fg_attr(parent_sty, "def:heading4")}/>
+      <style name="def:heading5"  scale="1.1"   bold="true"#{style_fg_attr(parent_sty, "def:heading5")}/>
+      <style name="def:heading6"  scale="1.0"   bold="true"#{style_fg_attr(parent_sty, "def:heading6")}/>
+      <style name="def:bold"      bold="true"/>
+    </style-scheme>
+  XML
+  user_styles_dir = File.expand_path("~/.config/vimamsa/styles")
+  FileUtils.mkdir_p(user_styles_dir)
+  IO.write(File.join(user_styles_dir, "_vimamsa_overlay.xml"), xml)
+end
+
+# Build a StyleSchemeManager with the project styles dir appended,
+# apply the overlay on top of the user's chosen base scheme,
+# and return the overlay scheme object.
+def load_vimamsa_scheme
+  base_id = cnf.style_scheme! || "molokai_edit"
+  generate_vimamsa_overlay(base_id)
+  user_styles_dir = File.expand_path("~/.config/vimamsa/styles")
+  ssm = GtkSource::StyleSchemeManager.new
+  ssm.set_search_path(ssm.search_path << ppath("styles/") << user_styles_dir)
+  ssm.get_scheme(VIMAMSA_OVERLAY_SCHEME_ID)
+end
+
+# Returns true if the given GtkSource::StyleScheme has a light background.
+# Reads the background color of the "text" style and computes relative luminance.
+def scheme_is_light?(sty)
+  text_style = sty.get_style("text")
+  return false if text_style.nil?
+  bg = text_style.background
+  return false if bg.nil? || !bg.start_with?("#")
+  hex = bg.delete("#")
+  hex = hex.chars.map { |c| c * 2 }.join if hex.length == 3
+  return false unless hex.length == 6
+  r = hex[0, 2].to_i(16) / 255.0
+  g = hex[2, 2].to_i(16) / 255.0
+  b = hex[4, 2].to_i(16) / 255.0
+  luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b
+  luminance > 0.5
+end
+
+# Apply dark/light GTK preference to match the given style scheme.
+def gui_apply_color_mode(sty)
+  Gtk::Settings.default.gtk_application_prefer_dark_theme = !scheme_is_light?(sty)
+end
+
+def gui_refresh_style_scheme
+  return unless $vmag
+  sty = load_vimamsa_scheme
+  return if sty.nil?
+  gui_apply_color_mode(sty)
+  for _k, view in $vmag.buffers
+    view.buffer.style_scheme = sty
+  end
+end
+
 def gui_refresh_font
   return unless $vmag
   provider = Gtk::CssProvider.new

data/lib/vimamsa/gui_sourceview.rb

@@ -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()
@@ -228,6 +310,7 @@ class VSourceView < GtkSource::View
 
     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
@@ -484,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
@@ -608,7 +692,7 @@ class VSourceView < GtkSource::View
         self.style_context.add_provider(prov)
         @cursor_prov = prov
       end
-      @ctype == ctype
+      @ctype = ctype
     end
   end
 
@@ -666,6 +750,8 @@ class VSourceView < GtkSource::View
       self.cursor_visible = false
       self.cursor_visible = true
     end
+
+    update_cursor_unmask
   end #end draw_cursor
 
   CONTEXT_MENU_ITEMS = [
@@ -691,14 +777,42 @@ class VSourceView < GtkSource::View
         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}") }

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
+