CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/NucleusLib/pnInputCore/plKeyMap.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, 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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//
//	plKeyMap - Generic class that defines a mapping of 1-or-2 key codes to
//				ControlEventCodes
//
//////////////////////////////////////////////////////////////////////////////

#ifndef _plKeyMap_h
#define _plKeyMap_h


#include "hsTypes.h"
#include "plInputMap.h"
#include "plControlEventCodes.h"

#include "hsTemplates.h"


//// plKeyCombo //////////////////////////////////////////////////////////////
//	Tiny class/data type representing a single key combo. Ex. shift+C

class plKeyCombo
{
	public:
		plKeyDef	fKey;
		UInt8		fFlags;

		// The ordering of this lets us treat the flags as a priority number.
		// kCtrl + kShift > kCtrl > kShift > no flags
		enum Flags
		{
			kShift	= 0x01,
			kCtrl	= 0x02
		};

		static plKeyCombo	kUnmapped;

		plKeyCombo();
		plKeyCombo( plKeyDef k, UInt8 flags = 0 ) : fKey( k ), fFlags( flags ) { }
		
		hsBool	IsSatisfiedBy(const plKeyCombo &combo) const;		

		hsBool	operator==( const plKeyCombo &rhs ) const { return ( fKey == rhs.fKey ) && ( fFlags == rhs.fFlags ); }
		hsBool	operator!=( const plKeyCombo &rhs ) const { return ( fKey != rhs.fKey ) || ( fFlags != rhs.fFlags ); }
};

//// For the Particularly Lazy... ////////////////////////////////////////////

class plShiftKeyCombo : public plKeyCombo
{
	public:
		plShiftKeyCombo( plKeyDef k ) : plKeyCombo( k, kShift ) {}
};

class plCtrlKeyCombo : public plKeyCombo
{
	public:
		plCtrlKeyCombo( plKeyDef k ) : plKeyCombo( k, kCtrl ) {}
};

class plCtrlShiftKeyCombo : public plKeyCombo
{
	public:
		plCtrlShiftKeyCombo( plKeyDef k ) : plKeyCombo( k, kCtrl | kShift ) {}
};

//// plKeyBinding ////////////////////////////////////////////////////////////
//	Record for a single binding of 1-or-2 keys to a ControlEventCode, with
//	optional string if necessary (for, say console command bindings)

class plKeyBinding
{
	protected:

		ControlEventCode	fCode;
		UInt32				fCodeFlags;	// Needed?
		plKeyCombo			fKey1;		// KEY_UNMAPPED for not-used
		plKeyCombo			fKey2;
		char				*fString;

	public:

		plKeyBinding();
		plKeyBinding( ControlEventCode code, UInt32 codeFlags, const plKeyCombo &key1, const plKeyCombo &key2, const char *string = nil );
		virtual ~plKeyBinding();

		ControlEventCode	GetCode( void ) const { return fCode; }
		UInt32				GetCodeFlags( void ) const { return fCodeFlags; }
		const plKeyCombo	&GetKey1( void ) const { return fKey1; }
		const plKeyCombo	&GetKey2( void ) const { return fKey2; }
		const char			*GetExtendedString( void ) const { return fString; }
		const plKeyCombo	&GetMatchingKey( plKeyDef keyDef ) const;

		void	SetKey1( const plKeyCombo &newCombo );
		void	SetKey2( const plKeyCombo &newCombo );
		void	ClearKeys( void );
		hsBool	HasUnmappedKey() const;
};

//// plKeyMap ////////////////////////////////////////////////////////////////
//	Basically an array of plKeyBindings with some extra helpers

class plKeyMap : public plInputMap
{
	public:

		// Konstants for the bind preference
		enum BindPref
		{
			kNoPreference = 0,		// Just bind to any free one, else first
			kNoPreference2nd,		// Bind to a free one, or second key if no free one
			kFirstAlways,			// Bind to first key no matter what
			kSecondAlways			// Ditto but for 2nd key
		};

	protected:

		hsTArray<plKeyBinding *>	fBindings;

		plKeyBinding	*IFindBindingByKey( const plKeyCombo &combo ) const;
		void			 IFindAllBindingsByKey( const plKeyCombo &combo, hsTArray<plKeyBinding*> &result ) const;
		plKeyBinding	*IFindBinding( ControlEventCode code ) const;
		plKeyBinding	*IFindConsoleBinding( const char *command ) const;

		void			IActuallyBind( plKeyBinding *binding, const plKeyCombo &combo, BindPref pref );
		void			ICheckAndBindDupe( plKeyDef origKey, plKeyDef dupeKey );
			
	public:

		plKeyMap();
		virtual ~plKeyMap();

		// Adds a given control code to the map. Once you add it, you can't change its flags. Returns false if the code is already present
		hsBool	AddCode( ControlEventCode code, UInt32 codeFlags );

		// Same but for console commands. No flags b/c console commands always use the same flags
		hsBool	AddConsoleCommand( const char *command );


		// Adds a key binding to a given code. Returns false if the code isn't in this map or if key is already mapped.
		hsBool	BindKey( const plKeyCombo &combo, ControlEventCode code, BindPref pref = kNoPreference );

		// Console command version
		hsBool	BindKeyToConsoleCmd( const plKeyCombo &combo, const char *command, BindPref pref = kNoPreference );


		// Searches for the binding for a given code. Returns nil if not found
		const plKeyBinding	*FindBinding( ControlEventCode code ) const;

		// Searches for the binding by key. Returns nil if not found
		const plKeyBinding	*FindBindingByKey( const plKeyCombo &combo ) const;

		// Finds multiple bindings (when there are unneeded ctrl/shift flags)
		void FindAllBindingsByKey( const plKeyCombo &combo, hsTArray<const plKeyBinding*> &result ) const;
		
		// Searches for the binding by console command. Returns nil if not found
		const plKeyBinding* plKeyMap::FindConsoleBinding( const char *command ) const;

		// Make sure the given keys are clear of bindings, i.e. not used
		void	EnsureKeysClear( const plKeyCombo &key1, const plKeyCombo &key2 );

		// Unmaps the given key, no matter what binding it is in
		void	UnmapKey( const plKeyCombo &combo );

		// Unmaps the keys for a single binding
		void	UnmapBinding( ControlEventCode code );

		// Unmaps all the bindings, but leaves the code records themselves
		void	UnmapAllBindings( void );

		// Erases the given code binding. Note: should never really be used, but provided here for completeness
		void	EraseBinding( ControlEventCode code );

		// Clears ALL bindings
		void	ClearAll( void );

		static const char* GetStringCtrl();
		static const char* GetStringShift();
		static const char* GetStringUnmapped();


		UInt32				GetNumBindings( void ) const { return fBindings.GetCount(); }
		const plKeyBinding	&GetBinding( UInt32 i ) const { return *fBindings[ i ]; }
		void				HandleAutoDualBinding( plKeyDef key1, plKeyDef key2 );

		static char		*ConvertVKeyToChar( UInt32 vk );
		static plKeyDef	ConvertCharToVKey( const char *c );

		static Win32keyConvert  fKeyConversionEnglish[];
		static Win32keyConvert  fKeyConversionFrench[];
		static Win32keyConvert  fKeyConversionGerman[];
		//static Win32keyConvert  fKeyConversionSpanish[];
		//static Win32keyConvert  fKeyConversionItalian[];

};


#endif // _plKeyMap_h