feat: source event and triggers

Author: jialeicui

README.md

@@ -0,0 +1,71 @@
+# KeySwift
+
+KeySwift is a keyboard remapping tool designed for Linux gnome desktop environments. It allows you to customize keyboard mappings for different applications, enhancing your productivity and typing experience.
+
+## Features
+
+- **Application-specific remapping**: Define custom keyboard mappings for specific applications
+- **Flexible configuration**: Simple and intuitive configuration format
+
+## Installation
+
+Download the latest release from the [Releases](https://github.com/jialeicui/keyswift/releases) page.
+
+Or install from source:
+
+```bash
+git clone https://github.com/jialeicui/keyswift.git
+cd keyswift
+make install
+```
+
+## Configuration
+
+Create a configuration file at `~/.config/keyswift/config.yml`. Here's an example:
+
+```yaml
+# yaml-language-server: $schema=schema.json
+# KeySwift Configuration File
+
+mode_actions:
+  default:
+    if: "true"
+    triggers:
+      - source_event:
+          key_press_event:
+            key: "esc"
+        action:
+          set_value:
+            normal: true
+      - source_event:
+          window_focus_event:
+            window_class:
+              - kitty
+        action:
+          set_value:
+            terminal: true
+  normal:
+    if: normal
+    triggers:
+      - source_event:
+          key_press_event:
+            key: "j"
+        action:
+          map_to_keys:
+            keys:
+              - key: "down"
+```
+
+## Acknowledgments
+
+KeySwift was inspired by several excellent projects:
+
+- [xremap](https://github.com/xremap/xremap): A key remapper for X11 and Wayland
+- [kmonad](https://github.com/kmonad/kmonad): An advanced keyboard manager with powerful customization features
+- [autokey](https://github.com/autokey/autokey): A desktop automation utility for Linux
+
+Thank you to the maintainers of these projects for your contributions to open-source keyboard customization tools!
+
+## Getting Help
+
+If you encounter any issues or have questions, please [open an issue](https://github.com/jialeicui/keyswift/issues) on the GitHub repository.

cmd/keyswift/main.go

@@ -3,79 +3,285 @@ package main
 import (
 	"flag"
 	"fmt"
-	"log"
+	"os"
+	"os/signal"
 	"strings"
+	"sync"
+	"syscall"
 
 	"github.com/jialeicui/golibevdev"
 	"github.com/samber/lo"
+	log "github.com/sirupsen/logrus"
 
 	"github.com/jialeicui/keyswift/pkg/conf"
 	"github.com/jialeicui/keyswift/pkg/evdev"
 	"github.com/jialeicui/keyswift/pkg/keys"
-	"github.com/jialeicui/keyswift/pkg/wininfo"
+	"github.com/jialeicui/keyswift/pkg/mode"
 	"github.com/jialeicui/keyswift/pkg/wininfo/dbus"
 )
 
 var (
-	flagKeyboard = flag.String("keyboard", "Apple", "")
+	flagKeyboards = flag.String("keyboards", "keyboard", "Comma-separated list of keyboard device name substrings")
+	flagConfig    = flag.String("config", "", "Configuration file path (defaults to $XDG_CONFIG_HOME/keyswift/config.yaml)")
+	// TODO change this to false
+	flagVerbose = flag.Bool("verbose", true, "Enable verbose logging")
 )
 
-func main() {
-	c, err := conf.LoadConfig(conf.DefaultConfigPath())
-	if err != nil {
-		log.Fatal(err)
-	}
+// InputDevice represents a grabbed input device
+type InputDevice struct {
+	Device *golibevdev.InputDev
+	Name   string
+	Path   string
+}
 
-	fmt.Printf("Loaded config: %+v\n", c)
+// InputDeviceManager manages multiple input devices
+type InputDeviceManager struct {
+	devices []*InputDevice
+	wg      sync.WaitGroup
+}
+
+// NewInputDeviceManager creates a new input device manager
+func NewInputDeviceManager() *InputDeviceManager {
+	return &InputDeviceManager{
+		devices: make([]*InputDevice, 0),
+	}
+}
 
-	r, err := dbus.New()
+// AddDevice adds and grabs a new input device
+func (m *InputDeviceManager) AddDevice(name, path string) error {
+	dev, err := golibevdev.NewInputDev(path)
 	if err != nil {
-		log.Fatal(err)
+		return fmt.Errorf("failed to open input device %s: %w", path, err)
 	}
-	defer r.Close()
 
-	fmt.Println("Window Monitor service is running...")
+	if err = dev.Grab(); err != nil {
+		dev.Close()
+		return fmt.Errorf("failed to grab input device %s: %w", path, err)
+	}
 
-	r.OnActiveWindowChange(func(info *wininfo.WinInfo) {
-		fmt.Printf("Active window: %s - %s\n", info.Title, info.Class)
+	m.devices = append(m.devices, &InputDevice{
+		Device: dev,
+		Name:   name,
+		Path:   path,
 	})
+	return nil
+}
 
-	devs, err := evdev.NewOverviewImpl().ListInputDevices()
+// ProcessEvents starts processing events from all devices
+func (m *InputDeviceManager) ProcessEvents(virtualKeyboard *golibevdev.UInputDev, modeManager *mode.Manager) {
+	for _, dev := range m.devices {
+		m.wg.Add(1)
+		go func(d *InputDevice) {
+			defer m.wg.Done()
+			m.processDeviceEvents(d, virtualKeyboard, modeManager)
+		}(dev)
+	}
+}
+
+// processDeviceEvents processes events from a single device
+func (m *InputDeviceManager) processDeviceEvents(dev *InputDevice, virtualKeyboard *golibevdev.UInputDev, modeManager *mode.Manager) {
+	log.Infof("Starting event processing for device: %s", dev.Name)
+	for {
+		ev, err := dev.Device.NextEvent(golibevdev.ReadFlagNormal)
+		if err != nil {
+			log.Errorf("Error reading from device %s: %v", dev.Name, err)
+			return
+		}
+
+		log.Debugf("[%s] Received event: %+v", dev.Name, ev)
+
+		var handled bool
+		if ev.Type == golibevdev.EvKey {
+			// Convert to our event type
+			event := &mode.Event{
+				KeyPress: &mode.KeyPressEvent{
+					Key:      keyCodeToString(ev.Code.(golibevdev.KeyEventCode)),
+					Pressed:  ev.Value == 1,
+					Repeated: ev.Value == 2,
+				},
+			}
+			log.Debugf("[%s] Event: %+v", dev.Name, event.KeyPress)
+
+			// Process the event through the mode manager
+			handled, err = modeManager.ProcessEvent(event)
+			if err != nil {
+				log.Errorf("[%s] Error processing event: %v", dev.Name, err)
+				continue
+			}
+		}
+		// If the event wasn't handled by any mode, pass it through directly
+		if !handled {
+			log.Debugf("[%s] Passing through unhandled event: %+v", dev.Name, ev)
+			// Directly send the original key event to the output device
+			virtualKeyboard.WriteEvent(ev.Type, ev.Code, ev.Value)
+		}
+		log.Debug("--------------------")
+	}
+}
+
+// Wait waits for all event processing to complete
+func (m *InputDeviceManager) Wait() {
+	m.wg.Wait()
+}
+
+// Close closes all input devices
+func (m *InputDeviceManager) Close() {
+	for _, dev := range m.devices {
+		log.Infof("Closing device: %s", dev.Name)
+		dev.Device.Close()
+	}
+}
+
+func main() {
+	flag.Parse()
+
+	if *flagVerbose {
+		log.SetLevel(log.DebugLevel)
+	}
+
+	// Load configuration
+	configPath := *flagConfig
+	if configPath == "" {
+		configPath = conf.DefaultConfigPath()
+	}
+
+	c, err := conf.Load(configPath)
 	if err != nil {
 		log.Fatal(err)
 	}
+	fmt.Printf("Loaded config from %s\n", configPath)
 
-	dev, ok := lo.Find(devs, func(item *evdev.InputDevice) bool {
-		return strings.Contains(item.Name, *flagKeyboard)
-	})
-	if !ok {
-		log.Fatalf("Keyboard %s not found", *flagKeyboard)
+	// Initialize window info service
+	windowMonitor, err := dbus.New()
+	if err != nil {
+		log.Fatal(err)
 	}
+	defer windowMonitor.Close()
+	fmt.Println("Window Monitor service is running...")
 
+	// Initialize virtual keyboard for output
 	out, err := golibevdev.NewVirtualKeyboard("keyswift")
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer out.Close()
+	gnomeKeys := keys.NewGnomeKeys(out)
+
+	// Initialize mode manager
+	modeManager, err := mode.NewManager(c, gnomeKeys, windowMonitor)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println("Mode manager initialized")
 
-	in, err := golibevdev.NewInputDev(dev.Path)
+	// Find input devices
+	devs, err := evdev.NewOverviewImpl().ListInputDevices()
 	if err != nil {
 		log.Fatal(err)
 	}
-	defer in.Close()
 
-	gnome := keys.NewGnomeKeys(out)
+	// Parse keyboard patterns and find matching devices
+	keyboardPatterns := strings.Split(*flagKeyboards, ",")
+	var matchedDevices []*evdev.InputDevice
 
-	for {
-		ev, err := in.NextEvent(golibevdev.ReadFlagNormal)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if ev.Type != golibevdev.EvKey {
+	for _, pattern := range keyboardPatterns {
+		pattern = strings.TrimSpace(pattern)
+		if pattern == "" {
 			continue
 		}
-		if ev.Code == golibevdev.KeyC {
-			gnome.Copy()
+
+		matches := lo.Filter(devs, func(item *evdev.InputDevice, _ int) bool {
+			return strings.Contains(item.Name, pattern)
+		})
+
+		matchedDevices = append(matchedDevices, matches...)
+	}
+
+	// Remove duplicates
+	matchedDevices = lo.UniqBy(matchedDevices, func(dev *evdev.InputDevice) string {
+		return dev.Path
+	})
+
+	if len(matchedDevices) == 0 {
+		fmt.Println("Available keyboards:")
+		for _, d := range devs {
+			fmt.Printf("  - %s\n", d.Name)
 		}
+		log.Fatalf("No keyboards matching patterns: %s", *flagKeyboards)
+	}
+
+	// Initialize and set up the device manager
+	deviceManager := NewInputDeviceManager()
+	defer deviceManager.Close()
+
+	// Add all matched devices to the manager
+	for _, dev := range matchedDevices {
+		fmt.Printf("Using keyboard: %s (%s)\n", dev.Name, dev.Path)
+		if err := deviceManager.AddDevice(dev.Name, dev.Path); err != nil {
+			log.Warnf("Failed to add device %s: %v", dev.Name, err)
+			continue
+		}
+	}
+
+	// Handle signals
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		<-sigChan
+		fmt.Println("Shutting down...")
+		deviceManager.Close()
+		out.Close()
+		windowMonitor.Close()
+		os.Exit(0)
+	}()
+
+	// Start processing events from all devices
+	fmt.Printf("Processing events from %d devices... Press Ctrl+C to exit\n", len(deviceManager.devices))
+	deviceManager.ProcessEvents(out, modeManager)
+
+	// Wait for all processing to complete (typically won't reach here except on error)
+	deviceManager.Wait()
+}
+
+// keyCodeToString converts a key code to a string representation
+// This is a simplified version - you'd want a complete mapping
+func keyCodeToString(code golibevdev.KeyEventCode) string {
+	// You'll need a complete mapping from golibevdev key codes to strings
+	// This is just a starting point
+	keyMap := map[golibevdev.KeyEventCode]string{
+		golibevdev.KeyEsc: "esc",
+		golibevdev.KeyA:   "a",
+		golibevdev.KeyB:   "b",
+		golibevdev.KeyC:   "c",
+		golibevdev.KeyD:   "d",
+		golibevdev.KeyE:   "e",
+		golibevdev.KeyF:   "f",
+		golibevdev.KeyG:   "g",
+		golibevdev.KeyH:   "h",
+		golibevdev.KeyI:   "i",
+		golibevdev.KeyJ:   "j",
+		golibevdev.KeyK:   "k",
+		golibevdev.KeyL:   "l",
+		golibevdev.KeyM:   "m",
+		golibevdev.KeyN:   "n",
+		golibevdev.KeyO:   "o",
+		golibevdev.KeyP:   "p",
+		golibevdev.KeyQ:   "q",
+		golibevdev.KeyR:   "r",
+		golibevdev.KeyS:   "s",
+		golibevdev.KeyT:   "t",
+		golibevdev.KeyU:   "u",
+		golibevdev.KeyV:   "v",
+		golibevdev.KeyW:   "w",
+		golibevdev.KeyX:   "x",
+		golibevdev.KeyY:   "y",
+		golibevdev.KeyZ:   "z",
+		// Add more keys as needed
+	}
+
+	if name, ok := keyMap[code]; ok {
+		return name
 	}
+	return code.String()
 }