rkremap 0.3.0.1 → 0.5.0

data/lib/rkremap.rb

@@ -1,13 +1,25 @@
 # frozen_string_literal: true
 
-require_relative "rkremap/version"
+require_relative 'rkremap/version'
 require_relative 'rkremap/keycode'
 require_relative 'rkremap/winattr'
+require_relative 'rkremap/evdev_list'
 require_relative 'rkremap/evdev'
+require_relative 'rkremap/event'
+require_relative 'rkremap/uinput'
+require_relative 'rkremap/remap'
 
 class Rkremap
   include KeyCode
 
+  # /usr/include/linux/input-event-codes.h
+  EV_SYN = 0
+  EV_KEY = 1
+  EV_REL = 2
+  EV_ABS = 3
+  EV_MSC = 4
+  SYN_REPORT = 0
+
   EVENT_TYPE_VALUE = {
     release: 0,
     press:   1,
@@ -18,17 +30,21 @@ class Rkremap
   attr_accessor :modifiers
   attr_accessor :x11
   attr_accessor :auto_detect
+  attr_accessor :exclude
+  attr_accessor :mouse
 
   # @param devices [Array<String>, String]
-  def initialize(devices=nil)
-    if devices
-      devices = Array(devices)
-      @inputs = devices.map{|d| Evdev.new(d)}
-    else
+  # @param exclude [Regexp]
+  # @param mouse [Boolean]
+  def initialize(devices=[], exclude: nil, mouse: false)
+    if devices.empty?
       @auto_detect = true
-      @inputs = Evdev.detect.select(&:keyboard?)
+    else
+      devices = Array(devices)
     end
-    raise 'Unable to detect keyboard device' if @inputs.empty?
+    @devices = devices
+    @exclude = exclude
+    @mouse = mouse
     @uinput = Uinput.new
     @grab = false
     @x11 = false
@@ -38,60 +54,54 @@ class Rkremap
       KEY_LEFTALT,   KEY_RIGHTALT,
       KEY_LEFTMETA,  KEY_RIGHTMETA,
     ]
-    @events = []
+    @event_procs = []
     @mutex = Mutex.new
   end
 
+  # @overload remap(map)
+  #   @param map [Hash] from => to
+  # @overload remap(map:, hold: nil)
+  #   @param map [Hash] from => to
+  #   @param hold [Numeric] seconds
+  def remap(**opts)
+    map, hold = opts[:map], opts[:hold]
+    map ||= opts
+    Remap.new(self, map: map, hold: hold)
+  end
+
+  # @param device [Symbol, Regexp]
   # @param code [Integer]
   # @param type [Symbol] :press / :release / :repeat
-  def match(code: nil, type: nil, &block)
-    @events.push [{code: code, type: type}, block]
+  # @param app [Regexp, String]
+  def match(device: nil, code: nil, type: nil, app: nil, &block)
+    @event_procs.push [{device: device, code: code, type: type, app: app}, block]
   end
 
   def start(&block)
-    detect_device_loop if @auto_detect
+    @evdev_list = EvdevList.new(@devices, auto_detect: @auto_detect, exclude: @exclude, detect_mouse: @mouse)
+    @evdev_list.grab = @grab
+    @evdev_list.detect_loop
     @mod_state = @modifiers.map.to_h{|m| [m, false]}
-    @winattr = WinAttr.new if @x11
-    @inputs.each(&:grab) if @grab
+    winattr = WinAttr.new if @x11
     while true
       @keys = []
-      time, type, code, value = read_event
-      next if type != EV_KEY
-      event = Event.new(time, code, value, @winattr)
-      @events.each do |cond, b|
-        synchronize{ b.call event } if event.match?(**cond)
-        break if event.skipped
-      end
-      next if event.skipped
-      synchronize{ proc_event(code, value, event) }
-      @keys.each do |c, mod, app|
-        synchronize{ block.call(c, mod, app) } if block
-      end
-    end
-  end
-
-  def detect_device_loop
-    Thread.new do
-      while true
-        sleep 3
-        new_devs = Evdev.detect.select(&:keyboard?)
-        unless new_devs.empty?
-          new_devs.each(&:grab) if @grab
-          @inputs += new_devs
+      event = @evdev_list.read_event
+      if event.ev_type != EV_KEY
+        if event.device.grab?
+          @uinput.write_event(event.ev_type, event.code, event.value)
         end
+        next
       end
-    end
-  end
-
-  def read_event
-    while true
-      begin
-        input = Evdev.select(@inputs, 3)
-        next unless input
-        return input.read_event
-      rescue Errno::ENODEV
-        input.close rescue nil
-        @inputs.delete input
+      app = App.new(winattr) if winattr
+      event.app = app
+      @event_procs.each do |cond, b|
+        synchronize{ b.call(event, @mod_state.dup, app) } if event.match?(**cond)
+        break if event.skipped?
+      end
+      next if event.skipped?
+      synchronize{ proc_event(event, app) }
+      @keys.each do |c, mod, app_|
+        synchronize{ block.call(c, mod, app_) } if block
       end
     end
   end
