MegaGlest/source/shared_lib/include/platform/sdl/window.h

// ==============================================================
// ==============================================================
//	This file is part of Glest Shared Library (www.glest.org)
//
//	Copyright (C) 2005 Matthias Braun <matze@braunis.de>
//
//	You can redistribute this code 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
// ==============================================================

#ifndef _SHARED_PLATFORM_WINDOW_H_
#define _SHARED_PLATFORM_WINDOW_H_

#include <map>
#include <string>
#include <SDL.h>
#include <cassert>
#include "data_types.h"
#include "vec.h"
#include <vector>
#include "leak_dumper.h"

using std::map;
using std::vector;
using std::string;
using Shared::Graphics::Vec2i;

#if SDL_VERSION_ATLEAST(2,0,0)

typedef SDL_Keysym SDL_keysym;

#endif

namespace Shared{ namespace Platform{

class Timer;
//class PlatformContextGl;

enum MouseButton {
	mbUnknown,
	mbLeft,
	mbCenter,
	mbRight,
	mbButtonX1,
	mbButtonX2,

	mbCount
};

enum SizeState{
	ssMaximized,
	ssMinimized,
	ssRestored
};

class MouseState {
private:
	bool states[mbCount];


public:
	MouseState() {
		clear();
	}
	//MouseState(const MouseState &);
	//MouseState &operator=(const MouseState &);
	void clear() { memset(this, 0, sizeof(MouseState)); }

	bool get(MouseButton b) const {
		if(b > 0 && b < mbCount) {
			return states[b];
		}
		return false;
	}

	void set(MouseButton b, bool state) {
		if(b > 0 && b < mbCount) {
			states[b] = state;
		}
	}
};

enum WindowStyle{
	wsFullscreen,
	wsWindowedFixed,
	wsWindowedResizable
};

// =====================================================
//	class Window
// =====================================================

class Window {
private:
	static SDL_Window *sdlWindow;
	Uint32 lastMouseDown[mbCount];
	int lastMouseX[mbCount];
	int lastMouseY[mbCount];

    static int64 lastMouseEvent;	/** for use in mouse hover calculations */
    static MouseState mouseState;
    static Vec2i mousePos;
    static bool isKeyPressedDown;
	static bool isFullScreen;
	static SDL_keysym keystate;
	static bool tryVSynch;
	static int64 lastToggle ;

	static void setLastToggle(int64 lastToggle)	{Window::lastToggle = lastToggle;}
	static int64 getLastToggle() 				    {return Window::lastToggle;}

    static void setLastMouseEvent(int64 lastMouseEvent)	{Window::lastMouseEvent = lastMouseEvent;}
    static int64 getLastMouseEvent() 				    {return Window::lastMouseEvent;}

    static const MouseState &getMouseState() 				    {return Window::mouseState;}
    static void setMouseState(MouseButton b, bool state)		{Window::mouseState.set(b, state);}

    static const Vec2i &getMousePos() 					        {return Window::mousePos;}
    static void setMousePos(const Vec2i &mousePos)				{Window::mousePos = mousePos;}

    static void setKeystate(SDL_keysym state)					{ keystate = state; }

    //static bool masterserverMode;
    static map<wchar_t,bool> mapAllowedKeys;

protected:
	//int w, h;
	static bool isActive;
	static bool allowAltEnterFullscreenToggle;
	static int lastShowMouseState;

public:
	static SDL_Window *getSDLWindow();
	static bool handleEvent();
	static void revertMousePos();
	static Vec2i getOldMousePos();
	static bool isKeyDown() { return isKeyPressedDown; }
	static void setupGraphicsScreen(int depthBits=-1, int stencilBits=-1, bool hardware_acceleration=false, bool fullscreen_anti_aliasing=false);
	static const bool getIsFullScreen() { return isFullScreen; }
	static void setIsFullScreen(bool value) { isFullScreen = value; }
	//static SDL_keysym getKeystate() { return keystate; }
	static bool isKeyStateModPressed(int mod);
	static wchar_t extractLastKeyPressed();

	Window();
	Window(SDL_Window *sdlWindow);
	virtual ~Window();

