GeneralsZeroHour/Generals/Code/GameEngine/Include/GameClient/MetaEvent.h

/*
**	Command & Conquer Generals(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	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 3 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, see <http://www.gnu.org/licenses/>.
*/

////////////////////////////////////////////////////////////////////////////////
//																																						//
//  (c) 2001-2003 Electronic Arts Inc.																				//
//																																						//
////////////////////////////////////////////////////////////////////////////////

// FILE: MetaEvent.h ///////////////////////////////////////////////////////////
// Author: Steven Johnson, Dec 2001

#pragma once

#ifndef _H_MetaEvent
#define _H_MetaEvent

#include "Common/SubsystemInterface.h"
#include "GameClient/InGameUI.h"


enum MappableKeyCategories
{
	CATEGORY_CONTROL = 0,
	CATEGORY_INFORMATION,
	CATEGORY_INTERFACE,
	CATEGORY_SELECTION,
	CATEGORY_TAUNT,
	CATEGORY_TEAM,
	CATEGORY_MISC,
	CATEGORY_DEBUG,
	CATEGORY_NUM_CATEGORIES // keep this last
};

static const LookupListRec CategoryListName[] = 
{
	{"CONTROL",						CATEGORY_CONTROL},
	{"INFORMATION",				CATEGORY_INFORMATION},
	{"INTERFACE",					CATEGORY_INTERFACE},
	{"SELECTION",					CATEGORY_SELECTION},
	{"TAUNT",							CATEGORY_TAUNT},
	{"TEAM",							CATEGORY_TEAM},
	{"MISC",							CATEGORY_MISC},
	{"DEBUG",							CATEGORY_DEBUG},
	{NULL, 0}// keep this last
};


// -------------------------------------------------------------------------------
// the keys we allow to be mapped to Meta-events.
// note that this is a subset of all the keys available;
// in particular, "modifier" keys and keypad keys aren't
// available. Note that MappableKeyType is a SUBSET of
// KeyDefType; this is extremely important to maintain!
enum MappableKeyType
{
	MK_ESC					= KEY_ESC,
	MK_BACKSPACE		= KEY_BACKSPACE,
	MK_ENTER				= KEY_ENTER,
	MK_SPACE				= KEY_SPACE,
	MK_TAB					= KEY_TAB,
	MK_F1						= KEY_F1,
	MK_F2						= KEY_F2,
	MK_F3						= KEY_F3,
	MK_F4						= KEY_F4,
	MK_F5						= KEY_F5,
	MK_F6						= KEY_F6,
	MK_F7						= KEY_F7,
	MK_F8						= KEY_F8,
	MK_F9						= KEY_F9,
	MK_F10					= KEY_F10,
	MK_F11					= KEY_F11,
	MK_F12					= KEY_F12,
	MK_A						= KEY_A,
	MK_B						= KEY_B,
	MK_C						= KEY_C,
	MK_D						= KEY_D,
	MK_E						= KEY_E,
	MK_F						= KEY_F,
	MK_G						= KEY_G,
	MK_H						= KEY_H,
	MK_I						= KEY_I,
	MK_J						= KEY_J,
	MK_K						= KEY_K,
	MK_L						= KEY_L,
	MK_M						= KEY_M,
	MK_N						= KEY_N,
	MK_O						= KEY_O,
	MK_P						= KEY_P,
	MK_Q						= KEY_Q,
	MK_R						= KEY_R,
	MK_S						= KEY_S,
	MK_T						= KEY_T,
	MK_U						= KEY_U,
	MK_V						= KEY_V,
	MK_W						= KEY_W,
	MK_X						= KEY_X,
	MK_Y						= KEY_Y,
	MK_Z						= KEY_Z,
	MK_1						= KEY_1,
	MK_2						= KEY_2,
	MK_3						= KEY_3,
	MK_4						= KEY_4,
	MK_5						= KEY_5,
	MK_6						= KEY_6,
	MK_7						= KEY_7,
	MK_8						= KEY_8,
	MK_9						= KEY_9,
	MK_0						= KEY_0,
	MK_KP1					= KEY_KP1,
	MK_KP2					= KEY_KP2,
	MK_KP3					= KEY_KP3,
	MK_KP4					= KEY_KP4,
	MK_KP5					= KEY_KP5,
	MK_KP6					= KEY_KP6,
	MK_KP7					= KEY_KP7,
	MK_KP8					= KEY_KP8,
	MK_KP9					= KEY_KP9,
	MK_KP0					= KEY_KP0,
	MK_MINUS				= KEY_MINUS,
	MK_EQUAL				= KEY_EQUAL,
	MK_LBRACKET			= KEY_LBRACKET,
	MK_RBRACKET			= KEY_RBRACKET,
	MK_SEMICOLON		= KEY_SEMICOLON,
	MK_APOSTROPHE		= KEY_APOSTROPHE,
	MK_TICK					= KEY_TICK,
	MK_BACKSLASH		= KEY_BACKSLASH,
	MK_COMMA				= KEY_COMMA,
	MK_PERIOD				= KEY_PERIOD,
	MK_SLASH				= KEY_SLASH,
	MK_UP						= KEY_UP,
	MK_DOWN					= KEY_DOWN,
	MK_LEFT					= KEY_LEFT,
	MK_RIGHT				= KEY_RIGHT,
	MK_HOME					= KEY_HOME,
	MK_END					= KEY_END,
	MK_PGUP					= KEY_PGUP,
	MK_PGDN					= KEY_PGDN,
	MK_INS					= KEY_INS,
	MK_DEL					= KEY_DEL,
	MK_KPSLASH			= KEY_KPSLASH,
	MK_NONE					= KEY_NONE

};	

