rkremap 0.3.0 → 0.4.1

data/lib/rkremap.rb

@@ -1,13 +1,24 @@
 # 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'
 
 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 +29,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 +53,43 @@ class Rkremap
       KEY_LEFTALT,   KEY_RIGHTALT,
       KEY_LEFTMETA,  KEY_RIGHTMETA,
     ]
-    @events = []
+    @event_procs = []
     @mutex = Mutex.new
   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 +100,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 +128,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)
+      update_modifiers(code, value)
+    elsif value == 0
       write_event(code, value)
-    elsif value != 0
-      @keys.push [code, @mod_state.dup, App.new(event&.win, @winattr)]
+    else
+      @keys.push [code, @mod_state.dup, app]
     end
   end
 
@@ -140,46 +156,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
+  version: 0.4.1
 platform: ruby
 authors:
 - TOMITA Masahiro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-05 00:00:00.000000000 Z
-dependencies: []
+date: 2022-08-27 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
@@ -18,21 +32,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- example/henkan-alt.rb
+- example/henkan-super.rb
 - example/keylogger.rb
 - example/mac-shortcut.rb
 - 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/uinput.rb
 - lib/rkremap/version.rb
 - lib/rkremap/winattr.rb
-homepage: https://github.com/tmtm/rkremap
+homepage: https://gitlab.com/tmtms/rkremap
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/tmtm/rkremap
-  source_code_uri: https://github.com/tmtm/rkremap
+  homepage_uri: https://gitlab.com/tmtms/rkremap
+  source_code_uri: https://gitlab.com/tmtms/rkremap
   documentation_uri: https://www.rubydoc.info/gems/rkremap
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -50,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: key remapper

data/example/henkan-alt.rb

@@ -1,93 +0,0 @@
-# 変換/無変換キーを0.5秒以上押してるとALTキーとして扱う。
-# 0.5秒以内でも変換/無変換キーを押しながら他のキーを押すとALTキーとして扱う。
-
-require 'rkremap'
-include Rkremap::KeyCode
-
-rk = Rkremap.new
-rk.grab = true
-
-class State
-  attr_accessor :converted
-
-  def initialize
-    @press = nil
-    @converted = false
-    @thread = nil
-  end
-
-  def press(thread)
-    @press = true
-    @converted = false
-    @thread = thread
-  end
-
-  def release
-    @press = false
-    @converted = false
-    @thread.kill
-    @thread = nil
-  end
-
-  def pressed?
-    @press
-  end
-end
-
-state = {
-  KEY_HENKAN => State.new,
-  KEY_MUHENKAN => State.new,
-}
-
-MAP = {
-  KEY_HENKAN => KEY_RIGHTALT,
-  KEY_MUHENKAN => KEY_LEFTALT,
-}
-
-rk.match(code: [KEY_HENKAN, KEY_MUHENKAN], type: :press) do |event|
-  thr = Thread.new(event.code) do |code|
-    sleep 0.5
-    rk.synchronize do
-      if state[code].pressed?
-        rk.event(code: MAP[code], type: :press)
-        state[code].converted = true
-      end
-    end
-  end
-  state[event.code].press(thr)
-  event.skip
-end
-
-rk.match(code: [KEY_HENKAN, KEY_MUHENKAN], type: :release) do |event|
-  if state[event.code].converted
-    rk.event(code: MAP[event.code], type: :release)
-    event.skip
-  else
-    rk.event(code: event.code, type: :press)
-    rk.event(code: event.code, type: :release)
-  end
-  state[event.code].release
-end
-
-rk.match(code: [KEY_HENKAN, KEY_MUHENKAN], type: :repeat) do |event|
-  event.skip
-end
-
-rk.match(type: :press) do
-  [KEY_HENKAN, KEY_MUHENKAN].each do |code|
-    if state[code].pressed?
-      rk.event(code: MAP[code], type: :press)
-      state[code].converted = true
-    end
-  end
-end
-
-def code2key(code)
-  Rkremap::CODE_KEY[code].to_s.sub(/\AKEY_/, '')
-end
-
-rk.start do |code, mod|
-  key = (mod.select{|_, v| v}.keys + [code]).map{|c| code2key(c)}.join('-')
-  puts key
-  rk.key(code, mod)
-end