ktemkin · September 30, 2020 23:19
diff --git a/vim_clutch.py b/vim_clutch.py
 #!/usr/bin/env python2.7
 # public domain-y, Kate Temkin, 2015

 import asyncore
 import evdev
 import signal
 import re

 #Stores the product names for each device which can be used as a vim-clutch.
 COMPATIBLE_NAME_REGEX = "RDing FootSwitch.*";

 #
 # Advanced "configuration"
 #

 def press_handler(output_device, input_device, event):
    """
        Pedal-press handler.
        This function is called whenever the VIM clutch-pedal is pushed.
    """

    send_keypress(output_device, 'KEY_ESC')
    send_keypress(output_device, 'KEY_I')


 def release_handler(output_device, input_device, event):
    """
        Pedal-release handler.
        This function is called whenever the VIM clutch-pedal is released.
    """
    send_keypress(output_device, 'KEY_ESC')


 #
 # Core code starts here; modify the text below only if you know what you're doing!
 #

 class ClutchEventDispatcher(asyncore.file_dispatcher):
    """
        Special event handler designed to process asynchronous input
        from a vim-clutch footpedal.
    """

    def __init__(self, device, press_handler, release_handler):
        """
            Initializes a new ClutchEventDispatcher, setting up a "listener" for
            foot-pedal events.
        """

        #Store an internal reference to the foot-pedal device.
        self.device = device

        #And store references to the press and release callbacks.
        self.press_handler = press_handler
        self.release_handler = release_handler

        #And request that asyncore listend for changes in the event "file".
        asyncore.file_dispatcher.__init__(self, device)


    def recv(self, ign=None):
        """
            Overloaded function which recieves events from the foot-pedal.
            Used by asyncore to check for asynchronous input events.
        """
        return self.device.read()


    def handle_read(self):
        """
            Event handler for a foot-pedal event.
        """

        #Handle each of the received events, in the order that they were received.
        for event in self.recv():
            if event.type == evdev.ecodes.EV_KEY:

                #Wrap the event in the appropriate class...
                event = evdev.categorize(event)

                #If the clutch has been depressed, call the press handler.
                if event.keystate == event.key_down:
                    self.press_handler(self.device, event)

                #Otherwise, call the release handler.
                elif event.keystate == event.key_up:
                    self.release_handler(self.device, event)




 def main():
    """
        Handles events for all keyboard devices.
    """

    #Create a virtual keyboard device, which will be used to _send_ the resultant key-presses.
    output_device = evdev.UInput(events=None, name='Vim-Clutch Foot-Pedal')

    #And get a list of all foot-pedal devices which should be monitored for events.
    input_devices = compatible_devices()

    #Create generic press and release handlers which are closed over the output device.
    press_callback = lambda input_device, event : press_handler(output_device, input_device, event)
    release_callback = lambda input_device, event : release_handler(output_device, input_device, event)

    #For each foot-pedal detected.
    for device in input_devices:

        #Attain sole ownership of the device, so its events don't populate back up to X.
        device.grab()

        #And register handlers for the device's events.
        ClutchEventDispatcher(device, press_callback, release_callback)

    #Add a handler which releases devices on SIGTERM.
    signal.signal(signal.SIGTERM, lambda : cleanup(output_device, input_devices))

    #And loop indefinitely, handling "asynchronous" press events.
    try:
        asyncore.loop()

    #Allow the program to be closed by CTRL+C.
    except KeyboardInterrupt:
        cleanup(output_device, input_devices)


 def compatible_devices():
    """
        Returns a list of compatible evdev devices.
    """

    #Get reference to each evdev device installed in the system.
    devices = [evdev.InputDevice(d) for d in evdev.list_devices()]

    #Filter the device list so it only includes clutch-compatible foot switches.
    return [d for d in devices if re.match(COMPATIBLE_NAME_REGEX, d.name)]



 def send_keypress(output_device, keycode):
    """
        Sends a key-down and key-up event in rapid succession.
    """

    #Send a key-down event, followed by a key-up event.
    output_device.write(evdev.ecodes.EV_KEY, evdev.ecodes.ecodes[keycode], 1)
    output_device.write(evdev.ecodes.EV_KEY, evdev.ecodes.ecodes[keycode], 0)

    #And send a synchronization signal
    output_device.syn()



 def cleanup(output_device, input_devices):
    """
        Cleans up all device ownerships on program close.
    """

    #Release each of the input devices...
    for device in input_devices:
        device.ungrab()

    #And close the virtual output device.
    output_device.close()




 main()
	#!/usr/bin/env python2.7
	# public domain-y, Kate Temkin, 2015

	import asyncore
	import evdev
	import signal
	import re

	#Stores the product names for each device which can be used as a vim-clutch.
	COMPATIBLE_NAME_REGEX = "RDing FootSwitch.*";

	#
	# Advanced "configuration"
	#

	def press_handler(output_device, input_device, event):
	"""
	Pedal-press handler.
	This function is called whenever the VIM clutch-pedal is pushed.
	"""

	send_keypress(output_device, 'KEY_ESC')
	send_keypress(output_device, 'KEY_I')


	def release_handler(output_device, input_device, event):
	"""
	Pedal-release handler.
	This function is called whenever the VIM clutch-pedal is released.
	"""
	send_keypress(output_device, 'KEY_ESC')


	#
	# Core code starts here; modify the text below only if you know what you're doing!
	#

	class ClutchEventDispatcher(asyncore.file_dispatcher):
	"""
	Special event handler designed to process asynchronous input
	from a vim-clutch footpedal.
	"""

	def __init__(self, device, press_handler, release_handler):
	"""
	Initializes a new ClutchEventDispatcher, setting up a "listener" for
	foot-pedal events.
	"""

	#Store an internal reference to the foot-pedal device.
	self.device = device

	#And store references to the press and release callbacks.
	self.press_handler = press_handler
	self.release_handler = release_handler

	#And request that asyncore listend for changes in the event "file".
	asyncore.file_dispatcher.__init__(self, device)


	def recv(self, ign=None):
	"""
	Overloaded function which recieves events from the foot-pedal.
	Used by asyncore to check for asynchronous input events.
	"""
	return self.device.read()


	def handle_read(self):
	"""
	Event handler for a foot-pedal event.
	"""

	#Handle each of the received events, in the order that they were received.
	for event in self.recv():
	if event.type == evdev.ecodes.EV_KEY:

	#Wrap the event in the appropriate class...
	event = evdev.categorize(event)

	#If the clutch has been depressed, call the press handler.
	if event.keystate == event.key_down:
	self.press_handler(self.device, event)

	#Otherwise, call the release handler.
	elif event.keystate == event.key_up:
	self.release_handler(self.device, event)




	def main():
	"""
	Handles events for all keyboard devices.
	"""

	#Create a virtual keyboard device, which will be used to _send_ the resultant key-presses.
	output_device = evdev.UInput(events=None, name='Vim-Clutch Foot-Pedal')

	#And get a list of all foot-pedal devices which should be monitored for events.
	input_devices = compatible_devices()

	#Create generic press and release handlers which are closed over the output device.
	press_callback = lambda input_device, event : press_handler(output_device, input_device, event)
	release_callback = lambda input_device, event : release_handler(output_device, input_device, event)

	#For each foot-pedal detected.
	for device in input_devices:

	#Attain sole ownership of the device, so its events don't populate back up to X.
	device.grab()

	#And register handlers for the device's events.
	ClutchEventDispatcher(device, press_callback, release_callback)

	#Add a handler which releases devices on SIGTERM.
	signal.signal(signal.SIGTERM, lambda : cleanup(output_device, input_devices))

	#And loop indefinitely, handling "asynchronous" press events.
	try:
	asyncore.loop()

	#Allow the program to be closed by CTRL+C.
	except KeyboardInterrupt:
	cleanup(output_device, input_devices)


	def compatible_devices():
	"""
	Returns a list of compatible evdev devices.
	"""

	#Get reference to each evdev device installed in the system.
	devices = [evdev.InputDevice(d) for d in evdev.list_devices()]

	#Filter the device list so it only includes clutch-compatible foot switches.
	return [d for d in devices if re.match(COMPATIBLE_NAME_REGEX, d.name)]



	def send_keypress(output_device, keycode):
	"""
	Sends a key-down and key-up event in rapid succession.
	"""

	#Send a key-down event, followed by a key-up event.
	output_device.write(evdev.ecodes.EV_KEY, evdev.ecodes.ecodes[keycode], 1)
	output_device.write(evdev.ecodes.EV_KEY, evdev.ecodes.ecodes[keycode], 0)

	#And send a synchronization signal
	output_device.syn()



	def cleanup(output_device, input_devices):
	"""
	Cleans up all device ownerships on program close.
	"""

	#Release each of the input devices...
	for device in input_devices:
	device.ungrab()

	#And close the virtual output device.
	output_device.close()




	main()