fusuma-plugin-remap 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22d4ef7f153876d648359c14463da56777ecc7878cac97f79d1e29784a6673e8
-  data.tar.gz: f4381c0dcc9c5277fdeb14f0a19ee49772a3a06b07adfd9a31e0f43f5fff99a2
+  metadata.gz: ac440e4e38328075243e062af637b5bd00aa71a9d5afe32cc68d39a1410d2bc9
+  data.tar.gz: c629dc8add177f2a69e4cc6901a499633028458e4ccaf3ce9dd04563011b3960
 SHA512:
-  metadata.gz: a8111498a2c1d85caaf3a3c03af770c308f4e1b4c395a739f14e7832fd91280755b65424a9626a700b411112ab54b25a27f61a2d37aa64daf460573a3a4fe925
-  data.tar.gz: 54b0014a0f13b5a040f284ba8c3f87ecde1729ac0643b1fcb9d17411dfa9f1cd79ed03c8aa24dfeed2c2856df47ac76e69970eddba433b09a223bd695635edb2
+  metadata.gz: 257834827d4e8a1c05eeb5f52d2c1c803e32f2617d699373208cb41513d54abaa01937468087fb9b382ff67b76ebdde9bbb2a14ae9c8c89a3ea8d37259c1bde7
+  data.tar.gz: e8f5b3f9ab09e6c2575c747ed7a9f2abf52e85ad685974ddf7aa95f07f1f8ade8f594ba303f2cf0bb18dce4da6d4c64f82e78f3f9d8df32aea41214f4b011d49

data/README.md

@@ -41,20 +41,83 @@ $ sudo gem install fusuma-plugin-remap
 
 ### Remap
 