static const LookupListRec KeyNames[] = 
{
	{ "KEY_ESC", MK_ESC },
	{ "KEY_BACKSPACE", MK_BACKSPACE },
	{ "KEY_ENTER", MK_ENTER },
	{ "KEY_SPACE", MK_SPACE },
	{ "KEY_TAB", MK_TAB },
	{ "KEY_F1", MK_F1 },
	{ "KEY_F2", MK_F2 },
	{ "KEY_F3", MK_F3 },
	{ "KEY_F4", MK_F4 },
	{ "KEY_F5", MK_F5 },
	{ "KEY_F6", MK_F6 },
	{ "KEY_F7", MK_F7 },
	{ "KEY_F8", MK_F8 },
	{ "KEY_F9", MK_F9 },
	{ "KEY_F10", MK_F10 },
	{ "KEY_F11", MK_F11 },
	{ "KEY_F12", MK_F12 },
	{ "KEY_A", MK_A },
	{ "KEY_B", MK_B },
	{ "KEY_C", MK_C },
	{ "KEY_D", MK_D },
	{ "KEY_E", MK_E },
	{ "KEY_F", MK_F },
	{ "KEY_G", MK_G },
	{ "KEY_H", MK_H },
	{ "KEY_I", MK_I },
	{ "KEY_J", MK_J },
	{ "KEY_K", MK_K },
	{ "KEY_L", MK_L },
	{ "KEY_M", MK_M },
	{ "KEY_N", MK_N },
	{ "KEY_O", MK_O },
	{ "KEY_P", MK_P },
	{ "KEY_Q", MK_Q },
	{ "KEY_R", MK_R },
	{ "KEY_S", MK_S },
	{ "KEY_T", MK_T },
	{ "KEY_U", MK_U },
	{ "KEY_V", MK_V },
	{ "KEY_W", MK_W },
	{ "KEY_X", MK_X },
	{ "KEY_Y", MK_Y },
	{ "KEY_Z", MK_Z },
	{ "KEY_1", MK_1 },
	{ "KEY_2", MK_2 },
	{ "KEY_3", MK_3 },
	{ "KEY_4", MK_4 },
	{ "KEY_5", MK_5 },
	{ "KEY_6", MK_6 },
	{ "KEY_7", MK_7 },
	{ "KEY_8", MK_8 },
	{ "KEY_9", MK_9 },
	{ "KEY_0", MK_0 },
	{ "KEY_KP1", MK_KP1 },
	{ "KEY_KP2", MK_KP2 },
	{ "KEY_KP3", MK_KP3 },
	{ "KEY_KP4", MK_KP4 },
	{ "KEY_KP5", MK_KP5 },
	{ "KEY_KP6", MK_KP6 },
	{ "KEY_KP7", MK_KP7 },
	{ "KEY_KP8", MK_KP8 },
	{ "KEY_KP9", MK_KP9 },
	{ "KEY_KP0", MK_KP0 },
	{ "KEY_MINUS", MK_MINUS },
	{ "KEY_EQUAL", MK_EQUAL },
	{ "KEY_LBRACKET", MK_LBRACKET },
	{ "KEY_RBRACKET", MK_RBRACKET },
	{ "KEY_SEMICOLON", MK_SEMICOLON },
	{ "KEY_APOSTROPHE", MK_APOSTROPHE },
	{ "KEY_TICK", MK_TICK },
	{ "KEY_BACKSLASH", MK_BACKSLASH },
	{ "KEY_COMMA", MK_COMMA },
	{ "KEY_PERIOD", MK_PERIOD },
	{ "KEY_SLASH", MK_SLASH },
	{ "KEY_UP", MK_UP },
	{ "KEY_DOWN", MK_DOWN },
	{ "KEY_LEFT", MK_LEFT },
	{ "KEY_RIGHT", MK_RIGHT },
	{ "KEY_HOME", MK_HOME },
	{ "KEY_END", MK_END },
	{ "KEY_PGUP", MK_PGUP },
	{ "KEY_PGDN", MK_PGDN },
	{ "KEY_INS", MK_INS },
	{ "KEY_DEL", MK_DEL },
	{ "KEY_KPSLASH", MK_KPSLASH },
	{ "KEY_NONE", MK_NONE },
	{ NULL, 0	} // keep this last!
};

