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

internal/config/make_rule_targets.go

@@ -48,6 +48,25 @@ func makeRuleTargetAxis(targetConfig RuleTargetConfig, devs map[string]*evdev.In
 	)
 }
 
+func makeRuleTargetRelaxis(targetConfig RuleTargetConfig, devs map[string]*evdev.InputDevice) (*mappingrules.RuleTargetRelaxis, error) {
+	device, ok := devs[targetConfig.Device]
+	if !ok {
+		return nil, fmt.Errorf("non-existent device '%s'", targetConfig.Device)
+	}
+
+	eventCode, ok := evdev.RELFromString[targetConfig.Axis]
+	if !ok {
+		return nil, fmt.Errorf("invalid button code '%s'", targetConfig.Button)
+	}
+
+	return mappingrules.NewRuleTargetRelaxis(
+		targetConfig.Device,
+		device,
+		eventCode,
+		targetConfig.Inverted,
+	)
+}
+
 func makeRuleTargetModeSelect(targetConfig RuleTargetConfig, allModes []string) (*mappingrules.RuleTargetModeSelect, error) {
 	if ok := validateModes(targetConfig.Modes, allModes); !ok {
 		return nil, errors.New("undefined mode in mode select list")

internal/config/make_rules.go

@@ -40,6 +40,8 @@ func (parser *ConfigParser) BuildRules(pDevs map[string]*evdev.InputDevice, vDev
 			newRule, err = makeMappingRuleAxis(ruleConfig, pDevs, vDevs, base)
 		case RuleTypeAxisToButton:
 			newRule, err = makeMappingRuleAxisToButton(ruleConfig, pDevs, vDevs, base)
+		case RuleTypeAxisToRelaxis:
+			newRule, err = makeMappingRuleAxisToRelaxis(ruleConfig, pDevs, vDevs, base)
 		case RuleTypeModeSelect:
 			newRule, err = makeMappingRuleModeSelect(ruleConfig, pDevs, modes, base)
 		default:
@@ -151,6 +153,28 @@ func makeMappingRuleAxisToButton(ruleConfig RuleConfig,
 	return mappingrules.NewMappingRuleAxisToButton(base, input, output, ruleConfig.RepeatRateMin, ruleConfig.RepeatRateMax), nil
 }
 
+func makeMappingRuleAxisToRelaxis(ruleConfig RuleConfig,
+	pDevs map[string]*evdev.InputDevice,
+	vDevs map[string]*evdev.InputDevice,
+	base mappingrules.MappingRuleBase) (*mappingrules.MappingRuleAxisToRelaxis, error) {
+
+	input, err := makeRuleTargetAxis(ruleConfig.Input, pDevs)
+	if err != nil {
+		return nil, err
+	}
+
+	output, err := makeRuleTargetRelaxis(ruleConfig.Output, vDevs)
+	if err != nil {
+		return nil, err
+	}
+
+	return mappingrules.NewMappingRuleAxisToRelaxis(base,
+		input, output,
+		ruleConfig.RepeatRateMin,
+		ruleConfig.RepeatRateMax,
+		ruleConfig.Increment), nil
+}
+
 func makeMappingRuleModeSelect(ruleConfig RuleConfig,
 	pDevs map[string]*evdev.InputDevice,
 	modes []string,

internal/config/schema.go

@@ -1,5 +1,11 @@
 // These types comprise the YAML schema for configuring Joyful.
 // The config files will be combined and then unmarshalled into this
+//
+// TODO: currently the types in here aren't especially strong; each one is
+// decomposed into a different object based on the Type fields. We should implement
+// some sort of delayed unmarshalling technique, for example see ideas at
+// https://stackoverflow.com/questions/70635636/unmarshaling-yaml-into-different-struct-based-off-yaml-field
+// Then we can be more explicit about the interface here.
 
 package config
 
@@ -27,14 +33,15 @@ type RuleConfig struct {
 	Modes         []string           `yaml:"modes,omitempty"`
 	RepeatRateMin int                `yaml:"repeat_rate_min,omitempty"`
 	RepeatRateMax int                `yaml:"repeat_rate_max,omitempty"`
+	Increment     int                `yaml:"increment,omitempty"`
 }
 
 type RuleTargetConfig struct {
 	Device        string   `yaml:"device,omitempty"`
 	Button        string   `yaml:"button,omitempty"`
 	Axis          string   `yaml:"axis,omitempty"`
-	DeadzoneStart int32    `yaml:"axis_start,omitempty"`
-	DeadzoneEnd   int32    `yaml:"axis_end,omitempty"`
+	DeadzoneStart int32    `yaml:"deadzone_start,omitempty"`
+	DeadzoneEnd   int32    `yaml:"deadzone_end,omitempty"`
 	Inverted      bool     `yaml:"inverted,omitempty"`
 	Modes         []string `yaml:"modes,omitempty"`
 }

internal/config/variables.go

@@ -8,12 +8,13 @@ const (
 	DeviceTypePhysical = "physical"
 	DeviceTypeVirtual  = "virtual"
 
-	RuleTypeButton       = "button"
-	RuleTypeButtonCombo  = "button-combo"
-	RuleTypeLatched      = "button-latched"
-	RuleTypeAxis         = "axis"
-	RuleTypeModeSelect   = "mode-select"
-	RuleTypeAxisToButton = "axis-to-button"
+	RuleTypeButton        = "button"
+	RuleTypeButtonCombo   = "button-combo"
+	RuleTypeLatched       = "button-latched"
+	RuleTypeAxis          = "axis"
+	RuleTypeModeSelect    = "mode-select"
+	RuleTypeAxisToButton  = "axis-to-button"
+	RuleTypeAxisToRelaxis = "axis-to-relaxis"
 )
 
 var (