vimamsa 0.1.5 → 0.1.8

data/lib/vimamsa/gui_select_window.rb

@@ -0,0 +1,177 @@
+def gui_select_update_window(item_list, jump_keys, select_callback, update_callback, opt={})
+  $selup = SelectUpdateWindow.new(nil, item_list, jump_keys, select_callback, update_callback, opt)
+  $selup.run
+end
+
+class SelectUpdateWindow
+  COLUMN_JUMP_KEY = 0
+  COLUMN_DESCRIPTION = 1
+
+  def update_item_list(item_list)
+    # debug item_list.inspect
+    @model.clear
+    for item in item_list
+      iter = @model.append
+      if !@opt[:columns].nil?
+        v = item
+      else
+        v = ["", item[0]]
+      end
+      debug v.inspect
+      iter.set_values(v)
+    end
+
+    set_selected_row(0)
+  end
+
+  def set_selected_row(rownum)
+    rownum = 0 if rownum < 0
+    @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
+  end
+
+  def initialize(main_window, item_list, jump_keys, select_callback, update_callback, opt = {})
+    @window = Gtk::Window.new(:toplevel)
+    # @window.screen = main_window.screen
+    @window.title = ""
+    if !opt[:title].nil?
+      @window.title = opt[:title]
+    end
+
+    @selected_row = 0
+    @opt = opt
+
+    debug item_list.inspect
+    @update_callback = method(update_callback)
+    @select_callback = method(select_callback)
+    # debug @update_callback_m.call("").inspect
+
+    vbox = Gtk::Box.new(:vertical, 8)
+    vbox.margin = 8
+    @window.add(vbox)
+
+    @entry = Gtk::SearchEntry.new
+    @entry.width_chars = 45
+    container = Gtk::Box.new(:horizontal, 10)
+    # container.halign = :start
+    container.halign = :center
+    container.pack_start(@entry,
+                         :expand => false, :fill => false, :padding => 0)
+
+    # create tree view
+    @model = Gtk::ListStore.new(String, String)
+    treeview = Gtk::TreeView.new(@model)
+    treeview.search_column = COLUMN_DESCRIPTION
+    @tv = treeview
+    # item_list = @update_callback.call("")
+    update_item_list(item_list)
+
+    @window.signal_connect("key-press-event") do |_widget, event|
+      # debug "KEYPRESS 1"
+      @entry.handle_event(event)
+    end
+
+    @entry.signal_connect("key_press_event") do |widget, event|
+      # debug "KEYPRESS 2"
+      if event.keyval == Gdk::Keyval::KEY_Down
+        debug "DOWN"
+        set_selected_row(@selected_row + 1)
+        # fixed = iter[COLUMN_FIXED]
+
+        true
+      elsif event.keyval == Gdk::Keyval::KEY_Up
+        set_selected_row(@selected_row - 1)
+        debug "UP"
+        true
+      elsif event.keyval == Gdk::Keyval::KEY_Return
+        path = Gtk::TreePath.new(@selected_row.to_s)
+        iter = @model.get_iter(path)
+        ret = iter[1]
+        @select_callback.call(ret, @selected_row)
+        @window.destroy
+        # debug iter[1].inspect
+        true
+      elsif event.keyval == Gdk::Keyval::KEY_Escape
+        @window.destroy
+        true
+      else
+        false
+      end
+    end
+
+    @entry.signal_connect("search-changed") do |widget|
+      debug "search changed: #{widget.text || ""}"
+      item_list = @update_callback.call(widget.text)
+
+      update_item_list(item_list)
+      # label.text = widget.text || ""
+    end
+    @entry.signal_connect("changed") { debug "[changed] " }
+    @entry.signal_connect("next-match") { debug "[next-match] " }
+
+    if !opt[:desc].nil?
+      descl = Gtk::Label.new(opt[:desc])
+      vbox.pack_start(descl, :expand => false, :fill => false, :padding => 0)
+    end
+
+    # label = Gtk::Label.new(<<-EOF)
+    # Search:
+    # EOF
+
+    # label = Gtk::Label.new("Input:")
+    # vbox.pack_start(label, :expand => false, :fill => false, :padding => 0)
+
+    vbox.pack_start(container, :expand => false, :fill => false, :padding => 0)
+    sw = Gtk::ScrolledWindow.new(nil, nil)
+    sw.shadow_type = :etched_in
+    sw.set_policy(:never, :automatic)
+    vbox.pack_start(sw, :expand => true, :fill => true, :padding => 0)
+
+    sw.add(treeview)
+
+    if !opt[:columns].nil?
+      for col in opt[:columns]
+        renderer = Gtk::CellRendererText.new
+        column = Gtk::TreeViewColumn.new(col[:title],
+                                         renderer,
+                                         "text" => col[:id])
+        column.sort_column_id = col[:id]
+        treeview.append_column(column)
+      end
+    else
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new("JMP",
+                                       renderer,
+                                       "text" => COLUMN_JUMP_KEY)
+      column.sort_column_id = COLUMN_JUMP_KEY
+      treeview.append_column(column)
+
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new("Description",
+                                       renderer,
+                                       "text" => COLUMN_DESCRIPTION)
+      column.sort_column_id = COLUMN_DESCRIPTION
+      treeview.append_column(column)
+    end
+
+    @window.set_default_size(280, 500)
+    debug "SelectUpdateWindow"
+  end
+
+  def run
+    if !@window.visible?
+      @window.show_all
+      # add_spinner
+    else
+      @window.destroy
+      # GLib::Source.remove(@tiemout) unless @timeout.zero?
+      @timeout = 0
+    end
+    @window
+  end
+end