	static void addAllowedKeys(string keyList);
	static void clearAllowedKeys();
	static bool isAllowedKey(wchar_t key);

	virtual int getScreenWidth() = 0;
	virtual int getScreenHeight() = 0;

	virtual bool ChangeVideoMode(bool preserveContext,int resWidth, int resHeight,
			bool fullscreenWindow, int colorBits, int depthBits, int stencilBits,
            bool hardware_acceleration, bool fullscreen_anti_aliasing,
            float gammaValue) = 0;
	//static void setMasterserverMode(bool value) { Window::masterserverMode = value;}
	//static bool getMasterserverMode() { return Window::masterserverMode;}

	static bool getTryVSynch() { return tryVSynch; }
	static void setTryVSynch(bool value) { tryVSynch = value; }

	WindowHandle getHandle()	{return 0;}
	string getText();
	int getX()					{ return 0; }
	int getY()					{ return 0; }
	int getW()					{ return getScreenWidth(); }
	int getH()					{ return getScreenHeight(); }

	//component state
	int getClientW()			{ return getW(); }
	int getClientH()			{ return getH(); }
	float getAspect();

	//object state
	void setText(string text);
	void setStyle(WindowStyle windowStyle);
	void setSize(int w, int h);
	void setPos(int x, int y);
	void setEnabled(bool enabled);
	void setVisible(bool visible);

	//misc
	void create();
	void destroy();
	void minimize();

	static void setAllowAltEnterFullscreenToggle(bool value) { allowAltEnterFullscreenToggle = value; }
	static bool getAllowAltEnterFullscreenToggle() { return allowAltEnterFullscreenToggle; }

	static char getRawKey(SDL_keysym keysym);

protected:

	void setSDLWindow(SDL_Window *window);

	virtual void eventCreate(){}
	virtual void eventMouseDown(int x, int y, MouseButton mouseButton){}
	virtual void eventMouseUp(int x, int y, MouseButton mouseButton){}
	virtual void eventMouseMove(int x, int y, const MouseState* mouseState){}
	virtual void eventMouseDoubleClick(int x, int y, MouseButton mouseButton){}
	virtual void eventMouseWheel(int x, int y, int zDelta) {}
	virtual void eventKeyDown(SDL_KeyboardEvent key) {}
	virtual void eventKeyUp(SDL_KeyboardEvent key) {}
	virtual void eventKeyPress(SDL_KeyboardEvent c) {}
	virtual bool eventTextInput(std::string text) { return false; }
	virtual bool eventSdlKeyDown(SDL_KeyboardEvent key) { return false; }
	virtual void eventResize() {};
	virtual void eventPaint() {}
	virtual void eventTimer(int timerId) {}
	virtual void eventActivate(bool activated) {};
	virtual void eventResize(SizeState sizeState) {};
	virtual void eventMenu(int menuId) {}
	virtual void eventClose() {};
	virtual void eventDestroy() {};
	virtual void eventToggleFullScreen(bool isFullscreen) {};
	virtual void eventWindowEvent(SDL_WindowEvent event) {}

private:
	/// needed to detect double clicks
	void handleMouseDown(SDL_Event event);
	void handleMouseWheel(SDL_Event event);

	static MouseButton getMouseButton(int sdlButton);
	//static char getKey(SDL_keysym keysym, bool skipSpecialKeys=false);
	//static char getNormalKey(SDL_keysym keysym,bool skipSpecialKeys=false);
	static void toggleFullscreen();

	static wchar_t convertStringtoSDLKey(const string &value);
};

bool isKeyPressed(SDL_Keycode compareKey, SDL_KeyboardEvent input, vector<int> modifiersToCheck);
bool isKeyPressed(SDL_Keycode compareKey, SDL_KeyboardEvent input, bool modifiersAllowed=true);

SDL_Keycode extractKeyPressed(SDL_KeyboardEvent input);
//bool isAllowedInputTextKey(SDL_Keycode key);

//wchar_t extractKeyPressedUnicode(SDL_KeyboardEvent input);
vector<int> extractKeyPressedUnicodeLength(string text);
bool isAllowedInputTextKey(wchar_t &key);

}}//end namespace

#endif