fusuma-plugin-thumbsense 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25560d1130c397e047ad36abc976e19e3117d57b02525f82db04a66771900772
-  data.tar.gz: fb72b8d4b755c6fa03dd71cb296218f30377f7f0bc189e04ea80c4f137b9ee10
+  metadata.gz: 1bdd2539bacc9ce3db7375ce445affc2a22fcadfc5a7849243737c8fe028911e
+  data.tar.gz: 4b4b1e40b305ef98b032ae186828dbd69b50fb8d82e978fb02d7a2540f8da517
 SHA512:
-  metadata.gz: a4344efe92c9a0abdf086adeba86e6a5dc2df9ff542b07df304ea9532ccc1058c338d0b902cc560579d129b1250ac4ceef55291b025cd8c82e6633a6dbbe46b4
-  data.tar.gz: b9b4e0c163e9dc4f3ddaa1aed115b367e5f4282684cb5741e534c51e77071bb9cba44248f8a6aa80d127e429ef291ea30e202c2e859c0b9d258545d8783181da
+  metadata.gz: e69801eb4e32d544bf7ba7a322b9204683211372e94ef36375e1c2c70a730254638da594fcbf3e13b4c31a7d3a9cba64a25ef3b086696e44bf1dbccb5b145724
+  data.tar.gz: 16d973013a91adc273687a849f48915c6acff2d3bff72ed97aaf44e7b89328051d32c32e1e0a2fb514453cdda80b0989df12bbe039df3209bd69d3d659780e1b

data/README.md

@@ -1,51 +1,109 @@
 # Fusuma::Plugin::Thumbsense [![Gem Version](https://badge.fury.io/rb/fusuma-plugin-thumbsense.svg)](https://badge.fury.io/rb/fusuma-plugin-thumbsense) [![Build Status](https://github.com/iberianpig/fusuma-plugin-thumbsense/actions/workflows/main.yml/badge.svg)](https://github.com/iberianpig/fusuma-plugin-thumbsense/actions/workflows/main.yml)
 
