package mappingrules import ( "slices" "time" "github.com/holoplot/go-evdev" ) type MappingRuleBase struct { Name string Output RuleTarget Modes []string } // A Simple Mapping Rule can map a button to a button or an axis to an axis. type MappingRuleSimple struct { MappingRuleBase Input RuleTarget } // A Combo Mapping Rule can require multiple physical button presses for a single output button type MappingRuleCombo struct { MappingRuleBase Inputs []RuleTarget State int } type MappingRuleLatched struct { MappingRuleBase Input RuleTarget State bool } // TODO: How are we going to implement this? It needs to operate on a timer... type MappingRuleProportionalAxis struct { MappingRuleBase Input *RuleTargetAxis Output *RuleTargetButton Sensitivity int32 LastValue int32 LastEvent time.Time } func (rule *MappingRuleBase) OutputName() string { return rule.Output.GetDeviceName() } func (rule *MappingRuleBase) modeCheck(mode *string) bool { if rule.Modes[0] == "*" { return true } return slices.Contains(rule.Modes, *mode) } func (rule *MappingRuleSimple) MatchEvent(device *evdev.InputDevice, event *evdev.InputEvent, mode *string) *evdev.InputEvent { if !rule.MappingRuleBase.modeCheck(mode) { return nil } if device != rule.Input.GetDevice() || event.Code != rule.Input.GetCode() { return nil } return rule.Output.CreateEvent(rule.Input.NormalizeValue(event.Value), mode) } func (rule *MappingRuleCombo) MatchEvent(device *evdev.InputDevice, event *evdev.InputEvent, mode *string) *evdev.InputEvent { if !rule.MappingRuleBase.modeCheck(mode) { return nil } // Check each of the inputs, and if we find a match, proceed var match RuleTarget for _, input := range rule.Inputs { if device == input.GetDevice() && event.Code == input.GetCode() { match = input } } if match == nil { return nil } // Get the value and add/subtract it from State inputValue := match.NormalizeValue(event.Value) oldState := rule.State if inputValue == 0 { rule.State = max(rule.State-1, 0) } if inputValue == 1 { rule.State++ } targetState := len(rule.Inputs) if oldState == targetState-1 && rule.State == targetState { return rule.Output.CreateEvent(1, mode) } if oldState == targetState && rule.State == targetState-1 { return rule.Output.CreateEvent(0, mode) } return nil } func (rule *MappingRuleLatched) MatchEvent(device *evdev.InputDevice, event *evdev.InputEvent, mode *string) *evdev.InputEvent { if !rule.MappingRuleBase.modeCheck(mode) { return nil } if device != rule.Input.GetDevice() || event.Code != rule.Input.GetCode() || rule.Input.NormalizeValue(event.Value) == 0 { return nil } // Input is pressed, so toggle state and emit event var value int32 rule.State = !rule.State if rule.State { value = 1 } else { value = 0 } return rule.Output.CreateEvent(value, mode) } func (rule *MappingRuleProportionalAxis) MatchEvent(device *evdev.InputDevice, event *evdev.InputEvent, mode *string) *evdev.InputEvent { if !rule.MappingRuleBase.modeCheck(mode) { return nil } if device != rule.Input.GetDevice() || event.Code != rule.Input.GetCode() { return nil } // set the last value to the normalized input value rule.LastValue = rule.Input.NormalizeValue(event.Value) return nil } // TimerEvent returns an event when enough time has passed (compared to the last recorded axis value) // to emit an event. func (rule *MappingRuleProportionalAxis) TimerEvent() *evdev.InputEvent { // This is tighter coupling than we'd like, but it will do for now. // TODO: maybe it would be better to just be more declarative about event types and their inputs and outputs. if rule.LastValue < rule.Input.AxisStart { rule.LastEvent = time.Now() return nil } // calculate target time until next event press // nextEvent := rule.LastEvent + (rule.LastValue) // TODO: figure out what the condition should be if false { // TODO: emit event rule.LastEvent = time.Now() } return nil }