rbindkeys 0.0.1

data/lib/rbindkeys/device.rb

@@ -0,0 +1,25 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require "revdev"
+
+module Rbindkeys
+
+  class Device < Revdev::EventDevice
+
+    def release_all_key
+      ie = Revdev::InputEvent.new nil, 0, 0, 0
+      Revdev.constants.select{|c| c.match(/^(?:KEY|BTN)/)}.each do |c|
+        ie.type = Revdev::EV_KEY
+        ie.code = Revdev.const_get c
+        ie.value = 0
+        write_input_event ie
+
+        ie.type = Revdev::EV_SYN
+        ie.code = 0
+        write_input_event ie
+      end
+    end
+
+  end
+
+end

data/lib/rbindkeys/device_operator.rb

@@ -0,0 +1,78 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'revdev'
+
+module Rbindkeys
+
+  # device operations like send key event, send LED event, etc.
+  class DeviceOperator
+
+    LOG = LogUtils.get_logger name
+
+    # real event device
+    attr_reader :device
+
+    # uinput device
+    attr_reader :virtural
+
+    # key code set which was send press event but is not send release event
+    attr_reader :pressed_key_set
+
+    def initialize dev, vdev
+      @device = dev
+      @virtual = vdev
+      @pressed_key_set = []
+    end
+
+    def release_key code
+      send_key code, 0
+    end
+    def press_key code
+      send_key code, 1
+    end
+    def pressing_key code
+      send_key code, 2
+    end
+
+    def send_key code, state
+      send_event Revdev::EV_KEY, code, state
+    end
+
+    def send_event *args
+      event =
+        case args.length
+        when 1 then args[0]
+        when 3 then
+          @cache_input_event ||= Revdev::InputEvent.new nil, 0, 0, 0
+          @cache_input_event.type = args[0]
+          @cache_input_event.code = args[1]
+          @cache_input_event.value = args[2]
+          @cache_input_event
+        else raise ArgumentError, "expect a InputEvent or 3 Fixnums (type, code, state)"
+        end
+      dev = case event.type
+            when Revdev::EV_KEY then @virtual
+            when Revdev::EV_LED then @device
+            else @virtual
+            end
+
+      update_pressed_key_set event
+      dev.write_input_event event
+      LOG.info "write\t#{KeyEventHandler.get_state_by_value event} "+
+        "#{event.hr_code}(#{event.code})" if LOG.info?
+    end
+
+    def update_pressed_key_set event
+      if event.type == Revdev::EV_KEY
+        case event.value
+        when 0 then @pressed_key_set.delete event.code
+        when 1 then  @pressed_key_set << event.code
+        when 2 then # do nothing
+        else raise UnknownKeyValue, "expect 0, 1 or 2"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/rbindkeys/fix_resolver.rb

@@ -0,0 +1,26 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module Rbindkeys
+
+  # last resolvers which return @val as the resolve result
+  class FixResolver < BindResolver
+    private_class_method :new
+    @@pool = {}
+
+    def self.instance val
+      @@pool[val] or (@@pool[val] = new val)
+    end
+
+    def initialize val
+      @val = val
+    end
+
+    def bind input, output
+      raise RuntimeError, 'cannot bind any input/output'
+    end
+
+    def resolve code, code_set
+      @val
+    end
+  end
+end

data/lib/rbindkeys/key_bind.rb

@@ -0,0 +1,21 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module Rbindkeys
+  class KeyBind
+
+    attr_reader :input
+
+    attr_reader :output
+
+    # when a signal of any input release event was accepted,
+    # if @inputs_recovery is true, outputs are released and other inputs are pressed,
+    # if @inputs_recovery is false or nil, outputs are released.
+    attr_reader :input_recovery
+
+    def initialize input, output, opt = {}
+      @input = input
+      @output = output
+      @input_recovery = opt[:input_recovery]
+    end
+  end
+end

data/lib/rbindkeys/key_event_handler.rb