// -------------------------------------------------------------------------------
enum MappableKeyTransition
{
	DOWN,
	UP,
	DOUBLEDOWN	// if a key transition is repeated immediately, we generate this.
};

static const LookupListRec TransitionNames[] = 
{
	{ "DOWN",				DOWN },
	{ "UP",					UP },
	{ "DOUBLEDOWN",	DOUBLEDOWN },
	{ NULL, 0	}// keep this last!
};

// -------------------------------------------------------------------------------
// an easier-to-type subset of the KEY_STATE stuff.
enum MappableKeyModState
{
	NONE							= 0,
	CTRL							= KEY_STATE_LCONTROL,
	ALT								= KEY_STATE_LALT,
	SHIFT							= KEY_STATE_LSHIFT,
	CTRL_ALT					= CTRL|ALT,
	SHIFT_CTRL				= SHIFT|CTRL,
	SHIFT_ALT					= SHIFT|ALT,
	SHIFT_ALT_CTRL		= SHIFT|ALT|CTRL
};

static const LookupListRec ModifierNames[] = 
{
	{ "NONE",							NONE },
	{ "CTRL",							CTRL },
	{ "ALT",							ALT },
	{ "SHIFT",						SHIFT },
	{ "CTRL_ALT",					CTRL_ALT },
	{ "SHIFT_CTRL",				SHIFT_CTRL },
	{ "SHIFT_ALT",				SHIFT_ALT },
	{ "SHIFT_ALT_CTRL" ,	SHIFT_ALT_CTRL },
	{ NULL, 0	}// keep this last!
};



// -------------------------------------------------------------------------------
// CommandUsableInType sets in what state the commands are allowed.
enum CommandUsableInType
{
	COMMANDUSABLE_NONE				= 0,

	COMMANDUSABLE_SHELL				= (1 << 0),
	COMMANDUSABLE_GAME				= (1 << 1)
};

static const char* TheCommandUsableInNames[] =
{
	"SHELL",
	"GAME",

	NULL
};

// -------------------------------------------------------------------------------
class MetaMapRec : public MemoryPoolObject
{
	MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE(MetaMapRec, "MetaMapRec")		
public:
	MetaMapRec*							m_next;
	GameMessage::Type				m_meta;						///< the meta-event to emit
	MappableKeyType					m_key;						///< the key we want
	MappableKeyTransition		m_transition;			///< the state of the key
	MappableKeyModState			m_modState;				///< the required state of the ctrl-alt-shift keys
	CommandUsableInType			m_usableIn;				///< the allowed place the command can be used in
	// Next fields are added for Key mapping Dialog
	MappableKeyCategories		m_category;				///< This is the catagory the key falls under
	UnicodeString						m_description;		///< The description string for the keys
	UnicodeString						m_displayName;		///< The display name of our command
};
EMPTY_DTOR(MetaMapRec)


//-----------------------------------------------------------------------------
class MetaEventTranslator : public GameMessageTranslator                          
{
private:

	Int						m_lastKeyDown;	// really a MappableKeyType
	Int						m_lastModState;	// really a MappableKeyModState

	enum { NUM_MOUSE_BUTTONS = 3 };
	ICoord2D m_mouseDownPosition[NUM_MOUSE_BUTTONS];
	Bool	m_nextUpShouldCreateDoubleClick[NUM_MOUSE_BUTTONS];

public:
	MetaEventTranslator();
	~MetaEventTranslator();
	virtual GameMessageDisposition translateGameMessage(const GameMessage *msg);
};	

//-----------------------------------------------------------------------------
class MetaMap : public SubsystemInterface
{
	friend class MetaEventTranslator;

private:
	MetaMapRec *m_metaMaps;

protected:
	GameMessage::Type findGameMessageMetaType(const char* name);
	MetaMapRec *getMetaMapRec(GameMessage::Type t);

public:
	
	MetaMap();
	~MetaMap();

	void init() { }
	void reset() { }
	void update() { }

	static void parseMetaMap(INI* ini);
	const MetaMapRec *getFirstMetaMapRec() const { return m_metaMaps; }
};

extern MetaMap *TheMetaMap;

#endif