data/lib/vimamsa/gui_sourceview.rb

@@ -0,0 +1,294 @@
+
+class VSourceView < GtkSource::View
+  def initialize(title = nil)
+    # super(:toplevel)
+    super()
+    debug "vsource init"
+    @last_keyval = nil
+    @last_event = [nil, nil]
+
+    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("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
+      debug "MOVE CURSOR: #{curpos}"
+      buf.set_pos(curpos)
+      $update_cursor = false
+    end
+    debug $view.visible_rect.inspect
+
+    debug "key 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
+
+    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 }
+    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
+        $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
+    # 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()
+    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
+    # debug "===================="
+    # debug a.lines[0..10].join()
+    # debug "===================="
+    # debug b.lines[0..10].join()
+    # debug "===================="
+    if a == b
+      debug "Buffers match"
+    else
+      debug "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
+    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)
+
+    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?
+      debug iterxy.inspect
+      debug 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?
+      debug "VISUAL MODE"
+      (_start, _end) = buf.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
+      itr = buffer.get_iter_at(:offset => buf.pos)
+      $view.buffer.select_range(itr, itr)
+      debug "INSERT MODE"
+    end
+  end
+
+  # def quit
+  # destroy
+  # true
+  # end
+end
+

data/lib/vimamsa/hyper_plain_text.rb

@@ -1,10 +1,5 @@
-
-
-def hpt_open_link()
-end
-
 def hpt_check_cur_word(w)
-  puts "check_cur_word(w)"
+  debug "check_cur_word(w)"
   m = w.match(/⟦(.*)⟧/)
   if m
     fpfx = m[1]
@@ -12,8 +7,10 @@ def hpt_check_cur_word(w)
       dn = File.dirname($buffer.fname)
 
       fcands = []
-      fcands << "#{dn}/#{fpfx}"
-      fcands << "#{dn}/#{fpfx}.txt"
+      if fpfx[0] != "/"
+        fcands << "#{dn}/#{fpfx}"
+        fcands << "#{dn}/#{fpfx}.txt"
+      end
       fcands << File.expand_path("#{fpfx}")
       fcands << File.expand_path("#{fpfx}.txt")
 
@@ -38,22 +35,23 @@ def hpt_check_cur_word(w)
   return nil
 end
 
+# Scan images inserted with ⟦img:filepath⟧ syntax
 def hpt_scan_images()
   return if !buf.fname
   return if !buf.fname.match(/.*txt$/)
   imgpos = scan_indexes(buf, /⟦img:.+?⟧/)
   imgtags = buf.scan(/(⟦img:(.+?)⟧)/)
-  # i = 0
   c = 0
   imgpos.each.with_index { |x, i|
     a = imgpos[i]
     t = imgtags[i]
     insert_pos = a + t[0].size + c
     imgfn = File.expand_path(t[1])
-    # Ripl.start :binding => binding
     next if !File.exist?(imgfn)
+    # Show as image in gui, handle as empty space in txt file
     if buf[insert_pos..(insert_pos + 2)] != "\n \n"
       buf.insert_txt_at("\n \n", insert_pos)
+      buf.view.handle_deltas
       c += 3
     end
     buf.add_image(imgfn, insert_pos + 1)