xbmc/input/InputManager.h

   1 #pragma once
   2 /*
   3 *      Copyright (C) 2005-2014 Team XBMC
   4 *      http://xbmc.org
   5 *
   6 *  This Program is free software; you can redistribute it and/or modify
   7 *  it under the terms of the GNU General Public License as published by
   8 *  the Free Software Foundation; either version 2, or (at your option)
   9 *  any later version.
  10 *
  11 *  This Program is distributed in the hope that it will be useful,
  12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 *  GNU General Public License for more details.
  15 *
  16 *  You should have received a copy of the GNU General Public License
  17 *  along with XBMC; see the file COPYING.  If not, see
  18 *  <http://www.gnu.org/licenses/>.
  19 *
  20 */
  21
  22 #include <map>
  23 #include <string>
  24 #include <vector>
  25
  26 #if defined(HAS_LIRC)
  27 #include "input/linux/LIRC.h"
  28 #endif
  29 #if defined(HAS_IRSERVERSUITE)
  30 #include "input/windows/IRServerSuite.h"
  31 #endif
  32
  33 #include "windowing/XBMC_events.h"
  34 #include "input/KeyboardStat.h"
  35 #include "input/MouseStat.h"
  36 #include "settings/lib/ISettingCallback.h"
  37 #include "threads/CriticalSection.h"
  38
  39 class CKey;
  40
  41 namespace KEYBOARD
  42 {
  43   class IKeyboardHandler;
  44 }
  45
  46 class CInputManager : public ISettingCallback
  47 {
  48 private:
  49   CInputManager() { }
  50   CInputManager(const CInputManager&);
  51   CInputManager const& operator=(CInputManager const&);
  52   virtual ~CInputManager() { };
  53
  54 public:
  55   /*! \brief static method to get the current instance of the class. Creates a new instance the first time it's called.
  56   */
  57   static CInputManager& GetInstance();
  58
  59   /*! \brief decode an input event from remote controls.
  60
  61    \param windowId Currently active window
  62    \return true if event is handled, false otherwise
  63   */
  64   bool ProcessRemote(int windowId);
  65
  66   /*! \brief decode a mouse event and reset idle timers.
  67
  68   \param windowId Currently active window
  69   \return true if event is handled, false otherwise
  70   */
  71   bool ProcessMouse(int windowId);
  72
  73   /*! \brief decode an event from the event service, this can be mouse, key, joystick, reset idle timers.
  74
  75   \param windowId Currently active window
  76   \param frameTime Time in seconds since last call
  77   \return true if event is handled, false otherwise
  78   */
  79   bool ProcessEventServer(int windowId, float frameTime);
  80
  81   /*! \brief decode an event from peripherals.
  82
  83   \param frameTime Time in seconds since last call
  84   \return true if event is handled, false otherwise
  85   */
  86   bool ProcessPeripherals(float frameTime);
  87
  88   /*! \brief Dispatch actions queued since the last call to Process()
  89    */
  90   void ProcessQueuedActions();
  91
  92   /*! \brief Queue an action to be processed on the next call to Process()
  93    */
  94   void QueueAction(const CAction& action);
  95
  96   /*! \brief Process all inputs
  97    *
  98    * \param windowId Currently active window
  99    * \param frameTime Time in seconds since last call
 100    * \return true on success, false otherwise
 101    */
 102   bool Process(int windowId, float frameTime);
 103
 104   /*!
 105    * \brief Call once during application startup to initialize peripherals that need it
 106    */
 107   void InitializeInputs();
 108
 109   /*! \brief Enable or disable the joystick
 110    *
 111    * \param enabled true to enable joystick, false to disable
 112    * \return void
 113    */
 114   void SetEnabledJoystick(bool enabled = true);
 115
 116   /*! \brief Handle an input event
 117    *
 118    * \param newEvent event details
 119    * \return true on succesfully handled event
 120    * \sa XBMC_Event
 121    */
 122   bool OnEvent(XBMC_Event& newEvent);
 123
 124   /*! \brief Control if the mouse is actively used or not
 125    *
 126    * \param[in] active sets mouse active or inactive
 127    */
 128   void SetMouseActive(bool active = true);
 129
 130   /*! \brief Control if we should use a mouse or not
 131    *
 132    * \param[in] mouseEnabled sets mouse enabled or disabled
 133    */
 134   void SetMouseEnabled(bool mouseEnabled = true);
 135
 136   /*! \brief Set the current state of the mouse such as click, drag operation
 137    *
 138    * \param[in] mouseState which state the mouse should be set to
 139    * \sa MOUSE_STATE
 140    */
 141   void SetMouseState(MOUSE_STATE mouseState);
 142
 143   /*! \brief Check if the mouse is currently active
 144    *
 145    * \return true if active, false otherwise
 146    */
 147   bool IsMouseActive();
 148
 149   /*! \brief Get the current state of the mouse, such as click or drag operation
 150    *
 151    * \return the current state of the mouse as a value from MOUSE_STATE
 152    * \sa MOUSE_STATE
 153    */
 154   MOUSE_STATE GetMouseState();
 155
 156   /*! \brief Get the current mouse positions x and y coordinates
 157    *
 158    * \return a struct containing the x and y coordinates
 159    * \sa MousePosition
 160    */
 161   MousePosition GetMousePosition();
 162
 163   /*! \brief Set the current screen resolution and pointer speed
 164    *
 165    * \param[in] maxX    screen width
 166    * \param[in] maxY    screen height
 167    * \param[in] speedX  mouse speed in x dimension
 168    * \param[in] speedY  mouse speed in y dimension
 169    * \return
 170    */
 171   void SetMouseResolution(int maxX, int maxY, float speedX, float speedY);
 172
 173   /*! \brief Enable the remote control
 174    *
 175    */
 176   void EnableRemoteControl();
 177
 178   /*! \brief Disable the remote control
 179    *
 180    */
 181   void DisableRemoteControl();
 182
 183   /*! \brief Try to connect to a remote control to listen for commands
 184    *
 185    */
 186   void InitializeRemoteControl();
 187
 188   /*! \brief Check if the remote control is enabled
 189    *
 190    * \return true if remote control is enabled, false otherwise
 191    */
 192   bool IsRemoteControlEnabled();
 193
 194   /*! \brief Check if the remote control is initialized
 195    *
 196    * \return true if initialized, false otherwise
 197    */
 198   bool IsRemoteControlInitialized();
 199
 200   /*! \brief Set the device name to use with LIRC, does nothing
 201    *   if IRServerSuite is used
 202    *
 203    * \param[in] name Name of the device to use with LIRC
 204    */
 205   void SetRemoteControlName(const std::string& name);
 206
 207   /*! \brief Returns whether or not we can handle a given built-in command. */
 208
 209   bool HasBuiltin(const std::string& command);
 210
 211   /*! \brief Parse a builtin command and execute any input action
 212    *  currently only LIRC commands implemented
 213    *
 214    * \param[in] execute Command to execute
 215    * \param[in] params  parameters that was passed to the command
 216    * \return 0 on success, -1 on failure
 217    */
 218   int ExecuteBuiltin(const std::string& execute, const std::vector<std::string>& params);
 219
 220   virtual void OnSettingChanged(const CSetting *setting) override;
 221
 222   void RegisterKeyboardHandler(KEYBOARD::IKeyboardHandler* handler);
 223   void UnregisterKeyboardHandler(KEYBOARD::IKeyboardHandler* handler);
 224
 225 private:
 226
 227   /*! \brief Process keyboard event and translate into an action
 228   *
 229   * \param CKey keypress details
 230   * \return true on succesfully handled event
 231   * \sa CKey
 232   */
 233   bool OnKey(const CKey& key);
 234
 235   /*! \brief Process key up event
 236    *
 237    * \param CKey details of released key
 238    * \sa CKey
 239    */
 240   void OnKeyUp(const CKey& key);
 241
 242   /*! \brief Determine if an action should be processed or just
 243   *   cancel the screensaver
 244   *
 245   * \param action Action that is about to be processed
 246   * \return true on any poweractions such as shutdown/reboot/sleep/suspend, false otherwise
 247   * \sa CAction
 248   */
 249   bool AlwaysProcess(const CAction& action);
 250
 251   /*! \brief Send the Action to CApplication for further handling,
 252   *   play a sound before or after sending the action.
 253   *
 254   * \param action Action to send to CApplication
 255   * \return result from CApplication::OnAction
 256   * \sa CAction
 257   */
 258   bool ExecuteInputAction(const CAction &action);
 259
 260   CKeyboardStat m_Keyboard;
 261   CMouseStat m_Mouse;
 262   CKey m_LastKey;
 263
 264 #if defined(HAS_LIRC) || defined(HAS_IRSERVERSUITE)
 265   CRemoteControl m_RemoteControl;
 266 #endif
 267
 268 #if defined(HAS_EVENT_SERVER)
 269   std::map<std::string, std::map<int, float> > m_lastAxisMap;
 270 #endif
 271
 272   std::vector<CAction> m_queuedActions;
 273   CCriticalSection     m_actionMutex;
 274
 275   std::vector<KEYBOARD::IKeyboardHandler*> m_keyboardHandlers;
 276 };