171 lines
5.1 KiB
C++
171 lines
5.1 KiB
C++
/*
|
|
* Copyright 2019-2020 PixlOne
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
#include <cmath>
|
|
#include "AxisGesture.h"
|
|
#include "../../InputDevice.h"
|
|
#include "../../util/log.h"
|
|
|
|
using namespace logid::actions;
|
|
|
|
AxisGesture::AxisGesture(Device *device, libconfig::Setting &root) :
|
|
Gesture (device), _config (device, root)
|
|
{
|
|
}
|
|
|
|
void AxisGesture::press(bool init_threshold)
|
|
{
|
|
_axis = init_threshold ? _config.threshold() : 0;
|
|
_axis_remainder = 0;
|
|
_hires_remainder = 0;
|
|
}
|
|
|
|
void AxisGesture::release(bool primary)
|
|
{
|
|
// Do nothing
|
|
(void)primary; // Suppress unused warning
|
|
}
|
|
|
|
void AxisGesture::move(int16_t axis)
|
|
{
|
|
int16_t new_axis = _axis+axis;
|
|
int low_res_axis = InputDevice::getLowResAxis(_config.axis());
|
|
int hires_remainder = _hires_remainder;
|
|
|
|
if(new_axis > _config.threshold()) {
|
|
double move = axis;
|
|
if(_axis < _config.threshold())
|
|
move = new_axis - _config.threshold();
|
|
bool negative_multiplier = _config.multiplier() < 0;
|
|
if(negative_multiplier)
|
|
move *= -_config.multiplier();
|
|
else
|
|
move *= _config.multiplier();
|
|
|
|
double move_floor = floor(move);
|
|
_axis_remainder = move - move_floor;
|
|
if(_axis_remainder >= 1) {
|
|
double int_remainder = floor(_axis_remainder);
|
|
move_floor += int_remainder;
|
|
_axis_remainder -= int_remainder;
|
|
}
|
|
|
|
if(negative_multiplier)
|
|
move_floor = -move_floor;
|
|
|
|
if(low_res_axis != -1) {
|
|
int lowres_movement = 0, hires_movement = move_floor;
|
|
virtual_input->moveAxis(_config.axis(), hires_movement);
|
|
hires_remainder += hires_movement;
|
|
if(abs(hires_remainder) >= 60) {
|
|
lowres_movement = hires_remainder/120;
|
|
if(lowres_movement == 0)
|
|
lowres_movement = hires_remainder > 0 ? 1 : -1;
|
|
hires_remainder -= lowres_movement*120;
|
|
virtual_input->moveAxis(low_res_axis, lowres_movement);
|
|
}
|
|
|
|
_hires_remainder = hires_remainder;
|
|
} else {
|
|
virtual_input->moveAxis(_config.axis(), move_floor);
|
|
}
|
|
}
|
|
_axis = new_axis;
|
|
}
|
|
|
|
bool AxisGesture::metThreshold() const
|
|
{
|
|
return _axis >= _config.threshold();
|
|
}
|
|
|
|
void AxisGesture::setHiresMultiplier(double multiplier)
|
|
{
|
|
_config.setHiresMultiplier(multiplier);
|
|
}
|
|
|
|
AxisGesture::Config::Config(Device *device, libconfig::Setting &setting) :
|
|
Gesture::Config(device, setting, false)
|
|
{
|
|
try {
|
|
auto& axis = setting.lookup("axis");
|
|
if(axis.isNumber()) {
|
|
_axis = axis;
|
|
} else if(axis.getType() == libconfig::Setting::TypeString) {
|
|
try {
|
|
_axis = virtual_input->toAxisCode(axis);
|
|
} catch(InputDevice::InvalidEventCode& e) {
|
|
logPrintf(WARN, "Line %d: Invalid axis %s, skipping."
|
|
, axis.getSourceLine(), axis.c_str());
|
|
}
|
|
} else {
|
|
logPrintf(WARN, "Line %d: axis must be string or int, skipping.",
|
|
axis.getSourceLine(), axis.c_str());
|
|
throw InvalidGesture();
|
|
}
|
|
} catch(libconfig::SettingNotFoundException& e) {
|
|
logPrintf(WARN, "Line %d: axis is a required field, skippimg.",
|
|
setting.getSourceLine());
|
|
throw InvalidGesture();
|
|
}
|
|
|
|
try {
|
|
auto& multiplier = setting.lookup("axis_multiplier");
|
|
if(multiplier.isNumber()) {
|
|
if(multiplier.getType() == libconfig::Setting::TypeFloat)
|
|
_multiplier = multiplier;
|
|
else
|
|
_multiplier = (int)multiplier;
|
|
} else {
|
|
logPrintf(WARN, "Line %d: axis_multiplier must be a number, "
|
|
"setting to default (1).",
|
|
multiplier.getSourceLine());
|
|
}
|
|
} catch(libconfig::SettingNotFoundException& e) {
|
|
// Ignore
|
|
}
|
|
|
|
if(InputDevice::getLowResAxis(_axis) != -1)
|
|
_multiplier *= 120;
|
|
}
|
|
|
|
unsigned int AxisGesture::Config::axis() const
|
|
{
|
|
return _axis;
|
|
}
|
|
|
|
double AxisGesture::Config::multiplier() const
|
|
{
|
|
return _multiplier;
|
|
}
|
|
|
|
bool AxisGesture::wheelCompatibility() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void AxisGesture::Config::setHiresMultiplier(double multiplier)
|
|
{
|
|
if(_hires_multiplier == multiplier || multiplier == 0)
|
|
return;
|
|
|
|
if(InputDevice::getLowResAxis(_axis) != -1) {
|
|
_multiplier *= _hires_multiplier;
|
|
_multiplier /= multiplier;
|
|
}
|
|
|
|
_hires_multiplier = multiplier;
|
|
} |