@@ -0,0 +1,243 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys/key_event_handler/configurer'
+require 'active_window_x'
+
+module Rbindkeys
+
+  # retrive key binds with key event
+  class KeyEventHandler
+    include Revdev
+
+    LOG = LogUtils.get_logger name
+
+    # device operator
+    attr_reader :operator
+
+    # defaulut key bind set which retrive key binds with a key event
+    attr_reader :default_bind_resolver
+
+    # current key bind set which retrive key binds with a key event
+    attr_reader :bind_resolver
+
+    # a hash (key:WindowMatcher, val:BindResolver) to switch BindResolver
+    # by the title or app_name of active window
+    attr_reader :window_bind_resolver_map
+
+    # proccessed resolver before bind_resolver
+    attr_reader :pre_bind_resolver
+
+    # code set of pressed key on the event device
+    attr_reader :pressed_key_set
+
+    # pressed key binds
+    attr_reader :active_bind_set
+
+    def initialize device_operator
+      @operator = device_operator
+      @default_bind_resolver = BindResolver.new
+      @window_bind_resolver = nil
+      @bind_resolver = @default_bind_resolver
+      @window_bind_resolver_map = []
+      @pre_bind_resolver = {}
+      @pressed_key_set = []
+      @active_bind_set = []
+    end
+
+    def load_config file
+      code = File.read file
+      instance_eval code, file
+    end
+
+    def handle event
+      if LOG.info?
+        LOG.info "" unless LOG.debug?
+        LOG.info "read\t#{KeyEventHandler.get_state_by_value event} "+
+          "#{event.hr_code}(#{event.code})"
+      end
+
+      # handle pre_key_bind_set
+      event.code = (@pre_bind_resolver[event.code] or event.code)
+
+      # swich to handle event with event.value
+      result =
+        case event.value
+        when 0 then handle_release_event event
+        when 1 then handle_press_event event
+        when 2 then handle_pressing_event event
+        else raise UnknownKeyValue, "expect 0, 1 or 2 as event.value(#{event.value})"
+        end
+
+      case result
+      when :through
+        fill_gap_pressed_state event if event.value == 1
+        @operator.send_event event
+      when :ignore
+        # ignore the original event
+      end
+
+      handle_pressed_keys event
+
+      LOG.info "pressed_keys real:#{@pressed_key_set.inspect} "+
+        "virtual:#{@operator.pressed_key_set.inspect}" if LOG.info?
+    end
+
+    def handle_release_event event
+      release_bind_set = []
+      @active_bind_set.reject! do |key_bind|
+        if key_bind.input.include? event.code
+          release_bind_set << key_bind
+          true
+        else
+          false
+        end
+      end
+
+      if release_bind_set.empty?
+        :through
+      else
+        release_bind_set.each do |kb|
+          kb.output.each {|c|@operator.release_key c}
+          if kb.input_recovery
+            kb.input.clone.delete_if {|c|c==event.code}.each {|c|@operator.press_key c}
+          end
+        end
+        :ignore
+      end
+    end
+
+    def set_bind_resolver resolver
+      old_resolver = @bind_resolver if LOG.info?
+      @bind_resolver = resolver
+      LOG.info "switch bind_resolver: #{old_resolver} => "+
+        "#{@bind_resolver}" if LOG.info?
+      @bind_resolver
+    end
+
+    def handle_press_event event
+      r = @bind_resolver.resolve event.code, @pressed_key_set
+
+      LOG.debug "resolve result: #{r.inspect}" if LOG.debug?
+
+      if r.kind_of? KeyBind
+
+        if @bind_resolver.two_stroke?
+          set_bind_resolver (@window_bind_resolver or @default_bind_resolver)
+        end
+
+        if r.output.kind_of? Array
+          r.input.clone.delete_if{|c|c==event.code}.each {|c| @operator.release_key c}
+          r.output.each {|c| @operator.press_key c}
+          @active_bind_set << r
+          :ignore
+        elsif r.output.kind_of? BindResolver
+          set_bind_resolver r.output
+          :ignore
+        elsif r.output.kind_of? Proc
+          r.output.call event, @operator
+        elsif r.output.kind_of? Symbol
+          r
+        end
+      else
+        r
+      end
+    end
+
+    def handle_pressing_event event
+      if @active_bind_set.empty?
+        :through
+      else
+        @active_bind_set.each {|kb| kb.output.each {|c| @operator.pressing_key c}}
+        :ignore
+      end
+    end
+
+    def fill_gap_pressed_state event
+      return if @operator.pressed_key_set == @pressed_key_set
+      sub = @pressed_key_set - @operator.pressed_key_set
+      if event.value == 0
+        sub.delete event.code
+      end
+      sub.each {|code| @operator.press_key code}
+    end
+
+    def handle_pressed_keys event
+      if event.value == 1
+        @pressed_key_set << event.code
+        @pressed_key_set.sort! # TODO do not sort. implement an bubble insertion
+      elsif event.value == 0
+        if @pressed_key_set.delete(event.code).nil?
+          LOG.warn "#{event.code} does not exists on @pressed_keys" if LOG.warn?
+        end
+      end
+    end
+
+    def active_window_changed window
+      if not window.nil?
+        title = window.title
+        app_name = window.app_name
+        if LOG.info?
+          LOG.info "" unless LOG.debug?
+          LOG.info "change active_window: :class => \"#{app_name}\", :title => \"#{title}\""
+        end
+
+        @window_bind_resolver_map.each do |matcher, bind_resolver|
+          if matcher.match? app_name, title
+            if LOG.info?
+              LOG.info "=> matcher #{matcher.app_name.inspect}, #{matcher.title.inspect}"
+              LOG.info "   bind_resolver #{bind_resolver.inspect}"
+            end
+            set_bind_resolver bind_resolver
+            @window_bind_resolver = bind_resolver
+            return
+          end
+        end
+      else
+        if LOG.info?
+          LOG.info "" unless LOG.debug?
+          LOG.info "change active_window: nil"
+        end
+      end
+
+      LOG.info "=> no matcher" if LOG.info?
+      set_bind_resolver @default_bind_resolver
+      @window_bind_resolver = nil
+      return
+    end
+
+    class << self
+      # parse and normalize to Fixnum/Array
+      def parse_code code, depth = 0
+        if code.kind_of? Symbol
+          code = parse_symbol code
+        elsif code.kind_of? Array
+          raise ArgumentError, "expect Array is the depth less than 1" if depth >= 1
+          code.map!{|c| parse_code c, (depth+1)}
+        elsif code.kind_of? Fixnum and depth == 0
+          code = [code]
+        elsif not code.kind_of? Fixnum
+          raise ArgumentError, "expect Symbol / Fixnum / Array"
+        end
+        code
+      end
+
+      # TODO convert :j -> KEY_J, :ctrl -> KEY_LEFTCTRL
+      def parse_symbol sym
+        if not sym.kind_of? Symbol
+          raise ArgumentError, "expect Symbol / Fixnum / Array"
+        end
+        Revdev.const_get sym
+      end
+
+      def get_state_by_value ev
+        case ev.value
+        when 0 then 'released '
+        when 1 then 'pressed  '
+        when 2 then 'pressing '
+        end
+      end
+    end
+
+  end
+
+end

