(WIP) Implement axis-to-relaxis repeats; similar to buttons but for discretized relative axis inputs. (i.e. mousewheel)

internal/mappingrules/interfaces.go

@@ -1,11 +1,20 @@
 package mappingrules
 
-import "github.com/holoplot/go-evdev"
+import (
+	"time"
+
+	"github.com/holoplot/go-evdev"
+)
 
 type MappingRule interface {
 	MatchEvent(RuleTargetDevice, *evdev.InputEvent, *string) (*evdev.InputDevice, *evdev.InputEvent)
 }
 
+type TimedEventEmitter interface {
+	TimerEvent() *evdev.InputEvent
+	GetOutputDevice() *evdev.InputDevice
+}
+
 // RuleTargets represent either a device input to match on, or an output to produce.
 // Some RuleTarget types may work via side effects, such as RuleTargetModeSelect.
 type RuleTarget interface {
@@ -39,4 +48,5 @@ type RuleTargetDevice interface {
 const (
 	AxisValueMin = int32(-32768)
 	AxisValueMax = int32(32767)
+	NoNextEvent  = time.Duration(-1)
 )

internal/mappingrules/mapping_rule_axis_to_button.go

@@ -19,10 +19,6 @@ type MappingRuleAxisToButton struct {
 	pressed       bool
 }
 
-const (
-	NoNextEvent = time.Duration(-1)
-)
-
 func NewMappingRuleAxisToButton(base MappingRuleBase, input *RuleTargetAxis, output *RuleTargetButton, repeatRateMin, repeatRateMax int) *MappingRuleAxisToButton {
 	return &MappingRuleAxisToButton{
 		MappingRuleBase: base,
@@ -50,6 +46,7 @@ func (rule *MappingRuleAxisToButton) MatchEvent(device RuleTargetDevice, event *
 	}
 
 	// If we aren't repeating, we trigger the event immediately
+	// TODO: we aren't using pressed correctly; that should be set *and released* in here...
 	if rule.RepeatRateMin == 0 || rule.RepeatRateMax == 0 {
 		rule.nextEvent = time.Millisecond
 		return nil, nil
@@ -73,7 +70,7 @@ func (rule *MappingRuleAxisToButton) TimerEvent() *evdev.InputEvent {
 	}
 
 	// This indicates that we should not emit another event
-	if rule.nextEvent == -1 {
+	if rule.nextEvent == NoNextEvent {
 		rule.lastEvent = time.Now()
 		return nil
 	}
@@ -86,3 +83,7 @@ func (rule *MappingRuleAxisToButton) TimerEvent() *evdev.InputEvent {
 
 	return nil
 }
+
+func (rule *MappingRuleAxisToButton) GetOutputDevice() *evdev.InputDevice {
+	return rule.Output.Device
+}

internal/mappingrules/mapping_rule_axis_to_relaxis.go

@@ -0,0 +1,98 @@
+package mappingrules
+
+import (
+	"time"
+
+	"git.annabunches.net/annabunches/joyful/internal/logger"
+	"github.com/holoplot/go-evdev"
+)
+
+// TODO: add tests
+
+// TODO: deadzones seem to calculate correctly in one direction but not the other when computing axis strength...
+
+// MappingRuleAxisToRelaxis represents a rule that converts an axis input into a (potentially repeating)
+// button output.
+type MappingRuleAxisToRelaxis struct {
+	MappingRuleBase
+	Input         *RuleTargetAxis
+	Output        *RuleTargetRelaxis
+	RepeatRateMin int
+	RepeatRateMax int
+	Increment     int32
+	nextEvent     time.Duration
+	lastEvent     time.Time
+}
+
+func NewMappingRuleAxisToRelaxis(
+	base MappingRuleBase,
+	input *RuleTargetAxis,
+	output *RuleTargetRelaxis,
+	repeatRateMin, repeatRateMax, increment int) *MappingRuleAxisToRelaxis {
+
+	return &MappingRuleAxisToRelaxis{
+		MappingRuleBase: base,
+		Input:           input,
+		Output:          output,
+		RepeatRateMin:   repeatRateMin,
+		RepeatRateMax:   repeatRateMax,
+		Increment:       int32(increment),
+		lastEvent:       time.Now(),
+		nextEvent:       NoNextEvent,
+	}
+}
+
+func (rule *MappingRuleAxisToRelaxis) MatchEvent(
+	device RuleTargetDevice,
+	event *evdev.InputEvent,
+	mode *string) (*evdev.InputDevice, *evdev.InputEvent) {
+
+	if !rule.MappingRuleBase.modeCheck(mode) ||
+		!rule.Input.MatchEventDeviceAndCode(device, event) {
+		return nil, nil
+	}
+
+	defer func() {
+		logger.Logf("DEBUG: Rule '%s' nextEvent == '%v' with device value '%d'", rule.Name, rule.nextEvent, event.Value)
+	}()
+
+	// If we're inside the deadzone, unset the next event
+	if rule.Input.InDeadZone(event.Value) {
+		rule.nextEvent = NoNextEvent
+		return nil, nil
+	}
+
+	// If we aren't repeating, we trigger the event immediately
+	// TODO: this still needs the pressed parameter...
+	if rule.RepeatRateMin == 0 || rule.RepeatRateMax == 0 {
+		rule.nextEvent = time.Millisecond
+		return nil, nil
+	}
+
+	// use the axis value and the repeat rate to set a target time until the next event
+	strength := 1.0 - rule.Input.GetAxisStrength(event.Value)
+	rate := int64(LerpInt(rule.RepeatRateMax, rule.RepeatRateMin, strength))
+	rule.nextEvent = time.Duration(rate * int64(time.Millisecond))
+	return nil, nil
+}
+
+// TimerEvent returns an event when enough time has passed (compared to the last recorded axis value)
+// to emit an event.
+func (rule *MappingRuleAxisToRelaxis) TimerEvent() *evdev.InputEvent {
+	// This indicates that we should not emit another event
+	if rule.nextEvent == NoNextEvent {
+		rule.lastEvent = time.Now()
+		return nil
+	}
+
+	if time.Now().Compare(rule.lastEvent.Add(rule.nextEvent)) > -1 {
+		rule.lastEvent = time.Now()
+		return rule.Output.CreateEvent(rule.Increment, nil)
+	}
+
+	return nil
+}
+
+func (rule *MappingRuleAxisToRelaxis) GetOutputDevice() *evdev.InputDevice {
+	return rule.Output.Device.(*evdev.InputDevice)
+}

internal/mappingrules/rule_target_relaxis.go

@@ -0,0 +1,46 @@
+package mappingrules
+
+import (
+	"github.com/holoplot/go-evdev"
+)
+
+type RuleTargetRelaxis struct {
+	DeviceName string
+	Device     RuleTargetDevice
+	Axis       evdev.EvCode
+	Inverted   bool
+}
+
+func NewRuleTargetRelaxis(device_name string,
+	device RuleTargetDevice,
+	axis evdev.EvCode,
+	inverted bool) (*RuleTargetRelaxis, error) {
+
+	return &RuleTargetRelaxis{
+		DeviceName: device_name,
+		Device:     device,
+		Axis:       axis,
+		Inverted:   inverted,
+	}, nil
+}
+
+// NormalizeValue takes a raw input value and converts it to a value suitable for output.
+//
+// Relative axes are currently only supported for output.
+// TODO: make this have an error return?
+func (target *RuleTargetRelaxis) NormalizeValue(value int32) int32 {
+	return 0
+}
+
+func (target *RuleTargetRelaxis) CreateEvent(value int32, mode *string) *evdev.InputEvent {
+	return &evdev.InputEvent{
+		Type:  evdev.EV_REL,
+		Code:  target.Axis,
+		Value: value,
+	}
+}
+
+// Relative axis is only supported for output.
+func (target *RuleTargetRelaxis) MatchEvent(device RuleTargetDevice, event *evdev.InputEvent) bool {
+	return false
+}