uvos/TrainControllerUi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

move build system to cmake, add train overlord

Browse Source
This commit is contained in:
uvos
2022-03-13 22:21:13 +01:00
parent ddd0b3a732
commit a1f9fa172b
60 changed files with 338 additions and 997 deletions
Download Patch File Download Diff File Expand all files Collapse all files

423
src/trainControllerUI/jsbackend/VirtualJoystick.cpp.orig Normal file
View File

@ -0,0 +1,423 @@
/*
* Copyright (c) 2015-2017 Alex Spataru <alex_spataru@outlook.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <math.h>
#include "VirtualJoystick.h"
VirtualJoystick::VirtualJoystick(QObject *parent)
: QObject(parent)
{
m_axisRange = 1;
m_joystickEnabled = false;
m_joystick.blacklisted = false;
m_joystick.name = tr("Virtual Joystick");
/* Initialize POVs */
m_joystick.povs.append(0);
/* Initialize axes */
m_axisStatus = QVector<AxisState>(NUMBER_OF_AXES, AxisState::STILL);
m_axisValue = QVector<qint16>(NUMBER_OF_AXES, 0);
for (int i = 0; i < NUMBER_OF_AXES; ++i)
{
m_joystick.axes.append(0);
}
/* Initialize buttons */
for (int i = 0; i < NUMBER_OF_BUTTONS; ++i)
m_joystick.buttons.append(false);
m_timerUpdateAxis.reset(new QTimer());
connect(m_timerUpdateAxis.get(), &QTimer::timeout, this, &VirtualJoystick::updateAxis);
}
/**
* Returns the current axis range of the joystick.
* The axis range is an absolute value that represents the maximum value that
* the joystick can have.
*
* For example, the \c QJoystick system supports an axis range of 1 (-1 to 1).
* If you set an axis range of 0.8 to the virtual joystick, then it will report
* values ranging from -0.8 to 0.8.
*/
qreal VirtualJoystick::axisRange() const
{
return m_axisRange;
}
/**
* Returns \c true if the virtual joystick is enabled.
*/
bool VirtualJoystick::joystickEnabled() const
{
return m_joystickEnabled;
}
/**
* Returns a pointer to the virtual josytick device. This can be used if you
* need to customize the virtual joystick (e.g. add new axes or buttons).
*/
QJoystickDevice *VirtualJoystick::joystick()
{
return &m_joystick;
}
/**
* Sets the ID of the virtual joystick device. The \c QJoysticks will
* automatically change the \a ID of the virtual joystick when it scans for
* new joysticks.
*
* The virtual joystick will ALWAYS be the last joystick to be registered.
*/
void VirtualJoystick::setJoystickID(int id)
{
m_joystick.id = id;
}
/**
* Changes the axis range that the joystick can use. For example, if you set
* an axis range of 0.8, then axis values will be reported from -0.8 to 0.8.
*
* If you set an axis range of 1 (maximum), then the joystick will report axis
* values ranging from -1 to 1.
*/
void VirtualJoystick::setAxisRange(qreal range)
{
range = fabs(range);
if (range > 1)
range = 1;
m_axisRange = range;
}
/**
* Enables or disables the virtual joystick device.
*/
void VirtualJoystick::setJoystickEnabled(bool enabled)
{
if (enabled)
{
// That means that the axes will be updated each 10 ms
m_timerUpdateAxis->start(10);
qApp->installEventFilter(this);
}
else
{
m_timerUpdateAxis->stop();
// Removing the event filter since the joystick is no longer active
qApp->removeEventFilter(this);
}
m_joystickEnabled = enabled;
emit enabledChanged();
}
void VirtualJoystick::setAxisSensibility(qreal sensibility)
{
if (sensibility > 1 || sensibility < 0)
{
qFatal("Fatal: VirtualJoystick Axis sensibility must be a value between 0 and 1");
}
const qint16 stepMinimum = 50;
const qint16 stepMaximum = 1000;
m_axisStep = static_cast<qint16>((-stepMaximum + stepMinimum) * sensibility) + stepMaximum;
}
/**
* Polls the keyboard events and if required, reports a change in the axis
* values of the virtual joystick device.
*/
void VirtualJoystick::readAxes(int key, bool pressed)
{
/* Horizontal axis on thumb 1 */
if (key == Qt::Key_A)
{
if (pressed)
m_axisStatus[AXIS_AD] = DECREASE;
else
m_axisStatus[AXIS_AD] = STILL;
}
else if (key == Qt::Key_D)
{
if (pressed)
m_axisStatus[AXIS_AD] = INCREASE;
else
m_axisStatus[AXIS_AD] = STILL;
}
/* Vertical axis on thumb 1 */
if (key == Qt::Key_S)
{
if (pressed)
m_axisStatus[AXIS_SW] = DECREASE;
else
m_axisStatus[AXIS_SW] = STILL;
}
else if (key == Qt::Key_W)
{
if (pressed)
m_axisStatus[AXIS_SW] = INCREASE;
else
m_axisStatus[AXIS_SW] = STILL;
}
/* Trigger 1 */
if (key == Qt::Key_Q)
{
if (pressed)
m_axisStatus[AXIS_QE] = DECREASE;
else
m_axisStatus[AXIS_QE] = STILL;
}
else if (key == Qt::Key_E)
{
if (pressed)
m_axisStatus[AXIS_QE] = INCREASE;
else
m_axisStatus[AXIS_QE] = STILL;
}
/* Trigger 2 */
if (key == Qt::Key_U)
{
if (pressed)
m_axisStatus[AXIS_UO] = DECREASE;
else
m_axisStatus[AXIS_UO] = STILL;
}
else if (key == Qt::Key_O)
{
if (pressed)
m_axisStatus[AXIS_UO] = INCREASE;
else
m_axisStatus[AXIS_UO] = STILL;
}
/* Horizontal axis on thumb 2 */
if (key == Qt::Key_J)
{
if (pressed)
m_axisStatus[AXIS_JL] = DECREASE;
else
m_axisStatus[AXIS_JL] = STILL;
}
else if (key == Qt::Key_L)
{
if (pressed)
m_axisStatus[AXIS_JL] = INCREASE;
else
m_axisStatus[AXIS_JL] = STILL;
}
/* Vertical axis on thumb 2 */
if (key == Qt::Key_K)
{
if (pressed)
m_axisStatus[AXIS_KI] = DECREASE;
else
m_axisStatus[AXIS_KI] = STILL;
}
else if (key == Qt::Key_I)
{
if (pressed)
m_axisStatus[AXIS_KI] = INCREASE;
else
m_axisStatus[AXIS_KI] = STILL;
}
}
void VirtualJoystick::updateAxis()
{
for (quint8 i = 0; i < NUMBER_OF_AXES; i++)
{
changeAxisValue(i);
}
}
/**
* Polls the keyboard events and if required, reports a change in the POV/hat
* values of the virtual joystick device.
*/
void VirtualJoystick::readPOVs(int key, bool pressed)
{
int angle = 0;
if (key == Qt::Key_Up)
angle = 360;
else if (key == Qt::Key_Right)
angle = 90;
else if (key == Qt::Key_Left)
angle = 270;
else if (key == Qt::Key_Down)
angle = 180;
if (!pressed)
angle = 0;
if (joystickEnabled())
{
QJoystickPOVEvent event;
event.pov = 0;
event.angle = angle;
event.joystick = joystick();
emit povEvent(event);
}
}
/**
* Polls the keyboard events and if required, reports a change in the button
* values of the virtual joystick device.
*/
void VirtualJoystick::readButtons(int key, bool pressed)
{
int button = -1;
if (key == Qt::Key_0)
{ // Special key that reset all axes
button = 0;
resetAllAxes();
}
else if (key == Qt::Key_1)
button = 1;
else if (key == Qt::Key_2)
button = 2;
else if (key == Qt::Key_3)
button = 3;
else if (key == Qt::Key_4)
button = 4;
else if (key == Qt::Key_5)
button = 5;
else if (key == Qt::Key_6)
button = 6;
else if (key == Qt::Key_7)
button = 7;
else if (key == Qt::Key_8)
button = 8;
else if (key == Qt::Key_9)
button = 9;
if (button != -1 && joystickEnabled())
{
QJoystickButtonEvent event;
event.button = button;
event.pressed = pressed;
event.joystick = joystick();
emit buttonEvent(event);
}
}
/**
* Called when the event filter detects a keyboard event.
*
* This function prompts the joystick to update its axis, button and POV values
* based on the keys that have been pressed or released.
*/
void VirtualJoystick::processKeyEvent(QKeyEvent *event, bool pressed)
{
if (joystickEnabled())
{
readPOVs(event->key(), pressed);
readAxes(event->key(), pressed);
readButtons(event->key(), pressed);
}
}
/**
* "Listens" for keyboard presses or releases while any window or widget of the
* application is focused.
*
* \note This function may or may not detect keyboard events when the
* application is not focused. This depends on the operating system and
* the window manager that is being used.
*/
bool VirtualJoystick::eventFilter(QObject *object, QEvent *event)
{
Q_UNUSED(object);
switch (event->type())
{
case QEvent::KeyPress:
processKeyEvent(static_cast<QKeyEvent *>(event), true);
break;
case QEvent::KeyRelease:
processKeyEvent(static_cast<QKeyEvent *>(event), false);
break;
default:
break;
}
return false;
}
void VirtualJoystick::changeAxisValue(quint8 axis)
{
switch (m_axisStatus[axis])
{
case STILL:
return;
case INCREASE:
if (m_axisValue[axis] > AXIS_MAXIMUM_VIRTUAL_JOYSTICK - m_axisStep)
m_axisValue[axis] = AXIS_MAXIMUM_VIRTUAL_JOYSTICK;
else
m_axisValue[axis] += m_axisStep;
break;
case DECREASE:
if (m_axisValue[axis] < AXIS_MINIMUM_VIRTUAL_JOYSTICK + m_axisStep)
m_axisValue[axis] = AXIS_MINIMUM_VIRTUAL_JOYSTICK;
else
m_axisValue[axis] -= m_axisStep;
break;
}
QJoystickAxisEvent event;
event.axis = axis;
event.value = m_axisRange * static_cast<qreal>(m_axisValue[axis]) / AXIS_MAXIMUM_VIRTUAL_JOYSTICK;
event.joystick = joystick();
emit axisEvent(event);
}
void VirtualJoystick::resetAllAxes()
{
for (quint8 i = 0; i < NUMBER_OF_AXES; i++)
{
m_axisValue[i] = 0;
QJoystickAxisEvent event;
event.axis = i;
event.value = 0;
event.joystick = joystick();
emit axisEvent(event);
}
}