-Currently, remapping is only possible in the thumbsense context.
-Please install [fusuma-plugin-thumbsense](https://github.com/iberianpig/fusuma-plugin-thumbsense)
+You can remap keys in `~/.config/fusuma/config.yml`. The `remap` section defines key remappings.
 
-First, add the 'thumbsense' context to `~/.config/fusuma/config.yml`.
-The context is separated by `---` and specified by `context: { thumbsense: true }`.
+#### Basic Remap
 
-### Example
+Simple key-to-key remapping without any context:
 
-Set the following code in `~/.config/fusuma/config.yml`.
+```yaml
+remap:
+  CAPSLOCK: LEFTCTRL
+  LEFTALT: LEFTMETA
+  LEFTMETA: LEFTALT
+```
+
+#### Key Alias for Modifiers
+
+When a simple key remap is defined (e.g., `CAPSLOCK: LEFTCTRL`), the key acts as an **alias** for the target modifier. The modifier state tracks the remapped key, not the physical key.
+
+```yaml
+remap:
+  CAPSLOCK: LEFTCTRL  # CAPSLOCK acts as LEFTCTRL alias
+  LEFTCTRL+LEFTSHIFT+J: LEFTMETA+LEFTCTRL+DOWN  # Combination using the alias
+```
+
+With this configuration:
+- Physical `CAPSLOCK` is treated as `LEFTCTRL`
+- Physical `CAPSLOCK+LEFTSHIFT+J` triggers `LEFTCTRL+LEFTSHIFT+J` combination
+- This outputs `LEFTMETA+LEFTCTRL+DOWN`
+
+#### Output Sequence
+
+You can send multiple key combinations in sequence using an array:
+
+```yaml
+remap:
+  LEFTCTRL+U: [LEFTSHIFT+HOME, DELETE]  # Select to line start, then delete
+  LEFTCTRL+K: [LEFTSHIFT+END, DELETE]   # Select to line end, then delete
+```
+
+#### Modifier + Key Combinations
+
+Remap modifier key combinations to other keys or combinations:
+
+```yaml
+remap:
+  LEFTCTRL+J: DOWN
+  LEFTCTRL+K: UP
+  LEFTCTRL+H: LEFT
+  LEFTCTRL+L: RIGHT
+  LEFTALT+N: LEFTCTRL+TAB           # Next tab
+  LEFTALT+P: LEFTCTRL+LEFTSHIFT+TAB # Previous tab
+```
+
+### Context
+
+You can define different remappings for different contexts. Contexts are separated by `---`.
+
+#### Application Context
+
+Remap keys only for specific applications:
 
 ```yaml
+---
+context:
+  application: Alacritty
 
+remap:
+  LEFTMETA+N: LEFTCTRL+LEFTSHIFT+T  # New tab in terminal
+  LEFTMETA+W: LEFTCTRL+LEFTSHIFT+W  # Close tab
+```
+
+#### Thumbsense Context
+
+For thumbsense mode, install [fusuma-plugin-thumbsense](https://github.com/iberianpig/fusuma-plugin-thumbsense):
+
+```yaml
 ---
-context: 
+context:
   thumbsense: true
 
 remap:
@@ -65,6 +128,78 @@ remap:
   SPACE: BTN_LEFT
 ```
 
+#### Device Context
+
+You can define different remappings for specific keyboard devices. The `device` pattern uses case-insensitive partial matching against the physical device name.
+
+```yaml
+---
+# HHKB-specific remappings (matches device names containing "HHKB")
+context:
+  device: HHKB
+
+remap:
+  LEFTCTRL: LEFTMETA  # Swap Ctrl to Meta on HHKB
+
+---
+# Built-in keyboard remappings (matches "AT Translated Set 2 keyboard")
+context:
+  device: AT Translated
+
+remap:
+  LEFTALT: LEFTCTRL   # Remap Alt to Ctrl on built-in keyboard
+```
+
+To find your keyboard's device name, run:
+```sh
+libinput list-devices
+```
+
+#### Combined Contexts
+
+You can combine multiple context conditions. When multiple contexts are active, mappings are merged with priority order: `device` < `thumbsense` < `application`.
+
+```yaml
+---
+# HHKB + Thumbsense mode
+context:
+  device: HHKB
+  thumbsense: true
+
+remap:
+  J: BTN_LEFT
+  K: BTN_RIGHT
+```
+
+### Complete Example
+
+```yaml
+# Default remappings (always active)
+remap:
+  CAPSLOCK: LEFTCTRL
+  LEFTALT: LEFTMETA
+  LEFTMETA: LEFTALT
+  LEFTCTRL+J: DOWN
+  LEFTCTRL+K: UP
+
+---
+# Application-specific remappings
+context:
+  application: Alacritty
+
+remap:
+  LEFTMETA+N: LEFTCTRL+LEFTSHIFT+T
+
+---
+# Thumbsense mode
+context:
+  thumbsense: true
+
+remap:
+  J: BTN_LEFT
+  K: BTN_RIGHT
+```
+
 ## Emergency Stop Keybind for Virtual Keyboard
 
 This plugin includes a special keybind for emergency stop. Pressing this key combination will ungrab the physical keyboard and terminate the Fusuma process. This feature is particularly useful in situations where the plugin or system becomes unresponsive.

data/lib/fusuma/plugin/remap/device_matcher.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "fusuma/config"
+
+module Fusuma
+  module Plugin
+    module Remap
+      # Matches device names against device patterns defined in config
+      class DeviceMatcher
+        def initialize
+          @patterns = nil
+        end
+
+        # Find matching device pattern for a device name
+        # @param device_name [String] physical device name (e.g., "PFU HHKB-Hybrid")
+        # @return [String, nil] matched pattern (e.g., "HHKB"), or nil if no match
+        def match(device_name)
+          return nil if device_name.nil?
+
+          patterns.find { |pattern| device_name =~ /#{pattern}/i }
+        end
+
+        private
+
+        # Collect device patterns from config (cached)
+        # @return [Array<String>] device patterns (e.g., ["HHKB", "AT Translated"])
+        def patterns
+          @patterns ||= collect_patterns
+        end
+
+        # Collect unique device patterns from all context sections in keymap
+        def collect_patterns
+          keymap = Config.instance.keymap
+          return [] unless keymap.is_a?(Array)
+
+          keymap.filter_map { |section| section.dig(:context, :device) }.uniq
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/remap/keyboard_remapper.rb

@@ -4,6 +4,8 @@ require "set"
 require_relative "layer_manager"
 require_relative "uinput_keyboard"
 require_relative "device_selector"
+require_relative "device_matcher"
+require_relative "modifier_state"
 require "fusuma/device"
 
 module Fusuma
@@ -14,6 +16,7 @@ module Fusuma
 
         VIRTUAL_KEYBOARD_NAME = "fusuma_virtual_keyboard"
         DEFAULT_EMERGENCY_KEYBIND = "RIGHTCTRL+LEFTCTRL".freeze
+        DEVICE_CHECK_INTERVAL = 3 # seconds - interval for checking new devices
 
         # Key conversion tables for better performance and readability
         KEYMAP = Revdev.constants.select { |c| c.start_with?("KEY_", "BTN_") }
@@ -30,20 +33,44 @@ module Fusuma
           @layer_manager = layer_manager # request to change layer
           @fusuma_writer = fusuma_writer # write event to original keyboard
           @config = config
+          @device_matcher = DeviceMatcher.new
+          @device_mappings = {}
         end
 
         def run
           create_virtual_keyboard
           @source_keyboards = reload_keyboards
 
+          # Manage modifier key states
+          @modifier_state = ModifierState.new
+
           old_ie = nil
           layer = nil
-          next_mapping = nil
           current_mapping = {}
 
           loop do
-            ios = IO.select([*@source_keyboards.map(&:file), @layer_manager.reader])
-            io = ios.first.first
+            ios = IO.select(
+              [*@source_keyboards.map(&:file), @layer_manager.reader],
+              nil,
+              nil,
+              DEVICE_CHECK_INTERVAL
+            )
+
+            # Timeout - check for new devices
+            if ios.nil?
+              check_and_add_new_devices
+              next
+            end
+
+            readable_ios = ios.first
+
+            # Prioritize layer changes over keyboard events to ensure
+            # layer state is updated before processing key inputs
+            io = if readable_ios.include?(@layer_manager.reader)
+              @layer_manager.reader
+            else
+              readable_ios.first
+            end
 
             if io == @layer_manager.reader
               layer = @layer_manager.receive_layer # update @current_layer
@@ -51,24 +78,40 @@ module Fusuma
                 next
               end
 
-              next_mapping = @layer_manager.find_mapping(layer)
+              # Clear device mapping cache when layer changes
+              @device_mappings = {}
+              @layer_changed = true
               next
             end
 
-            if next_mapping && virtual_keyboard_all_key_released?
-              if current_mapping != next_mapping
-                current_mapping = next_mapping
-              end
-              next_mapping = nil
+            source_keyboard = @source_keyboards.find { |kbd| kbd.file == io }
+            input_event = source_keyboard.read_input_event
+            current_device_name = source_keyboard.device_name
+
+            # Get device-specific mapping
+            device_mapping = get_mapping_for_device(current_device_name, layer || {})
+
+            # Wait until all virtual keys are released before applying new mapping
+            if @layer_changed && virtual_keyboard_all_key_released?
+              @layer_changed = false
             end
 
-            input_event = @source_keyboards.find { |kbd| kbd.file == io }.read_input_event
+            # Use device-specific mapping (wait during layer change to prevent key stuck)
+            current_mapping = @layer_changed ? current_mapping : device_mapping
+
             input_key = code_to_key(input_event.code)
 
+            # Apply simple key-to-key remapping first (modmap-style)
+            # e.g., CAPSLOCK -> LEFTCTRL, so modifier state tracks the remapped key
+            effective_key = apply_simple_remap(current_mapping, input_key)
+
             if input_event.type == EV_KEY
               @emergency_stop.call(old_ie, input_event)
 
               old_ie = input_event
+
+              @modifier_state.update(effective_key, input_event.value)
+
               if input_event.value != 2 # repeat
                 data = {key: input_key, status: input_event.value, layer: layer}
                 begin
@@ -81,28 +124,60 @@ module Fusuma
               end
             end
 
-            remapped = current_mapping.fetch(input_key.to_sym, nil)
+            remapped, is_modifier_remap = find_remapping(current_mapping, effective_key)
             case remapped
             when String, Symbol
-              # Remapped to another key - continue processing below
+              # Continue to key output processing below
+            when Array
+              # Output sequence: e.g., [LEFTSHIFT+HOME, DELETE]
+              if input_event.value == 1
+                execute_modifier_remap(remapped, input_event)
+              end
+              next
             when Hash
               # Command execution (e.g., {:SENDKEY=>"LEFTCTRL+BTN_LEFT", :CLEARMODIFIERS=>true})
               # Skip input event processing and let Fusuma's Executor handle this
               next
             when nil
-              # Not remapped - write original key event as-is
-              uinput_keyboard.write_input_event(input_event)
+              if effective_key != input_key
+                # Output simple-remapped key (e.g., CAPSLOCK -> LEFTCTRL)
+                remapped_code = key_to_code(effective_key)
+                if remapped_code
+                  remapped_event = InputEvent.new(nil, input_event.type, remapped_code, input_event.value)
+                  update_virtual_key_state(effective_key, remapped_event.value)
+                  write_event_with_log(remapped_event, context: "simple remap from #{input_key}")
+                else
+                  write_event_with_log(input_event, context: "simple remap failed")
+                end
+              else
+                write_event_with_log(input_event, context: "passthrough")
+              end
               next
             else
-              # Invalid remapping configuration
               MultiLogger.warn("Invalid remapped value - type: #{remapped.class}, key: #{input_key}")
               next
             end
 
+            # For modifier remaps, handle specially:
+            # Release currently pressed modifiers → Send remapped key → Re-press modifiers
+            if is_modifier_remap && input_event.value == 1
+              execute_modifier_remap(remapped, input_event)
+              next
+            end
+
+            # Handle key combination output (e.g., "LEFTALT+LEFT")
+            # If remapped value contains "+", it's a key combination that needs special handling
+            if remapped.to_s.include?("+")
+              if input_event.value == 1 # only on key press
+                send_key_combination(remapped, input_event.type)
+              end
+              next
+            end
+
             remapped_code = key_to_code(remapped)
             if remapped_code.nil?
               MultiLogger.warn("Invalid remapped value - unknown key: #{remapped}, input: #{input_key}")
-              uinput_keyboard.write_input_event(input_event)
+              write_event_with_log(input_event, context: "remap failed")
               next
             end
 
@@ -122,9 +197,10 @@ module Fusuma
             # this is because the command will be executed by fusuma process
             next if remapped_event.code.nil?
 
-            uinput_keyboard.write_input_event(remapped_event)
+            write_event_with_log(remapped_event, context: "remapped from #{input_key}")
           rescue Errno::ENODEV => e # device is removed
             MultiLogger.error "Device is removed: #{e.message}"
+            @device_mappings = {} # Clear cache for new device configuration
             @source_keyboards = reload_keyboards
           end
         rescue EOFError => e # device is closed
@@ -148,6 +224,56 @@ module Fusuma
           MultiLogger.error e.backtrace.join("\n")
         end
 
+        # Get mapping for specific device from cache or LayerManager
+        # @param device_name [String] Physical device name
+        # @param layer [Hash] Layer information
+        # @return [Hash] Mapping for the device
+        def get_mapping_for_device(device_name, layer)
+          matched_pattern = @device_matcher.match(device_name)
+          effective_layer = matched_pattern ? layer.merge(device: matched_pattern) : layer
+          cache_key = [device_name, layer].hash
+          @device_mappings[cache_key] ||= @layer_manager.find_merged_mapping(effective_layer)
+        end
+
+        # Check for newly connected devices and add them to source_keyboards
+        # Called periodically via IO.select timeout
+        def check_and_add_new_devices
+          current_device_paths = @source_keyboards.map { |kbd| kbd.file.path }
+
+          selector = KeyboardSelector.new(@config[:keyboard_name_patterns])
+          available_devices = selector.try_open_devices
+
+          new_devices = available_devices.reject do |device|
+            current_device_paths.include?(device.file.path)
+          end
+
+          # Close devices that are already in source_keyboards to avoid duplicate file handles
+          available_devices.each do |device|
+            device.file.close if current_device_paths.include?(device.file.path)
+          end
+
+          return if new_devices.empty?
+
+          MultiLogger.info("New keyboard(s) detected: #{new_devices.map(&:device_name)}")
+
+          grabbed_devices = []
+          new_devices.each do |device|
+            wait_release_all_keys(device)
+            device.grab
+            MultiLogger.info "Grabbed keyboard: #{device.device_name}"
+            grabbed_devices << device
+          rescue Errno::EBUSY
+            MultiLogger.error "Failed to grab keyboard: #{device.device_name}"
+          rescue Errno::ENODEV
+            MultiLogger.warn "Device removed during grab: #{device.device_name}"
+          end
+
+          return if grabbed_devices.empty?
+
+          @source_keyboards.concat(grabbed_devices)
+          @device_mappings = {} # Clear cache for new device configuration
+        end
+
         def uinput_keyboard
           @uinput_keyboard ||= UinputKeyboard.new("/dev/uinput")
         end
@@ -284,7 +410,7 @@ module Fusuma
           second_keycode = key_to_code(keybinds[1])
 
           @emergency_stop = lambda do |prev, current|
-            if (prev&.code == first_keycode && prev.value != 0) && (current.code == second_keycode && current.value != 0)
+            if prev&.code == first_keycode && prev.value != 0 && current.code == second_keycode && current.value != 0
               MultiLogger.info "Emergency ungrab keybind is pressed: #{keybinds[0]}+#{keybinds[1]}"
               @destroy.call
             end
@@ -367,6 +493,160 @@ module Fusuma
           end
         end
 
+        # Apply simple key-to-key remapping (modmap-style)
+        # - Returns remapped key if simple remap exists
+        # - Skips combinations (containing "+"), Arrays, and Hashes
+        # - Returns original key if no match
+        #
+        # @param mapping [Hash] remapping configuration
+        # @param key [String] input key name
+        # @return [String] remapped key or original key
+        def apply_simple_remap(mapping, key)
+          remapped = mapping.fetch(key.to_sym, nil)
+          if remapped.is_a?(String) && !remapped.include?("+")
+            remapped
+          else
+            key
+          end
+        end
+
+        # Search for remapping
+        # If modifier keys are pressed, first search with modifier+key
+        #
+        # @param mapping [Hash] remapping configuration
+        # @param input_key [String] input key name
+        # @return [Array] [remapped key, is modifier remap]
+        def find_remapping(mapping, input_key)
+          # If modifier keys are pressed, first search with modifier+key (e.g., "LEFTCTRL+A")
+          if @modifier_state&.pressed_modifiers&.any?
+            combined_key = @modifier_state.current_combination(input_key)
+            remapped = mapping.fetch(combined_key.to_sym, nil)
+            if remapped
+              # For modifier key remapping (e.g., LEFTMETA: LEFTALT), set is_modifier_remap to false
+              # This distinguishes it from modifier+key combinations (e.g., LEFTCTRL+A: HOME)
+              # Modifier key itself should be remapped directly without execute_modifier_remap
+              is_modifier_remap = !@modifier_state.modifier?(input_key)
+              return [remapped.is_a?(Array) ? remapped : remapped.to_s, is_modifier_remap]
+            end
+          end
+
+          # If not found, search with simple key (e.g., "A")
+          remapped = mapping.fetch(input_key.to_sym, nil)
+          # If remapped is an Array (output sequence), return as is
+          result = remapped.is_a?(Array) ? remapped : remapped&.to_s
+          [result, false]
+        end
+
+        # Execute remapping with modifier keys
+        # @param remapped [String, Array] remapped key (single or array)
+        # @param input_event [InputEvent] original input event
+        #
+        # === Output sequence support ===
+        # If remapped is an Array, send each element in order
+        # e.g., ["LEFTSHIFT+HOME", "DELETE"]
+        #      → Shift+Home (press/release) → Delete (press/release)
+        def execute_modifier_remap(remapped, input_event)
+          # 1. Temporarily release currently pressed modifier keys
+          release_current_modifiers
+
+          # 2. Send remapped key(s) (press + release)
+          # === Output sequence support ===
+          send_key_combination(remapped, input_event.type)
+
+          # 3. Re-press modifier keys
+          restore_current_modifiers
+        end
+
+        # Release currently pressed modifier keys
+        def release_current_modifiers
+          return unless @modifier_state
+
+          @modifier_state.pressed_modifiers.each do |modifier_key|
+            code = key_to_code(modifier_key)
+            next unless code
+
+            release_event = InputEvent.new(nil, EV_KEY, code, 0)
+            write_event_with_log(release_event, context: "modifier release")
+          end
+        end
+
+        # Re-press modifier keys
+        def restore_current_modifiers
+          return unless @modifier_state
+
+          @modifier_state.pressed_modifiers.each do |modifier_key|
+            code = key_to_code(modifier_key)
+            next unless code
+
+            press_event = InputEvent.new(nil, EV_KEY, code, 1)
+            write_event_with_log(press_event, context: "modifier restore")
+          end
+        end
+
+        # Send a key combination (e.g., "LEFTCTRL+O" → press Ctrl, press O, release O, release Ctrl)
+        # @param key_input [String, Array] Key string or array
+        #   - String: Single key combination (e.g., "Q", "LEFTCTRL+O")
+        #   - Array: Output sequence (e.g., ["LEFTSHIFT+HOME", "DELETE"])
+        # @param event_type [Integer] Event type
+        # @return [void]
+        #
+        # === Output sequence support ===
+        # If Array, send each element in order
+        def send_key_combination(key_input, event_type)
+          # If Array, send each element in order
+          if key_input.is_a?(Array)
+            key_input.each { |key| send_key_combination(key.to_s, event_type) }
+            return
+          end
+
+          keys = key_input.to_s.split("+")
+
+          # Press all keys
+          keys.each do |key|
+            code = key_to_code(key)
+            next unless code
+
+            press_event = InputEvent.new(nil, event_type, code, 1)
+            write_event_with_log(press_event, context: "combination")
+          end
+
+          # Release all keys in reverse order
+          keys.reverse.each do |key|
+            code = key_to_code(key)
+            next unless code
+
+            release_event = InputEvent.new(nil, event_type, code, 0)
+            write_event_with_log(release_event, context: "combination")
+          end
+        end
+
+        # Convert key event value to state string
+        # @param value [Integer] 0=released, 1=pressed, 2=repeat
+        # @return [String]
+        def value_to_state(value)
+          case value
+          when 0 then "released"
+          when 1 then "pressed"
+          when 2 then "repeat"
+          else "unknown(#{value})"
+          end
+        end
+
+        # Write input event with debug logging
+        # @param event [InputEvent] event to send
+        # @param context [String, nil] additional context info
+        def write_event_with_log(event, context: nil)
+          if event.type == EV_KEY
+            key = code_to_key(event.code)
+            state = value_to_state(event.value)
+            msg = "[REMAP] #{key} #{state}"
+            msg += " (#{context})" if context
+            MultiLogger.debug(msg)
+          end
+
+          uinput_keyboard.write_input_event(event)
+        end
+
         # Devices to detect key presses and releases
         class KeyboardSelector
           def initialize(names)
@@ -377,28 +657,41 @@ module Fusuma
           # If no device is found, it will wait for 3 seconds and try again
           # @return [Array<Revdev::EventDevice>]
           def select
-            displayed_no_keyboard = false
+            logged_no_device = false
             loop do
-              Fusuma::Device.reset # reset cache to get the latest device information
-              devices = Fusuma::Device.all.select do |d|
-                next if d.name == VIRTUAL_KEYBOARD_NAME
+              keyboards = try_open_devices
 
-                Array(@names).any? { |name| d.name =~ /#{name}/ }
-              end
-              if devices.empty?
-                unless displayed_no_keyboard
+              if keyboards.empty?
+                unless logged_no_device
                   MultiLogger.warn "No keyboard found: #{@names}"
-                  displayed_no_keyboard = true
+                  logged_no_device = true
                 end
-                wait_for_device
 
-                next
+                wait_for_device
+              else
+                return keyboards
               end
+            end
+          end
+
+          def try_open_devices
+            Fusuma::Device.reset # reset cache to get the latest device information
+            devices = Fusuma::Device.all.select do |d|
+              next if d.name == VIRTUAL_KEYBOARD_NAME
 
-              return devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+              Array(@names).any? { |name| d.name =~ /#{name}/ }
+            end
+
+            devices.filter_map do |d|
+              Revdev::EventDevice.new("/dev/input/#{d.id}")
+            rescue Errno::ENOENT, Errno::ENODEV, Errno::EACCES => e
+              MultiLogger.warn "Failed to open #{d.name} (/dev/input/#{d.id}): #{e.message}"
+              nil
             end
           end
 
+          private
+
           def wait_for_device
             sleep 3
           end

data/lib/fusuma/plugin/remap/layer_manager.rb

@@ -8,6 +8,14 @@ module Fusuma
       class LayerManager
         require "singleton"
         include Singleton
+
+        # Priority order for context types (higher number = higher priority)
+        CONTEXT_PRIORITIES = {
+          device: 1,
+          thumbsense: 2,
+          application: 3
+        }.freeze
+
         attr_reader :reader, :writer, :current_layer, :layers
 
         def initialize
@@ -74,6 +82,56 @@ module Fusuma
             result || {}
           end
         end
+
+        # Find merged mapping from all applicable layers
+        # Merges mappings from default, individual contexts, and complete match
+        # Higher priority contexts override lower priority ones
+        # @param [Hash] layer current active layer (e.g., { thumbsense: true, application: "Google-chrome" })
+        # @return [Hash] merged remap mapping
+        def find_merged_mapping(layer)
+          @merged_layers ||= {}
+          @merged_layers[layer] ||= merge_all_applicable_mappings(layer)
+        end
+
+        private
+
+        def merge_all_applicable_mappings(layer)
+          mappings = []
+
+          # 1. default (no context) - priority 0
+          default_mapping = find_mapping_for_context({})
+          mappings << [0, default_mapping] if default_mapping
+
+          # 2. Each single context key's mapping
+          layer.each do |key, value|
+            single_context = {key => value}
+            mapping = find_mapping_for_context(single_context)
+            if mapping
+              priority = CONTEXT_PRIORITIES.fetch(key, 1)
+              mappings << [priority, mapping]
+            end
+          end
+
+          # 3. Complete match (multiple keys) - highest priority
+          if layer.keys.size > 1
+            complete_mapping = find_mapping_for_context(layer)
+            mappings << [100, complete_mapping] if complete_mapping
+          end
+
+          # Merge in priority order (lower priority first, higher priority overwrites)
+          mappings.sort_by(&:first).reduce({}) { |merged, (_, m)| merged.merge(m) }
+        end
+
+        def find_mapping_for_context(context)
+          result = nil
+          Fusuma::Config::Searcher.with_context(context) do
+            result = Fusuma::Config.search(Fusuma::Config::Index.new(:remap))
+            next unless result
+
+            result = result.deep_transform_keys { |key| key.upcase.to_sym }
+          end
+          result
+        end
       end
     end
   end

data/lib/fusuma/plugin/remap/modifier_state.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Fusuma
+  module Plugin
+    module Remap
+      # Tracks the pressed state of modifier keys
+      class ModifierState
+        MODIFIERS = Set.new(%w[
+          LEFTCTRL RIGHTCTRL
+          LEFTALT RIGHTALT
+          LEFTSHIFT RIGHTSHIFT
+          LEFTMETA RIGHTMETA
+        ]).freeze
+
+        def initialize
+          @pressed = Set.new
+        end
+
+        def update(key, event_value)
+          return unless modifier?(key)
+
+          case event_value
+          when 1 then @pressed.add(key)
+          when 0 then @pressed.delete(key)
+          end
+        end
+
+        def current_combination(key)
+          return key if modifier?(key)
+
+          modifiers = pressed_modifiers
+          if modifiers.empty?
+            key
+          else
+            "#{modifiers.join("+")}+#{key}"
+          end
+        end
+
+        def pressed_modifiers
+          @pressed.to_a.sort
+        end
+
+        def modifier?(key)
+          MODIFIERS.include?(key)
+        end
+
+        def reset
+          @pressed.clear
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/remap/version.rb

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Remap
-      VERSION = "0.12.0"
+      VERSION = "0.13.0"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-remap
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - iberianpig
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-09 00:00:00.000000000 Z
+date: 2026-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma
@@ -120,9 +120,11 @@ files:
 - lib/fusuma/plugin/inputs/remap_touchpad_input.rb
 - lib/fusuma/plugin/inputs/remap_touchpad_input.yml
 - lib/fusuma/plugin/remap.rb
+- lib/fusuma/plugin/remap/device_matcher.rb
 - lib/fusuma/plugin/remap/device_selector.rb
 - lib/fusuma/plugin/remap/keyboard_remapper.rb
 - lib/fusuma/plugin/remap/layer_manager.rb
+- lib/fusuma/plugin/remap/modifier_state.rb
 - lib/fusuma/plugin/remap/touchpad_remapper.rb
 - lib/fusuma/plugin/remap/uinput_keyboard.rb
 - lib/fusuma/plugin/remap/uinput_touchpad.rb