7 files changed, 402 insertions, 539 deletions

diff --git a/engines/sword25/input/inputengine.cpp b/engines/sword25/input/inputengine.cpp
index a893152934..a57af23e6b 100644
--- a/engines/sword25/input/inputengine.cpp
+++ b/engines/sword25/input/inputengine.cpp
@@ -34,21 +34,366 @@
 
 #define BS_LOG_PREFIX "INPUTENGINE"
 
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
+#include "common/algorithm.h"
+#include "common/events.h"
+#include "common/system.h"
+#include "common/util.h"
+#include "sword25/kernel/kernel.h"
+#include "sword25/kernel/callbackregistry.h"
+#include "sword25/kernel/inputpersistenceblock.h"
+#include "sword25/kernel/outputpersistenceblock.h"
 #include "sword25/input/inputengine.h"
 
-// -----------------------------------------------------------------------------
-
 namespace Sword25 {
 
-InputEngine::InputEngine(Kernel *pKernel) : Service(pKernel) {
-	if (!_RegisterScriptBindings())
+#define DOUBLE_CLICK_TIME 500
+#define DOUBLE_CLICK_RECT_SIZE 4
+
+InputEngine::InputEngine(Kernel *pKernel) :
+	Service(pKernel),
+	m_CurrentState(0),
+	m_LeftMouseDown(false),
+	m_RightMouseDown(false),
+	m_MouseX(0),
+	m_MouseY(0),
+	m_LeftDoubleClick(false),
+	m_DoubleClickTime(DOUBLE_CLICK_TIME),
+	m_DoubleClickRectWidth(DOUBLE_CLICK_RECT_SIZE),
+	m_DoubleClickRectHeight(DOUBLE_CLICK_RECT_SIZE),
+	m_LastLeftClickTime(0),
+	m_LastLeftClickMouseX(0),
+	m_LastLeftClickMouseY(0) {
+	memset(m_KeyboardState[0], 0, sizeof(m_KeyboardState[0]));
+	memset(m_KeyboardState[1], 0, sizeof(m_KeyboardState[1]));
+	m_LeftMouseState[0] = false;
+	m_LeftMouseState[1] = false;
+	m_RightMouseState[0] = false;
+	m_RightMouseState[1] = false;
+
+	if (!registerScriptBindings())
 		BS_LOG_ERRORLN("Script bindings could not be registered.");
 	else
 		BS_LOGLN("Script bindings registered.");
 }
 
+Service *InputEngine_CreateObject(Kernel *pKernel) {
+	return new InputEngine(pKernel);
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::Init() {
+	// No initialisation needed
+	return true;
+}
+
+// -----------------------------------------------------------------------------
+
+void InputEngine::Update() {
+	Common::Event event;
+	m_CurrentState ^= 1;
+
+	// Loop through processing any pending events
+	bool handleEvents = true;
+	while (handleEvents && g_system->getEventManager()->pollEvent(event)) {
+		switch (event.type) {
+		case Common::EVENT_LBUTTONDOWN:
+		case Common::EVENT_LBUTTONUP:
+			m_LeftMouseDown = event.type == Common::EVENT_LBUTTONDOWN;
+			m_MouseX = event.mouse.x;
+			m_MouseY = event.mouse.y;
+			handleEvents = false;
+			break;
+		case Common::EVENT_RBUTTONDOWN:
+		case Common::EVENT_RBUTTONUP:
+			m_RightMouseDown = event.type == Common::EVENT_RBUTTONDOWN;
+			m_MouseX = event.mouse.x;
+			m_MouseY = event.mouse.y;
+			handleEvents = false;
+			break;
+
+		case Common::EVENT_MOUSEMOVE:
+			m_MouseX = event.mouse.x;
+			m_MouseY = event.mouse.y;
+			break;
+
+		case Common::EVENT_KEYDOWN:
+		case Common::EVENT_KEYUP:
+			AlterKeyboardState(event.kbd.keycode, (event.type == Common::EVENT_KEYDOWN) ? 0x80 : 0);
+			break;
+
+		case Common::EVENT_QUIT:
+			Kernel::GetInstance()->GetWindow()->SetWindowAlive(false);
+			break;
+
+		default:
+			break;
+		}
+	}
+
+	m_LeftMouseState[m_CurrentState] = m_LeftMouseDown;
+	m_RightMouseState[m_CurrentState] = m_RightMouseDown;
+
+	TestForLeftDoubleClick();
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::IsLeftMouseDown() {
+	return m_LeftMouseDown;
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::IsRightMouseDown() {
+	return m_RightMouseDown;
+}
+
+// -----------------------------------------------------------------------------
+
+void InputEngine::TestForLeftDoubleClick() {
+	m_LeftDoubleClick = false;
+
+	// Only bother checking for a double click if the left mouse button was clicked
+	if (WasLeftMouseDown()) {
+		// Get the time now
+		uint Now = Kernel::GetInstance()->GetMilliTicks();
+
+		// A double click is signalled if
+		// 1. The two clicks are close enough together
+		// 2. The mouse cursor hasn't moved much
+		if (Now - m_LastLeftClickTime <= m_DoubleClickTime &&
+		        ABS(m_MouseX - m_LastLeftClickMouseX) <= m_DoubleClickRectWidth / 2 &&
+		        ABS(m_MouseY - m_LastLeftClickMouseY) <= m_DoubleClickRectHeight / 2) {
+			m_LeftDoubleClick = true;
+
+			// Reset the time and position of the last click, so that clicking is not
+			// interpreted as the first click of a further double-click
+			m_LastLeftClickTime = 0;
+			m_LastLeftClickMouseX = 0;
+			m_LastLeftClickMouseY = 0;
+		} else {
+			// There is no double click. Remember the position and time of the click,
+			// in case it's the first click of a double-click sequence
+			m_LastLeftClickTime = Now;
+			m_LastLeftClickMouseX = m_MouseX;
+			m_LastLeftClickMouseY = m_MouseY;
+		}
+	}
+}
+
+// -----------------------------------------------------------------------------
+
+void InputEngine::AlterKeyboardState(int keycode, byte newState) {
+	m_KeyboardState[m_CurrentState][keycode] = newState;
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::IsLeftDoubleClick() {
+	return m_LeftDoubleClick;
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::WasLeftMouseDown() {
+	return (m_LeftMouseState[m_CurrentState] == false) && (m_LeftMouseState[m_CurrentState ^ 1] == true);
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::WasRightMouseDown() {
+	return (m_RightMouseState[m_CurrentState] == false) && (m_RightMouseState[m_CurrentState ^ 1] == true);
+}
+
+// -----------------------------------------------------------------------------
+
+int InputEngine::GetMouseX() {
+	return m_MouseX;
+}
+
+// -----------------------------------------------------------------------------
+
+int InputEngine::GetMouseY() {
+	return m_MouseY;
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::IsKeyDown(uint KeyCode) {
+	return (m_KeyboardState[m_CurrentState][KeyCode] & 0x80) != 0;
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::WasKeyDown(uint KeyCode) {
+	return ((m_KeyboardState[m_CurrentState][KeyCode] & 0x80) == 0) &&
+	       ((m_KeyboardState[m_CurrentState ^ 1][KeyCode] & 0x80) != 0);
+}
+
+// -----------------------------------------------------------------------------
+
+void InputEngine::SetMouseX(int PosX) {
+	m_MouseX = PosX;
+	g_system->warpMouse(m_MouseX, m_MouseY);
+}
+
+// -----------------------------------------------------------------------------
+
+void InputEngine::SetMouseY(int PosY) {
+	m_MouseY = PosY;
+	g_system->warpMouse(m_MouseX, m_MouseY);
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::RegisterCharacterCallback(CharacterCallback Callback) {
+	if (Common::find(m_CharacterCallbacks.begin(), m_CharacterCallbacks.end(), Callback) == m_CharacterCallbacks.end()) {
+		m_CharacterCallbacks.push_back(Callback);
+		return true;
+	} else {
+		BS_LOG_WARNINGLN("Tried to register an CharacterCallback that was already registered.");
+		return false;
+	}
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::UnregisterCharacterCallback(CharacterCallback Callback) {
+	Common::List<CharacterCallback>::iterator CallbackIter = Common::find(m_CharacterCallbacks.begin(),
+	        m_CharacterCallbacks.end(), Callback);
+	if (CallbackIter != m_CharacterCallbacks.end()) {
+		m_CharacterCallbacks.erase(CallbackIter);
+		return true;
+	} else {
+		BS_LOG_WARNINGLN("Tried to unregister an CharacterCallback that was not previously registered.");
+		return false;
+	}
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::RegisterCommandCallback(CommandCallback Callback) {
+	if (Common::find(m_CommandCallbacks.begin(), m_CommandCallbacks.end(), Callback) == m_CommandCallbacks.end()) {
+		m_CommandCallbacks.push_back(Callback);
+		return true;
+	} else {
+		BS_LOG_WARNINGLN("Tried to register an CommandCallback that was already registered.");
+		return false;
+	}
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::UnregisterCommandCallback(CommandCallback Callback) {
+	Common::List<CommandCallback>::iterator CallbackIter =
+	    Common::find(m_CommandCallbacks.begin(), m_CommandCallbacks.end(), Callback);
+	if (CallbackIter != m_CommandCallbacks.end()) {
+		m_CommandCallbacks.erase(CallbackIter);
+		return true;
+	} else {
+		BS_LOG_WARNINGLN("Tried to unregister an CommandCallback that was not previously registered.");
+		return false;
+	}
+}
+
+// -----------------------------------------------------------------------------
+
+void InputEngine::ReportCharacter(byte Character) {
+	Common::List<CharacterCallback>::const_iterator CallbackIter = m_CharacterCallbacks.begin();
+	while (CallbackIter != m_CharacterCallbacks.end()) {
+		// Iterator vor dem Aufruf erhöhen und im Folgendem auf einer Kopie arbeiten.
+		// Dieses Vorgehen ist notwendig da der Iterator möglicherweise von der Callbackfunktion durch das Deregistrieren des Callbacks
+		// invalidiert wird.
+		Common::List<CharacterCallback>::const_iterator CurCallbackIter = CallbackIter;
+		++CallbackIter;
+
+		(*CurCallbackIter)(Character);
+	}
+}
+
+// -----------------------------------------------------------------------------
+
+void InputEngine::ReportCommand(KEY_COMMANDS Command) {
+	Common::List<CommandCallback>::const_iterator CallbackIter = m_CommandCallbacks.begin();
+	while (CallbackIter != m_CommandCallbacks.end()) {
+		// Iterator vor dem Aufruf erhöhen und im Folgendem auf einer Kopie arbeiten.
+		// Dieses Vorgehen ist notwendig da der Iterator möglicherweise von der Callbackfunktion durch das Deregistrieren des Callbacks
+		// invalidiert wird.
+		Common::List<CommandCallback>::const_iterator CurCallbackIter = CallbackIter;
+		++CallbackIter;
+
+		(*CurCallbackIter)(Command);
+	}
+}
+
+// -----------------------------------------------------------------------------
+// Persistenz
+// -----------------------------------------------------------------------------
+
+bool InputEngine::persist(OutputPersistenceBlock &writer) {
+	// Anzahl an Command-Callbacks persistieren.
+	writer.write(m_CommandCallbacks.size());
+
+	// Alle Command-Callbacks einzeln persistieren.
+	{
+		Common::List<CommandCallback>::const_iterator It = m_CommandCallbacks.begin();
+		while (It != m_CommandCallbacks.end()) {
+			writer.write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
+			++It;
+		}
+	}
+
+	// Anzahl an Character-Callbacks persistieren.
+	writer.write(m_CharacterCallbacks.size());
+
+	// Alle Character-Callbacks einzeln persistieren.
+	{
+		Common::List<CharacterCallback>::const_iterator It = m_CharacterCallbacks.begin();
+		while (It != m_CharacterCallbacks.end()) {
+			writer.write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
+			++It;
+		}
+	}
+
+	return true;
+}
+
+// -----------------------------------------------------------------------------
+
+bool InputEngine::unpersist(InputPersistenceBlock &reader) {
+	// Command-Callbackliste leeren.
+	m_CommandCallbacks.clear();
+
+	// Anzahl an Command-Callbacks lesen.
+	uint CommandCallbackCount;
+	reader.read(CommandCallbackCount);
+
+	// Alle Command-Callbacks wieder herstellen.
+	for (uint i = 0; i < CommandCallbackCount; ++i) {
+		Common::String CallbackFunctionName;
+		reader.read(CallbackFunctionName);
+
+		m_CommandCallbacks.push_back(reinterpret_cast<CommandCallback>(
+		                                 CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
+	}
+
+	// Character-Callbackliste leeren.
+	m_CharacterCallbacks.clear();
+
+	// Anzahl an Character-Callbacks lesen.
+	uint CharacterCallbackCount;
+	reader.read(CharacterCallbackCount);
+
+	// Alle Character-Callbacks wieder herstellen.
+	for (uint i = 0; i < CharacterCallbackCount; ++i) {
+		Common::String CallbackFunctionName;
+		reader.read(CallbackFunctionName);
+
+		m_CharacterCallbacks.push_back(reinterpret_cast<CharacterCallback>(CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
+	}
+
+	return reader.isGood();
+}
+
 } // End of namespace Sword25
diff --git a/engines/sword25/input/inputengine.h b/engines/sword25/input/inputengine.h
index ba683443dd..540817b5ce 100644
--- a/engines/sword25/input/inputengine.h
+++ b/engines/sword25/input/inputengine.h
@@ -58,7 +58,7 @@ namespace Sword25 {
 class InputEngine : public Service, public Persistable {
 public:
 	InputEngine(Kernel *pKernel);
-	virtual ~InputEngine() {};
+	~InputEngine() {};
 
 	// NOTE: These codes are registered in inputengine_script.cpp
 	// Any changes to these enums must also adjust the above file.
@@ -176,7 +176,7 @@ public:
 	 * Initialises the input engine
 	 * @return          Returns a true on success, otherwise false.
 	 */
-	virtual bool Init() = 0;
+	bool Init();
 
 	/**
 	 * Performs a "tick" of the input engine.
@@ -185,17 +185,17 @@ public:
 	 * of the input engine that are not running in their own thread, or to perform
 	 * additional administrative tasks that are needed.
 	 */
-	virtual void Update() = 0;
+	void Update();
 
 	/**
 	 * Returns true if the left mouse button is pressed
 	 */
-	virtual bool IsLeftMouseDown() = 0;
+	bool IsLeftMouseDown();
 
 	/**
 	 * Returns true if the right mouse button is pressed.
 	*/
-	virtual bool IsRightMouseDown() = 0;
+	bool IsRightMouseDown();
 
 	/**
 	 * Returns true if the left mouse button was pressed and released.
@@ -203,7 +203,7 @@ public:
 	 * The difference between this and IsLeftMouseDown() is that this only returns
 	 * true when the left mouse button is released.
 	*/
-	virtual bool WasLeftMouseDown() = 0;
+	bool WasLeftMouseDown();
 
 	/**
 	 * Returns true if the right mouse button was pressed and released.
@@ -211,39 +211,39 @@ public:
 	 * The difference between this and IsRightMouseDown() is that this only returns
 	 * true when the right mouse button is released.
 	*/
-	virtual bool WasRightMouseDown() = 0;
+	bool WasRightMouseDown();
 
 	/**
 	 * Returns true if the left mouse button double click was done
 	 */
-	virtual bool IsLeftDoubleClick() = 0;
+	bool IsLeftDoubleClick();
 
 	/**
 	 * Returns the X position of the cursor in pixels
 	*/
-	virtual int GetMouseX() = 0;
+	int GetMouseX();
 
 	/**
 	 * Returns the Y position of the cursor in pixels
 	 */
-	virtual int GetMouseY() = 0;
+	int GetMouseY();
 
 	/**
 	 * Sets the X position of the cursor in pixels
 	 */
-	virtual void SetMouseX(int PosX) = 0;
+	void SetMouseX(int PosX);
 
 	/**
 	 * Sets the Y position of the cursor in pixels
 	 */
-	virtual void SetMouseY(int PosY) = 0;
+	void SetMouseY(int PosY);
 
 	/**
 	 * 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.
 	 */
-	virtual bool IsKeyDown(uint KeyCode) = 0;
+	bool IsKeyDown(uint KeyCode);
 
 	/**
 	 * Returns true if a certain key was pushed and released.
@@ -253,7 +253,7 @@ public:
 	 * strings that users type.
 	 * @param KeyCode       The key code to be checked
 	 */
-	virtual bool WasKeyDown(uint KeyCode) = 0;
+	bool WasKeyDown(uint KeyCode);
 
 	typedef CallbackPtr CharacterCallback;
 
@@ -269,13 +269,13 @@ public:
 	 * The input of strings by the user through use of callbacks should be implemented.
 	 * @return              Returns true if the function was registered, otherwise false.
 	*/
-	virtual bool RegisterCharacterCallback(CallbackPtr Callback) = 0;
+	bool RegisterCharacterCallback(CallbackPtr Callback);
 
 	/**
 	 * De-registeres a previously registered callback function.
 	 * @return              Returns true if the function could be de-registered, otherwise false.
 	 */
-	virtual bool UnregisterCharacterCallback(CallbackPtr Callback) = 0;
+	bool UnregisterCharacterCallback(CallbackPtr Callback);
 
 	typedef CallbackPtr CommandCallback;
 
@@ -288,19 +288,44 @@ public:
 	 * The input of strings by the user through the use of callbacks should be implemented.
 	 * @return              Returns true if the function was registered, otherwise false.
 	 */
-	virtual bool RegisterCommandCallback(CallbackPtr Callback) = 0;
+	bool RegisterCommandCallback(CallbackPtr Callback);
 
 	/**
 	 * Un-register a callback function for the input of commands that can have an influence on the string input.
 	 * @return              Returns true if the function could be de-registered, otherwise false.
 	 */
-	virtual bool UnregisterCommandCallback(CommandCallback Callback) = 0;
+	bool UnregisterCommandCallback(CommandCallback Callback);
 
-	virtual void ReportCharacter(byte Character) = 0;
-	virtual void ReportCommand(KEY_COMMANDS Command) = 0;
+	void ReportCharacter(byte Character);
+	void ReportCommand(KEY_COMMANDS Command);
+
+	bool persist(OutputPersistenceBlock &writer);
+	bool unpersist(InputPersistenceBlock &reader);
+
+private:
+	bool registerScriptBindings();
 
 private:
-	bool _RegisterScriptBindings();
+	void TestForLeftDoubleClick();
+	void AlterKeyboardState(int keycode, byte newState);
+
+	byte                            m_KeyboardState[2][256];
+	bool                            m_LeftMouseState[2];
+	bool                            m_RightMouseState[2];
+	uint                    m_CurrentState;
+	int                             m_MouseX;
+	int                             m_MouseY;
+	bool                            m_LeftMouseDown;
+	bool                            m_RightMouseDown;
+	bool                            m_LeftDoubleClick;
+	uint                    m_DoubleClickTime;
+	int                             m_DoubleClickRectWidth;
+	int                             m_DoubleClickRectHeight;
+	uint                    m_LastLeftClickTime;
+	int                             m_LastLeftClickMouseX;
+	int                             m_LastLeftClickMouseY;
+	Common::List<CommandCallback>       m_CommandCallbacks;
+	Common::List<CharacterCallback> m_CharacterCallbacks;
 };
 
 } // End of namespace Sword25
diff --git a/engines/sword25/input/inputengine_script.cpp b/engines/sword25/input/inputengine_script.cpp
index d3092af794..791414f639 100644
--- a/engines/sword25/input/inputengine_script.cpp
+++ b/engines/sword25/input/inputengine_script.cpp
@@ -335,7 +335,7 @@ static const lua_constant_reg PACKAGE_CONSTANTS[] = {
 
 // -----------------------------------------------------------------------------
 
-bool InputEngine::_RegisterScriptBindings() {
+bool InputEngine::registerScriptBindings() {
 	Kernel *pKernel = Kernel::GetInstance();
 	BS_ASSERT(pKernel);
 	ScriptEngine *pScript = static_cast<ScriptEngine *>(pKernel->GetService("script"));
diff --git a/engines/sword25/input/scummvminput.cpp b/engines/sword25/input/scummvminput.cpp
deleted file mode 100644
index 34763b0125..0000000000
--- a/engines/sword25/input/scummvminput.cpp
+++ /dev/null
@@ -1,403 +0,0 @@
-/* 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.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-#include "common/algorithm.h"
-#include "common/events.h"
-#include "common/system.h"
-#include "common/util.h"
-#include "sword25/kernel/kernel.h"
-#include "sword25/kernel/callbackregistry.h"
-#include "sword25/kernel/inputpersistenceblock.h"
-#include "sword25/kernel/outputpersistenceblock.h"
-#include "sword25/input/scummvminput.h"
-
-#define BS_LOG_PREFIX "SCUMMVMINPUT"
-
-namespace Sword25 {
-
-#define DOUBLE_CLICK_TIME 500
-#define DOUBLE_CLICK_RECT_SIZE 4
-
-// -----------------------------------------------------------------------------
-// Constructor / Destructor
-// -----------------------------------------------------------------------------
-
-ScummVMInput::ScummVMInput(Kernel *pKernel) :
-	m_CurrentState(0),
-	m_LeftMouseDown(false),
-	m_RightMouseDown(false),
-	m_MouseX(0),
-	m_MouseY(0),
-	m_LeftDoubleClick(false),
-	m_DoubleClickTime(DOUBLE_CLICK_TIME),
-	m_DoubleClickRectWidth(DOUBLE_CLICK_RECT_SIZE),
-	m_DoubleClickRectHeight(DOUBLE_CLICK_RECT_SIZE),
-	m_LastLeftClickTime(0),
-	m_LastLeftClickMouseX(0),
-	m_LastLeftClickMouseY(0),
-	InputEngine(pKernel) {
-	memset(m_KeyboardState[0], 0, sizeof(m_KeyboardState[0]));
-	memset(m_KeyboardState[1], 0, sizeof(m_KeyboardState[1]));
-	m_LeftMouseState[0] = false;
-	m_LeftMouseState[1] = false;
-	m_RightMouseState[0] = false;
-	m_RightMouseState[1] = false;
-}
-
-ScummVMInput::~ScummVMInput() {
-}
-
-// -----------------------------------------------------------------------------
-
-Service *ScummVMInput_CreateObject(Kernel *pKernel) {
-	return new ScummVMInput(pKernel);
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::Init() {
-	// No initialisation needed
-	return true;
-}
-
-// -----------------------------------------------------------------------------
-
-void ScummVMInput::Update() {
-	Common::Event event;
-	m_CurrentState ^= 1;
-
-	// Loop through processing any pending events
-	bool handleEvents = true;
-	while (handleEvents && g_system->getEventManager()->pollEvent(event)) {
-		switch (event.type) {
-		case Common::EVENT_LBUTTONDOWN:
-		case Common::EVENT_LBUTTONUP:
-			m_LeftMouseDown = event.type == Common::EVENT_LBUTTONDOWN;
-			m_MouseX = event.mouse.x;
-			m_MouseY = event.mouse.y;
-			handleEvents = false;
-			break;
-		case Common::EVENT_RBUTTONDOWN:
-		case Common::EVENT_RBUTTONUP:
-			m_RightMouseDown = event.type == Common::EVENT_RBUTTONDOWN;
-			m_MouseX = event.mouse.x;
-			m_MouseY = event.mouse.y;
-			handleEvents = false;
-			break;
-
-		case Common::EVENT_MOUSEMOVE:
-			m_MouseX = event.mouse.x;
-			m_MouseY = event.mouse.y;
-			break;
-
-		case Common::EVENT_KEYDOWN:
-		case Common::EVENT_KEYUP:
-			AlterKeyboardState(event.kbd.keycode, (event.type == Common::EVENT_KEYDOWN) ? 0x80 : 0);
-			break;
-
-		case Common::EVENT_QUIT:
-			Kernel::GetInstance()->GetWindow()->SetWindowAlive(false);
-			break;
-
-		default:
-			break;
-		}
-	}
-
-	m_LeftMouseState[m_CurrentState] = m_LeftMouseDown;
-	m_RightMouseState[m_CurrentState] = m_RightMouseDown;
-
-	TestForLeftDoubleClick();
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::IsLeftMouseDown() {
-	return m_LeftMouseDown;
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::IsRightMouseDown() {
-	return m_RightMouseDown;
-}
-
-// -----------------------------------------------------------------------------
-
-void ScummVMInput::TestForLeftDoubleClick() {
-	m_LeftDoubleClick = false;
-
-	// Only bother checking for a double click if the left mouse button was clicked
-	if (WasLeftMouseDown()) {
-		// Get the time now
-		uint Now = Kernel::GetInstance()->GetMilliTicks();
-
-		// A double click is signalled if
-		// 1. The two clicks are close enough together
-		// 2. The mouse cursor hasn't moved much
-		if (Now - m_LastLeftClickTime <= m_DoubleClickTime &&
-		        ABS(m_MouseX - m_LastLeftClickMouseX) <= m_DoubleClickRectWidth / 2 &&
-		        ABS(m_MouseY - m_LastLeftClickMouseY) <= m_DoubleClickRectHeight / 2) {
-			m_LeftDoubleClick = true;
-
-			// Reset the time and position of the last click, so that clicking is not
-			// interpreted as the first click of a further double-click
-			m_LastLeftClickTime = 0;
-			m_LastLeftClickMouseX = 0;
-			m_LastLeftClickMouseY = 0;
-		} else {
-			// There is no double click. Remember the position and time of the click,
-			// in case it's the first click of a double-click sequence
-			m_LastLeftClickTime = Now;
-			m_LastLeftClickMouseX = m_MouseX;
-			m_LastLeftClickMouseY = m_MouseY;
-		}
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-void ScummVMInput::AlterKeyboardState(int keycode, byte newState) {
-	m_KeyboardState[m_CurrentState][keycode] = newState;
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::IsLeftDoubleClick() {
-	return m_LeftDoubleClick;
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::WasLeftMouseDown() {
-	return (m_LeftMouseState[m_CurrentState] == false) && (m_LeftMouseState[m_CurrentState ^ 1] == true);
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::WasRightMouseDown() {
-	return (m_RightMouseState[m_CurrentState] == false) && (m_RightMouseState[m_CurrentState ^ 1] == true);
-}
-
-// -----------------------------------------------------------------------------
-
-int ScummVMInput::GetMouseX() {
-	return m_MouseX;
-}
-
-// -----------------------------------------------------------------------------
-
-int ScummVMInput::GetMouseY() {
-	return m_MouseY;
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::IsKeyDown(uint KeyCode) {
-	return (m_KeyboardState[m_CurrentState][KeyCode] & 0x80) != 0;
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::WasKeyDown(uint KeyCode) {
-	return ((m_KeyboardState[m_CurrentState][KeyCode] & 0x80) == 0) &&
-	       ((m_KeyboardState[m_CurrentState ^ 1][KeyCode] & 0x80) != 0);
-}
-
-// -----------------------------------------------------------------------------
-
-void ScummVMInput::SetMouseX(int PosX) {
-	m_MouseX = PosX;
-	g_system->warpMouse(m_MouseX, m_MouseY);
-}
-
-// -----------------------------------------------------------------------------
-
-void ScummVMInput::SetMouseY(int PosY) {
-	m_MouseY = PosY;
-	g_system->warpMouse(m_MouseX, m_MouseY);
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::RegisterCharacterCallback(CharacterCallback Callback) {
-	if (Common::find(m_CharacterCallbacks.begin(), m_CharacterCallbacks.end(), Callback) == m_CharacterCallbacks.end()) {
-		m_CharacterCallbacks.push_back(Callback);
-		return true;
-	} else {
-		BS_LOG_WARNINGLN("Tried to register an CharacterCallback that was already registered.");
-		return false;
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::UnregisterCharacterCallback(CharacterCallback Callback) {
-	Common::List<CharacterCallback>::iterator CallbackIter = Common::find(m_CharacterCallbacks.begin(),
-	        m_CharacterCallbacks.end(), Callback);
-	if (CallbackIter != m_CharacterCallbacks.end()) {
-		m_CharacterCallbacks.erase(CallbackIter);
-		return true;
-	} else {
-		BS_LOG_WARNINGLN("Tried to unregister an CharacterCallback that was not previously registered.");
-		return false;
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::RegisterCommandCallback(CommandCallback Callback) {
-	if (Common::find(m_CommandCallbacks.begin(), m_CommandCallbacks.end(), Callback) == m_CommandCallbacks.end()) {
-		m_CommandCallbacks.push_back(Callback);
-		return true;
-	} else {
-		BS_LOG_WARNINGLN("Tried to register an CommandCallback that was already registered.");
-		return false;
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::UnregisterCommandCallback(CommandCallback Callback) {
-	Common::List<CommandCallback>::iterator CallbackIter =
-	    Common::find(m_CommandCallbacks.begin(), m_CommandCallbacks.end(), Callback);
-	if (CallbackIter != m_CommandCallbacks.end()) {
-		m_CommandCallbacks.erase(CallbackIter);
-		return true;
-	} else {
-		BS_LOG_WARNINGLN("Tried to unregister an CommandCallback that was not previously registered.");
-		return false;
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-void ScummVMInput::ReportCharacter(byte Character) {
-	Common::List<CharacterCallback>::const_iterator CallbackIter = m_CharacterCallbacks.begin();
-	while (CallbackIter != m_CharacterCallbacks.end()) {
-		// Iterator vor dem Aufruf erhöhen und im Folgendem auf einer Kopie arbeiten.
-		// Dieses Vorgehen ist notwendig da der Iterator möglicherweise von der Callbackfunktion durch das Deregistrieren des Callbacks
-		// invalidiert wird.
-		Common::List<CharacterCallback>::const_iterator CurCallbackIter = CallbackIter;
-		++CallbackIter;
-
-		(*CurCallbackIter)(Character);
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-void ScummVMInput::ReportCommand(KEY_COMMANDS Command) {
-	Common::List<CommandCallback>::const_iterator CallbackIter = m_CommandCallbacks.begin();
-	while (CallbackIter != m_CommandCallbacks.end()) {
-		// Iterator vor dem Aufruf erhöhen und im Folgendem auf einer Kopie arbeiten.
-		// Dieses Vorgehen ist notwendig da der Iterator möglicherweise von der Callbackfunktion durch das Deregistrieren des Callbacks
-		// invalidiert wird.
-		Common::List<CommandCallback>::const_iterator CurCallbackIter = CallbackIter;
-		++CallbackIter;
-
-		(*CurCallbackIter)(Command);
-	}
-}
-
-// -----------------------------------------------------------------------------
-// Persistenz
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::persist(OutputPersistenceBlock &writer) {
-	// Anzahl an Command-Callbacks persistieren.
-	writer.write(m_CommandCallbacks.size());
-
-	// Alle Command-Callbacks einzeln persistieren.
-	{
-		Common::List<CommandCallback>::const_iterator It = m_CommandCallbacks.begin();
-		while (It != m_CommandCallbacks.end()) {
-			writer.write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
-			++It;
-		}
-	}
-
-	// Anzahl an Character-Callbacks persistieren.
-	writer.write(m_CharacterCallbacks.size());
-
-	// Alle Character-Callbacks einzeln persistieren.
-	{
-		Common::List<CharacterCallback>::const_iterator It = m_CharacterCallbacks.begin();
-		while (It != m_CharacterCallbacks.end()) {
-			writer.write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
-			++It;
-		}
-	}
-
-	return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool ScummVMInput::unpersist(InputPersistenceBlock &reader) {
-	// Command-Callbackliste leeren.
-	m_CommandCallbacks.clear();
-
-	// Anzahl an Command-Callbacks lesen.
-	uint CommandCallbackCount;
-	reader.read(CommandCallbackCount);
-
-	// Alle Command-Callbacks wieder herstellen.
-	for (uint i = 0; i < CommandCallbackCount; ++i) {
-		Common::String CallbackFunctionName;
-		reader.read(CallbackFunctionName);
-
-		m_CommandCallbacks.push_back(reinterpret_cast<CommandCallback>(
-		                                 CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
-	}
-
-	// Character-Callbackliste leeren.
-	m_CharacterCallbacks.clear();
-
-	// Anzahl an Character-Callbacks lesen.
-	uint CharacterCallbackCount;
-	reader.read(CharacterCallbackCount);
-
-	// Alle Character-Callbacks wieder herstellen.
-	for (uint i = 0; i < CharacterCallbackCount; ++i) {
-		Common::String CallbackFunctionName;
-		reader.read(CallbackFunctionName);
-
-		m_CharacterCallbacks.push_back(reinterpret_cast<CharacterCallback>(CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
-	}
-
-	return reader.isGood();
-}
-
-} // End of namespace Sword25
diff --git a/engines/sword25/input/scummvminput.h b/engines/sword25/input/scummvminput.h
deleted file mode 100644
index dcb6b8733f..0000000000
--- a/engines/sword25/input/scummvminput.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/* 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.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-#ifndef SWORD25_STDWININPUT_H
-#define SWORD25_STDWININPUT_H
-
-/// Includes
-#include "common/scummsys.h"
-#include "common/list.h"
-#include "sword25/kernel/common.h"
-#include "sword25/input/inputengine.h"
-
-namespace Sword25 {
-
-/// Forward class definitions
-class Kernel;
-
-/// Class definitions
-class ScummVMInput : public InputEngine {
-public:
-	ScummVMInput(Kernel *pKernel);
-	virtual ~ScummVMInput();
-
-	virtual bool Init();
-	virtual void Update();
-	virtual bool IsLeftMouseDown();
-	virtual bool IsRightMouseDown();
-	virtual bool WasLeftMouseDown();
-	virtual bool WasRightMouseDown();
-	virtual bool IsLeftDoubleClick();
-	virtual int GetMouseX();
-	virtual int GetMouseY();
-	virtual bool IsKeyDown(uint KeyCode);
-	virtual bool WasKeyDown(uint KeyCode);
-	virtual void SetMouseX(int PosX);
-	virtual void SetMouseY(int PosY);
-	virtual bool RegisterCharacterCallback(CallbackPtr Callback);
-	virtual bool UnregisterCharacterCallback(CallbackPtr Callback);
-	virtual bool RegisterCommandCallback(CallbackPtr Callback);
-	virtual bool UnregisterCommandCallback(CallbackPtr Callback);
-	virtual void ReportCharacter(byte Character);
-	virtual void ReportCommand(KEY_COMMANDS Command);
-
-	bool persist(OutputPersistenceBlock &writer);
-	bool unpersist(InputPersistenceBlock &reader);
-
-private:
-	void TestForLeftDoubleClick();
-	void AlterKeyboardState(int keycode, byte newState);
-
-	byte                            m_KeyboardState[2][256];
-	bool                            m_LeftMouseState[2];
-	bool                            m_RightMouseState[2];
-	uint                    m_CurrentState;
-	int                             m_MouseX;
-	int                             m_MouseY;
-	bool                            m_LeftMouseDown;
-	bool                            m_RightMouseDown;
-	bool                            m_LeftDoubleClick;
-	uint                    m_DoubleClickTime;
-	int                             m_DoubleClickRectWidth;
-	int                             m_DoubleClickRectHeight;
-	uint                    m_LastLeftClickTime;
-	int                             m_LastLeftClickMouseX;
-	int                             m_LastLeftClickMouseY;
-	Common::List<CommandCallback>       m_CommandCallbacks;
-	Common::List<CharacterCallback> m_CharacterCallbacks;
-};
-
-} // End of namespace Sword25
-
-#endif
diff --git a/engines/sword25/kernel/service_ids.h b/engines/sword25/kernel/service_ids.h
index c2d65d989f..bf60279679 100644
--- a/engines/sword25/kernel/service_ids.h
+++ b/engines/sword25/kernel/service_ids.h
@@ -51,7 +51,7 @@ namespace Sword25 {
 
 Service *OpenGLGfx_CreateObject(Kernel *pKernel);
 Service *PackageManager_CreateObject(Kernel *pKernel);
-Service *ScummVMInput_CreateObject(Kernel *pKernel);
+Service *InputEngine_CreateObject(Kernel *pKernel);
 Service *FMODExSound_CreateObject(Kernel *pKernel);
 Service *LuaScriptEngine_CreateObject(Kernel *pKernel);
 Service *Geometry_CreateObject(Kernel *pKernel);
@@ -66,7 +66,7 @@ const BS_ServiceInfo BS_SERVICE_TABLE[] = {
 	// BS_ServiceInfo("Superclass", "Service", CreateMethod)
 	BS_ServiceInfo("gfx", "opengl", OpenGLGfx_CreateObject),
 	BS_ServiceInfo("package", "archiveFS", PackageManager_CreateObject),
-	BS_ServiceInfo("input", "winapi", ScummVMInput_CreateObject),
+	BS_ServiceInfo("input", "winapi", InputEngine_CreateObject),
 	BS_ServiceInfo("sfx", "fmodex", FMODExSound_CreateObject),
 	BS_ServiceInfo("script", "lua", LuaScriptEngine_CreateObject),
 	BS_ServiceInfo("geometry", "std", Geometry_CreateObject),
diff --git a/engines/sword25/module.mk b/engines/sword25/module.mk
index 3c620da965..34a6988915 100644
--- a/engines/sword25/module.mk
+++ b/engines/sword25/module.mk
@@ -43,7 +43,6 @@ MODULE_OBJS := \
 	gfx/opengl/swimage.o \
 	input/inputengine.o \
 	input/inputengine_script.o \
-	input/scummvminput.o \
 	kernel/callbackregistry.o \
 	kernel/filesystemutil.o \
 	kernel/inputpersistenceblock.o \