entry.rb in ver-2010.08

- old
+ new

@@ -11,28 +11,32 @@
   class Entry < Tk::Tile::Entry
     space, word = /[^[:alnum:]]+/, /[[:alnum:]]/
     FORWARD_WORD = /#{space}+#{word}|#{word}+#{space}+#{word}/
     BACKWARD_WORD = /#{word}+/
 
+    def events
+      major_mode.event_history
+    end
+
+    def event
+      major_mode.event_history.last
+    end
+
     ## Maintenance
     def style
       style = cget(:style)
       style.flatten.first if style
     end
 
-    def quit(event = nil)
-      VER.exit
+    def message(*args)
+      VER.message(*args)
     end
 
-    def message(string)
-      self.value = string
+    def error(*args)
+      VER.warn(*args)
     end
 
-    def error(string)
-      self.value = string
-    end
-
     def insert(*args)
       super
       Tk::Event.generate(self, '<<Inserted>>')
       Tk::Event.generate(self, '<<Modified>>')
     end
@@ -47,134 +51,143 @@
     def delete(*args)
       super
       Tk::Event.generate(self, '<<Deleted>>')
       Tk::Event.generate(self, '<<Modified>>')
     end
-    alias kill delete # nobody wants to copy that way, right? ;)
 
+    def kill(*args)
+      Clipboard.dwim = get(*args)
+      delete(*args)
+    end
+
     def cursor=(pos)
       selection_clear
       super
       Tk::Event.generate(self, '<<Movement>>')
     end
 
     ## Insert
 
-    def insert_string(event)
+    def insert_string(event = self.event)
       insert(cursor, event.unicode)
     end
 
     # Insert X selection at cursor position
-    def insert_selection(event)
-      insert(cursor, Tk::Selection.get)
+    def insert_selection
+      insert(cursor, Tk::Selection.get(type: 'UTF8_STRING'))
     end
 
     # Insert a literal tab character at cursor position
-    def insert_tab(event)
+    def insert_tab
       insert(cursor, "\t")
     end
 
-    def transpose_chars(event)
+    def paste
+      return unless content = VER::Clipboard.get
+      insert(cursor, content)
+    end
+
+    def transpose_chars
       char = get[cursor]
       delete(cursor)
       insert(cursor - 1, char)
     end
 
     ## Delete
 
-    def delete_motion(motion)
+    def deleting(motion)
       delete(*virtual_movement(motion))
     end
 
-    def kill_motion(motion)
+    def killing(motion)
       kill(*virtual_movement(motion))
     end
 
-    def kill_prev_char(event)
-      kill_motion :prev_char
+    def delete_prev_char
+      deleting :prev_char
     end
 
-    def kill_next_char(event)
-      kill_motion :next_char
+    def delete_next_char
+      deleting :next_char
     end
 
-    def kill_prev_word(event)
-      kill_motion :prev_word
+    def delete_prev_word
+      deleting :prev_word
     end
 
-    def kill_next_word(event)
-      kill_motion :next_word
+    def delete_next_word
+      deleting :next_word
     end
 
-    def kill_end_of_line(event)
-      kill_motion :end_of_line
+    def kill_end_of_line
+      killing :end_of_line
     end
 
     ## Selection
 
-    def sel_prev_char(event)
+    def sel_prev_char
       # bind TEntry <Shift-Key-Left> 		{ ttk::entry::Extend %W prevchar }
       Tk.execute_only('ttk::entry::Extend', self, :prevchar)
     end
 
-    def sel_next_char(event)
+    def sel_next_char
       # bind TEntry <Shift-Key-Right>		{ ttk::entry::Extend %W nextchar }
       Tk.execute_only('ttk::entry::Extend', self, :nextchar)
     end
 
-    def sel_prev_word(event)
+    def sel_prev_word
       # bind TEntry <Shift-Control-Key-Left>	{ ttk::entry::Extend %W prevword }
       Tk.excute_only('ttk::entry::Extend', self, :prevword)
     end
 
-    def sel_next_word(event)
+    def sel_next_word
       # bind TEntry <Shift-Control-Key-Right>	{ ttk::entry::Extend %W nextword }
       Tk.execute_only('ttk::entry::Extend', self, :nextword)
     end
 
-    def sel_start_of_line(event)
+    def sel_start_of_line
       # bind TEntry <Shift-Key-Home>		{ ttk::entry::Extend %W home }
       Tk.execute_only('ttk::entry::Extend', self, :home)
     end
 
-    def sel_end_of_line(event)
+    def sel_end_of_line
       # bind TEntry <Shift-Key-End>		{ ttk::entry::Extend %W end }
       Tk.execute_only('ttk::entry::Extend', self, :end)
     end
 
     ## Movement
 
     # Move to the start of the current line.
-    def start_of_line(event)
+    def start_of_line
       self.cursor = 0
     end
 
     # Move to the end of the entry line.
-    def end_of_line(event)
+    def end_of_line
       self.cursor = :end
     end
 
     # Move forward a character.
-    def next_char(event)
+    def next_char
       self.cursor += 1
     end
 
     # Move back a character.
-    def prev_char(event)
+    def prev_char
       self.cursor -= 1
     end
 
     # Move forward to the end of the next word.
     # Words are composed of alphanumeric characters (letters and digits).
-    def next_word(event)
+    def next_word
       return unless md = get.match(FORWARD_WORD, cursor)
       self.cursor = md.offset(0).last
     end
 
     # Move back to the start of the current or previous word.
     # Words are composed of alphanumeric characters (letters and digits).
-    def prev_word(event)
+    def prev_word
       line = get.reverse
       pos = get.size - cursor
 
       return unless md = line.match(BACKWARD_WORD, pos)
       self.cursor = (line.size - md.offset(0).last)
@@ -214,24 +227,22 @@
     def end_of_history
       @history_index = 0
       self.value = @history[@history_index]
     end
 
-    ## Asking questions
-
     # Accept the line regardless of where the cursor is.
     # If this line is non-empty, it will be added to the history list.
     # If the line is a modified history line, the history line is restored to
     # its original state.
-    def accept_line(event)
+    def accept_line
       line = get
       Tk::Event.generate(self, '<<AcceptLine>>')
       delete(0, :end)
     end
 
-    def virtual_movement(name, count = 1)
+    def virtual_movement(name, *args)
       pos = cursor
-      __send__(name, count)
+      __send__(name, *args)
       mark = cursor
       self.cursor = pos
       return [pos, mark].sort
     rescue => ex
       VER.error(ex)