|
| CInputManager () |
|
| CInputManager (const CInputManager &)=delete |
|
CInputManager const & | operator= (CInputManager const &)=delete |
|
| ~CInputManager () override |
|
bool | ProcessMouse (int windowId) |
| decode a mouse event and reset idle timers.
|
|
bool | ProcessEventServer (int windowId, float frameTime) |
| decode an event from the event service, this can be mouse, key, joystick, reset idle timers.
|
|
bool | ProcessPeripherals (float frameTime) |
| decode an event from peripherals.
|
|
bool | Process (int windowId, float frameTime) |
| Process all inputs.
|
|
void | InitializeInputs () |
| Call once during application startup to initialize peripherals that need it.
|
|
void | Deinitialize () |
| Deinitialize input and keymaps.
|
|
bool | OnEvent (XBMC_Event &newEvent) |
| Handle an input event.
|
|
void | SetMouseActive (bool active=true) |
| Control if the mouse is actively used or not.
|
|
void | SetMouseEnabled (bool mouseEnabled=true) |
| Control if we should use a mouse or not.
|
|
void | SetMouseState (MOUSE_STATE mouseState) |
| Set the current state of the mouse such as click, drag operation.
|
|
bool | IsMouseActive () |
| Check if the mouse is currently active.
|
|
MOUSE_STATE | GetMouseState () |
| Get the current state of the mouse, such as click or drag operation.
|
|
MousePosition | GetMousePosition () |
| Get the current mouse positions x and y coordinates.
|
|
void | SetMouseResolution (int maxX, int maxY, float speedX, float speedY) |
| Set the current screen resolution and pointer speed.
|
|
bool | IsControllerEnabled () const |
| Get the status of the controller-enable setting.
|
|
bool | HasBuiltin (const std::string &command) |
| Returns whether or not we can handle a given built-in command.
|
|
int | ExecuteBuiltin (const std::string &execute, const std::vector< std::string > ¶ms) |
| Parse a builtin command and execute any input action currently only LIRC commands implemented.
|
|
bool | LoadKeymaps () |
|
bool | ReloadKeymaps () |
|
void | ClearKeymaps () |
|
void | AddKeymap (const std::string &keymap) |
|
void | RemoveKeymap (const std::string &keymap) |
|
const KODI::KEYMAP::IKeymapEnvironment * | KeymapEnvironment () const |
|
CAction | GetAction (int window, const CKey &key, bool fallback=true) |
| Obtain the action configured for a given window and key.
|
|
bool | TranslateCustomControllerString (int windowId, const std::string &controllerName, int buttonId, int &action, std::string &strAction) |
|
bool | TranslateTouchAction (int windowId, int touchAction, int touchPointers, int &action, std::string &actionString) |
|
std::vector< std::shared_ptr< const KODI::KEYMAP::IWindowKeymap > > | GetJoystickKeymaps () const |
|
void | QueueAction (const CAction &action) |
| Queue an action to be processed on the next call to Process()
|
|
void | OnSettingChanged (const std::shared_ptr< const CSetting > &setting) override |
| The value of the given setting has changed.
|
|
bool | OnAction (const CAction &action) override |
| Handle a GUI action.
|
|
void | RegisterKeyboardDriverHandler (KODI::KEYBOARD::IKeyboardDriverHandler *handler) |
|
void | UnregisterKeyboardDriverHandler (KODI::KEYBOARD::IKeyboardDriverHandler *handler) |
|
virtual void | RegisterMouseDriverHandler (KODI::MOUSE::IMouseDriverHandler *handler) |
|
virtual void | UnregisterMouseDriverHandler (KODI::MOUSE::IMouseDriverHandler *handler) |
|
virtual | ~ISettingCallback ()=default |
|
virtual bool | OnSettingChanging (const std::shared_ptr< const CSetting > &setting) |
| The value of the given setting is being changed.
|
|
virtual void | OnSettingAction (const std::shared_ptr< const CSetting > &setting) |
| The given setting has been activated.
|
|
virtual bool | OnSettingUpdate (const std::shared_ptr< CSetting > &setting, const char *oldSettingId, const TiXmlNode *oldSettingNode) |
| The given setting needs to be updated.
|
|
virtual void | OnSettingPropertyChanged (const std::shared_ptr< const CSetting > &setting, const char *propertyName) |
| The given property of the given setting has changed.
|
|
virtual | ~IActionListener ()=default |
|
| Observable ()=default |
|
virtual | ~Observable ()=default |
|
Observable & | operator= (const Observable &observable) |
|
virtual void | RegisterObserver (Observer *obs) |
| Register an observer.
|
|
virtual void | UnregisterObserver (Observer *obs) |
| Unregister an observer.
|
|
virtual void | NotifyObservers (const ObservableMessage message=ObservableMessageNone) |
| Send a message to all observers when m_bObservableChanged is true.
|
|
virtual void | SetChanged (bool bSetTo=true) |
| Mark an observable changed.
|
|
virtual bool | IsObserving (const Observer &obs) const |
| Check whether this observable is being observed by an observer.
|
|
Main input processing class.
This class consolidates all input generated from different sources such as mouse, keyboard, joystick or touch (in OnEvent).
Keyboard input is processed by CInputManager and forwarded to registered keyboard handlers (e.g. game clients) or as actions to the UI:
- If no keyboard handlers are registered or if they don't consume events, the keyboard events are forwarded to the UI via CInputManager::OnKey.
- Clients (e.g. game clients implementing KEYBOARD::IKeyboardHandler) call CInputManager::RegisterKeyboardHandler to register themselves as eligible for keyboard input events.
- Keyboards can emulate Joysticks as described in KEYBOARD::CJoystickEmulation.
Everything around mouse
Mouse input is processed by CInputManager and forwarded to registered mouse handlers (e.g. game clients) or as actions to the UI:
- If no mouse handlers are registered or if they don't consume events, the mouse input events are forwarded to the UI via CInputManager::ProcessMouse.
- Clients (e.g. game clients implementing MOUSE::IMouseInputHandler) call CInputManager::RegisterMouseHandler to register themselves as eligible for mouse input events.
- Mouse events (from CInputManager::OnEvent) are collected via implementations of MOUSE::IMouseDriverHandler and transformed into higher level features by MOUSE::IMouseButtonMap instances before they are sent to the handlers.