/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
/*
* This code is based on Broken Sword 2.5 engine
*
* Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
*
* Licensed under GNU GPL v2
*
*/
/*
* BS_InputEngine
* -------------
* This is the input interface engine that contains all the methods that an
* input source must implement.
* All input engines must be derived from this class.
*
* Autor: Alex Arnst
*/
#ifndef SWORD25_INPUTENGINE_H
#define SWORD25_INPUTENGINE_H
#include "common/keyboard.h"
#include "sword25/kernel/common.h"
#include "sword25/kernel/service.h"
#include "sword25/kernel/persistable.h"
namespace Sword25 {
/// Class definitions
class InputEngine : public Service, public Persistable {
public:
InputEngine(Kernel *pKernel);
~InputEngine();
// NOTE: These codes are registered in inputengine_script.cpp
// If you add or remove entries of this enum, you must also adjust
// the above file.
enum KEY_CODES {
KEY_BACKSPACE = Common::KEYCODE_BACKSPACE,
KEY_TAB = Common::KEYCODE_TAB,
KEY_CLEAR = Common::KEYCODE_CLEAR,
KEY_RETURN = Common::KEYCODE_RETURN,
KEY_PAUSE = Common::KEYCODE_PAUSE,
KEY_CAPSLOCK = Common::KEYCODE_CAPSLOCK,
KEY_ESCAPE = Common::KEYCODE_ESCAPE,
KEY_SPACE = Common::KEYCODE_SPACE,
KEY_PAGEUP = Common::KEYCODE_PAGEUP,
KEY_PAGEDOWN = Common::KEYCODE_PAGEDOWN,
KEY_END = Common::KEYCODE_END,
KEY_HOME = Common::KEYCODE_HOME,
KEY_LEFT = Common::KEYCODE_LEFT,
KEY_UP = Common::KEYCODE_UP,
KEY_RIGHT = Common::KEYCODE_RIGHT,
KEY_DOWN = Common::KEYCODE_DOWN,
KEY_PRINTSCREEN = Common::KEYCODE_PRINT,
KEY_INSERT = Common::KEYCODE_INSERT,
KEY_DELETE = Common::KEYCODE_DELETE,
KEY_0 = Common::KEYCODE_0,
KEY_1 = Common::KEYCODE_1,
KEY_2 = Common::KEYCODE_2,
KEY_3 = Common::KEYCODE_3,
KEY_4 = Common::KEYCODE_4,
KEY_5 = Common::KEYCODE_5,
KEY_6 = Common::KEYCODE_6,
KEY_7 = Common::KEYCODE_7,
KEY_8 = Common::KEYCODE_8,
KEY_9 = Common::KEYCODE_9,
KEY_A = Common::KEYCODE_a,
KEY_B = Common::KEYCODE_b,
KEY_C = Common::KEYCODE_c,
KEY_D = Common::KEYCODE_d,
KEY_E = Common::KEYCODE_e,
KEY_F = Common::KEYCODE_f,
KEY_G = Common::KEYCODE_g,
KEY_H = Common::KEYCODE_h,
KEY_I = Common::KEYCODE_i,
KEY_J = Common::KEYCODE_j,
KEY_K = Common::KEYCODE_k,
KEY_L = Common::KEYCODE_l,
KEY_M = Common::KEYCODE_m,
KEY_N = Common::KEYCODE_n,
KEY_O = Common::KEYCODE_o,
KEY_P = Common::KEYCODE_p,
KEY_Q = Common::KEYCODE_q,
KEY_R = Common::KEYCODE_r,
KEY_S = Common::KEYCODE_s,
KEY_T = Common::KEYCODE_t,
KEY_U = Common::KEYCODE_u,
KEY_V = Common::KEYCODE_v,
KEY_W = Common::KEYCODE_w,
KEY_X = Common::KEYCODE_x,
KEY_Y = Common::KEYCODE_y,
KEY_Z = Common::KEYCODE_z,
KEY_NUMPAD0 = Common::KEYCODE_KP0,
KEY_NUMPAD1 = Common::KEYCODE_KP1,
KEY_NUMPAD2 = Common::KEYCODE_KP2,
KEY_NUMPAD3 = Common::KEYCODE_KP3,
KEY_NUMPAD4 = Common::KEYCODE_KP4,
KEY_NUMPAD5 = Common::KEYCODE_KP5,
KEY_NUMPAD6 = Common::KEYCODE_KP6,
KEY_NUMPAD7 = Common::KEYCODE_KP7,
KEY_NUMPAD8 = Common::KEYCODE_KP8,
KEY_NUMPAD9 = Common::KEYCODE_KP9,
KEY_MULTIPLY = Common::KEYCODE_KP_MULTIPLY,
KEY_ADD = Common::KEYCODE_KP_PLUS,
KEY_SEPARATOR = Common::KEYCODE_EQUALS, // FIXME: This mapping is just a wild guess!!
KEY_SUBTRACT = Common::KEYCODE_KP_MINUS,
KEY_DECIMAL = Common::KEYCODE_KP_PERIOD,
KEY_DIVIDE = Common::KEYCODE_KP_DIVIDE,
KEY_F1 = Common::KEYCODE_F1,
KEY_F2 = Common::KEYCODE_F2,
KEY_F3 = Common::KEYCODE_F3,
KEY_F4 = Common::KEYCODE_F4,
KEY_F5 = Common::KEYCODE_F5,
KEY_F6 = Common::KEYCODE_F6,
KEY_F7 = Common::KEYCODE_F7,
KEY_F8 = Common::KEYCODE_F8,
KEY_F9 = Common::KEYCODE_F9,
KEY_F10 = Common::KEYCODE_F10,
KEY_F11 = Common::KEYCODE_F11,
KEY_F12 = Common::KEYCODE_F12,
KEY_NUMLOCK = Common::KEYCODE_NUMLOCK,
KEY_SCROLL = Common::KEYCODE_SCROLLOCK,
KEY_LSHIFT = Common::KEYCODE_LSHIFT,
KEY_RSHIFT = Common::KEYCODE_RSHIFT,
KEY_LCONTROL = Common::KEYCODE_LCTRL,
KEY_RCONTROL = Common::KEYCODE_RCTRL
};
// NOTE: These codes are registered in inputengine_script.cpp
// If you add or remove entries of this enum, you must also adjust
// the above file.
enum KEY_COMMANDS {
KEY_COMMAND_ENTER = 1,
KEY_COMMAND_LEFT = 2,
KEY_COMMAND_RIGHT = 3,
KEY_COMMAND_HOME = 4,
KEY_COMMAND_END = 5,
KEY_COMMAND_BACKSPACE = 6,
KEY_COMMAND_TAB = 7,
KEY_COMMAND_INSERT = 8,
KEY_COMMAND_DELETE = 9
};
/// --------------------------------------------------------------
/// THESE METHODS MUST BE IMPLEMENTED BY THE INPUT ENGINE
/// --------------------------------------------------------------
/**
* Initializes the input engine
* @return Returns a true on success, otherwise false.
*/
bool init();
/**
* Performs a "tick" of the input engine.
*
* This method should be called once per frame. It can be used by implementations
* of the input engine that are not running in their own thread, or to perform
* additional administrative tasks that are needed.
*/
void update();
/**
* Returns true if the left mouse button is pressed
*/
bool isLeftMouseDown();
/**
* Returns true if the right mouse button is pressed.
*/
bool isRightMouseDown();
/**
* Returns true if the left mouse button was pressed and released.
*
* The difference between this and IsLeftMouseDown() is that this only returns
* true when the left mouse button is released.
*/
bool wasLeftMouseDown();
/**
* Returns true if the right mouse button was pressed and released.
*
* The difference between this and IsRightMouseDown() is that this only returns
* true when the right mouse button is released.
*/
bool wasRightMouseDown();
/**
* Returns true if the left mouse button double click was done
*/
bool isLeftDoubleClick();
/**
* Returns the X position of the cursor in pixels
*/
int getMouseX();
/**
* Returns the Y position of the cursor in pixels
*/
int getMouseY();
/**
* Returns true if a given key was pressed
* @param KeyCode The key code to be checked
* @return Returns true if the given key is done, otherwise false.
*/
bool isKeyDown(uint keyCode);
/**
* Returns true if a certain key was pushed and released.
*
* The difference between IsKeyDown() is that this only returns true after the key
* has been released. This method facilitates the retrieval of keys, and reading
* strings that users type.
* @param KeyCode The key code to be checked
*/
bool wasKeyDown(uint keyCode);
typedef void (*CharacterCallback)(int command);
/**
* Registers a callback function for keyboard input.
*
* The callback that is registered with this function will be called whenever an
* input key is pressed. A letter entry is different from the query using the
* methods isKeyDown() and wasKeyDown() in the sense that are treated instead
* of actual scan-coded letters. These were taken into account, among other things:
* the keyboard layout, the condition the Shift and Caps Lock keys and the repetition
* of longer holding the key.
* The input of strings by the user through use of callbacks should be implemented.
*/
void setCharacterCallback(CharacterCallback callback);
typedef void (*CommandCallback)(int command);
/**
* Registers a callback function for the input of commands that can have influence on the string input
*
* The callback that is registered with this function will be called whenever the input service
* has a key that affects the character string input. This could be the following keys:
* Enter, End, Left, Right, ...
* The input of strings by the user through the use of callbacks should be implemented.
*/
void setCommandCallback(CommandCallback callback);
void reportCharacter(byte character);
void reportCommand(KEY_COMMANDS command);
bool persist(OutputPersistenceBlock &writer);
bool unpersist(InputPersistenceBlock &reader);
private:
bool registerScriptBindings();
void unregisterScriptBindings();
private:
void testForLeftDoubleClick();
void alterKeyboardState(int keycode, byte newState);
byte _keyboardState[2][512];
bool _leftMouseState[2];
bool _rightMouseState[2];
uint _currentState;
int _mouseX;
int _mouseY;
bool _leftMouseDown;
bool _rightMouseDown;
bool _leftDoubleClick;
uint _doubleClickTime;
int _doubleClickRectWidth;
int _doubleClickRectHeight;
uint _lastLeftClickTime;
int _lastLeftClickMouseX;
int _lastLeftClickMouseY;
CommandCallback _commandCallback;
CharacterCallback _characterCallback;
};
} // End of namespace Sword25
#endif