/*==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==*/
//////////////////////////////////////////////////////////////////////////////
// //
// plInputInterface.cpp - A single layer on the input interface stack //
// //
//// History /////////////////////////////////////////////////////////////////
// //
// 2.20.02 mcn - Created. //
// //
//////////////////////////////////////////////////////////////////////////////
#include "hsConfig.h"
#include "hsWindows.h"
#include "hsTypes.h"
#include "plInputInterface.h"
#include "plInputInterfaceMgr.h"
#include "pnInputCore/plKeyMap.h"
#include "plMessage/plInputEventMsg.h"
#include "hsResMgr.h"
#include "plgDispatch.h"
//// Constructor/Destructor //////////////////////////////////////////////////
plInputInterface::plInputInterface()
{
fEnabled = false;
fControlMap = TRACKED_NEW plKeyMap;
}
plInputInterface::~plInputInterface()
{
delete fControlMap;
}
void plInputInterface::ClearKeyMap()
{
if( fControlMap != nil )
fControlMap->ClearAll();
}
//// Read/Write //////////////////////////////////////////////////////////////
void plInputInterface::Read( hsStream* s, hsResMgr* mgr )
{
}
void plInputInterface::Write( hsStream* s, hsResMgr* mgr )
{
}
//// Helper Functions ////////////////////////////////////////////////////////
hsBool plInputInterface::IOwnsControlCode( ControlEventCode code )
{
if( fControlMap->FindBinding( code ) != nil )
return true;
return false;
}
//// IVerifyShiftKey /////////////////////////////////////////////////////////
// special logic so the shift key can make everyone totally happy...
hsBool plInputInterface::IVerifyShiftKey( plKeyDef key, int index )
{
// if we are mapped to the actual shift key, return true
if (key == KEY_SHIFT)
return true;
// if anything else is mapped to this key + shift, return false
/* for (int i=0; i < fControlMap->GetNumBindings(); i++)
{
if (index == i)
continue;
if (fKeyMap->fMap[i]->fKeyDef == key && fKeyMap->fMap[i]->fKeyFlags & plKeyInfo::kKeyShift )
return false;
}
*/ return true;
}
void plInputInterface::IDeactivateBinding(const plKeyBinding *binding)
{
if( !(binding->GetCodeFlags() & kControlFlagNoDeactivate) && !(binding->GetCodeFlags() & kControlFlagToggle) )
{
plCtrlCmd *pCmd = TRACKED_NEW plCtrlCmd( this );
pCmd->fControlCode = binding->GetCode();
pCmd->fControlActivated = false;
pCmd->SetCmdString( binding->GetExtendedString() );
pCmd->fNetPropagateToPlayers = ( binding->GetCodeFlags() & kControlFlagNetPropagate ) ? true : false;
fMessageQueue->Append( pCmd );
}
IClearKeyControlFlag(binding->GetCode());
}
//// ProcessKeyBindings //////////////////////////////////////////////////////
// Processes the given key event as a key binding, if one exists. If not,
// returns false.
hsBool plInputInterface::ProcessKeyBindings( plInputEventMsg *msg )
{
int i;
hsBool activate;
plKeyEventMsg *keyMsg = plKeyEventMsg::ConvertNoRef( msg );
if( keyMsg == nil )
return false;
/// We might have controls that are currently enabled that are triggered in part by
/// modifiers (ctrl or shift)...if that is true, then we want to disable them if either
/// of those modifiers are up, no matter what key this message is for
hsTArray<Int16> enabledCtrls;
fKeyControlFlags.Enumerate( enabledCtrls );
for( i = 0; i < enabledCtrls.GetCount(); i++ )
{
const plKeyBinding *binding = fControlMap->FindBinding( (ControlEventCode)enabledCtrls[ i ] );
if( binding == nil )
; // Somehow we lost the binding??
else
{
bool wantShift, wantCtrl;
if( fKeyControlsFrom2ndKeyFlags.IsBitSet( enabledCtrls[ i ] ) )
{
wantShift = ( binding->GetKey2().fFlags & plKeyCombo::kShift ) || ( binding->GetKey2().fKey == KEY_SHIFT );
wantCtrl = ( binding->GetKey2().fFlags & plKeyCombo::kCtrl ) || ( binding->GetKey2().fKey == KEY_CTRL );
}
else
{
wantShift = ( binding->GetKey1().fFlags & plKeyCombo::kShift ) || ( binding->GetKey1().fKey == KEY_SHIFT );
wantCtrl = ( binding->GetKey1().fFlags & plKeyCombo::kCtrl ) || ( binding->GetKey1().fKey == KEY_CTRL );
}
if( ( wantShift && !keyMsg->GetShiftKeyDown() ) || ( wantCtrl && !keyMsg->GetCtrlKeyDown() ) )
{
IDeactivateBinding(binding);
fKeyControlsFrom2ndKeyFlags.SetBit(enabledCtrls[i], false);
}
}
}
/// Process any binding for this message's key code now
plKeyCombo combo( keyMsg->GetKeyCode(), ( keyMsg->GetShiftKeyDown() ? plKeyCombo::kShift : 0 ) |
( keyMsg->GetCtrlKeyDown() ? plKeyCombo::kCtrl : 0 ) );
hsTArray<const plKeyBinding *> bindings;
fControlMap->FindAllBindingsByKey(combo, bindings);
// The first binding is the one we want. (FindAllBindingsByKey guarantees this)
const plKeyBinding *binding = (bindings.GetCount() ? bindings[0] : nil);
// If other bindings were found, they lose out to the first one.
for (i = 1; i < bindings.GetCount(); i++)
IDeactivateBinding(bindings[i]);
/*
const plKeyBinding *binding = fControlMap->FindBindingByKey( combo );
if( binding == nil )
{
// Don't panic just yet, there are some special cases with the shift key to check first
if( keyMsg->GetKeyCode() == KEY_SHIFT || keyMsg->GetShiftKeyDown() )
{
// See, there are two other cases to consider: 1) we have a binding directly to the shift
// key, which wouldn't have the shift flag set (so the above search wouldn't have caught it).
// The second case would be if we have a matching binding without shift...
// which is VALID so long as no other bindings respond to this key combo + shift, but of course,
// if there were, we'd have found them already!
// Either way, we remove the shift flag and try again
combo.fFlags &= ~plKeyCombo::kShift;
binding = fControlMap->FindBindingByKey( combo );
}
}
*/
if (!binding)
return false;
UInt32 codeFlags = binding->GetCodeFlags();
// Filter out no-repeat messages
if( ( codeFlags & kControlFlagNoRepeat ) && keyMsg->GetRepeat() )
return false;
if( codeFlags & kControlFlagNormal )
{
// "Normal" behavior--enable on key down, disable on key up
activate = keyMsg->GetKeyDown() ? true : false;
}
else if( codeFlags & kControlFlagToggle )
{
// Toggle behavior
if( ( codeFlags & kControlFlagDownEvent ) && !keyMsg->GetKeyDown() )
return false;
if( ( codeFlags & kControlFlagUpEvent ) && keyMsg->GetKeyDown() )
return false;
if( IHasKeyControlFlag( binding->GetCode() ) )
activate = false;
else
activate = true;
}
else
{
// Remaining ones are triggered to activate on their flagged event and
// deactivate when that turns false
if( ( codeFlags & kControlFlagDownEvent ) && !keyMsg->GetKeyDown() )
activate = false;
else if( ( codeFlags & kControlFlagUpEvent ) && keyMsg->GetKeyDown() )
activate = false;
else
activate = true;
}
hsBool wasActive = IHasKeyControlFlag(binding->GetCode());
// Set or clear our flags, since we do that even if we don't send a message
if( activate )
{
ISetKeyControlFlag( binding->GetCode() );
fKeyControlsFrom2ndKeyFlags.SetBit( binding->GetCode(), ( binding->GetKey2() == combo ) ? true : false );
}
else
{
IClearKeyControlFlag( binding->GetCode() );
fKeyControlsFrom2ndKeyFlags.SetBit( binding->GetCode(), 0 );
}
// Filter out codes that only want their activate messages sent (like console commands)
if( ( codeFlags & kControlFlagNoDeactivate ) && !activate )
return false;
if (!IControlCodeEnabled(binding->GetCode()))
{
if (activate || (codeFlags & kControlFlagToggle) || !wasActive)
{
// It's ok to deactivate a disabled control, but not activate it
return false;
}
}
/// OK, generate the message to send
plCtrlCmd *pCmd = TRACKED_NEW plCtrlCmd( this );
pCmd->fControlCode = binding->GetCode();
pCmd->fControlActivated = activate;
pCmd->SetCmdString( binding->GetExtendedString() );
pCmd->fNetPropagateToPlayers = ( codeFlags & kControlFlagNetPropagate ) ? true : false;
fMessageQueue->Append( pCmd );
return true;
}
hsBool plInputInterface::IControlCodeEnabled(ControlEventCode code )
{
return (!fDisabledControls.IsBitSet(code));
}