data/lib/rbindkeys/key_event_handler/configurer.rb

@@ -0,0 +1,142 @@
+# -*- coding:utf-8; mode:ruby; -*-
+#
+# a part of KeyEventHandler (see lib/rbindkeys/key_event_handler.rb)
+#
+
+module Rbindkeys
+  class KeyEventHandler
+
+    # pre-prosessed key codes replacement for all inputs
+    def pre_bind_key input, output
+      if not (input.kind_of? Fixnum and output.kind_of? Fixnum)
+        raise ArgumentError, 'expect Fixnum for input and output'
+      end
+
+      if @pre_bind_resolver.has_key? input
+        raise DuplicateNodeError, "1st arg (#{input}) was already entried"
+      end
+
+      LOG.info "pre_bind_key #{input.inspect},\t#{output.inspect}" if LOG.info?
+
+      @pre_bind_resolver[input] = output
+      [input, output]
+    end
+
+    # define a new key binding
+    def bind_key input, output=nil, resolver=@bind_resolver, &block
+      if input.kind_of?(Array) or input.kind_of?(Fixnum)
+        input = KeyEventHandler.parse_code input
+      else
+        raise ArgumentError, '1st arg expect Array / Fixnum'
+      end
+
+      if block_given?
+        output = block
+      elsif output.nil?
+        raise ArgumentError, 'expect 1 arg with a block / 2 args'
+      elsif output.kind_of? BindResolver
+      elsif output.kind_of?(Array) or output.kind_of?(Fixnum)
+        output = KeyEventHandler::parse_code output
+      elsif output == :through or output == :ignore
+      else
+        raise ArgumentError, '2nd arg expect Array / Fixnum / BindResolver / '+
+          'Symbol(:through/:ignore)'
+      end
+
+      LOG.info "bind_key #{input.inspect},\t#{output.inspect}\t#{resolver}" if LOG.info?
+
+      resolver.bind input, output
+    end
+
+    # setting for 2stroke key binding
+    # _input_ :: prefix key. (e.g. [KEY_LEFTCTRL, KEY_X] (C-x)
+    # _resolver_ :: upper bind_resolver for fall throught
+    # _block_ :: to define sub-binds on this prefix key bind
+    def bind_prefix_key input, resolver=@bind_resolver, &block
+      if not block_given?
+        raise ArgumentError, "expect a block"
+      end
+
+      input = KeyEventHandler::parse_code input
+      LOG.info "bind_prefix_key #{input.inspect}\t#{resolver}" if LOG.info?
+      tmp = input.clone
+      tail_input = tmp.pop
+
+      binded_resolver = resolver.just_resolve tail_input, tmp
+      if binded_resolver == nil
+        binded_resolver = BindResolver.new :ignore, true
+        resolver.bind input, binded_resolver
+      elsif not binded_resolver.kind_of? BindResolver
+        raise DuplicateNodeError, "the codes (#{input.inspect}) was already binded"
+      end
+
+      @bind_resolver = binded_resolver
+      yield
+      @bind_resolver = resolver
+      binded_resolver
+    end
+
+    def new_bind_resolver upper_resolver=@bind_resolver, &block
+      if not block_given?
+        raise ArgumentError, "expect a block"
+      end
+
+      new_resolver = BindResolver.new upper_resolver
+
+      old_resolver = @bind_resolver
+      @bind_resolver = new_resolver
+      yield
+      @bind_resolver = old_resolver
+
+      new_resolver
+    end
+
+    # switch bind_resolver if the active window match _arg_
+    #
+    # _upper\_resolver_ :: a upper bind_resolver, :through, :ignore
+    # _arg_ :: a hash or a regexp
+    #
+    # ==arg
+    # if a hash, which have entries :title => Regexp and/or :class => Regexp,
+    # was given, this bind is active when the window title match with
+    # :title's Regexp AND the window class match with :class's Regexp.
+    # if a regexp was given, this bind is active when the window title match
+    # with the given regexp
+    def window upper_resolver, arg
+      if upper_resolver.nil?
+        upper_resolver = @bind_resolver
+      elsif upper_resolver.kind_of? Symbol
+        upper_resolver = FixResolver.instance upper_resolver
+      elsif not upper_resolver.kind_of? BindResolver
+        raise ArgumentError, "1nd argument is expected to be a BindResolver or"+
+          " a Symbol : #{ upper_resolver.to_s}"
+      end
+
+      if arg.kind_of? Regexp
+        arg = { :title => arg }
+      elsif arg.kind_of? Hash
+        arg.each do |k, v|
+          if not (k.kind_of?(Symbol) and v.kind_of?(Regexp))
+            raise ArgumentError, 'the 2nd argument Hash must only have'+
+              " Symbol keys and Regexp values : #{arg.inspect}"
+          end
+        end
+      else
+        raise ArgumentError, "2nd argument is expected to be a Hash or a Regexp : #{arg}"
+      end
+
+      resolver = BindResolver.new(upper_resolver)
+      @window_bind_resolver_map.push [WindowMatcher.new(arg), resolver]
+
+      if block_given?
+        old_resolver = @bind_resolver
+        @bind_resolver = resolver
+        yield
+        @bind_resolver = old_resolver
+      end
+
+      resolver
+    end
+
+  end
+end