fusuma-plugin-remap 0.3.0 → 0.4.0

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

@@ -0,0 +1,343 @@
+require "revdev"
+require "msgpack"
+require "set"
+require_relative "layer_manager"
+require_relative "uinput_keyboard"
+
+module Fusuma
+  module Plugin
+    module Remap
+      class KeyboardRemapper
+        include Revdev
+
+        VIRTUAL_KEYBOARD_NAME = "fusuma_virtual_keyboard"
+
+        # @param layer_manager [Fusuma::Plugin::Remap::LayerManager]
+        # @param fusuma_writer [IO]
+        # @param config [Hash]
+        def initialize(layer_manager:, fusuma_writer:, config: {})
+          @layer_manager = layer_manager # request to change layer
+          @fusuma_writer = fusuma_writer # write event to original keyboard
+          @config = config
+        end
+
+        def run
+          create_virtual_keyboard
+          @source_keyboards = reload_keyboards
+
+          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
+
+            if io == @layer_manager.reader
+              layer = @layer_manager.receive_layer # update @current_layer
+              if layer.nil?
+                next
+              end
+
+              next_mapping = @layer_manager.find_mapping(layer)
+              next
+            end
+
+            if next_mapping && virtual_keyboard_all_key_released?
+              if current_mapping != next_mapping
+                current_mapping = next_mapping
+              end
+              next_mapping = nil
+            end
+
+            input_event = @source_keyboards.find { |kbd| kbd.file == io }.read_input_event
+            input_key = find_key_from_code(input_event.code)
+
+            if input_event.type == EV_KEY
+              @emergency_stop.call(old_ie, input_event)
+
+              old_ie = input_event
+              if input_event.value != 2 # repeat
+                data = {key: input_key, status: input_event.value, layer: layer}
+                @fusuma_writer.write(data.to_msgpack)
+              end
+            end
+
+            remapped = current_mapping.fetch(input_key.to_sym, nil)
+            if remapped.nil?
+              uinput_keyboard.write_input_event(input_event)
+              next
+            end
+
+            remapped_event = InputEvent.new(nil, input_event.type, find_code_from_key(remapped), input_event.value)
+
+            # Workaround to solve the problem that the remapped key remains pressed
+            # when the key pressed before remapping is released after remapping
+            unless record_virtual_keyboard_event?(remapped, remapped_event.value)
+              # set original key before remapping
+              remapped_event.code = input_event.code
+            end
+
+            # remap to command will be nil
+            # e.g) remap: { X: { command: echo 'foo' } }
+            # this is because the command will be executed by fusuma process
+            next if remapped_event.code.nil?
+
+            uinput_keyboard.write_input_event(remapped_event)
+          rescue Errno::ENODEV => e # device is removed
+            MultiLogger.error "Device is removed: #{e.message}"
+            @source_keyboards = reload_keyboards
+          end
+        rescue EOFError => e # device is closed
+          MultiLogger.error "Device is closed: #{e.message}"
+        ensure
+          @destroy.call
+        end
+
+        private
+
+        def reload_keyboards
+          source_keyboards = KeyboardSelector.new(@config[:keyboard_name_patterns]).select
+
+          MultiLogger.info("Reload keyboards: #{source_keyboards.map(&:device_name)}")
+
+          set_trap(source_keyboards)
+          # TODO: Extract to a configuration file or make it optional
+          #       it should stop other remappers
+          set_emergency_ungrab_keybinds("RIGHTCTRL", "LEFTCTRL")
+          grab_keyboards(source_keyboards)
+        rescue => e
+          MultiLogger.error "Failed to reload keyboards: #{e.message}"
+          MultiLogger.error e.backtrace.join("\n")
+        end
+
+        def uinput_keyboard
+          @uinput_keyboard ||= UinputKeyboard.new("/dev/uinput")
+        end
+
+        def pressed_virtual_keys
+          @pressed_virtual_keys ||= Set.new
+        end
+
+        # record virtual keyboard event
+        # @param [String] remapped_value remapped key name
+        # @param [Integer] event_value event value
+        # @return [Boolean] false if the key was pressed before remapping started and was released
+        # @return [Boolean] true if the key was not pressed before remapping started
+        def record_virtual_keyboard_event?(remapped_value, event_value)
+          case event_value
+          when 0
+            pressed_virtual_keys.delete?(remapped_value)
+          when 1
+            pressed_virtual_keys.add?(remapped_value)
+            true # Always return true because the remapped key may be the same
+          else
+            # 2 is repeat
+            true
+          end
+        end
+
+        def virtual_keyboard_all_key_released?
+          pressed_virtual_keys.empty?
+        end
+
+        def create_virtual_keyboard
+          touchpad_name_patterns = @config[:touchpad_name_patterns]
+          internal_touchpad = TouchpadSelector.new(touchpad_name_patterns).select.first
+
+          if internal_touchpad.nil?
+            MultiLogger.error("No touchpad found: #{touchpad_name_patterns}")
+            exit
+          end
+
+          MultiLogger.info "Create virtual keyboard: #{VIRTUAL_KEYBOARD_NAME}"
+
+          uinput_keyboard.create VIRTUAL_KEYBOARD_NAME,
+            Revdev::InputId.new(
+              # disable while typing is enabled when
+              # - Both the keyboard and touchpad are BUS_I8042
+              # - The touchpad and keyboard have the same vendor/product
+              # ref: (https://wayland.freedesktop.org/libinput/doc/latest/palm-detection.html#disable-while-typing)
+              #
+              {
+                bustype: Revdev::BUS_I8042,
+                vendor: internal_touchpad.device_id.vendor,
+                product: internal_touchpad.device_id.product,
+                version: internal_touchpad.device_id.version
+              }
+            )
+        end
+
+        def grab_keyboards(keyboards)
+          keyboards.each do |keyboard|
+            wait_release_all_keys(keyboard)
+            begin
+              keyboard.grab
+              MultiLogger.info "Grabbed #{keyboard.device_name}"
+            rescue Errno::EBUSY
+              MultiLogger.error "Failed to grab #{keyboard.device_name}"
+            end
+          end
+        end
+
+        # @param [Array<Revdev::EventDevice>] keyboards
+        def set_trap(keyboards)
+          @destroy = lambda do
+            keyboards.each do |kbd|
+              kbd.ungrab
+            rescue Errno::EINVAL
+            rescue Errno::ENODEV
+              # already ungrabbed
+            end
+
+            begin
+              uinput_keyboard.destroy
+            rescue IOError
+              # already destroyed
+            end
+
+            exit 0
+          end
+
+          Signal.trap(:INT) { @destroy.call }
+          Signal.trap(:TERM) { @destroy.call }
+        end
+
+        # Emergency stop keybind for virtual keyboard
+        def set_emergency_ungrab_keybinds(first_key, second_key)
+          first_keycode = find_code_from_key(first_key)
+          second_keycode = find_code_from_key(second_key)
+          MultiLogger.info "Emergency ungrab keybind: #{first_key} + #{second_key}"
+
+          @emergency_stop = lambda do |prev, current|
+            if (prev&.code == first_keycode && prev.value != 0) && (current.code == second_keycode && current.value != 0)
+              MultiLogger.info "Emergency ungrab keybind: #{first_key} + #{second_key}"
+              @destroy.call
+            end
+          end
+        end
+
+        # Find remappable key from mapping and return remapped key code
+        # If not found, return original key code
+        # If the key is found but its value is not valid, return nil
+        # @example
+        #  find_remapped_code({ "A" => "b" }, 30) # => 48
+        #  find_remapped_code({ "A" => "b" }, 100) # => 100
+        #  find_remapped_code({ "A" => {command: 'echo foobar'}  }, 30) # => nil
+        #
+        # @param [Hash] mapping
+        # @param [Integer] code
+        # @return [Integer, nil]
+        def find_remapped_code(mapping, code)
+          key = find_key_from_code(code) # key = "A"
+          remapped_key = mapping.fetch(key.to_sym, nil) # remapped_key = "b"
+          return code unless remapped_key # return original code if key is not found
+
+          find_code_from_key(remapped_key) # remapped_code = 48
+        end
+
+        # Find key name from key code
+        # @example
+        #  find_key_from_code(30) # => "A"
+        #  find_key_from_code(48) # => "B"
+        # @param [Integer] code
+        # @return [String]
+        def find_key_from_code(code)
+          # { 30 => :A, 48 => :B, ... }
+          @keys_per_code ||= Revdev.constants.select { |c| c.start_with? "KEY_" }.map { |c| [Revdev.const_get(c), c.to_s.delete_prefix("KEY_")] }.to_h
+          @keys_per_code[code]
+        end
+
+        # Find key code from key name (e.g. "A", "B", "BTN_LEFT")
+        # If key name is not found, return nil
+        # @example
+        #  find_code_from_key("A") # => 30
+        #  find_code_from_key("B") # => 48
+        #  find_code_from_key("BTN_LEFT") # => 272
+        #  find_code_from_key("NOT_FOUND") # => nil
+        # @param [String] key
+        # @return [Integer] when key is available
+        # @return [nil] when key is not available
+        def find_code_from_key(key)
+          # { KEY_A => 30, KEY_B => 48, ... }
+          @codes_per_key ||= Revdev.constants.select { |c| c.start_with?("KEY_", "BTN_") }.map { |c| [c, Revdev.const_get(c)] }.to_h
+
+          case key
+          when String
+            if key.start_with?("BTN_")
+              @codes_per_key[key.upcase.to_sym]
+            else
+              @codes_per_key["KEY_#{key}".upcase.to_sym]
+            end
+          when Integer
+            @codes_per_key["KEY_#{key}".upcase.to_sym]
+          end
+        end
+
+        def released_all_keys?(device)
+          # key status if all bytes are 0, the key is not pressed
+          bytes = device.read_ioctl_with(Revdev::EVIOCGKEY)
+          bytes.unpack("C*").all? { |byte| byte == 0 }
+        end
+
+        def wait_release_all_keys(device, &block)
+          loop do
+            if released_all_keys?(device)
+              break true
+            else
+              # wait until all keys are released
+              device.read_input_event
+            end
+          end
+        end
+
+        # Devices to detect key presses and releases
+        class KeyboardSelector
+          def initialize(names = ["keyboard", "Keyboard", "KEYBOARD"])
+            @names = names
+          end
+
+          # Select devices that match the name
+          # If no device is found, it will wait for 3 seconds and try again
+          # @return [Array<Revdev::EventDevice>]
+          def select
+            loop do
+              Fusuma::Device.reset # reset cache to get the latest device information
+              devices = Fusuma::Device.all.select { |d| Array(@names).any? { |name| d.name =~ /#{name}/ } }
+              if devices.empty?
+                wait_for_device
+
+                next
+              end
+
+              return devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+            end
+          end
+
+          def wait_for_device
+            sleep 3
+          end
+        end
+
+        class TouchpadSelector
+          def initialize(names = nil)
+            @names = names
+          end
+
+          # @return [Array<Revdev::EventDevice>]
+          def select
+            devices = if @names
+              Fusuma::Device.all.select { |d| Array(@names).any? { |name| d.name =~ /#{name}/ } }
+            else
+              # available returns only touchpad devices
+              Fusuma::Device.available
+            end
+
+            devices.map { |d| Revdev::EventDevice.new("/dev/input/#{d.id}") }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,28 +8,33 @@ module Fusuma
       class LayerManager
         require "singleton"
         include Singleton
-        attr_reader :reader, :writer, :current_layer
+        attr_reader :reader, :writer, :current_layer, :layers
 
         def initialize
           @layers = {}
           @reader, @writer = IO.pipe
           @current_layer = {} # preserve order
+          @last_layer = nil
+          @last_remove = nil
         end
 
         # @param [Hash] layer
         # @param [Boolean] remove
         def send_layer(layer:, remove: false)
-          # puts "send_layer: #{layer} remove: #{remove}"
-          return if @last_layer == layer && @last_remove == remove
+          return if (@last_layer == layer) && (@last_remove == remove)
 
           @last_layer = layer
           @last_remove = remove
-          @writer.puts({layer: layer, remove: remove}.to_msgpack)
+          @writer.write({layer: layer, remove: remove}.to_msgpack)
         end
 
-        # Read layer from pipe and return remap layer
+        # Read layer from pipe and update @current_layer
+        # @return [Hash] current layer
         # @example
-        # @return [Hash]
+        #  receive_layer
+        #  # => { thumbsense: true }
+        #  receive_layer
+        #  # => { thumbsense: true, application: "Google-chrome" }
         def receive_layer
           @layer_unpacker ||= MessagePack::Unpacker.new(@reader)
 
@@ -41,28 +46,28 @@ module Fusuma
           layer = data[:layer] # e.g { thumbsense: true }
           remove = data[:remove] # e.g true
 
+          # update @current_layer
           if remove
             @current_layer.delete_if { |k, _v| layer.key?(k) }
           else
             # If duplicate keys exist, order of keys is preserved
             @current_layer.merge!(layer)
           end
+          @current_layer
         end
 
         # Find remap layer from config
         # @param [Hash] layer
-        # @return [Hash]
-        def find_mapping(layer = @current_layer)
+        # @return [Hash] remap layer
+        def find_mapping(layer)
           @layers[layer] ||= begin
             result = nil
-            _ = Fusuma::Config::Searcher.find_context(layer) {
+            _ = Fusuma::Config::Searcher.find_context(layer) do
               result = Fusuma::Config.search(Fusuma::Config::Index.new(:remap))
               next unless result
 
-              result = result.deep_transform_keys do |key|
-                key.upcase.to_sym
-              end
-            }
+              result = result.deep_transform_keys { |key| key.upcase.to_sym }
+            end
 
             result || {}
           end

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

@@ -0,0 +1,168 @@
+require "revdev"
+require "msgpack"
+require "set"
+
+require_relative "uinput_touchpad"
+
+module Fusuma
+  module Plugin
+    module Remap
+      class TouchpadRemapper
+        include Revdev
+
+        VIRTUAL_TOUCHPAD_NAME = "fusuma_virtual_touchpad"
+
+        # @param fusuma_writer [IO]
+        # @param source_touchpad [Revdev::Device]
+        def initialize(fusuma_writer:, source_touchpad:)
+          @source_touchpad = source_touchpad # original touchpad
+          @fusuma_writer = fusuma_writer # write event to fusuma_input
+          @palm_detector ||= PalmDetection.new(source_touchpad)
+        end
+
+        # TODO: grab touchpad events and remap them
+        #       send remapped events to virtual touchpad or virtual mouse
+        def run
+          create_virtual_touchpad
+
+          touch_state = {}
+          mt_slot = 0
+          finger_state = nil
+          loop do
+            IO.select([@source_touchpad.file]) # , @layer_manager.reader])
+
+            ## example of input_event
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 57 (ABS_MT_TRACKING_ID), value 43679
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 53 (ABS_MT_POSITION_X), value 648
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 54 (ABS_MT_POSITION_Y), value 209
+            # Event: time 1698456258.380027, type 1 (EV_KEY), code 330 (BTN_TOUCH), value 1
+            # Event: time 1698456258.380027, type 1 (EV_KEY), code 325 (BTN_TOOL_FINGER), value 1
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 0 (ABS_X), value 648
+            # Event: time 1698456258.380027, type 3 (EV_ABS), code 1 (ABS_Y), value 209
+            # Event: time 1698456258.380027, type 4 (EV_MSC), code 5 (MSC_TIMESTAMP), value 0
+            # Event: time 1698456258.380027, -------------- SYN_REPORT ------------
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 47 (ABS_MT_SLOT), value 1
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 57 (ABS_MT_TRACKING_ID), value 43680
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 53 (ABS_MT_POSITION_X), value 400
+            # Event: time 1698456258.382693, type 3 (EV_ABS), code 54 (ABS_MT_POSITION_Y), value 252
+            # Event: time 1698456258.382693, type 1 (EV_KEY), code 325 (BTN_TOOL_FINGER), value 0
+            # Event: time 1698456258.382693, type 1 (EV_KEY), code 333 (BTN_TOOL_DOUBLETAP), value 1
+            # Event: time 1698456258.382693, type 4 (EV_MSC), code 5 (MSC_TIMESTAMP), value 7100
+            # Event: time 1698456258.382693, -------------- SYN_REPORT ------------
+            input_event = @source_touchpad.read_input_event
+
+            touch_state[mt_slot] ||= {MT_TRACKING_ID: nil, X: nil, Y: nil, valid_touch_point: false}
+            syn_report = nil
+
+            case input_event.type
+            when Revdev::EV_ABS
+              case input_event.code
+              when Revdev::ABS_MT_SLOT
+                mt_slot = input_event.value
+                touch_state[mt_slot] ||= {}
+              when Revdev::ABS_MT_TRACKING_ID
+                touch_state[mt_slot][:MT_TRACKING_ID] = input_event.value
+                if input_event.value == -1
+                  touch_state[mt_slot] = {}
+                end
+              when Revdev::ABS_MT_POSITION_X
+                touch_state[mt_slot][:X] = input_event.value
+              when Revdev::ABS_MT_POSITION_Y
+                touch_state[mt_slot][:Y] = input_event.value
+              when Revdev::ABS_X, Revdev::ABS_Y
+                # ignore
+              when Revdev::ABS_MT_PRESSURE
+                # ignore
+              when Revdev::ABS_MT_TOOL_TYPE
+                # ignore
+              else
+                raise "unhandled event"
+              end
+            when Revdev::EV_KEY
+              case input_event.code
+              when Revdev::BTN_TOUCH
+                # ignore
+              when Revdev::BTN_TOOL_FINGER
+                finger_state = (input_event.value == 1) ? 1 : 0
+              when Revdev::BTN_TOOL_DOUBLETAP
+                finger_state = (input_event.value == 1) ? 2 : 1
+              when Revdev::BTN_TOOL_TRIPLETAP
+                finger_state = (input_event.value == 1) ? 3 : 2
+              when Revdev::BTN_TOOL_QUADTAP
+                finger_state = (input_event.value == 1) ? 4 : 3
+              when 0x148 # define BTN_TOOL_QUINTTAP	0x148	/* Five fingers on trackpad */
+                finger_state = (input_event.value == 1) ? 5 : 4
+              end
+            when Revdev::EV_MSC
+              case input_event.code
+              when 0x05 # define MSC_TIMESTAMP		0x05
+                # ignore
+                # current_timestamp = input_event.value
+              end
+            when Revdev::EV_SYN
+              case input_event.code
+              when Revdev::SYN_REPORT
+                syn_report = input_event.value
+              when Revdev::SYN_DROPPED
+                MultiLogger.error "Dropped: #{input_event.value}"
+              else
+                raise "unhandled event", "#{input_event.hr_type}, #{input_event.hr_code}, #{input_event.value}"
+              end
+            else
+              raise "unhandled event", "#{input_event.hr_type}, #{input_event.hr_code}, #{input_event.value}"
+            end
+
+            # TODO:
+            # Remember the most recent valid touch position and exclude it if it is close to that position
+            # For example, when dragging, it is possible to touch around the edge of the touchpad again after reaching the edge of the touchpad, so in that case, you do not want to execute palm detection
+            if touch_state[mt_slot][:valid_touch_point] != true
+              touch_state[mt_slot][:valid_touch_point] = @palm_detector.palm?(touch_state[mt_slot])
+            end
+
+            if syn_report
+              # TODO: define format as fusuma_input
+              data = {finger: finger_state, touch_state: touch_state}
+              @fusuma_writer.write(data.to_msgpack)
+            end
+          end
+        end
+
+        private
+
+        def uinput
+          @uinput ||= UinputTouchpad.new "/dev/uinput"
+        end
+
+        def create_virtual_touchpad
+          MultiLogger.info "Create virtual keyboard: #{VIRTUAL_TOUCHPAD_NAME}"
+
+          uinput.create_from_device(name: VIRTUAL_TOUCHPAD_NAME, device: @source_touchpad)
+        end
+
+        # Detect palm touch
+        class PalmDetection
+          def initialize(touchpad)
+            @max_x = touchpad.absinfo_for_axis(Revdev::ABS_MT_POSITION_X)[:absmax]
+            @max_y = touchpad.absinfo_for_axis(Revdev::ABS_MT_POSITION_Y)[:absmax]
+          end
+
+          def palm?(touch_state)
+            return false unless touch_state[:X] && touch_state[:Y]
+
+            if 0.8 * @max_y < touch_state[:Y]
+              true
+            else
+              !(
+                # Disable 20% of the touch area on the left, right
+                (touch_state[:X] < 0.2 * @max_x || touch_state[:X] > 0.8 * @max_x) ||
+                # Disable 10% of the touch area on the top edge
+                (touch_state[:Y] < 0.1 * @max_y && (touch_state[:X] < 0.2 * @max_x || touch_state[:X] > 0.8 * @max_x)
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require "ruinput"
+
+class UinputKeyboard < Ruinput::UinputDevice
+  include Ruinput
+
+  # create virtual event divece
+  # _name_ :: device name
+  # _id_ :: InputId ("struct input_id" on input.h)
+  def create name = DEFAULT_DEVICE_NAME, id = DEFAULT_INPUT_ID
+    if !name.is_a? String
+      raise ArgumentError, "1st arg expect String"
+    elsif !id.is_a? Revdev::InputId
+      raise ArgumentError, "2nd arg expect Revdev::InputId"
+    end
+
+    uud = Ruinput::UinputUserDev.new({
+      name: name,
+      id: id,
+      ff_effects_max: 0,
+      absmax: [],
+      absmin: [],
+      absfuzz: [],
+      absflat: []
+    })
+
+    @file.syswrite uud.to_byte_string
+
+    set_all_events
+
+    @file.ioctl UI_DEV_CREATE, nil
+    @is_created = true
+  end
+
+  def set_all_events
+    raise "invalid method call: this uinput is already created" if @is_created
+
+    mouse_btns = [
+      Revdev::BTN_0,
+      Revdev::BTN_MISC,
+      Revdev::BTN_1,
+      Revdev::BTN_2,
+      Revdev::BTN_3,
+      Revdev::BTN_4,
+      Revdev::BTN_5,
+      Revdev::BTN_6,
+      Revdev::BTN_7,
+      Revdev::BTN_8,
+      Revdev::BTN_9,
+      Revdev::BTN_LEFT,
+      Revdev::BTN_MOUSE,
+      Revdev::BTN_MIDDLE,
+      Revdev::BTN_RIGHT,
+      Revdev::BTN_SIDE,
+      Revdev::BTN_EXTRA,
+      Revdev::BTN_FORWARD,
+      Revdev::BTN_BACK,
+      Revdev::BTN_TASK
+      # Revdev::BTN_TRIGGER, # libinput recognized as joystick if set
+    ].freeze
+
+    keyboard_keys = Revdev.constants.select { |c| c.start_with? "KEY_" }.map { |c| Revdev.const_get(c) }.freeze
+
+    @file.ioctl UI_SET_EVBIT, Revdev::EV_KEY
+    @counter = 0
+    Revdev::KEY_CNT.times do |i|
+      # https://github.com/mooz/xkeysnail/pull/101/files
+      if keyboard_keys.include?(i) || mouse_btns.include?(i)
+        # puts "setting #{i} (#{Revdev::REVERSE_MAPS[:KEY][i]})"
+        @file.ioctl UI_SET_KEYBIT, i
+      end
+    end
+
+    # @file.ioctl UI_SET_EVBIT, Revdev::EV_MSC
+    # Revdev::MSC_CNT.times do |i|
+    #   @file.ioctl UI_SET_MSCBIT, i
+    # end
+
+    mouse_rel = [
+      Revdev::REL_X,
+      Revdev::REL_Y,
+      Revdev::REL_WHEEL,
+      Revdev::REL_HWHEEL
+    ].freeze
+
+    @file.ioctl UI_SET_EVBIT, Revdev::EV_REL
+    Revdev::REL_CNT.times do |i|
+      if mouse_rel.include?(i)
+        # puts "setting #{i} (#{Revdev::REVERSE_MAPS[:REL][i]})"
+        @file.ioctl UI_SET_RELBIT, i
+      end
+    end
+
+    @file.ioctl UI_SET_EVBIT, Revdev::EV_REP
+  end
+end