vimamsa 0.1.4 → 0.1.7

data/lib/vimamsa/gui_gtk_sourceview.rb

@@ -0,0 +1,294 @@
+
+class VSourceView < GtkSource::View
+  def initialize(title = nil)
+    # super(:toplevel)
+    super()
+    puts "vsource init"
+    @last_keyval = nil
+    @last_event = [nil, nil]
+
+    signal_connect "button-press-event" do |_widget, event|
+      if event.button == Gdk::BUTTON_PRIMARY
+        # puts "Gdk::BUTTON_PRIMARY"
+        false
+      elsif event.button == Gdk::BUTTON_SECONDARY
+        # puts "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
+      puts "MOVE CURSOR: #{curpos}"
+      buf.set_pos(curpos)
+      $update_cursor = false
+    end
+    puts $view.visible_rect.inspect
+
+    puts "key event"
+    puts 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 }
+    puts keynfo.inspect
+    # $kbd.match_key_conf(key_str, nil, :key_press)
+    # puts "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
+    # puts 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
+    # puts "===================="
+    # puts a.lines[0..10].join()
+    # puts "===================="
+    # puts b.lines[0..10].join()
+    # puts "===================="
+    if a == b
+      puts "Buffers match"
+    else
+      puts "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
+    puts "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?
+      puts iterxy.inspect
+      puts 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?
+      puts "VISUAL MODE"
+      (_start, _end) = buf.get_visual_mode_range2
+      puts "#{_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)
+      puts "INSERT MODE"
+    end
+  end
+
+  # def quit
+  # destroy
+  # true
+  # end
+end
+

data/lib/vimamsa/gui_menu.rb

@@ -0,0 +1,100 @@
+module Vimamsa
+  class Menu
+    def add_to_menu(_mpath, x)
+      mpath = _mpath.split(".")
+      curnfo = @nfo
+      for y in mpath
+        puts curnfo.inspect
+        if y.equal?(mpath.last)
+          curnfo[y] = x
+        elsif curnfo[y].nil?
+          curnfo[y] = { :label => y, :items => {} }
+        end
+        curnfo[y][:items] = {} if curnfo[y][:items].class != Hash
+        curnfo = curnfo[y][:items]
+      end #end for
+    end
+
+    def add_menu_items()
+      add_to_menu "File.Save", { :label => "Save", :action => :buf_save }
+      add_to_menu "File.Save as", { :label => "Save As...", :action => :buf_save_as }
+      add_to_menu "File.Open", { :label => "Open", :action => :open_file_dialog }
+
+      add_to_menu "File.New", { :label => "New file", :action => :buf_new }
+      add_to_menu "File.Revert", { :label => "Reload file from disk", :action => :buf_revert }
+
+      add_to_menu "File.Quit", { :label => "Quit", :action => :quit }
+
+      add_to_menu "Edit.Undo", { :label => "Undo edit", :action => :edit_undo }
+      add_to_menu "Edit.Redo", { :label => "Redo edit", :action => :edit_redo }
+      add_to_menu "Edit.SearchReplace", { :label => "Search and replace", :action => :gui_search_replace }
+      add_to_menu "Edit.Find", { :label => "Find", :action => :find_in_buffer }
+
+      add_to_menu "Actions.SearchForActions", { :label => "Search for Actions", :action => :search_actions }
+
+      add_to_menu "Actions.Grep", { :label => "Grep lines", :action => :invoke_grep_search }
+
+      add_to_menu "Actions.FileHistoryFinder", { :label => "Search files in history", :action => :gui_file_history_finder }
+
+      add_to_menu "Actions.experimental.Diff", { :label => "Show Diff of\nunsaved changes", :action => :diff_buffer }
+
+      add_to_menu "Actions.EncryptFile", { :label => "Encrypt file", :action => :encrypt_file }
+
+      #TODO: :auto_indent_buffer
+
+      # add_to_menu "Actions.Ack", { :label => "source code search (Ack)", :action => :ack_search }
+
+    end
+
+    def initialize(menubar)
+      # nfo["file"] = { :items => {}, :label => "File" }
+      # nfo["actions"] = { :items => {}, :label => "Actions" }
+      # nfo["help"] = { :items => {}, :label => "Help" }
+
+      @nfo = {}
+
+      add_menu_items
+
+      # add_to_menu("help.extra.keybindings", { :label => "Show keybindings" })
+      # add_to_menu("help.extra.nfo.keybindings", { :label => "Show keybindings" })
+      # add_to_menu("help.keybindings", { :label => "Show keybindings <span foreground='#888888'  >C ? k</span>" }) #font='12' weight='ultrabold'
+
+      for k, v in @nfo
+        build_menu(v, menubar)
+      end
+    end
+
+    def build_menu(nfo, parent)
+      menu = Gtk::Menu.new
+      if nfo[:action]
+        kbd_str = ""
+        for mode_str in ["C", "V"]
+          c_kbd = vma.kbd.act_bindings[mode_str][nfo[:action]]
+          if c_kbd.class == String
+            kbd_str = "   <span foreground='#888888'><span weight='bold'>[#{mode_str}]</span> #{c_kbd}</span>"
+            break
+          end
+        end
+
+        label_str = nfo[:label] + kbd_str
+        menuitem = Gtk::MenuItem.new(:label => label_str)
+        menuitem.children[0].set_markup(label_str)
+
+        menuitem.signal_connect("activate") do
+          call_action(nfo[:action])
+        end
+      else
+        menuitem = Gtk::MenuItem.new(:label => nfo[:label])
+        menuitem.children[0].set_markup(nfo[:label])
+      end
+
+      if !nfo[:items].nil? and !nfo[:items].empty?
+        for k2, item in nfo[:items]
+          build_menu(item, menu)
+        end
+        menuitem.submenu = menu
+      end
+      parent.append(menuitem)
+    end
+  end #end class
+end

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)
+    # puts item_list.inspect
+    @model.clear
+    for item in item_list
+      iter = @model.append
+      if !@opt[:columns].nil?
+        v = item
+      else
+        v = ["", item[0]]
+      end
+      puts 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
+
+    puts item_list.inspect
+    @update_callback = method(update_callback)
+    @select_callback = method(select_callback)
+    # puts @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|
+      # puts "KEYPRESS 1"
+      @entry.handle_event(event)
+    end
+
+    @entry.signal_connect("key_press_event") do |widget, event|
+      # puts "KEYPRESS 2"
+      if event.keyval == Gdk::Keyval::KEY_Down
+        puts "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)
+        puts "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
+        # puts 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|
+      puts "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") { puts "[changed] " }
+    @entry.signal_connect("next-match") { puts "[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)
+    puts "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