ver 2010.02 → 2010.08

data/lib/ver/entry.rb

@@ -13,22 +13,26 @@ module VER
     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
-    end
-
-    def message(string)
-      self.value = string
+    def message(*args)
+      VER.message(*args)
     end
 
-    def error(string)
-      self.value = string
+    def error(*args)
+      VER.warn(*args)
     end
 
     def insert(*args)
@@ -49,7 +53,11 @@ module VER
       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
@@ -59,21 +67,26 @@ module VER
 
     ## 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)
@@ -81,62 +94,62 @@ module VER
 
     ## 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
@@ -144,35 +157,35 @@ module VER
     ## 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
 
@@ -216,21 +229,19 @@ module VER
       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

data/lib/ver/event.rb

@@ -0,0 +1,335 @@
+module VER
+  # This is used to represent events.
+  # It also represents the minimum required properties for events.
+  #
+  # The reason we don't use the default Tk::Event::Data is to compensate for
+  # differences of platforms and to have correct values for the event even if
+  # we generate them in specs.
+  class Event < Struct.new(:pattern, :keysym, :unicode)
+    PATTERN = {}
+    UNICODE  = Hash.new{|h,k| h[k] = Set.new }
+    KEYSYM   = Hash.new{|h,k| h[k] = Set.new }
+
+    def self.each(&block)
+      PATTERN.values.each(&block)
+    end
+
+    def self.pattern(pattern, keysym, unicode)
+      event = new(pattern, keysym, unicode)
+      PATTERN[event.pattern] = event
+      UNICODE[event.unicode] << event
+      KEYSYM[event.keysym] << event
+      event
+    end
+
+    def self.fake(alias_pattern, keysym, unicode = '')
+      event = pattern("<#{alias_pattern}>", keysym, unicode)
+      MODIFIERS.each{|mod| pattern("<#{mod}-#{alias_pattern}>", keysym, unicode) }
+      event
+    end
+
+    # given a <pattern>, this returns the event for this pattern.
+    # given a unicode char, returns the event with shortest pattern.
+    def self.[](string)
+      pattern = nil
+
+      case string
+      when /^<(.*)>$/ # an actual or virtual pattern
+        pattern = expand_pattern(string)
+        PATTERN.fetch(pattern)
+      when /^[^-]{2,}$/ # keysym
+        pattern = "<#{string}>"
+        KEYSYM.fetch(string)
+      when /^.$/ # single unicode char
+        pattern = "<#{string}>"
+        UNICODE.fetch(string).min_by{|event| event.pattern.size }
+      end
+    rescue KeyError => ex
+      capture(pattern || string)
+    end
+
+    def self.key?(string)
+      if string =~ /^<(.*)>$/
+        PATTERN.fetch(string)
+      elsif string.size == 1
+        UNICODE.fetch(string).min_by{|event| event.pattern.size }
+      else # it may be keysym, but let's try to make it pattern instead
+        PATTERN.fetch("<#{string}>")
+      end
+
+      true
+    rescue KeyError
+      false
+    end
+
+    MODIFIERS = %w[
+      Control Mod1 M1 Command Alt Mod2 M2 Option Shift Mod3 M3 Lock Mod4 M4
+      Extended Mod5 M5 Button1 B1 Meta M Button2 B2 Double Button3 B3 Triple
+      Button4 B4 Quadruple Button5 B5 ]
+
+    DETAILS = %w[
+      Activate Destroy Map ButtonPress Button Enter MapRequest ButtonRelease
+      Expose Motion Circulate FocusIn MouseWheel CirculateRequest FocusOut
+      Property Colormap Gravity Reparent Configure KeyPress Key ResizeRequest
+      ConfigureRequest KeyRelease Unmap Create Leave Visibility Deactivate ]
+
+    require 'abbrev'
+    MODIFIERS_ABBREV = MODIFIERS.abbrev
+    DETAILS_ABBREV = DETAILS.abbrev
+
+    # because Control is used a lot more than Command.
+    MODIFIERS_ABBREV['C'] = 'Control'
+
+    PATTERN_ALIAS = {}
+
+    # pattern has the form of <modifier-modifier-type-detail>
+    # This may be shortened down to <detail>.
+    # Here we expand short forms of modifier and type.
+    # Short modifiers take precedence over short types, as they are way more
+    # used.
+    def self.expand_pattern(given_pattern)
+      *parts, detail = given_pattern[1..-2].split('-')
+
+      if parts.empty?
+        PATTERN_ALIAS.fetch(given_pattern, given_pattern)
+      else
+        parts.map! do |part|
+          MODIFIERS_ABBREV[part] || DETAILS_ABBREV[part] || part
+        end
+
+        aliased_detail = PATTERN_ALIAS.fetch(detail, detail)
+        inner = (parts << aliased_detail).join('-')
+        pattern = "<#{inner}>"
+        PATTERN_ALIAS.fetch(pattern, pattern)
+      end
+    end
+
+    def self.capture(pattern)
+      l "capturing %p" % [pattern]
+      @entry ||= setup_capture
+      @pending += 1
+
+      @entry.bind(pattern){|event|
+        keysym, unicode = event.keysym, event.unicode
+        l "Received: %p" % [[pattern, keysym, unicode]]
+
+        if pattern =~ /^<(.*)>$/
+          pattern(pattern, keysym, unicode)
+        elsif pattern.size == 1
+          pattern("<#{keysym}>", keysym, unicode)
+        else
+          raise "Don't know how to handle: %p" % [event]
+        end
+
+        Tk.callback_break
+      }
+
+      @entry.value = ""
+
+      send_pattern = if Platform.mac?
+                       pattern
+                     else
+                       pattern.gsub(/\bAlt\b/, 'M1')
+                     end
+
+      counter = 0
+      until self.key?(pattern)
+        Tk::Event.generate(@entry, send_pattern, when: :now)
+        Tk.update
+        counter += 1
+
+        # just try a couple of times before annoying the user.
+        if counter == 10
+          @entry.value = "Please press %p" % [pattern]
+          @entry.focus
+        end
+      end
+
+      @progress.step
+      @pending -= 1
+      self[pattern]
+    end
+
+    def self.setup_capture
+      @toplevel = Tk::Toplevel.new
+      @label = Tk::Tile::Label.new(
+        @toplevel,
+        text: "Detected updates to keymap, this may take a few seconds..."
+      )
+      @entry = Tk::Entry.new(@toplevel)
+      @progress = Tk::Tile::Progressbar.new(
+        @toplevel,
+        orient: :horizontal,
+        mode: :indeterminate
+      )
+
+      @pending = 0
+      @label.pack fill: :x
+      @progress.pack fill: :x
+      @entry.pack fill: :x
+      @entry.bind('<Map>'){ @entry.focus }
+      @entry
+    end
+
+    def self.done_yet?
+      return if !@toplevel || @pending > 0
+      persist!
+      @toplevel.destroy
+      @toplevel = @entry = @label = @progress = nil
+    end
+
+    def self.persist_location
+      VER.options.home_conf_dir/'.events'
+    end
+
+    def self.persist!
+      path = persist_location
+      l "Persisting event patterns to #{path}"
+      path.open 'wb+' do |io|
+        io.write(Marshal.dump(PATTERN))
+      end
+    end
+
+    def self.load!
+      path = persist_location
+      l "Attempt to load event patterns from #{path}"
+
+      path.open 'rb' do |io|
+        pattern = Marshal.load(io.read)
+        pattern.each do |sym, event|
+          PATTERN[event.pattern] = event
+          UNICODE[event.unicode] << event
+          KEYSYM[event.keysym] << event
+        end
+      end
+
+      load_aliases
+      l "Event patterns loaded"
+    rescue Errno::ENOENT
+      # Mostly harmless, the .events file isn't created yet.
+      l "Attempt to load event patterns failed"
+      load_default
+      load_aliases
+    end
+
+    def self.load_default
+      # To make creation easier, we define well-known patterns for ASCII here.
+      # The rest is still to be defined by actual events.
+      ('0'..'9').each{|chr| pattern("<Key-#{chr}>", chr, chr) }
+      ('A'..'Z').each{|chr| pattern(chr, chr, chr) }
+      ('a'..'z').each{|chr| pattern(chr, chr, chr) }
+      keysyms = {
+        'space'        => ' ',
+        'exclam'       => '!',
+        'quotedbl'     => '"',
+        'numbersign'   => '#',
+        'dollar'       => '$',
+        'percent'      => '%',
+        'ampersand'    => '&',
+        'parenleft'    => '(',
+        'parenright'   => ')',
+        'asterisk'     => '*',
+        'plus'         => '+',
+        'comma'        => ',',
+        'minus'        => '-',
+        'period'       => '.',
+        'slash'        => '/',
+        'colon'        => ':',
+        'semicolon'    => ';',
+        'less'         => '<',
+        'equal'        => '=',
+        'greater'      => '>',
+        'question'     => '?',
+        'at'           => '@',
+        'bracketleft'  => '[',
+        'backslash'    => '\\',
+        'bracketright' => ']',
+        'asciicircum'  => '^',
+        'underscore'   => '_',
+        'quoteright'   => '`',
+        'braceleft'    => '{',
+        'bar'          => '|',
+        'braceright'   => '}',
+        'asciitilde'   => '~',
+
+        # Now a couple of basic keys that don't change across platforms
+        'BackSpace'    => "\b",
+        'Delete'       => "\x7F",
+        'Down'         => '',
+        'End'          => '',
+        'Escape'       => "\e",
+        'Home'         => '',
+        'Insert'       => '',
+        'Left'         => '',
+        'Next'         => '',
+        'Prior'        => '',
+        'Return'       => "\n",
+        'Right'        => '',
+        'Tab'          => "\t",
+        'Up'           => '',
+      }
+
+      if Platform.x11?
+        keysyms.merge!({
+          'apostrophe'   => "'",
+          'grave'        => '`',
+        })
+      end
+
+      keysyms.each do |keysym, unicode|
+        pattern("<#{keysym}>", keysym, unicode)
+      end
+
+      # F1-F12
+      1.upto(12){|n| pattern("<F#{n}>", "F#{n}", '') }
+
+      # Something for german keyboards
+      pattern('<Control-bracketleft>', 'bracketleft', '[')
+      pattern('<Control-bracketright>', 'bracketright', ']')
+    end
+
+    # Compatibility between windowingsystems
+    def self.load_aliases
+      if Platform.unix? && Platform.x11?
+        # Shift-Fn is handled differently, we alias them to F12+n
+        # So if you map <F13>, it works, do not use <Shift-F1> or
+        # <XF86_Switch_VT_1> in the keymap itself.
+        1.upto 12 do |n|
+          add_alias(fsym: "F#{12 + n}", tsym: "XF86_Switch_VT_#{n}")
+        end
+      else
+        # Here we map all Shift-Fn keys to a F12+n pattern.
+        1.upto 12 do |n|
+          add_alias(fsym: "F#{12 + n}", tsym: "F#{n}", tpat: "<Shift-F#{n}>")
+        end
+      end
+
+      if Platform.mac?
+        pattern '<Shift-Insert>', 'Shift-Insert', ''
+        if Platform.x11?
+          pattern '<Shift-Left>',  'Left',  ''
+          pattern '<Shift-Right>', 'Right', ''
+          pattern '<Shift-Control-Left>', 'Shift-Control-Left', "\uffe1"
+          pattern '<Shift-Control-Right>', 'Shift-Control-Right', "\uffe2"
+          pattern '<Shift-Down>', 'Down', "\uff54"
+          pattern '<Shift-Up>',   'Up',   "\uff52"
+          pattern '<ISO_Left_Tab>', 'Tab', "\t"
+        end
+      end
+    end
+
+
+    def self.add_alias(from, to = {})
+      fsym = from[:keysym] || from[:fsym] || raise(ArgumentError, "Need keysym")
+      tsym = to[  :keysym] || from[:tsym] || raise(ArgumentError, "Need keysym")
+      fpat = from[:pattern] || from[:fpat] || "<#{fsym}>"
+      tpat = to[  :pattern] || from[:tpat] || "<#{tsym}>"
+      unicode = from[:unicode] || to[:unicode] || ''
+
+      event = pattern(tpat, tsym, unicode)
+      PATTERN[fpat] = event
+      KEYSYM[fsym] << event
+      PATTERN_ALIAS[fpat] = tpat
+    end
+  end
+end