Anna Rose Wiggins
8d2b15a7c8
Reviewed-on: #17 Co-authored-by: Anna Rose Wiggins <annabunches@gmail.com> Co-committed-by: Anna Rose Wiggins <annabunches@gmail.com>
104 lines
3 KiB
Go
104 lines
3 KiB
Go
package mappingrules
|
|
|
|
import (
|
|
"time"
|
|
|
|
"git.annabunches.net/annabunches/joyful/internal/configparser"
|
|
"github.com/holoplot/go-evdev"
|
|
"github.com/jonboulle/clockwork"
|
|
)
|
|
|
|
// TODO: add tests
|
|
|
|
// MappingRuleAxisToRelaxis represents a rule that converts an axis input into a (potentially repeating)
|
|
// relative axis output. This is most commonly used to generate mouse output events
|
|
type MappingRuleAxisToRelaxis struct {
|
|
MappingRuleBase
|
|
Input *RuleTargetAxis
|
|
Output *RuleTargetRelaxis
|
|
RepeatRateMin int
|
|
RepeatRateMax int
|
|
Increment int32
|
|
nextEvent time.Duration
|
|
lastEvent time.Time
|
|
clock clockwork.Clock
|
|
}
|
|
|
|
func NewMappingRuleAxisToRelaxis(ruleConfig configparser.RuleConfigAxisToRelaxis,
|
|
pDevs map[string]Device,
|
|
vDevs map[string]Device,
|
|
base MappingRuleBase) (*MappingRuleAxisToRelaxis, error) {
|
|
|
|
input, err := NewRuleTargetAxisFromConfig(ruleConfig.Input, pDevs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
output, err := NewRuleTargetRelaxisFromConfig(ruleConfig.Output, vDevs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &MappingRuleAxisToRelaxis{
|
|
MappingRuleBase: base,
|
|
Input: input,
|
|
Output: output,
|
|
RepeatRateMin: ruleConfig.RepeatRateMin,
|
|
RepeatRateMax: ruleConfig.RepeatRateMax,
|
|
Increment: int32(ruleConfig.Increment),
|
|
lastEvent: time.Now(),
|
|
nextEvent: NoNextEvent,
|
|
clock: clockwork.NewRealClock(),
|
|
}, nil
|
|
}
|
|
|
|
func (rule *MappingRuleAxisToRelaxis) MatchEvent(
|
|
device Device,
|
|
event *evdev.InputEvent,
|
|
mode *string) (*evdev.InputDevice, *evdev.InputEvent) {
|
|
|
|
if !rule.MappingRuleBase.modeCheck(mode) ||
|
|
!rule.Input.MatchEventDeviceAndCode(device, event) {
|
|
return nil, nil
|
|
}
|
|
|
|
// 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 = rule.clock.Now()
|
|
return nil
|
|
}
|
|
|
|
if rule.clock.Now().Compare(rule.lastEvent.Add(rule.nextEvent)) > -1 {
|
|
rule.lastEvent = rule.clock.Now()
|
|
return rule.Output.CreateEvent(rule.Increment, nil)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (rule *MappingRuleAxisToRelaxis) GetOutputDevice() *evdev.InputDevice {
|
|
return rule.Output.Device.(*evdev.InputDevice)
|
|
}
|