ver 2010.02 → 2010.08

data/lib/ver/methods/selection.rb

@@ -3,31 +3,35 @@ module VER
     module Selection
       module_function
 
-      def enter(text, old_mode, new_mode)
-        unless old_mode.name =~ /^select/
-          text.store(self, :start, text.index(:insert))
-        end
-
-        text.store(self, :mode, new_mode)
-        text.store(self, :refresh, true)
-        Undo.separator(text)
-        refresh(text)
-      end
-
-      def leave(text, old_mode, new_mode)
-        return if new_mode.name =~ /^select/
-
-        text.store(self, :mode, new_mode)
-        text.store(self, :refresh, false)
-        Undo.separator(text)
-        clear(text)
-      end
+      def pipe(buffer)
+        paths = ENV['PATH'].split(':').map{|path| Pathname(path).expand_path }
 
-      def select_mode(text)
-        if mode = text.store(self, :mode)
-          mode.to_sym
+        buffer.ask 'Pipe command: ' do |answer, action|
+          case action
+          when :complete
+            current = answer.split.last
+            paths.map{|path|
+              (path/"*#{current}*").glob.select{|file|
+                begin
+                  file = File.readlink(file) if File.symlink?(file)
+                  stat = File.stat(file)
+                  stat.file? && stat.executable?
+                rescue Errno::ENOENT
+                end
+              }
+            }.flatten.compact
+          when :attempt
+            buffer.at_sel.pipe!(answer)
+            buffer.at_sel.finish
+            :abort
+          end
         end
       end
+    end
+  end
+end
+
+__END__
 
       def refresh(text)
         return unless text.store(self, :refresh)
@@ -187,30 +191,6 @@ module VER
         finish(text)
       end
 
-      def pipe(text)
-        paths = ENV['PATH'].split(':').map{|path| Pathname(path).expand_path }
-
-        text.ask 'Pipe command: ' do |answer, action|
-          case action
-          when :complete
-            current = answer.split.last
-            paths.map{|path|
-              (path/"*#{current}*").glob.select{|file|
-                begin
-                  file = File.readlink(file) if File.symlink?(file)
-                  stat = File.stat(file)
-                  stat.file? && stat.executable?
-                rescue Errno::ENOENT
-                end
-              }
-            }.flatten.compact
-          when :attempt
-            pipe_execute(text, answer)
-            finish(text)
-            :abort
-          end
-        end
-      end
 
       def comment(text)
         comment = "#{text.options.comment_line} "
@@ -413,14 +393,6 @@ module VER
 
         from_y, to_y = [ly, ry].sort
         from_x, to_x = [lx, rx].sort
-
-        code = [%(set win "#{text.tk_pathname}")]
-
-        from_y.upto to_y do |y|
-          code << "$win tag add sel #{y}.#{from_x} #{y}.#{to_x + 1}"
-        end
-
-        Tk.execute_only(Tk::TclString.new(code.join("\n")))
       end
 
       def refresh_char(text, start)

data/lib/ver/methods/snippet.rb

@@ -5,109 +5,134 @@ module VER
     module Snippet
       module_function
 
-      def dwim(text)
-        jump(text) or complete(text) && jump(text)
+      def dwim(buffer)
+        jump(buffer) or complete(buffer) && jump(buffer)
       end
 
-      def jump(text)
-        jump_marks_and_tags(text) || jump_home(text)
+      def jump(buffer)
+        jump_marks_and_tags(buffer) || jump_home(buffer)
       end
 
-      def jump_home(text)
-        if text.mark_names.include?(:ver_snippet_0)
-          text.mark_set(:insert, :ver_snippet_0)
-          text.mark_unset(:ver_snippet_0)
+      def jump_home(buffer)
+        if buffer.mark_names.include?(:ver_snippet_0)
+          buffer.mark_set(:insert, :ver_snippet_0)
+          buffer.mark_unset(:ver_snippet_0)
           true
         else
-          cancel(text)
+          cancel(buffer)
           false
         end
       end
 
-      def jump_marks_and_tags(text)
-        (marks(text) + tags(text)).
+      def jump_marks_and_tags(buffer)
+        (marks(buffer) + tags(buffer)).
           sort_by{|_, name, _|
             name =~ /_0$/ ? 'zero' : name
           }.each do |idx, name, type|
