typer_controller.py

import time
import threading
import sys
import pyperclip
import subprocess
import os

# Conditional imports for cross-platform support
try:
    if sys.platform.startswith('linux'):
        import evdev
        from evdev import ecodes
    else:
        evdev = None
except ImportError:
    evdev = None

try:
    from pynput import keyboard
    from pynput.keyboard import Key, Controller
except ImportError:
    keyboard = None

# Known terminal emulator WM_CLASS values (lowercase)
TERMINAL_WM_CLASSES = {
    "gnome-terminal", "gnome-terminal-server", "konsole", "xfce4-terminal",
    "lxterminal", "urxvt", "xterm", "rxvt", "alacritty", "kitty", "wezterm",
    "foot", "footclient", "st", "st-256color", "termite", "terminator",
    "tilix", "guake", "tilda", "yakuake", "cool-retro-term", "hyper",
    "iterm2", "windows-terminal", "tabby", "warp", "rio", "ghostty",
}

class TyperController:
    def __init__(self, on_press_callback, on_release_callback, hotkey="KEY_RIGHTALT", mode="hold", paste_method="auto"):
        self.on_press_callback = on_press_callback
        self.on_release_callback = on_release_callback
        self.mode = mode
        self.is_active = False
        self.hotkey_str = hotkey
        self.paste_method = paste_method
        
        # Keyboard controller for typing (pynput is good for this everywhere)
        self.controller = Controller() if keyboard else None
        
        # State for listener
        self.running = False
        self.threads = []
        
        # Map keys for different platforms
        self._setup_platform_mapping()

    def _setup_platform_mapping(self):
        if not hasattr(self, 'uinput'):
            self.uinput = None
            
        if sys.platform.startswith('linux') and evdev:
            # Linux (evdev for reliable global hotkeys on Wayland/X11)
            self.trigger_code = getattr(ecodes, self.hotkey_str, ecodes.KEY_RIGHTALT)
            self.use_evdev = True
            if self.uinput is None:
                try:
                    self.uinput = evdev.UInput()
                except Exception as e:
                    print(f"Could not create UInput: {e}")
        else:
            # Windows/Mac (pynput)
            mapping = {
                "KEY_RIGHTALT": [Key.alt_gr, Key.alt_r],
                "KEY_LEFTCTRL": [Key.ctrl_l],
                "KEY_RIGHTCTRL": [Key.ctrl_r],
                "KEY_SPACE": [Key.space],
                "KEY_CAPSLOCK": [Key.caps_lock],
                "KEY_F10": [Key.f10]
            }
            self.target_keys = mapping.get(self.hotkey_str, [Key.alt_gr])
            self.use_evdev = False

    def _is_terminal_focused(self):
        if sys.platform != "linux":
            return None

        wm_class = None

        # Try X11 method first
        if "DISPLAY" in os.environ:
            try:
                result = subprocess.run(
                    ["xdotool", "getactivewindow"],
                    capture_output=True, text=True, timeout=1
                )
                if result.returncode == 0:
                    wid = result.stdout.strip()
                    result = subprocess.run(
                        ["xprop", "-id", wid, "WM_CLASS"],
                        capture_output=True, text=True, timeout=1
                    )
                    if result.returncode == 0 and result.stdout.strip():
                        # WM_CLASS format: "instance", "class"
                        parts = result.stdout.strip().split('"')
                        if len(parts) >= 4:
                            wm_class = parts[3].lower()
            except (FileNotFoundError, subprocess.TimeoutExpired):
                pass

        # Wayland: try GNOME Shell via D-Bus
        if wm_class is None:
            try:
                result = subprocess.run(
                    ["gdbus", "call", "--session", "--dest", "org.gnome.Shell",
                     "--object-path", "/org/gnome/Shell",
                     "--method", "org.gnome.Shell.Introspect.GetWindows"],
                    capture_output=True, text=True, timeout=2
                )
                if result.returncode == 0:
                    # Crude extraction — look for wm_class in the output
                    import re
                    matches = re.findall(r'"wm_class"\s*:\s*"([^"]+)"', result.stdout)
                    if matches:
                        wm_class = matches[0].lower()
            except (FileNotFoundError, subprocess.TimeoutExpired):
                pass

        # Wayland: try KDE KWin via D-Bus
        if wm_class is None:
            try:
                result = subprocess.run(
                    ["qdbus", "org.kde.KWin", "/KWin", "org.kde.KWin.getActiveWindow"],
                    capture_output=True, text=True, timeout=2
                )
                if result.returncode == 0 and result.stdout.strip():
                    # KWin returns a window ID; use xprop on it if XWayland
                    wid = result.stdout.strip()
                    if "DISPLAY" in os.environ:
                        result = subprocess.run(
                            ["xprop", "-id", wid, "WM_CLASS"],
                            capture_output=True, text=True, timeout=1
                        )
                        if result.returncode == 0:
                            parts = result.stdout.strip().split('"')
                            if len(parts) >= 4:
                                wm_class = parts[3].lower()
            except (FileNotFoundError, subprocess.TimeoutExpired):
                pass

        if wm_class is None:
            return None

        return wm_class in TERMINAL_WM_CLASSES

    def update_settings(self, hotkey, mode, paste_method=None):
        self.hotkey_str = hotkey
        self.mode = mode
        self.is_active = False
        if paste_method is not None:
            self.paste_method = paste_method
        self._setup_platform_mapping()

    def start_listening(self):
        self.running = True
        if self.use_evdev:
            self._start_evdev_listening()
        else:
            self._start_pynput_listening()

    def stop_listening(self):
        self.running = False
        if hasattr(self, 'pynput_listener') and self.pynput_listener:
            self.pynput_listener.stop()
            self.pynput_listener = None
        
        # Evdev threads will exit on self.running = False
        self.threads = []

    # --- Linux (evdev) Implementation ---
    def _start_evdev_listening(self):
        kbd_devices = []
        try:
            devices = [evdev.InputDevice(path) for path in evdev.list_devices()]
            for device in devices:
                if ecodes.EV_KEY in device.capabilities():
                    kbd_devices.append(device)
        except: pass
        
        if not kbd_devices:
            print("No keyboard devices found for evdev. Falling back to pynput.")
            self.use_evdev = False
            self._start_pynput_listening()
            return

        for device in kbd_devices:
            t = threading.Thread(target=self._evdev_loop, args=(device,), daemon=True)
            t.start()
            self.threads.append(t)

    def _evdev_loop(self, device):
        try:
            for event in device.read_loop():
                if not self.running: break
                if event.type == ecodes.EV_KEY and event.code == self.trigger_code:
                    if event.value == 1: # Press
                        if self.mode == "hold":
                            if not self.is_active:
                                self.is_active = True
                                self.on_press_callback()
                        else: # toggle
                            if not self.is_active:
                                self.is_active = True
                                self.on_press_callback()
                            else:
                                self.is_active = False
                                self.on_release_callback()
                    elif event.value == 0: # Release
                        if self.mode == "hold" and self.is_active:
                            self.is_active = False
                            self.on_release_callback()
        except: pass

    # --- Windows/Mac (pynput) Implementation ---
    def _start_pynput_listening(self):
        if not keyboard: return
        self.pynput_listener = keyboard.Listener(
            on_press=self._on_pynput_press, 
            on_release=self._on_pynput_release
        )
        self.pynput_listener.start()

    def _on_pynput_press(self, key):
        if key in self.target_keys:
            if self.mode == "hold":
                if not self.is_active:
                    self.is_active = True
                    self.on_press_callback()
            else: # toggle
                if not self.is_active:
                    self.is_active = True
                    self.on_press_callback()
                else:
                    self.is_active = False
                    self.on_release_callback()

    def _on_pynput_release(self, key):
        if key in self.target_keys:
            if self.mode == "hold" and self.is_active:
                self.is_active = False
                self.on_release_callback()

    # --- Typing Implementation (Cross-platform bridge) ---
    def _key_event(self, code, value):
        self.uinput.write(ecodes.EV_KEY, code, value)
        self.uinput.syn()
        time.sleep(0.03)

    def _paste_ctrl_v(self):
        if self.use_evdev and hasattr(self, 'uinput') and self.uinput:
            self._key_event(ecodes.KEY_LEFTCTRL, 1)
            self._key_event(ecodes.KEY_V, 1)
            self._key_event(ecodes.KEY_V, 0)
            self._key_event(ecodes.KEY_LEFTCTRL, 0)
        else:
            modifier = Key.cmd if sys.platform == 'darwin' else Key.ctrl
            with self.controller.pressed(modifier):
                self.controller.press('v')
                self.controller.release('v')

    def _paste_ctrl_shift_v(self):
        if self.use_evdev and hasattr(self, 'uinput') and self.uinput:
            self._key_event(ecodes.KEY_LEFTCTRL, 1)
            self._key_event(ecodes.KEY_LEFTSHIFT, 1)
            self._key_event(ecodes.KEY_V, 1)
            self._key_event(ecodes.KEY_V, 0)
            self._key_event(ecodes.KEY_LEFTSHIFT, 0)
            self._key_event(ecodes.KEY_LEFTCTRL, 0)
        else:
            modifier = Key.cmd if sys.platform == 'darwin' else Key.ctrl
            with self.controller.pressed(modifier):
                with self.controller.pressed(Key.shift):
                    self.controller.press('v')
                    self.controller.release('v')

    def type_text(self, text):
        if not text: return
        time.sleep(0.2)
        try:
            pyperclip.copy(text + " ")

            method = self.paste_method
            if method == "auto":
                is_terminal = self._is_terminal_focused()
                if is_terminal is None:
                    method = "ctrl_v"
                elif is_terminal:
                    method = "ctrl_shift_v"
                else:
                    method = "ctrl_v"

            if method == "ctrl_shift_v":
                self._paste_ctrl_shift_v()
            else:
                self._paste_ctrl_v()
        except Exception as e:
            print(f"Typing error: {e}")