+Remapper from key to click only while tapping the touchpad.  
+Implemented as [Fusuma](https://github.com/iberianpig/fusuma) Plugin.
+
 **THIS PLUGIN IS EXPERIMENTAL.**
 
-ThumbSense plugin for [Fusuma](https://github.com/iberianpig/fusuma)
+## What is ThumbSense?
+[ThumbSense](https://www2.sonycsl.co.jp/person/rekimoto/tsense/soft/index.html) is a tool that lets you control a laptop's touchpad using the keyboard. It assigns certain keyboard keys as mouse buttons and switches between acting as mouse buttons or normal keyboard keys based on whether the user's thumb is touching the touchpad. ThumbSense aims to make it easier to use the touchpad without moving your hand away from the keyboard.
 
-ThumbSense is a tool that lets you control a laptop's touchpad using the keyboard. It assigns certain keyboard keys as mouse buttons and switches between acting as mouse buttons or normal keyboard keys based on whether the user's thumb is touching the touchpad. ThumbSense aims to make it easier to use the touchpad without moving your hand away from the keyboard.
+## Installation
 
-[ThumbSense](https://www2.sonycsl.co.jp/person/rekimoto/tsense/soft/index.html)
+### Requirements
 
-## Installation
+- [fusuma](https://github.com/iberianpig/fusuma#update)  2.0 or later
+- [fusuma-plugin-keypress](https://github.com/iberianpig/fusuma-plugin-keypress) 0.5 or later
+  - fusuma-plugin-keypress is used to get keyboard input and is installed automatically.
+- [fusuma-plugin-remap](https://github.com/iberianpig/fusuma-plugin-remap)
+  - You need to set up udev rules for creating a virtual input device.
+  - fusuma-plugin-remap is installed automatically.
+  - Please refer to [fusuma-plugin-remap's README](https://github.com/iberianpig/fusuma-plugin-remap?tab=readme-ov-file#set-up-udev-rules) for details.
+
+### Install and set up fusuma-plugin-thumbsense
 
 Run the following code in your terminal.
 
-### Install fusuma-plugin-thumbsense
+#### Install ruby-dev and build-essential for installing native extension
+```sh
+$ sudo apt install ruby-dev build-essential
+```
 
-This plugin requires [fusuma](https://github.com/iberianpig/fusuma#update) 2.0 or later and [fusuma-plugin-keypress](https://github.com/iberianpig/fusuma-plugin-keypress) 0.5 or later.
-  - fusuma-plugin-keypress is used to get keyboard input and is installed automatically.
+#### Install libevdev-dev for building fusuma-plugin-remap
+```sh
+$ sudo apt install libevdev-dev
+```
 
+#### set up udev rules for creating a virtual input device (fusuma-plugin-remap)
 ```sh
-$ sudo gem install fusuma-plugin-thumbsense
+$ echo 'KERNEL=="uinput", MODE="0660", GROUP="input", OPTIONS+="static_node=uinput"' | sudo tee /etc/udev/rules.d/60-udev-fusuma-remap.rules
+$ sudo udevadm control --reload-rules && sudo udevadm trigger
 ```
 
 
+#### Install fusuma-plugin-thumbsense
+```sh
+$ sudo gem install fusuma-plugin-thumbsense
+```
+
 ## Properties
 
-### Thumbsense
+### Thumbsense context
+
+First, add the thumbsense `context` to `~/.config/fusuma/config.yml`.
+The `context` is separated by `---` and specified by `context: thumbsense`.
+Fusuma will switch to the `thumbsense` context while tapping the touchpad.
 
-First, add the `thumbsense` context to `~/.config/fusuma/config.yml`.
-The context is separated by `---` and specified by `context: thumbsense`.
+### Remap key to mouse button
+
+You can remap keys to mouse buttons while tapping the touchpad.
+The `remap` property is specified in the `thumbsense` context.
+
+Available mouse buttons are:
+
+- `BTN_LEFT`
+- `BTN_MIDDLE`
+- `BTN_RIGHT`
+- `BTN_SIDE`
+- `BTN_EXTRA`
+- `BTN_FORWARD`
+- `BTN_BACK`
+- `BTN_TASK`
+- `BTN_0`
+- `BTN_1`
+-   ...
+- `BTN_9`
 
 ## Example
 
 Set the following code in `~/.config/fusuma/config.yml`.
 
 ```yaml
+# add thumbsense context
+
 ---
 context: thumbsense
 
 remap:
+  F: BTN_LEFT
+  E: BTN_MIDDLE
+  D: BTN_RIGHT
+  SPACE: BTN_LEFT
   J: BTN_LEFT
   K: BTN_RIGHT
 ```
 
-### TODO
+## TODO
+
+- thumbsense
+  - [x] change layer of remap while tapping
+  - [ ] make it possible to execute executor like `command:` `sendkey:`
 
-- Using the fusuma-plugin-sendkey to emulate mouse buttons
-- Creating a simple key remapper using evdev and uinput to prevent the pressing of J/K keys on the physical keyboard from being sent.
+- remap
+  - [x] remap to single key like `remap: { J: BTN_LEFT }` 
+  - [x] send BTN_LEFT/BTN_MIDDLE/BTN_RIGHT click `remap: { I: BTN_MIDDLE }`
+  - [ ] remap multiple keys like `remap: { H: LEFTCTRL+TAB }`
+  - [ ] remap POINTER_MOTION to POINTER_SCROLL_FINGER `remap: { S: POINTER_SCROLL_FINGER }`
 
 ## Contributing
 

data/fusuma-plugin-thumbsense.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.7"
   # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
   # support focal (20.04LTS) 2.7
-  spec.add_dependency "fusuma", ">= 3.1"
-  spec.add_dependency "fusuma-plugin-keypress", ">= 0.5"
-  spec.add_dependency "fusuma-plugin-remap"
+  spec.add_dependency "fusuma", ">= 3.2"
+  spec.add_dependency "fusuma-plugin-keypress", ">= 0.11"
+  spec.add_dependency "fusuma-plugin-remap", ">= 0.4"
   spec.metadata = {
     "rubygems_mfa_required" => "true"
   }

data/lib/fusuma/plugin/buffers/thumbsense_buffer.rb

@@ -5,7 +5,7 @@ module Fusuma
     module Buffers
       # manage events and generate command
       class ThumbsenseBuffer < Buffer
-        DEFAULT_SOURCE = "thumbsense_parser"
+        DEFAULT_SOURCE = "remap_touchpad_input"
 
         def config_param_types
           {
@@ -20,8 +20,7 @@ module Fusuma
           # skip palm/begin record
           return if !ended?(@events.last)
 
-          released_finger = @events.last.record.finger
-          @events.delete_if { |e| e.record.finger == released_finger }
+          clear
         end
 
         # @param event [Event]

data/lib/fusuma/plugin/buffers/thumbsense_buffer.yml

@@ -0,0 +1,4 @@
+plugin:
+  buffers:
+    thumbsense_buffer:
+      source: remap_touchpad_input

data/lib/fusuma/plugin/detectors/thumbsense_detector.rb

@@ -10,8 +10,8 @@ module Fusuma
     module Detectors
       # Detect Thumbsense context and change remap layer of fusuma-plugin-remap
       class ThumbsenseDetector < Detector
+        # keypress buffer is used to detect modifier keys
         SOURCES = %w[thumbsense keypress].freeze
-        BUFFER_TYPE = "thumbsense"
 
         MODIFIER_KEYS = Set.new(%w[
           CAPSLOCK
@@ -28,51 +28,74 @@ module Fusuma
         LAYER_CONTEXT = {thumbsense: true}.freeze
 
         # Detect Context event and change remap layer of fusuma-plugin-remap
-        # @param buffers [Array<Buffer>]
+        # @param buffers [Array<Buffer>] ThumbsenseBuffer, KeypressBuffer
         # @return [Event] if Thumbsense context is detected
+        # @return [Array<Event>] if Thumbsense context and Remap index when keypress is detected
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
-          thumbsense_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
-
-          return if thumbsense_buffer.empty?
-
-          MultiLogger.debug("thumbsense_buffer: #{thumbsense_buffer.events.map(&:record).map { |r| "#{r.finger} #{r.gesture} #{r.status}" }}")
+          @thumbsense_buffer ||= find_buffer(buffers, "thumbsense")
+          @keypress_buffer ||= find_buffer(buffers, "keypress")
 
           layer_manager = Fusuma::Plugin::Remap::LayerManager.instance
 
-          if touch_released?(thumbsense_buffer)
+          # layer is thumbsense => create thumbsense context and remap index
+          # touch is touching   => create thumbsense context and remap index
+          # touch is released   => remove thumbsense context
+          # keypress -> touch   => remove thumbsense context
+          if touch_released? && !thumbsense_layer?
+            MultiLogger.debug("thumbsense layer removed")
             layer_manager.send_layer(layer: LAYER_CONTEXT, remove: true)
             return
           end
 
-          keypress_buffer = buffers.find { |b| b.type == "keypress" }
+          # When keypress event is first:
+          # If current layer is thumbsense, the layer should not be changed
+          # If current layer is not thumbsense, it should remain a normal key
+          # In other words, if the key event comes first, do nothing
+          if keypress_first?
+            MultiLogger.debug("keypress event is first")
 
-          # If only modifier keys are pressed or no key is pressed
-          if pressed_codes(keypress_buffer).all? { |code| MODIFIER_KEYS.include?(code) }
-
-            # Even if the palm is detected, keep the thumbsense layer until `:end` event
-            if palm_detected?(thumbsense_buffer)
-              layer_manager.send_layer(layer: LAYER_CONTEXT, remove: true)
-              return
-            end
+            return
+          end
 
-            layer_manager.send_layer(layer: LAYER_CONTEXT)
+          MultiLogger.debug("thumbsense context created") unless thumbsense_layer?
+          layer_manager.send_layer(layer: LAYER_CONTEXT)
 
-            # create thumbsense context
-            record = Events::Records::ContextRecord.new(
+          # create thumbsense context
+          context = create_event(
+            record: Events::Records::ContextRecord.new(
               name: :thumbsense,
               value: true
             )
-            return create_event(record: record)
+          )
+
+          # TODO: Threshold
+          # create remap index
+          index = if (keys = pressed_codes) && !keys.empty?
+            MultiLogger.debug("thumbsense remap index created: #{keys}")
+            combined_keys = keys.join("+")
+            create_event(
+              record: Events::Records::IndexRecord.new(
+                index: Config::Index.new([:remap, combined_keys])
+              )
+            )
           end
 
-          nil
+          [context, index].compact
         end
 
         private
 
-        def pressed_codes(keypress_buffer)
-          records = keypress_buffer.events.map(&:record)
+        # @param buffers [Array<Buffer>]
+        # @param type [String]
+        # @return [Buffer]
+        def find_buffer(buffers, type)
+          buffers.find { |b| b.type == type }
+        end
+
+        # @return [Array<String>]
+        def pressed_codes
+          records = @keypress_buffer.events.map(&:record)
           codes = []
           records.each do |r|
             if r.status == "pressed"
@@ -84,45 +107,43 @@ module Fusuma
           codes
         end
 
-        def touching?(thumbsense_buffer)
-          !touch_released?(thumbsense_buffer)
+        # @return [TrueClass, FalseClass]
+        def touching?
+          !touch_released?(@thumbsense_buffer)
         end
 
         # @return [TrueClass, FalseClass]
-        def touch_released?(thumbsense_buffer)
-          thumbsense_events = thumbsense_buffer.events
-          touch_num = thumbsense_events.count { |e| (e.record.status == "begin") }
-          release_num = thumbsense_events.count { |e| e.record.status == "end" }
+        def touch_released?
+          return true if @thumbsense_buffer.empty?
 
-          touch_num <= release_num
+          @thumbsense_buffer.events.map(&:record).last&.status == "end"
         end
 
-        # Detect palm, except when there is another touch
-        # @param thumbsense_buffer [Buffer]
         # @return [TrueClass, FalseClass]
-        def palm_detected?(thumbsense_buffer)
-          # finger is a number to distinguish different touches and palms
-          # If the count remains, it is judged as a touch state
-          touch_state_per_finger = {}
-          thumbsense_buffer.events.each do |e|
-            f = e.record.finger
-            touch_state_per_finger[f] ||= 0
-
-            case e.record.status
-            when "begin"
-              touch_state_per_finger[f] += 1
-            when "palm"
-              if touch_state_per_finger[f] < 0
-                # NOTE: If Palm continues, it is equivalent to end
-                touch_state_per_finger[f] = 0
-              else
-                touch_state_per_finger[f] -= 1
-              end
-            when "end"
-              touch_state_per_finger[f] = 0
-            end
+        def thumbsense_layer?
+          return if @keypress_buffer.empty?
+
+          last_keypress = @keypress_buffer.events.last.record
+          return if last_keypress.status == "released"
+
+          current_layer = last_keypress&.layer
+          current_layer && current_layer["thumbsense"]
+        end
+
+        # Check if keypress event is first, before thumbsense event
+        # If last keypress event is modifier key, return false
+        # @param keypress_buffer [Buffer]
+        # @param thumbsense_buffer [Buffer]
+        # @return [TrueClass] if keypress event is first
+        # @return [FalseClass] if keypress event is NOT first or buffers are empty
+        def keypress_first?
+          return false if @thumbsense_buffer.empty? || @keypress_buffer.empty?
+
+          if (keys = pressed_codes) && !keys.empty?
+            return false if MODIFIER_KEYS.include?(keys.first)
           end
-          touch_state_per_finger.values.all? { |count| count <= 0 }
+
+          @keypress_buffer.events.first.time < @thumbsense_buffer.events.first.time
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Thumbsense
-      VERSION = "0.6.0"
+      VERSION = "0.8.0"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-thumbsense
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-03 00:00:00.000000000 Z
+date: 2024-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: fusuma-plugin-keypress
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: fusuma-plugin-remap
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
 description: fusuma-plugin-thumbsense is Fusuma plugin for thumbsense.
 email:
 - yhkyky@gmail.com
@@ -65,10 +65,8 @@ files:
 - bin/setup
 - fusuma-plugin-thumbsense.gemspec
 - lib/fusuma/plugin/buffers/thumbsense_buffer.rb
+- lib/fusuma/plugin/buffers/thumbsense_buffer.yml
 - lib/fusuma/plugin/detectors/thumbsense_detector.rb
-- lib/fusuma/plugin/filters/thumbsense_filter.rb
-- lib/fusuma/plugin/filters/thumbsense_filter.yml
-- lib/fusuma/plugin/parsers/thumbsense_parser.rb
 - lib/fusuma/plugin/thumbsense.rb
 - lib/fusuma/plugin/thumbsense/version.rb
 homepage: https://github.com/iberianpig/fusuma-plugin-thumbsense
@@ -91,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: Thumbsense plugin for Fusuma

data/lib/fusuma/plugin/filters/thumbsense_filter.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "fusuma/device"
-
-module Fusuma
-  module Plugin
-    module Filters
-      # Filter keyboard events from libinput_command_input
-      class ThumbsenseFilter < Filter
-        DEFAULT_SOURCE = "libinput_command_input"
-
-        # @return [TrueClass] when keeping it
-        # @return [FalseClass] when discarding it
-        def keep?(record)
-          case record.to_s
-          when %r{\sevent\d+\s+-\sbutton state: touch (?<finger>[[:digit:]])}
-            true
-          when %r{\sevent\d+\s+-\spalm: touch (?<finger>[[:digit:]])}
-            true
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fusuma/plugin/filters/thumbsense_filter.yml

@@ -1,4 +0,0 @@
-plugin:
-  inputs:
-    libinput_command_input:
-      verbose: true

data/lib/fusuma/plugin/parsers/thumbsense_parser.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-# require 'fusuma/plugin/parsers/parser.rb'
-# require 'fusuma/plugin/events/event.rb'
-
-module Fusuma
-  module Plugin
-    module Parsers
-      # parse libinput and generate event
-      class ThumbsenseParser < Parser
-        DEFAULT_SOURCE = "libinput_command_input"
-
-        #    ... event7  - button state: touch 3 from BUTTON_STATE_AREA    event BUTTON_EVENT_UP          to BUTTON_STATE_NONE
-        # 10766: event7  - button state: touch 1 from BUTTON_STATE_AREA    event BUTTON_EVENT_UP          to BUTTON_STATE_NONE
-        # 10768: event7  - button state: touch 0 from BUTTON_STATE_AREA    event BUTTON_EVENT_UP          to BUTTON_STATE_NONE
-
-        # @param record [String]
-        # @return [Records::Gesture, nil]
-        def parse_record(record)
-          gesture = "touch"
-
-          case record.to_s
-
-          # touched
-          when %r{\sevent\d+\s+-\sbutton state: touch (?<finger>[[:digit:]]) from BUTTON_STATE_NONE}
-            status = "begin"
-            finger = $~[:finger].to_i + 1
-          # released
-          when %r{\sevent\d+\s+-\sbutton state: touch (?<finger>[[:digit:]]) .* to BUTTON_STATE_NONE}
-            status = "end"
-            finger = $~[:finger].to_i + 1
-
-          # palm
-          when %r{\sevent\d+\s+-\spalm: touch (?<finger>[[:digit:]]) .*}
-            status = "palm"
-            finger = $~[:finger].to_i + 1
-          else
-            return
-          end
-
-          Events::Records::GestureRecord.new(status: status, gesture: gesture, finger: finger, delta: nil)
-        end
-
-        def tag
-          "thumbsense_parser"
-        end
-      end
-    end
-  end
-end