+
           case type
           when :tag
-            return jump_tag(text, name)
+            return jump_tag(buffer, name)
           when :mark
-            return jump_mark(text, name)
+            return jump_mark(buffer, name)
           end
         end
 
         false
       end
 
-      def marks(text)
-        text.mark_names.map{|mark|
+      def marks(buffer)
+        buffer.mark_names.map{|mark|
           next unless mark =~ /^ver_snippet_(\d+)$/
           [$1.to_i, mark, :mark]
         }.compact
       end
 
-      def tags(text)
-        text.tag_names.map{|tag|
+      def tags(buffer)
+        buffer.tag_names.map{|tag|
           next unless tag =~ /^ver\.snippet\.(\d+)$/
           [$1.to_i, tag, :tag]
         }.compact
       end
 
-      def jump_tag(text, name)
-        text.minor_mode(:control, :snippet)
-        from, to = text.tag_ranges(name).first
+      def jump_tag(buffer, name)
+        buffer.minor_mode(:insert, :snippet)
+        from, to = *buffer.tag_ranges(name).first
         return unless from
 
-        text.mark_set(:insert, from)
+        buffer.mark_set(:insert, from)
         true
       end
 
-      def jump_mark(text, name)
-        text.mark_set('insert', name)
+      def jump_mark(buffer, name)
+        buffer.mark_set('insert', name)
         if name =~ /_0$/
-          cancel(text, :insert)
+          cancel(buffer, :insert)
         else
-          text.mark_unset(name)
+          buffer.mark_unset(name)
         end
 
         true
       end
 
-      def cancel(text, into_mode = :control)
-        marks(text).each{|_, mark, _| text.mark_unset(mark) }
-        tags(text).each{|_, tag, _| text.tag_delete(tag) }
-        text.minor_mode(:snippet, into_mode) if text.minor_mode?(:snippet)
+      def cancel(buffer, into_mode = :control)
+        marks(buffer).each{|_, mark, _| buffer.mark_unset(mark) }
+        tags(buffer).each{|_, tag, _| buffer.tag_delete(tag) }
+        buffer.minor_mode(:snippet, into_mode) if buffer.minor_mode?(:snippet)
       end
 
-      def insert_string(text, string)
-        tag = text.tag_names(:insert).find{|name| name =~ /^ver\.snippet\.(\d+)$/ }
+      def on_insert(buffer, string = buffer.event.unicode)
+        tag = buffer.tag_names(:insert).find{|name| name =~ /^ver\.snippet\.(\d+)$/ }
 
         if tag
-          from, to = text.tag_ranges(tag).first
-          text.tag_delete(tag, from, to)
-          text.replace(from, to, string)
+          from, to = *buffer.tag_ranges(tag).first
+          buffer.tag_delete(tag, from, to)
+          buffer.replace(from, to, string)
         else
-          text.insert(:insert, string)
+          buffer.insert(:insert, string)
         end
       end
 
-      def complete(text)
-        head = text.get('insert linestart', 'insert')
+      class Scope < Struct.new(:tags)
+        def include?(scope)
+          tags.include?(scope)
+        end
+      end
+
+      def complete(buffer)
+        sofar = buffer.get('insert linestart', 'insert')
+        l sofar: sofar
+
+        scope = Scope.new(buffer.tag_names(:insert))
+
+        buffer.snippets.each do |snippet|
+          next unless tab_trigger = snippet[:tabTrigger]
+          next unless sofar.end_with?(tab_trigger)
+          next unless scope.include?(snippet[:scope])
+          from = buffer.index("insert - #{tab_trigger.size} displaychars")
+          to = buffer.at_insert
+          return insert(buffer, from, to, snippet)
+        end
+
+        return
+
+        head = buffer.get('insert linestart', 'insert')
         name = head[/\S+$/]
-        from = text.index("insert - #{name.size} chars")
-        to = text.index("insert")
+        from = buffer.index("insert - #{name.size} chars")
+        to = buffer.index("insert")
+
+        l buffer.snippets
 
-        return unless snippet = text.snippets[name]
-        insert(text, from, to, snippet)
+        return unless snippet = buffer.snippets[name]
+        insert(buffer, from, to, snippet)
         true
       end
 
-      def insert(text, from, to, snippet_source)
-        text.delete(from, to)
-        text.mark_set(:insert, from)
+      def insert(buffer, from, to, snippet_source)
+        buffer.delete(from, to)
+        buffer.mark_set(:insert, from)
         snippet = VER::Snippet.new(snippet_source[:content])
-        snippet.apply_on(text)
+        snippet.apply_on(buffer)
       end
     end # Snippet
   end # Methods
@@ -147,9 +172,9 @@ module VER
       out
     end
 
-    def apply_on(widget)
+    def apply_on(buffer)
       parse(@snippet, out = [])
-      apply_out_on(widget, out)
+      apply_out_on(buffer, out)
     end
 
     private
@@ -215,11 +240,11 @@ module VER
       out
     end
 
-    def apply_out_on(widget, out)
-      indent = ' ' * widget.options.shiftwidth
-      initial_indent = widget.get('insert linestart', 'insert lineend')[/^\s+/]
+    def apply_out_on(buffer, out)
+      indent = ' ' * buffer.options.shiftwidth
+      initial_indent = buffer.get('insert linestart', 'insert lineend')[/^\s+/]
 
-      VER::Methods::Undo.record widget do |record|
+      buffer.undo_record do |record|
         out.each do |atom|
           case atom
           when String
@@ -229,12 +254,12 @@ module VER
             record.insert(:insert, atom)
           when Numeric
             mark = "ver_snippet_#{atom}"
-            widget.mark_set(mark, 'insert')
-            widget.mark_gravity(mark, 'left')
+            buffer.mark_set(mark, 'insert')
+            buffer.mark_gravity(mark, 'left')
           when Array
             number, content = atom
             tag = "ver.snippet.#{number}"
-            widget.tag_configure(tag, underline: true)
+            buffer.tag_configure(tag, underline: true)
             record.insert(:insert, content, tag)
           end
         end

data/lib/ver/methods/undo.rb

@@ -6,19 +6,17 @@ module VER
     module Undo
       module_function
 
-      # Redo +count+ changes made in the given +text+.
-      def redo(text, count = text.prefix_count)
-        count.times{ text.undoer.redo }
-        text.pristine = false
+      # Redo +count+ changes made in the given +buffer+.
+      def redo(buffer, count = buffer.prefix_count)
+        count.times{ buffer.redo }
       end
 
-      # Undo +count+ changes made in the given +text+
-      def undo(text, count = text.prefix_count)
-        count.times{ text.undoer.undo }
-        text.pristine = false
+      # Undo +count+ changes made in the given +buffer+
+      def undo(buffer, count = buffer.prefix_count)
+        count.times{ buffer.undo }
       end
 
-      # Wrapper to record multiple changes to given +text+ as one change, so
+      # Wrapper to record multiple changes to given +buffer+ as one change, so
       # they can be undone and redone together.
       # A user usually expects one command to correspond to one undo record,
       # except for things like replacement or input.
@@ -27,17 +25,15 @@ module VER
       #
       # @yieldparam [VER::Undo::AutoSeparator]
       #   proxy for delete/insert/replace methods
-      def record(text, &block)
-        VER.warn "Buffer is Read-only" if text.readonly
-        text.undoer.record_multi(&block)
-        text.pristine = false
+      def record(buffer, &block)
+        buffer.undo_record(&block)
       end
 
       # Insert a separator into the undo history, undo/redo apply always up to
       # the next separator.
-      # Operates on the undoer of the given +text+.
-      def separator(text)
-        text.undoer.separate!
+      # Operates on the undoer of the given +buffer+.
+      def separator(buffer)
+        buffer.undoer.separate!
       end
     end # Undo
   end # Methods

data/lib/ver/minibuffer.rb

@@ -1,217 +1,352 @@
 module VER
-  class MiniBuffer < Tk::Text
+  class MiniBuffer < Text
+    HISTORY = Hash.new{|h,k| h[k] = SizedArray.new(50) }
+
+    # NOTE:
+    #   {Text#dump} on a peer text widget causes segfault, I've reported the
+    #   issue to the tk maintainers and they are working on it.
+    #   All tcl/tk versions are affected AFAIK, take care.
+    class Peer < MiniBuffer
+      attr_reader :buffer
+
+      def initialize(text, parent, buffer, options = {})
+        @tk_parent = parent
+        @buffer = buffer
+        @tk_pathname = Tk.register_object(parent, self)
+        Tk.execute(text.tk_pathname, 'peer', 'create', @tk_pathname, options)
+        setup_common
+      end
+    end
+
+    def self.answer_from(text)
+      line = text.get('current linestart', 'current lineend')
+      minibuf = VER.minibuf
+      minibuf.answer = line
+      minibuf.complete_small
+    end
+
     include Keymapped
 
-    attr_accessor :messages_expire, :messages_pending, :char_width
+    attr_accessor :messages_expire, :char_width, :ask_stack,
+                  :at_insert, :completion_buffer
+    attr_reader :asking, :messages, :messages_pending, :buffer
 
     def initialize(*args)
       super
+      setup
+    end
+
+    def peer_create(parent, buffer, *args)
+      Peer.new(self, parent, buffer, *args)
+    end
+
+    def setup
+      setup_common
 
-      font = VER.options.font
+      @info.configure(foreground: '#fff')
+      @warn.configure(foreground: '#f00')
+      @highlight.configure(background: '#330')
+
+      # Now to the difficult part.
+      # When i talk about "tag", i mean the prompt and answer tags.
+      #
+      # If the "tag" contents are deleted, we will get errors in all places
+      # where it's used.
+      # To avoid that, we add extra tags called "tag"_keeper.
+      # These are elided and contain only one character, their priority is
+      # higher than "tag" to sure they never show.
+      # The character within is also tagged with "tag".
+      # When doing modifications, we just have to make sure that the
+      # "tag"_keeper tag stays around.
+      # To simplify referencing, we add a mark called "tag" with left gravity.
+      # When getting contents of "tag", get only non-elided part.
+
+      @prompt_keeper = tag(:prompt_keeper)
+      insert('1.0', 'p', @prompt_keeper)
+      @prompt_mark = mark(:prompt, '1.1', :left)
+      @prompt_tag  = tag(:prompt, '1.0', '1.1')
+      @prompt_keeper.configure(elide: true)
+      tag_lower(@prompt_tag, @prompt_keeper)
+
+      @answer_keeper = tag(:answer_keeper)
+      insert('1.1', 'a', :answer_keeper)
+      @answer_mark = mark(:answer, '1.2', :left)
+      @answer_tag  = tag(:answer, '1.1', '1.2')
+      @answer_keeper.configure(elide: true)
+      tag_lower(@answer_tag, @answer_keeper)
+
+      bind('<Configure>'){ pack_forget }
+    end
+
+    def setup_common
       configure(
-        font: font,
-        wrap: :none,
-        undo: true,
+        autoseparators: true,
+        background: '#000',
+        blockcursor: false,
         borderwidth: 0,
         exportselection: true,
+        font: VER.options.font,
+        foreground: '#fff',
+        highlightbackground: '#000', # this specifies the colors
+        highlightcolor: '#fff',      # that are used when the widget
+        highlightthickness: 1,       # has input focus.
+        insertbackground: '#fff',
         insertofftime: 0,
         setgrid: false, # wtf?
-        autoseparators: true,
-        blockcursor: false,
-        background: '#000',
-        foreground: '#fff',
-        insertbackground: '#fff'
+        undo: true,
+        wrap: :word
       )
 
       self.major_mode = :MiniBuffer
       self.messages_expire = false
-      self.messages_pending = 0
-      self.char_width = font.measure('0')
+      @messages_pending = Hash.new(0)
+      @messages = SizedArray.new(10)
+      self.char_width = VER.options.font.measure('0')
+      self.ask_stack = []
+      self.at_insert = mark(:insert)
+      self.completion_buffer = Tk::Text.new(tk_parent)
+      @old_grid_info = nil
+
+      [ :info, :warn, :highlight, :prompt, :answer ].each do |name|
+        instance_variable_set("@#{name}", tag(name))
+      end
 
-      tag_configure 'info', foreground: '#fff'
-      tag_configure 'warn', foreground: '#f00'
-      tag_configure 'highlight', background: '#330'
+      bind('<Configure>', &method(:adjust_size))
+      bind('<Destroy>', &method(:on_destroy))
+    end
 
-      bind('<Configure>'){ adjust_size }
+    def on_destroy(event)
+      @lock = true
     end
 
-    def adjust_size
-      configure(
-        width: (tk_parent.winfo_width / char_width.to_f).floor,
-        height: count('1.0', 'end', :lines)
-      )
+    def type(string)
+      major_mode.fake(string)
+    end
+
+    def history
+      HISTORY[@prompt.get]
+    end
+
+    def adjust_size(event = nil)
+      if get_displaychars('1.0', 'end').strip.empty?
+        if (info = grid_info) && !info.empty?
+          @old_grid_info = info
+          grid_forget
+        end
+      else
+        height = count('1.0', 'end', 'displaylines') || 1
+        grid_configure(@old_grid_info) if @old_grid_info
+        configure(height: height)
+      end
+
+      # a generous 25ms to make sure the display is updated.
+      # Might need longer, lemme know if that's the case.
+      Tk::After.ms(25){ buffer.see(:insert) } if buffer
+    rescue => ex
+      VER.error(ex)
     end
 
-    def prompt=(prompt)
-      replace 'prompt.first', 'prompt.last', prompt, 'prompt'
-    rescue
-      insert '1.0 linestart', prompt, 'prompt'
+    def prompt=(value)
+      replace('prompt', 'prompt.last', value, 'prompt')
     end
 
     def prompt
-      get('prompt.first', 'prompt.last')
-    rescue
-      ''
+      get_displaychars('prompt', 'prompt.last')
     end
 
-    def answer=(answer)
-      replace 'answer.first', 'answer.last', answer, 'answer'
-    rescue
-      insert 'prompt.last', answer, 'answer'
-    rescue
-      insert 'end', answer, 'answer'
+    def answer=(value)
+      replace('answer', 'answer.last', value, 'answer')
     end
 
     def answer
-      get('answer.first', 'answer.last')
-    rescue
-      ''
+      get_displaychars('answer', 'answer.last')
+    end
+
+    def warn(object)
+      case object
+      when Exception
+        message("#{object.class}: #{object}", 'warn')
+      when Symbol, String
+        message(object.to_s, 'warn')
+      else
+        message(object.to_str, 'warn')
+      end
     end
 
     def message(string, tag = 'info')
-      Tk::After.idle do
-        insert = index('insert')
+      insert = at_insert.index
 
+      begin
+        replace("#{tag}.first", "#{tag}.last", " #{string}", tag)
+        # mark(tag, "#{tag}.first", :left)
+      rescue
         begin
-          replace "#{tag}.first", "#{tag}.last", " #{string}", tag
+          insert(tag, " #{string}", tag)
         rescue
-          insert '1.0 lineend', " #{string}", tag
+          insert('1.0 lineend', " #{string}", tag)
         end
+      end
 
-        mark_set('insert', insert)
-        see "#{tag}.first"
-
+      if string.to_s.strip != ''
+        messages << string
         message_expire(tag) #  if messages_expire
-        message_notify(tag)
-        message_buffer_insert(string, tag)
+        # message_notify(tag)
       end
-    end
+      adjust_size
 
-    def message_buffer_insert(string, tag)
-      string = "#{string}\n" unless string.end_with?("\n")
-      buffer = Buffer[:Messages]
-      buffer.text.execute(:insert, :end, string, tag)
-
-      last_focus = Tk::Focus.focus # for some reason
-      buffer.text.see(:end)        # this changes focus to the text
-      Tk::Focus.focus(last_focus)  # so we restore it here
+      self.insert = insert
+      see "#{tag}.first"
     end
 
     def message_notify(tag, timeout = 500)
       tag_add('highlight', "#{tag}.first", "#{tag}.last")
 
       Tk::After.ms timeout.to_int do
-        tag_remove('highlight', "#{tag}.first", "#{tag}.last")
+        begin
+          tag_remove('highlight', "#{tag}.first", "#{tag}.last")
+        rescue
+        end
       end
     end
 
-    def message_expire(tag, timeout = 3000)
-      self.messages_pending += 1
+    def message_expire(tag, timeout = 5000)
+      self.messages_pending[tag] += 1
 
       Tk::After.ms timeout.to_int do
-        self.messages_pending -= 1
-        if messages_pending == 0
+        self.messages_pending[tag] -= 1
+        if messages_pending[tag] == 0
           delete("#{tag}.first", "#{tag}.last") rescue nil
+          adjust_size
         end
       end
     end
 
-    def warn(object)
-      case object
-      when Exception
-        message("#{object.class}: #{object}", 'warn')
-      when Symbol, String
-        message(object.to_s, 'warn')
-      else
-        message(object.to_str, 'warn')
-      end
+    def claim_focus
+      bind('<FocusOut>'){ focus; Tk.callback_break }
+      focus
     end
 
-    def ask(prompt, options = {}, &action)
-      @action = action || options[:action]
-      @caller = options.fetch(:caller)
+    def release_focus
+      bind('<FocusOut>'){ }
+    end
 
-      self.prompt = prompt
-      self.answer = options[:value].to_s
+    def ask(prompt, options = {}, action = nil, &block)
+      action ||= block
 
-      message ''
-      warn ''
-      self.messages_expire = true
-      bind('<FocusOut>'){ focus }
-      focus
+      if @asking
+        ask_stack << [prompt, options, action]
+      else
+        @asking = true
+        @action = action || options[:action]
+        @caller = options.fetch(:caller)
+
+        self.prompt = prompt
+        self.answer = options[:value]
+        self.insert = 'answer.last'
+
+        message ''
+        warn ''
+        self.messages_expire = true
+
+        # Make sure display is ready.
+        Tk.update
+        focus
+      end
     end
 
     def abort(event = nil)
-      self.answer = ''
       self.prompt = ''
-      bind('<FocusOut>'){ }
-      self.messages_expire = false
-      Buffer[:Completions].hide
-      @caller.focus
+      self.answer = ''
+      completion_buffer.place_forget rescue nil
+      @asking = false
+
+      if ask_stack.empty?
+        self.messages_expire = false
+        @caller.focus
+      else
+        ask(*ask_stack.shift)
+      end
     end
 
     def attempt(event = nil)
+      HISTORY[@prompt.get] << answer
       invoke(:attempt)
     end
 
-    def self.answer_from(text)
-      line = text.get('current linestart', 'current lineend')
-      minibuf = VER.minibuf
-      minibuf.answer = line
-      minibuf.complete_small
-    end
-
     def show_completions(completions)
-      buffer = Buffer[:Completions]
-      text = buffer.text
-      text.delete('1.0', 'end')
+      buffer = completion_buffer
+      buffer.delete('1.0', 'end')
       completions.each do |completion|
-        text.insert('end', completion, 'ver.minibuf.completion')
-        text.insert('end', "\n")
+        buffer.insert('end', completion, 'ver.minibuf.completion')
+        buffer.insert('end', "\n")
       end
-      buffer.show
+      buffer.place relx: 0.0, rely: 0.9, anchor: :sw, relheight: 0.9
     end
 
     def complete_small(event = nil)
       if choices = invoke(:complete)
-        if choices.size == 1
+        case choices.size
+        when 0
+        when 1
           self.answer = choices.first
+        else
+          self.answer = common_subchoice(choices)
         end
       end
     end
 
     def complete_large(event = nil)
       if choices = invoke(:complete)
-        if choices.size == 1
+        case choices.size
+        when 0
+        when 1
           self.answer = choices.first
-        elsif choices.size > 1
+        else
+          self.answer = common_subchoice(choices)
           show_completions(choices)
         end
       end
     end
 
+    def common_subchoice(choices)
+      longest = choices.max_by{|choice| choice.size }
+      common = ''
+
+      longest.each_char do |char|
+        current = common + char
+
+        if choices.all?{|choice| choice.start_with?(current) }
+          common << char
+        else
+          break
+        end
+      end
+
+      common
+    end
+
     def invoke(action, *args)
       Tk::Event.generate(self, "<<#{action.capitalize}>>")
-      case result = @action.call(answer, action, *args)
-      when :abort
-        abort
-      else
-        result
-      end
+      result = @action.call(answer, action, *args)
+      result == :abort ? abort : result
     end
 
-    def insert_string(event)
-      case string = event.unicode
-      when /^([[:word:][:ascii:]]| )+$/
+    def events
+      major_mode.event_history
+    end
+
+    def insert_string
+      case string = events.last.unicode
+      when /^[^\n\r[:cntrl:]]+$/
         insert(:insert, string, 'answer')
         invoke(:modified)
       else
-        p string
+        l insert_string: string
       end
     end
 
     def insert_selection(event = nil)
-      insert(:insert, Tk::Selection.get, 'answer')
+      insert(:insert, Tk::Selection.get(type: 'UTF8_STRING'), 'answer')
       invoke(:modified)
     end
 
@@ -221,73 +356,87 @@ module VER
     end
 
     def end_of_line(event = nil)
-      return if tag_ranges('answer').empty?
       mark_set('insert', 'answer.last')
       invoke(:movement)
     end
 
     def kill_end_of_line(event = nil)
-      return if tag_ranges('answer').empty?
+      content = get_displaychars('insert', 'answer.last')
+      copy(content) if content =~ /\S/
       delete('insert', 'answer.last')
       invoke(:modified)
     end
 
-    def kill_next_char(event = nil)
-      return if tag_ranges('answer').empty?
-      delete('insert')
+    def delete_next_char(event = nil)
+      return unless line = get_displaychars('insert', 'answer.last')
+      delete('insert') unless line == ''
       invoke(:modified)
     end
 
-    def kill_next_word(event = nil)
-      return if tag_ranges('answer').empty?
-      line = get('insert', 'answer.last')
+    def delete_next_word(event = nil)
+      line = get_displaychars('insert', 'answer.last')
       return unless word = line[/^\s*(?:\w+|[^\w\s]+)\s*/]
       delete('insert', "insert + #{word.size} chars")
       invoke(:modified)
     end
 
-    def kill_prev_char(event = nil)
-      return if tag_ranges('answer').empty?
-      delete('insert - 1 chars')
+    def delete_prev_char(event = nil)
+      return unless compare('insert', '>', 'answer')
+      delete('insert - 1 display chars')
       invoke(:modified)
     end
 
-    def kill_prev_word(event = nil)
-      return if tag_ranges('answer').empty?
-      line = get('answer.first', 'insert').reverse
+    def delete_prev_word(event = nil)
+      line = get_displaychars('answer', 'insert').reverse
       return unless word = line[/^\s*(?:\w+|[^\w\s]+)\s*/]
-      delete("insert - #{word.size} chars", 'insert')
+      delete("insert - #{word.size} display chars", 'insert')
       invoke(:modified)
     end
 
     def next_char(event = nil)
-      return if tag_ranges('answer').empty?
       return if compare('insert', '>=', 'answer.last')
       mark_set('insert', 'insert + 1 chars')
       invoke(:movement)
     end
 
     def prev_char(event = nil)
-      return if tag_ranges('answer').empty?
-      return if compare('insert', '<=', 'answer.first')
+      return if compare('insert', '<=', 'answer')
       mark_set('insert', 'insert - 1 chars')
       invoke(:movement)
     end
 
     def start_of_line(event = nil)
-      return if tag_ranges('answer').empty?
-      mark_set('insert', 'answer.first')
+      mark_set('insert', 'answer')
       invoke(:movement)
     end
 
     def transpose_chars(event = nil)
-      return if tag_ranges('answer').empty?
       insert = index('insert')
-      line = get('insert', 'answer.last')
+      line = get_displaychars('insert', 'answer.last')
       line[0, 2] = line[0, 2].reverse
       replace('insert', 'answer.last', line, 'answer')
       mark_set('insert', insert)
       invoke(:modified)
     end
+
+    def copy(string)
+      Clipboard.dwim = string
+    end
+
+    def paste(event = nil)
+      return unless content = Clipboard.dwim
+      insert(:insert, content, 'answer')
+      invoke(:modified)
+    end
+
+    def prev_history
+      history = HISTORY[@prompt.get]
+      l prev_history: history
+    end
+
+    def next_history
+      history = HISTORY[@prompt.get]
+      l next_history: history
+    end
   end
 end