Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 200 insertions, 0 deletions

diff --git a/xbmc/input/joysticks/DriverPrimitive.h b/xbmc/input/joysticks/DriverPrimitive.h
new file mode 100644
index 0000000..11d391b
--- /dev/null
+++ b/xbmc/input/joysticks/DriverPrimitive.h
@@ -0,0 +1,200 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "JoystickTypes.h"
+#include "input/keyboard/KeyboardTypes.h"
+#include "input/mouse/MouseTypes.h"
+
+#include <stdint.h>
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+/*!
+ * \ingroup joystick
+ * \brief Basic driver element associated with input events
+ *
+ * Driver input (bools, floats and enums) is split into primitives that better
+ * map to the physical features on a joystick.
+ *
+ * A bool obviously only maps to a single feature, so it is a driver
+ * primitive. Here, these are called "buttons".
+ *
+ * A hat enum encodes the state of the four hat directions. Each direction
+ * can map to a different feature, so a hat enum consists of four driver
+ * primitives called "hat directions".
+ *
+ * A float is a little trickier. Trivially, it can map to an analog stick or
+ * trigger. However, DirectInput combines two triggers onto a single axis.
+ * Therefore, the axis is split into two primitives called "semiaxes".
+ *
+ * The type determines the fields in use:
+ *
+ *    Button:
+ *       - driver index
+ *
+ *    Hat direction:
+ *       - driver index
+ *       - hat direction (up/right/down/left)
+ *
+ *    Semiaxis:
+ *       - driver index
+ *       - center (-1, 0 or 1)
+ *       - semiaxis direction (positive/negative)
+ *       - range (1 or 2)
+ *
+ *    Motor:
+ *       - driver index
+ *
+ *    Key:
+ *       - keycode
+ *
+ *    Mouse button:
+ *       - driver index
+ *
+ *    Relative pointer:
+ *       - pointer direction
+ *
+ * For more info, see "Chapter 2. Joystick drivers" in the documentation
+ * thread: http://forum.kodi.tv/showthread.php?tid=257764
+ */
+class CDriverPrimitive
+{
+public:
+  /*!
+   * \brief Construct an invalid driver primitive
+   */
+  CDriverPrimitive(void);
+
+  /*!
+   * \brief Construct a driver primitive representing a button or motor
+   */
+  CDriverPrimitive(PRIMITIVE_TYPE type, unsigned int index);
+
+  /*!
+   * \brief Construct a driver primitive representing one of the four
+   *        direction arrows on a dpad
+   */
+  CDriverPrimitive(unsigned int hatIndex, HAT_DIRECTION direction);
+
+  /*!
+   * \brief Construct a driver primitive representing the positive or negative
+   *        half of an axis
+   */
+  CDriverPrimitive(unsigned int axisIndex,
+                   int center,
+                   SEMIAXIS_DIRECTION direction,
+                   unsigned int range);
+
+  /*!
+   * \brief Construct a driver primitive representing a key on a keyboard
+   */
+  CDriverPrimitive(KEYBOARD::KeySymbol keycode);
+
+  /*!
+   * \brief Construct a driver primitive representing a mouse button
+   */
+  CDriverPrimitive(MOUSE::BUTTON_ID index);
+
+  /*!
+   * \brief Construct a driver primitive representing a relative pointer
+   */
+  CDriverPrimitive(RELATIVE_POINTER_DIRECTION direction);
+
+  bool operator==(const CDriverPrimitive& rhs) const;
+  bool operator<(const CDriverPrimitive& rhs) const;
+
+  bool operator!=(const CDriverPrimitive& rhs) const { return !operator==(rhs); }
+  bool operator>(const CDriverPrimitive& rhs) const { return !(operator<(rhs) || operator==(rhs)); }
+  bool operator<=(const CDriverPrimitive& rhs) const { return operator<(rhs) || operator==(rhs); }
+  bool operator>=(const CDriverPrimitive& rhs) const { return !operator<(rhs); }
+
+  /*!
+   * \brief The type of driver primitive
+   */
+  PRIMITIVE_TYPE Type(void) const { return m_type; }
+
+  /*!
+   * \brief The index used by the joystick driver
+   *
+   * Valid for:
+   *   - buttons
+   *   - hats
+   *   - semiaxes
+   *   - motors
+   */
+  unsigned int Index(void) const { return m_driverIndex; }
+
+  /*!
+   * \brief The direction arrow (valid for hat directions)
+   */
+  HAT_DIRECTION HatDirection(void) const { return m_hatDirection; }
+
+  /*!
+   * \brief The location of the zero point of the semiaxis
+   */
+  int Center() const { return m_center; }
+
+  /*!
+   * \brief The semiaxis direction (valid for semiaxes)
+   */
+  SEMIAXIS_DIRECTION SemiAxisDirection(void) const { return m_semiAxisDirection; }
+
+  /*!
+   * \brief The distance between the center and the farthest valid value (valid for semiaxes)
+   */
+  unsigned int Range() const { return m_range; }
+
+  /*!
+   * \brief The keyboard symbol (valid for keys)
+   */
+  KEYBOARD::KeySymbol Keycode() const { return m_keycode; }
+
+  /*!
+   * \brief The mouse button ID (valid for mouse buttons)
+   */
+  MOUSE::BUTTON_ID MouseButton() const { return static_cast<MOUSE::BUTTON_ID>(m_driverIndex); }
+
+  /*!
+   * \brief The relative pointer direction (valid for relative pointers)
+   */
+  RELATIVE_POINTER_DIRECTION PointerDirection() const { return m_pointerDirection; }
+
+  /*!
+   * \brief Test if an driver primitive is valid
+   *
+   * A driver primitive is valid if it has a known type and:
+   *
+   *   1) for hats, it is a cardinal direction
+   *   2) for semi-axes, it is a positive or negative direction
+   *   3) for keys, the keycode is non-empty
+   */
+  bool IsValid(void) const;
+
+  /*!
+   * \brief Convert primitive to a string suitable for logging
+   *
+   * \return The primitive as described by a short string, or empty if invalid
+   */
+  std::string ToString() const;
+
+private:
+  PRIMITIVE_TYPE m_type = PRIMITIVE_TYPE::UNKNOWN;
+  unsigned int m_driverIndex = 0;
+  HAT_DIRECTION m_hatDirection = HAT_DIRECTION::NONE;
+  int m_center = 0;
+  SEMIAXIS_DIRECTION m_semiAxisDirection = SEMIAXIS_DIRECTION::ZERO;
+  unsigned int m_range = 1;
+  KEYBOARD::KeySymbol m_keycode = XBMCK_UNKNOWN;
+  RELATIVE_POINTER_DIRECTION m_pointerDirection = RELATIVE_POINTER_DIRECTION::NONE;
+};
+} // namespace JOYSTICK
+} // namespace KODI