@@ -102,20 +112,27 @@ class Rkremap
 
   # @param code [Integer]
   # @param type [Symbol] :press / :release / :repeat
-  # @param ev [Rkmap::Event]
-  def event(code: nil, type: nil, event: nil)
+  def event(code: nil, type: nil)
     value = EVENT_TYPE_VALUE[type] or raise "invalid type: #{type.inspect}"
-    proc_event(code, value, event)
+    update_modifiers(code, value)
+    write_event(code, value)
   end
 
   # @param code [Integer]
   # @param mod [Hash] {MOD_KEY => true, ...}
   def key(code, mod={})
+    with_modifier(mod) do
+      write_event(code, 1)
+      write_event(code, 0)
+    end
+  end
+
+  # @param mod [Hash] {MOD_KEY => true, ...}
+  def with_modifier(mod, &block)
     mod_diff(mod).each do |mcode, state|
       write_event(mcode, state ? 1 : 0)
     end
-    write_event(code, 1)
-    write_event(code, 0)
+    block.call
     mod_diff(mod).each do |mcode, _|
       write_event(mcode, @mod_state[mcode] ? 1 : 0)
     end
@@ -123,12 +140,23 @@ class Rkremap
 
   private
 
-  def proc_event(code, value, event)
+  def update_modifiers(code, value)
     if @mod_state.include?(code)
       @mod_state[code] = value != 0
+    end
+  end
+
+  # @param event [Rkremap::Event]
+  # @param app [Rkremap::App]
+  def proc_event(event, app)
+    code, value = event.code, event.value
+    if @mod_state.include?(code)
       write_event(code, value)
-    elsif value != 0
-      @keys.push [code, @mod_state.dup, App.new(event&.win, @winattr)]
+      update_modifiers(code, value)
+    elsif value == 0
+      write_event(code, value)
+    else
+      @keys.push [code, @mod_state.dup, app]
     end
   end
 
@@ -140,46 +168,46 @@ class Rkremap
   # @param value [Integer] 0:release / 1:press / 2:repeat
   def write_event(code, value)
     @uinput.write_event(EV_KEY, code, value)
-    @uinput.write_event(EV_SYN, SYN_REPORT, 0)
-  end
-
-  class Event
-    attr_reader :time
-    attr_reader :code
-    attr_reader :type
-    attr_reader :win
-    attr_reader :skipped
-
-    def initialize(time, code, value, winattr)
-      @time = time
-      @code = code
-      @value = value
-      @type = value == 1 ? :press : value == 0 ? :release : :repeat
-      @win = winattr&.focus_win
-      @skipped = false
-    end
-
-    def match?(code: nil, type: nil)
-      (code.nil? || Array(code).include?(@code)) && (type.nil? || Array(type).include?(@type))
-    end
-
-    def skip
-      @skipped = true
-    end
   end
 
   class App
-    def initialize(win, winattr)
-      @win = win
+    # @param winattr [Rkremap::WinAttr]
+    def initialize(winattr)
       @winattr = winattr
+      @win = winattr.focus_win
     end
 
+    # @return [String, nil]
     def class_name
       @winattr.app_win(@win)[2] if @winattr && @win
     end
 
+    # @return [String, nil]
     def title
       @winattr.app_title(@win) if @winattr && @win
     end
+
+    # @param app [Array, Hash, String, Regexp]
+    # @return [Boolean]
+    def match?(app)
+      Array(app).each do |a|
+        a = {class_name: a, title: a} unless a.is_a? Hash
+        return true if match_sub(a[:class_name], class_name) || match_sub(a[:title], title)
+      end
+      false
+    end
+
+    # @param a [String, Regexp]
+    # @param b [String]
+    def match_sub(a, b)
+      case a
+      when String
+        a == b
+      when Regexp
+        a =~ b
+      else
+        false
+      end
+    end
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rkremap
 version: !ruby/object:Gem::Version
-  version: 0.3.0.1
+  version: 0.5.0
 platform: ruby
 authors:
 - TOMITA Masahiro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-18 00:00:00.000000000 Z
-dependencies: []
+date: 2022-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tmtms_timer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: key remapper
 email:
 - tommy@tmtm.org
@@ -24,7 +38,11 @@ files:
 - example/tmtms.rb
 - lib/rkremap.rb
 - lib/rkremap/evdev.rb
+- lib/rkremap/evdev_list.rb
+- lib/rkremap/event.rb
 - lib/rkremap/keycode.rb
+- lib/rkremap/remap.rb
+- lib/rkremap/uinput.rb
 - lib/rkremap/version.rb
 - lib/rkremap/winattr.rb
 homepage: https://gitlab.com/tmtms/rkremap