/*
 # Copyright (c) 2009 - OpenSLX Project, Computer Center University of Freiburg
 #
 # This program is free software distributed under the GPL version 2.
 # See http://openslx.org/COPYING
 #
 # If you have any feedback please consult http://openslx.org/feedback and
 # send your suggestions, praise, or complaints to feedback@openslx.org
 #
 # General information about OpenSLX can be found at http://openslx.org/
 # --------------------------------------------------------------------------
 # inputEvent.h:
 #  - Definition of an input event
 # --------------------------------------------------------------------------
 */

#ifndef INPUTEVENT_H_
#define INPUTEVENT_H_

#include <cassert>
#include <string>
#include <sstream>
#include <stdint.h>

#ifndef __linux
# error "This will only run on a Linux system. Porting is required for other systems."
#endif

struct QDataStream;
struct QString;
struct QMouseEvent;
struct QKeyEvent;

class InputEvent
{
private:
	friend QDataStream& operator<<(QDataStream&, InputEvent const&);
	friend QDataStream& operator>>(QDataStream&, InputEvent&);

	friend void eventToString(InputEvent const& evt, QString& str);
	friend bool eventFromString(QString const& str, InputEvent& evt);

	uint16_t type_;
	uint16_t code_;
	uint32_t value_;

	// InputEvents are immutable. Prohibit assignment:
	InputEvent& operator=(InputEvent const&); // There intentionally is no implementation.
public:
	InputEvent(uint16_t type, uint16_t code, uint32_t value) : type_(type), code_(code), value_(value)
	{
	}

	InputEvent()
	{
	}

	static InputEvent mouseMotion(uint16_t x, uint16_t y)
	{
		return InputEvent(ET_POINTER, 0, ((uint32_t)x << 16) | y);
	}

	static uint16_t mouseButtonsFromQt(int b);

	static InputEvent mousePressRelease(QMouseEvent const* event);
	static InputEvent keyboardPress(QKeyEvent const* event);
	static InputEvent keyboardRelease(QKeyEvent const* event);

	static const uint16_t ET_KEY = 0;
	static const uint16_t ET_BUTTON = 1;
	static const uint16_t ET_POINTER = 2;
	static const uint16_t ET_SPECIAL = 3;

	static const uint16_t EC_PRESS = 0;
	static const uint16_t EC_RELEASE = 1;
	static const uint16_t EC_REBOOT = 2;
	static const uint16_t EC_SYSRQ = 3;
	static const uint16_t EC_KILL_X = 4;

	typedef uint32_t event_key;

	typedef uint32_t event_key_modifiers;

	static const uint16_t EB_LEFT = 1;
	static const uint16_t EB_MIDDLE = 2;
	static const uint16_t EB_RIGHT = 4;

	static const uint32_t MODIFIER_MASK =
			0x7e000000;

	uint16_t type() const
	{
		return type_;
	}

	uint16_t code() const
	{
		return code_;
	}

	uint32_t value() const
	{
		return value_;
	}

	bool isKeyboard() const
	{
		return type_ == ET_KEY;
	}

	bool isButton() const
	{
		return type_ == ET_BUTTON;
	}

	bool isPointer() const
	{
		return type_ == ET_POINTER;
	}

	bool isSpecial() const
	{
		return type_ == ET_SPECIAL;
	}

	bool isPress() const
	{
		return code_ == EC_PRESS;
	}

	bool isRelease() const
	{
		return code_ == EC_RELEASE;
	}

	uint16_t pressedButton() const
	{
		assert(type_ == ET_BUTTON);
		return (value_ >> 16);
	}

	uint16_t heldButtons() const
	{
		assert(type_ == ET_BUTTON);
		return (value_ & 0xffff);
	}

	uint16_t xCoord() const
	{
		assert(type_ == ET_POINTER);
		return (value_ >> 16);
	}

	uint16_t yCoord() const
	{
		assert(type_ == ET_POINTER);
		return (value_ & 0xffff);
	}

	static std::string typeToString(uint16_t type)
	{
		switch(type)
		{
		case ET_BUTTON:
			return "BUTTON";
		case ET_KEY:
			return "KEY";
		case ET_POINTER:
			return "POINTER";
		case ET_SPECIAL:
			return "SPECIAL";
		default:
			std::ostringstream s;
			s << std::hex << type;
			return s.str();
		}
	}

	static std::string codeToString(uint16_t code)
	{
		switch(code)
		{
		case EC_PRESS:
			return "PRESS";
		case EC_RELEASE:
			return "RELEASE";
		case EC_SYSRQ:
			return "SYSRQ";
		case EC_REBOOT:
			return "REBOOT";
		case EC_KILL_X:
			return "KILL_X";
		default:
			std::ostringstream s;
			s << std::hex << code;
			return s.str();
		}
	}

	std::string toString() const
	{
		std::ostringstream s;
		s << typeToString(type_) << ':' << codeToString(code_) << ':' << std::hex << value_;
		return s.str();
	}

	uint32_t qt_keysym() const
	{
		return value_ & ~MODIFIER_MASK;
	}

	uint32_t qt_modifiers() const
	{
		return value_ & MODIFIER_MASK;
	}
};

#endif /* INPUTEVENT_H_ */