InputManager Class Reference

#include <inputmanager.h>

Public Member Functions
	InputManager ()
void	init ()
bool	handleEvent (const SDL_Event &event)
bool	checkKey (const InputActionData *const key) const
void	retrieve ()
void	store () const
void	resetKeys ()
void	makeDefault (const InputActionT i)
bool	hasConflicts (InputActionT &key1, InputActionT &key2) const
void	callbackNewKey ()
InputFunction &	getKey (InputActionT index) A_CONST
std::string	getKeyValueString (const InputActionT index) const
std::string	getKeyStringLong (const InputActionT index) const
std::string	getKeyValueByName (const std::string &keyName)
std::string	getKeyValueByNameLong (const std::string &keyName)
void	addActionKey (const InputActionT action, const InputTypeT type, const int val)
void	setNewKey (const SDL_Event &event, const InputTypeT type)
void	unassignKey ()
bool	isActionActive (const InputActionT index) const
void	setNewKeyIndex (const InputActionT value)
void	setSetupInput (Setup_Input *const setupInput)
InputActionT	getNewKeyIndex () const
void	updateKeyActionMap (KeyToActionMap &actionMap, KeyToIdMap &idMap, KeyTimeMap &keyTimeMap, const InputTypeT type) const
bool	invokeKey (const InputActionData *const key, const InputActionT keyNum)
bool	handleAssignKey (const SDL_Event &event, const InputTypeT type)
bool	triggerAction (const KeysVector *const ptrs)
InputActionT	getKeyIndex (const int value, const int grp, const InputTypeT type) const
void	updateConditionMask (const bool pressed)
InputActionT	getActionByKey (const SDL_Event &event) const
void	executeAction (const InputActionT keyNum)
bool	executeChatCommand (const std::string &cmd, const std::string &args, ChatTab *const tab)
bool	executeRemoteChatCommand (const std::string &cmd, const std::string &args, ChatTab *const tab)
bool	executeChatCommand (const InputActionT keyNum, const std::string &args, ChatTab *const tab)

Static Public Member Functions
static void	handleRepeat ()
static void	update ()
static InputActionT	getActionByConfigField (const std::string &field)
static void	addChatCommands (std::list< std::string > &arr)

Protected Member Functions
void	resetKey (const InputActionT i)
void	updateKeyString (const InputFunction &ki, const size_t actionIdx)

Static Protected Member Functions
static bool	isActionActive0 (const InputActionT index)

Protected Attributes
Setup_Input *	mSetupInput
InputActionT	mNewKeyIndex
int	mMask
StringInpActionMap	mNameMap
StringIntMap	mChatMap
InputFunction	mKey [static_cast< size_t >(InputAction::TOTAL)]
std::string	mKeyStr [static_cast< size_t >(InputAction::TOTAL)]

Detailed Description

Definition at line 46 of file inputmanager.h.

Constructor & Destructor Documentation

InputManager()

InputManager::InputManager

(

)

Definition at line 80 of file inputmanager.cpp.

                           :
    mSetupInput(nullptr),
    mNewKeyIndex(InputAction::NO_VALUE),
    mMask(1),
    mNameMap(),
    mChatMap(),
    mKey()
{
}

Member Function Documentation

addActionKey()

void InputManager::addActionKey	(	const InputActionT	action,
		const InputTypeT	type,
		const int	val
	)

Definition at line 511 of file inputmanager.cpp.

{
    if (CAST_S32(action) < 0 || action >= InputAction::TOTAL)
        return;
 
    int idx = -1;
    InputFunction &restrict key = mKey[CAST_SIZE(action)];
    for (size_t i = 0; i < inputFunctionSize; i ++)
    {
        const InputItem &restrict val2 = key.values[i];
        if (val2.type == InputType::UNKNOWN ||
            (val2.type == type && val2.value == val))
        {
            idx = CAST_S32(i);
            break;
        }
    }
    if (idx == -1)
    {
        for (size_t i = 1; i < inputFunctionSize; i ++)
        {
            InputItem &restrict val1 = key.values[i - 1];
            InputItem &restrict val2 = key.values[i];
            val1.type = val2.type;
            val1.value = val2.value;
        }
        idx = inputFunctionSize - 1;
    }
 
    key.values[idx] = InputItem(type, val);
    updateKeyString(key, CAST_SIZE(action));
}

References QuitDialog::action(), CAST_S32, CAST_SIZE, inputFunctionSize, restrict, InputAction::TOTAL, and InputType::UNKNOWN.

addChatCommands()

void InputManager::addChatCommands ( std::list< std::string > &  arr )

static

Definition at line 1082 of file inputmanager.cpp.

{
    const int sz = CAST_S32(InputAction::TOTAL);
    for (int i = 0; i < sz; i++)
    {
        const InputActionData &restrict ad = inputActionData[i];
        std::string cmd = ad.chatCommand;
        if (!cmd.empty())
        {
            StringVect tokens;
            splitToStringVector(tokens, cmd, '|');
            FOR_EACH (StringVectCIter, it, tokens)
            {
                cmd = std::string("/").append(*it);
                if (ad.useArgs == UseArgs_true)
                    cmd.append(" ");
                arr.push_back(cmd);
            }
        }
    }
}

References CAST_S32, InputActionData::chatCommand, FOR_EACH, inputActionData, restrict, splitToStringVector(), InputAction::TOTAL, and UseArgs_true.

Referenced by ChatWindow::fillCommands().

callbackNewKey()

void InputManager::callbackNewKey

(

)

Definition at line 358 of file inputmanager.cpp.

{
#ifndef DYECMD
    mSetupInput->newKeyCallback(mNewKeyIndex);
#endif  // DYECMD
}

References mNewKeyIndex, mSetupInput, and Setup_Input::newKeyCallback().

checkKey()

bool InputManager::checkKey

(

const InputActionData *const

key

)

const

Definition at line 857 of file inputmanager.cpp.

{
    // logger->log("checkKey mask=%d, condition=%d", mMask, key->condition);
    if ((key == nullptr) || (key->condition & mMask) != key->condition)
        return false;
 
    return key->modKeyIndex == InputAction::NO_VALUE
        || isActionActive0(key->modKeyIndex);
}

References InputAction::NO_VALUE.

executeAction()

void InputManager::executeAction

(

const InputActionT

keyNum

)

Definition at line 884 of file inputmanager.cpp.

{
    if (keyNum < InputAction::MOVE_UP || keyNum >= InputAction::TOTAL)
        return;
 
    ActionFuncPtr func = *(inputActionData[CAST_SIZE(
        keyNum)].action);
    if (func != nullptr)
    {
        InputEvent evt(keyNum, mMask);
        func(evt);
    }
}

References InputActionData::action, CAST_SIZE, inputActionData, and InputAction::TOTAL.

Referenced by WindowMenu::action(), HelpWindow::action(), InventoryWindow::action(), UploadListener::action(), Client::action(), TouchManager::executeAction(), TextField::focusGained(), PopupMenu::handleLink(), Desktop::handleLink(), ItemLinkHandler::handleLink(), and TextField::mousePressed().

executeChatCommand() [1/2]

bool InputManager::executeChatCommand	(	const InputActionT	keyNum,
		const std::string &	args,
		ChatTab *const	tab
	)

Definition at line 944 of file inputmanager.cpp.

{
    if (CAST_S32(keyNum) < 0 || keyNum >= InputAction::TOTAL)
        return false;
    ActionFuncPtr func = *(inputActionData[CAST_SIZE(
        keyNum)].action);
    if (func != nullptr)
    {
        InputEvent evt(args, tab, mMask);
        func(evt);
        return true;
    }
    return false;
}

References InputActionData::action, CAST_S32, CAST_SIZE, inputActionData, and InputAction::TOTAL.

executeChatCommand() [2/2]

bool InputManager::executeChatCommand	(	const std::string &	cmd,
		const std::string &	args,
		ChatTab *const	tab
	)

Definition at line 898 of file inputmanager.cpp.

{
    const StringIntMapCIter it = mChatMap.find(cmd);
    if (it != mChatMap.end())
    {
        ActionFuncPtr func = *(inputActionData[(*it).second].action);
        if (func != nullptr)
        {
            InputEvent evt(args, tab, mMask);
            func(evt);
            return true;
        }
    }
    else
    {
        reportAlways("Unknown chat command: /%s %s",
            cmd.c_str(),
            args.c_str())
    }
    return false;
}

References InputActionData::action, inputActionData, and reportAlways.

Referenced by InputActionReplayListener::action(), IPC::flush(), GuildTab::handleCommand(), PartyTab::handleCommand(), ChatTab::handleCommandStr(), PopupMenu::handleLink(), and ChatWindow::mousePressed().

executeRemoteChatCommand()

bool InputManager::executeRemoteChatCommand	(	const std::string &	cmd,
		const std::string &	args,
		ChatTab *const	tab
	)

Definition at line 922 of file inputmanager.cpp.

{
    const StringIntMapCIter it = mChatMap.find(cmd);
    if (it != mChatMap.end())
    {
        const InputActionData &restrict data = inputActionData[(*it).second];
        if (data.isProtected == Protected_true)
            return false;
        ActionFuncPtr func = *(data.action);
        if (func != nullptr)
        {
            InputEvent evt(args, tab, mMask);
            func(evt);
            return true;
        }
    }
    return false;
}

References data, inputActionData, Protected_true, and restrict.

Referenced by InputActionRemoteListener::action(), ItemLinkHandler::handleCommandLink(), and Ea::PlayerRecv::processPlayerClientCommand().

getActionByConfigField()

InputActionT InputManager::getActionByConfigField ( const std::string &  field )

static

Definition at line 1071 of file inputmanager.cpp.

{
    for (int i = 0; i < CAST_S32(InputAction::TOTAL); i ++)
    {
        const std::string cf = inputActionData[i].configField;
        if (field == cf)
            return static_cast<InputActionT>(i);
    }
    return InputAction::NO_VALUE;
}

References CAST_S32, InputActionData::configField, inputActionData, InputAction::NO_VALUE, and InputAction::TOTAL.

getActionByKey()

InputActionT InputManager::getActionByKey

(

const SDL_Event &

event

)

const

Definition at line 1055 of file inputmanager.cpp.

{
    // for now support only keyboard events
    if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP)
    {
        const InputActionT idx = keyboard.getActionId(event);
        if (CAST_S32(idx) >= 0 &&
            checkKey(&inputActionData[CAST_SIZE(idx)]))
        {
            return idx;
        }
    }
    return InputAction::NO_VALUE;
}

References CAST_S32, CAST_SIZE, KeyboardConfig::getActionId(), inputActionData, keyboard, and InputAction::NO_VALUE.

Referenced by SDLInput::convertKeyEventToKey().

getKey()

InputFunction & InputManager::getKey

(

InputActionT

index

)

Definition at line 388 of file inputmanager.cpp.

{
    if (CAST_S32(index) < 0 || index >= InputAction::TOTAL)
        index = InputAction::MOVE_UP;
    return mKey[CAST_SIZE(index)];
}

References CAST_S32, CAST_SIZE, InputAction::MOVE_UP, and InputAction::TOTAL.

Referenced by Joystick::isActionActive(), and KeyboardConfig::isActionActive().

getKeyIndex()

InputActionT InputManager::getKeyIndex	(	const int	value,
		const int	grp,
		const InputTypeT	type
	)		const

Definition at line 1034 of file inputmanager.cpp.

{
    for (size_t i = 0; i < CAST_SIZE(InputAction::TOTAL); i++)
    {
        const InputFunction &restrict key = mKey[i];
        const InputActionData &restrict kd = inputActionData[i];
        for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++)
        {
            const InputItem &restrict vali2 = key.values[i2];
            if (value == vali2.value &&
                (grp & kd.grp) != 0 && vali2.type == type)
            {
                return static_cast<InputActionT>(i);
            }
        }
    }
    return InputAction::NO_VALUE;
}

References CAST_SIZE, inputActionData, inputFunctionSize, InputAction::NO_VALUE, restrict, and InputAction::TOTAL.

Referenced by KeyboardConfig::getKeyIndex().

getKeyStringLong()

std::string InputManager::getKeyStringLong

(

const InputActionT

index

)

const

Definition at line 395 of file inputmanager.cpp.

{
    std::string keyStr;
    const InputFunction &restrict ki = mKey[CAST_SIZE(index)];
 
    for (size_t i = 0; i < inputFunctionSize; i ++)
    {
        const InputItem &restrict key = ki.values[i];
        std::string str;
        if (key.type == InputType::KEYBOARD)
        {
            if (key.value >= 0)
            {
                str = KeyboardConfig::getKeyName(key.value);
            }
            else if (key.value < -1)
            {
                // TRANSLATORS: long key name. must be short.
                str = strprintf(_("key_%d"), -key.value);
            }
        }
        else if (key.type == InputType::JOYSTICK)
        {
            // TRANSLATORS: long joystick button name. must be short.
            str = strprintf(_("JButton%d"), key.value + 1);
        }
        if (!str.empty())
        {
            if (keyStr.empty())
                keyStr = str;
            else
                keyStr.append(", ").append(str);
        }
    }
 
    if (keyStr.empty())
    {
        // TRANSLATORS: unknown long key type
        return _("unknown key");
    }
    return keyStr;
}

References _, CAST_SIZE, KeyboardConfig::getKeyName(), inputFunctionSize, InputType::JOYSTICK, InputType::KEYBOARD, restrict, and strprintf().

Referenced by OutfitWindow::keyName(), and Setup_Input::refreshAssignedKey().

getKeyValueByName()

std::string InputManager::getKeyValueByName

(

const std::string &

keyName

)

Definition at line 491 of file inputmanager.cpp.

{
    const StringInpActionMapCIter it = mNameMap.find(keyName);
 
    if (it == mNameMap.end())
        return std::string();
    return getKeyValueString((*it).second);
}

getKeyValueByNameLong()

std::string InputManager::getKeyValueByNameLong

(

const std::string &

keyName

)

Definition at line 501 of file inputmanager.cpp.

{
    const StringInpActionMapCIter it = mNameMap.find(keyName);
 
    if (it == mNameMap.end())
        return std::string();
    return getKeyStringLong((*it).second);
}

Referenced by BrowserBoxTools::replaceKeys().

getKeyValueString()

std::string InputManager::getKeyValueString

(

const InputActionT

index

)

const

Definition at line 485 of file inputmanager.cpp.

{
    return mKeyStr[CAST_SIZE(index)];
}

References CAST_SIZE.

Referenced by ItemShortcutContainer::draw(), EmoteShortcutContainer::draw(), WindowMenu::mouseMoved(), ItemShortcutContainer::safeDraw(), EmoteShortcutContainer::safeDraw(), and StatusPopup::setLabelText().

getNewKeyIndex()

InputActionT InputManager::getNewKeyIndex ( ) const

inline

Get the index of the new key to be assigned.

Definition at line 117 of file inputmanager.h.

        { return mNewKeyIndex; }

References mNewKeyIndex.

Referenced by Setup_Input::keyUnresolved().

handleAssignKey()

bool InputManager::handleAssignKey	(	const SDL_Event &	event,
		const InputTypeT	type
	)

Definition at line 576 of file inputmanager.cpp.

{
    if ((setupWindow != nullptr) && setupWindow->isWindowVisible() &&
        getNewKeyIndex() > InputAction::NO_VALUE)
    {
        setNewKey(event, type);
        callbackNewKey();
        setNewKeyIndex(InputAction::NO_VALUE);
        return true;
    }
    return false;
}

References Window::isWindowVisible(), InputAction::NO_VALUE, and setupWindow.

handleEvent()

bool InputManager::handleEvent

(

const SDL_Event &

event

)

Definition at line 598 of file inputmanager.cpp.

{
    BLOCK_START("InputManager::handleEvent")
    switch (event.type)
    {
        case SDL_KEYDOWN:
        {
#ifdef USE_SDL2
            if (keyboard.ignoreKey(event))
            {
                BLOCK_END("InputManager::handleEvent")
                return true;
            }
#endif  // USE_SDL2
 
            keyboard.refreshActiveKeys();
            updateConditionMask(true);
            if (handleAssignKey(event, InputType::KEYBOARD))
            {
                BLOCK_END("InputManager::handleEvent")
                return true;
            }
 
            keyboard.handleActivateKey(event);
            // send straight to gui for certain windows
#ifndef DYECMD
            if ((quitDialog != nullptr) || TextDialog::isActive())
            {
                if (guiInput != nullptr)
                    guiInput->pushInput(event);
                if (gui != nullptr)
                    gui->handleInput();
                BLOCK_END("InputManager::handleEvent")
                return true;
            }
#endif  // DYECMD
 
            break;
        }
        case SDL_KEYUP:
        {
#ifdef USE_SDL2
            if (keyboard.ignoreKey(event))
            {
                BLOCK_END("InputManager::handleEvent")
                return true;
            }
#endif  // USE_SDL2
 
            keyboard.refreshActiveKeys();
            updateConditionMask(false);
            keyboard.handleDeActicateKey(event);
            break;
        }
        case SDL_JOYBUTTONDOWN:
        {
            updateConditionMask(true);
//            joystick.handleActicateButton(event);
            if (handleAssignKey(event, InputType::JOYSTICK))
            {
                BLOCK_END("InputManager::handleEvent")
                return true;
            }
            break;
        }
        case SDL_JOYBUTTONUP:
        {
            updateConditionMask(false);
//            joystick.handleDeActicateButton(event);
            break;
        }
#ifdef USE_SDL2
        case SDL_FINGERDOWN:
            multiTouchManager.handleFingerDown(event);
            break;
        case SDL_FINGERUP:
            multiTouchManager.handleFingerUp(event);
            break;
#else  // USE_SDL2
#ifdef ANDROID
        case SDL_ACCELEROMETER:
        {
            break;
        }
#endif  // ANDROID
#endif  // USE_SDL2
 
        default:
            break;
    }
 
    if (guiInput != nullptr)
        guiInput->pushInput(event);
    if (gui != nullptr)
    {
        const bool res = gui->handleInput();
        if (res && event.type == SDL_KEYDOWN)
        {
            BLOCK_END("InputManager::handleEvent")
            return true;
        }
    }
 
    switch (event.type)
    {
        case SDL_KEYDOWN:
            if (isActionActive(InputAction::IGNORE_INPUT_1) ||
                isActionActive(InputAction::IGNORE_INPUT_2))
            {
                BLOCK_END("InputManager::handleEvent")
                return true;
            }
            if (triggerAction(keyboard.getActionVector(event)))
            {
                BLOCK_END("InputManager::handleEvent")
                return true;
            }
            break;
 
// disabled temporary
//        case SDL_KEYUP:
//            if (triggerAction(keyboard.getActionVector(event)))
//            {
//                BLOCK_END("InputManager::handleEvent")
//                return true;
//            }
//            break;
 
        case SDL_JOYBUTTONDOWN:
            if ((joystick != nullptr) && joystick->validate())
            {
                if (triggerAction(joystick->getActionVector(event)))
                {
                    BLOCK_END("InputManager::handleEvent")
                    return true;
                }
            }
            break;
#ifdef ANDROID
#ifndef USE_SDL2
        case SDL_ACCELEROMETER:
        {
            break;
        }
#endif  // USE_SDL2
#endif  // ANDROID
 
        default:
            break;
    }
 
    BLOCK_END("InputManager::handleEvent")
    return false;
}

References BLOCK_END, BLOCK_START, Joystick::getActionVector(), KeyboardConfig::getActionVector(), gui, guiInput, KeyboardConfig::handleActivateKey(), KeyboardConfig::handleDeActicateKey(), Gui::handleInput(), InputAction::IGNORE_INPUT_1, InputAction::IGNORE_INPUT_2, TextDialog::isActive(), InputType::JOYSTICK, joystick, InputType::KEYBOARD, keyboard, multiTouchManager, SDLInput::pushInput(), quitDialog, KeyboardConfig::refreshActiveKeys(), and Joystick::validate().

Referenced by EventsManager::handleCommonEvents().

handleRepeat()

void InputManager::handleRepeat ( )

static

Definition at line 753 of file inputmanager.cpp.

{
    const int time = tick_time;
    keyboard.handleRepeat(time);
    if (joystick != nullptr)
        joystick->handleRepeat(time);
}

References Joystick::handleRepeat(), KeyboardConfig::handleRepeat(), joystick, keyboard, and tick_time.

Referenced by Game::handleInput().

hasConflicts()

bool InputManager::hasConflicts	(	InputActionT &	key1,
		InputActionT &	key2
	)		const

No need to parse the square matrix: only check one triangle that's enough to detect conflicts

Definition at line 309 of file inputmanager.cpp.

{
    for (int i = 0; i < CAST_S32(InputAction::TOTAL); i++)
    {
        const InputActionData &restrict kdi = inputActionData[i];
        if (*kdi.configField == 0)
            continue;
 
        const InputFunction &restrict ki = mKey[i];
        for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++)
        {
            const InputItem &restrict vali2 = ki.values[i2];
            if (vali2.value == -1)
                continue;
 
            size_t j;
            for (j = i, j++; j < CAST_S32(InputAction::TOTAL); j++)
            {
                if ((kdi.grp & inputActionData[j].grp) == 0
                    || (*kdi.configField == 0))
                {
                    continue;
                }
 
                for (size_t j2 = 0; j2 < inputFunctionSize; j2 ++)
                {
                    const InputItem &restrict valj2 = mKey[j].values[j2];
                    // Allow for item shortcut and emote keys to overlap
                    // as well as emote and ignore keys, but no other keys
                    if (valj2.type != InputType::UNKNOWN
                        && vali2.value == valj2.value
                        && vali2.type == valj2.type)
                    {
                        key1 = static_cast<InputActionT>(i);
                        key2 = static_cast<InputActionT>(j);
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

References CAST_S32, InputActionData::grp, inputActionData, inputFunctionSize, restrict, InputAction::TOTAL, and InputType::UNKNOWN.

Referenced by Setup_Input::apply().

init()

void InputManager::init

(

)

Definition at line 90 of file inputmanager.cpp.

{
#ifdef __SWITCH__
    SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "1");
#endif
    for (size_t i = 0;
         i < CAST_SIZE(InputAction::TOTAL);
         i ++)
    {
        InputFunction &kf = mKey[i];
        mKeyStr[i].clear();
        for (size_t f = 0; f < inputFunctionSize; f ++)
        {
            InputItem &ki = kf.values[f];
            ki.type = InputType::UNKNOWN;
            ki.value = -1;
        }
    }
 
    mNewKeyIndex = InputAction::NO_VALUE;
 
    resetKeys();
    retrieve();
    update();
}

References CAST_SIZE, inputFunctionSize, mKey, mKeyStr, mNewKeyIndex, InputAction::NO_VALUE, resetKeys(), retrieve(), InputAction::TOTAL, InputItem::type, InputType::UNKNOWN, update(), InputItem::value, and InputFunction::values.

Referenced by Client::gameInit().

invokeKey()

bool InputManager::invokeKey	(	const InputActionData *const	key,
		const InputActionT	keyNum
	)

Definition at line 868 of file inputmanager.cpp.

{
    // no validation to keyNum because it validated in caller
 
    if (checkKey(key))
    {
        InputEvent evt(keyNum, mMask);
        ActionFuncPtr func = *(inputActionData[
            CAST_SIZE(keyNum)].action);
        if ((func != nullptr) && func(evt))
            return true;
    }
    return false;
}

References InputActionData::action, CAST_SIZE, and inputActionData.

isActionActive()

bool InputManager::isActionActive

(

const InputActionT

index

)

const

Definition at line 365 of file inputmanager.cpp.

{
    if (!isActionActive0(index))
        return false;
 
    const InputActionData &restrict key =
        inputActionData[CAST_SIZE(index)];
//    logger->log("isActionActive mask=%d, condition=%d, index=%d",
//        mMask, key.condition, index);
    if ((key.condition & mMask) != key.condition)
        return false;
    return true;
}

References CAST_SIZE, inputActionData, and restrict.

Referenced by InventoryWindow::action(), Actions::doSit(), ActorManager::findBeingByPixel(), ActorManager::findBeingsByPixel(), ActorManager::findNearestLivingBeing(), Game::handleInput(), Gui::handleKeyInput(), Game::handleMove(), TextField::keyPressed(), ChatWindow::keyPressed(), InventoryWindow::mouseClicked(), ChatWindow::mousePressed(), ItemContainer::mouseReleased(), InventoryWindow::moveItemToCraft(), and Viewport::validateSpeed().

isActionActive0()

bool InputManager::isActionActive0 ( const InputActionT  index )

staticprotected

Definition at line 379 of file inputmanager.cpp.

{
    if (keyboard.isActionActive(index))
        return true;
    if ((joystick != nullptr) && joystick->isActionActive(index))
        return true;
    return touchManager.isActionActive(index);
}

References Joystick::isActionActive(), KeyboardConfig::isActionActive(), TouchManager::isActionActive(), joystick, keyboard, and touchManager.

makeDefault()

void InputManager::makeDefault

(

const InputActionT

i

)

Definition at line 300 of file inputmanager.cpp.

{
    if (i > InputAction::NO_VALUE && i < InputAction::TOTAL)
    {
        resetKey(i);
        update();
    }
}

References InputAction::NO_VALUE, InputAction::TOTAL, and UserAgent::update().

Referenced by Setup_Input::action().

resetKey()

void InputManager::resetKey ( const InputActionT  i )

protected

Definition at line 253 of file inputmanager.cpp.

{
    InputFunction &restrict key = mKey[CAST_SIZE(i)];
    for (size_t i2 = 1; i2 < inputFunctionSize; i2 ++)
    {
        InputItem &restrict ki2 = key.values[i2];
        ki2.type = InputType::UNKNOWN;
        ki2.value = -1;
    }
    const InputActionData &restrict kd =
        inputActionData[CAST_SIZE(i)];
    InputItem &restrict val0 = key.values[0];
    val0.type = kd.defaultType1;
    InputItem &restrict val1 = key.values[1];
    val1.type = kd.defaultType2;
#ifdef USE_SDL2
    if (kd.defaultType1 == InputType::KEYBOARD)
    {
        val0.value = SDL_GetScancodeFromKey(kd.defaultValue1);
        if (val0.value == SDL_SCANCODE_UNKNOWN)
            val0.value = -1;
    }
    else
        val0.value = kd.defaultValue1;
    if (kd.defaultType2 == InputType::KEYBOARD)
    {
        val1.value = SDL_GetScancodeFromKey(kd.defaultValue2);
        if (val1.value == SDL_SCANCODE_UNKNOWN)
            val1.value = -1;
    }
    else
        val1.value = kd.defaultValue2;
#else  // USE_SDL2
 
    val0.value = kd.defaultValue1;
    val1.value = kd.defaultValue2;
#endif  // USE_SDL2
 
    updateKeyString(key, CAST_SIZE(i));
}

References CAST_SIZE, inputActionData, inputFunctionSize, InputType::KEYBOARD, restrict, and InputType::UNKNOWN.

Referenced by resetKeys().

resetKeys()

void InputManager::resetKeys

(

)

Definition at line 294 of file inputmanager.cpp.

{
    for (int i = 0; i < CAST_S32(InputAction::TOTAL); i++)
        resetKey(static_cast<InputActionT>(i));
}

References CAST_S32, resetKey(), and InputAction::TOTAL.

Referenced by Setup_Input::action(), and init().

retrieve()

void InputManager::retrieve

(

)

Definition at line 123 of file inputmanager.cpp.

{
    for (int i = 0; i < CAST_S32(InputAction::TOTAL); i ++)
    {
        const std::string &restrict cmd = inputActionData[i].chatCommand;
        if (!cmd.empty())
        {
            StringVect tokens;
            splitToStringVector(tokens, cmd, '|');
            FOR_EACH (StringVectCIter, it, tokens)
                mChatMap[*it] = i;
        }
#ifdef USE_SDL2
        const std::string cf = std::string("sdl2")
            + inputActionData[i].configField;
#else  // USE_SDL2
 
        const std::string cf = inputActionData[i].configField;
#endif  // USE_SDL2
 
        InputFunction &restrict kf = mKey[i];
        if (!cf.empty())
        {
            mNameMap[cf] = static_cast<InputActionT>(i);
            const std::string keyStr = config.getValue(cf, "");
            const size_t keyStrSize = keyStr.size();
            if (keyStr.empty())
            {
                updateKeyString(kf, i);
                continue;
            }
 
            StringVect keys;
            splitToStringVector(keys, keyStr, ',');
            unsigned int i2 = 0;
            for (StringVectCIter it = keys.begin(), it_end = keys.end();
                 it != it_end && i2 < inputFunctionSize; ++ it)
            {
                std::string keyStr2 = *it;
                if (keyStrSize < 2)
                    continue;
                InputTypeT type = InputType::KEYBOARD;
                if ((keyStr2[0] < '0' || keyStr2[0] > '9')
                    && keyStr2[0] != '-')
                {
                    switch (keyStr2[0])
                    {
                        case 'm':
                            type = InputType::MOUSE;
                            break;
                        case 'j':
                            type = InputType::JOYSTICK;
                            break;
                        default:
                            break;
                    }
                    keyStr2 = keyStr2.substr(1);
                }
                const int key = atoi(keyStr2.c_str());
                if (key >= -255 && key < SDLK_LAST)
                {
                    kf.values[i2] = InputItem(type, key);
                    i2 ++;
                }
            }
            for (; i2 < inputFunctionSize; i2 ++)
                kf.values[i2] = InputItem();
        }
        updateKeyString(kf, i);
    }
}

References CAST_S32, InputActionData::chatCommand, config, InputActionData::configField, FOR_EACH, ConfigurationObject::getValue(), inputActionData, inputFunctionSize, InputType::JOYSTICK, InputType::KEYBOARD, mChatMap, mKey, mNameMap, InputType::MOUSE, restrict, splitToStringVector(), InputAction::TOTAL, and updateKeyString().

Referenced by Setup_Input::cancel(), and init().

setNewKey()

void InputManager::setNewKey	(	const SDL_Event &	event,
		const InputTypeT	type
	)

Definition at line 546 of file inputmanager.cpp.

{
    int val = -1;
    if (type == InputType::KEYBOARD)
        val = KeyboardConfig::getKeyValueFromEvent(event);
    else if (type == InputType::JOYSTICK && (joystick != nullptr))
        val = joystick->getButtonFromEvent(event);
 
    if (val != -1)
    {
        addActionKey(mNewKeyIndex, type, val);
        update();
    }
}

References Joystick::getButtonFromEvent(), KeyboardConfig::getKeyValueFromEvent(), InputType::JOYSTICK, joystick, InputType::KEYBOARD, and UserAgent::update().

setNewKeyIndex()

void InputManager::setNewKeyIndex ( const InputActionT  value )

inline

Set the index of the new key to be assigned.

Definition at line 104 of file inputmanager.h.

        { mNewKeyIndex = value; }

References mNewKeyIndex.

Referenced by Setup_Input::action(), and Setup_Input::keyUnresolved().

setSetupInput()

void InputManager::setSetupInput ( Setup_Input *const  setupInput )

inline

Set a reference to the key setup window.

Definition at line 110 of file inputmanager.h.

        { mSetupInput = setupInput; }

References mSetupInput.

Referenced by Setup_Input::Setup_Input().

store()

void InputManager::store

(

)

const

Definition at line 195 of file inputmanager.cpp.

{
    for (int i = 0; i < CAST_S32(InputAction::TOTAL); i ++)
    {
#ifdef USE_SDL2
        const std::string cf = std::string("sdl2")
            + inputActionData[i].configField;
#else  // USE_SDL2
 
        const std::string cf = inputActionData[i].configField;
#endif  // USE_SDL2
 
        if (!cf.empty())
        {
            std::string keyStr;
            const InputFunction &restrict kf = mKey[i];
 
            for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++)
            {
                const InputItem &restrict key = kf.values[i2];
                if (key.type != InputType::UNKNOWN)
                {
                    std::string tmp("k");
                    switch (key.type)
                    {
                        case InputType::MOUSE:
                            tmp = "m";
                            break;
                        case InputType::JOYSTICK:
                            tmp = "j";
                            break;
                        case InputType::KEYBOARD:
                        case InputType::UNKNOWN:
                        default:
                            break;
                    }
                    if (key.value != -1)
                    {
                        if (keyStr.empty())
                        {
                            keyStr.append(tmp).append(toString(key.value));
                        }
                        else
                        {
                            keyStr.append(strprintf(",%s%d",
                                tmp.c_str(), key.value));
                        }
                    }
                }
            }
            if (keyStr.empty())
                keyStr = "-1";
 
            config.setValue(cf, keyStr);
        }
    }
}

References CAST_S32, config, InputActionData::configField, inputActionData, inputFunctionSize, InputType::JOYSTICK, InputType::KEYBOARD, mKey, InputType::MOUSE, restrict, Configuration::setValue(), strprintf(), Catch::toString(), InputAction::TOTAL, and InputType::UNKNOWN.

Referenced by Setup_Input::apply().

triggerAction()

bool InputManager::triggerAction

(

const KeysVector *const

ptrs

)

Definition at line 1014 of file inputmanager.cpp.

{
    if (ptrs == nullptr)
        return false;
 
//    logger->log("ptrs: %d", (int)ptrs.size());
 
    FOR_EACHP (KeysVectorCIter, it, ptrs)
    {
        const InputActionT keyNum = *it;
        if (CAST_S32(keyNum) < 0 || keyNum >= InputAction::TOTAL)
            continue;
 
        if (invokeKey(&inputActionData[CAST_SIZE(keyNum)], keyNum))
            return true;
    }
    return false;
}

References CAST_S32, CAST_SIZE, FOR_EACHP, inputActionData, and InputAction::TOTAL.

Referenced by Joystick::handleRepeat(), and KeyboardConfig::handleRepeat().

unassignKey()

void InputManager::unassignKey

(

)

Definition at line 562 of file inputmanager.cpp.

{
    InputFunction &restrict key = mKey[CAST_SIZE(mNewKeyIndex)];
    for (size_t i = 0; i < inputFunctionSize; i ++)
    {
        InputItem &restrict val = key.values[i];
        val.type = InputType::UNKNOWN;
        val.value = -1;
    }
    updateKeyString(key, CAST_SIZE(mNewKeyIndex));
    update();
}

References CAST_SIZE, inputFunctionSize, mKey, mNewKeyIndex, restrict, InputType::UNKNOWN, update(), and updateKeyString().

Referenced by Setup_Input::action().

update()

void InputManager::update ( )

static

Definition at line 116 of file inputmanager.cpp.

{
    keyboard.update();
    if (joystick != nullptr)
        joystick->update();
}

References joystick, keyboard, Joystick::update(), and KeyboardConfig::update().

Referenced by Setup_Input::action(), init(), and unassignKey().

updateConditionMask()

void InputManager::updateConditionMask

(

const bool

pressed

)

Definition at line 761 of file inputmanager.cpp.

{
    mMask = 1;
    if (keyboard.isEnabled())
        mMask |= InputCondition::ENABLED;
#ifndef DYECMD
    if (((chatWindow == nullptr) || !chatWindow->isInputFocused()) &&
        !NpcDialog::isAnyInputFocused() &&
        !InventoryWindow::isAnyInputFocused() &&
        ((tradeWindow == nullptr) || !tradeWindow->isInpupFocused()))
    {
        if (gui != nullptr)
        {
            FocusHandler *restrict const focus = gui->getFocusHandler();
            if (focus != nullptr)
            {
                if (dynamic_cast<TextField*>(focus->getFocused()) == nullptr)
                    mMask |= InputCondition::NOINPUT;
            }
            else
            {
                mMask |= InputCondition::NOINPUT;
            }
        }
        else
        {
            mMask |= InputCondition::NOINPUT;
        }
    }
 
    if (!BuyDialog::isActive() && !SellDialog::isActive())
        mMask |= InputCondition::NOBUYSELL;
 
    if (!PlayerInfo::isVending())
        mMask |= InputCondition::NOVENDING;
    if (!PlayerInfo::isInRoom())
        mMask |= InputCondition::NOROOM;
 
    const NpcDialog *restrict const dialog = NpcDialog::getActive();
    if ((dialog == nullptr) || !dialog->isTextInputFocused())
        mMask |= InputCondition::NONPCINPUT;
    if ((dialog == nullptr) || (dialog->isCloseState() != 0))
    {
        mMask |= InputCondition::NONPCDIALOG;
        if (!InventoryWindow::isStorageActive())
            mMask |= InputCondition::NOTALKING;
    }
    if ((setupWindow == nullptr) || !setupWindow->isWindowVisible())
        mMask |= InputCondition::NOSETUP;
 
    if ((Game::instance() != nullptr) && Game::instance()->getValidSpeed())
        mMask |= InputCondition::VALIDSPEED;
 
    if (Game::instance() != nullptr)
        mMask |= InputCondition::INGAME;
 
    if (localPlayer != nullptr)
    {
        if (localPlayer->getFollow().empty())
            mMask |= InputCondition::NOFOLLOW;
 
        if (!localPlayer->isTrickDead())
            mMask |= InputCondition::NOBLOCK;
 
        if (localPlayer->isAlive())
            mMask |= InputCondition::ALIVE;
    }
    else
    {
        mMask |= InputCondition::NOFOLLOW;
        mMask |= InputCondition::NOBLOCK;
    }
#endif  // DYECMD
 
    if (!settings.awayMode)
        mMask |= InputCondition::NOAWAY;
 
    if (gui != nullptr && gui->getFocusHandler()->getModalFocused() == nullptr)
        mMask |= InputCondition::NOMODAL;
 
    if (!settings.disableGameModifiers)
        mMask |= InputCondition::EMODS;
 
    if (!isActionActive0(InputAction::STOP_ATTACK)
        && !isActionActive0(InputAction::UNTARGET))
    {
        mMask |= InputCondition::NOTARGET;
    }
    // enable it temporary
    mMask |= InputCondition::KEY_DOWN;
//    if (pressed == true)
//        mMask |= InputCondition::KEY_DOWN;
//    else
//        mMask |= InputCondition::KEY_UP;
}

References InputCondition::ALIVE, Settings::awayMode, chatWindow, Settings::disableGameModifiers, InputCondition::EMODS, InputCondition::ENABLED, NpcDialog::getActive(), Gui::getFocusHandler(), LocalPlayer::getFollow(), FocusHandler::getModalFocused(), gui, InputCondition::INGAME, Game::instance(), SellDialog::isActive(), BuyDialog::isActive(), Being::isAlive(), InventoryWindow::isAnyInputFocused(), NpcDialog::isAnyInputFocused(), KeyboardConfig::isEnabled(), TradeWindow::isInpupFocused(), ChatWindow::isInputFocused(), PlayerInfo::isInRoom(), InventoryWindow::isStorageActive(), ActorSprite::isTrickDead(), PlayerInfo::isVending(), Window::isWindowVisible(), InputCondition::KEY_DOWN, keyboard, localPlayer, InputCondition::NOAWAY, InputCondition::NOBLOCK, InputCondition::NOBUYSELL, InputCondition::NOFOLLOW, InputCondition::NOINPUT, InputCondition::NOMODAL, InputCondition::NONPCDIALOG, InputCondition::NONPCINPUT, InputCondition::NOROOM, InputCondition::NOSETUP, InputCondition::NOTALKING, InputCondition::NOTARGET, InputCondition::NOVENDING, restrict, settings, setupWindow, InputAction::STOP_ATTACK, tradeWindow, InputAction::UNTARGET, and InputCondition::VALIDSPEED.

Referenced by moveChar().

updateKeyActionMap()

void InputManager::updateKeyActionMap	(	KeyToActionMap &	actionMap,
		KeyToIdMap &	idMap,
		KeyTimeMap &	keyTimeMap,
		const InputTypeT	type
	)		const

Definition at line 961 of file inputmanager.cpp.

{
    actionMap.clear();
    keyTimeMap.clear();
 
    for (size_t i = 0; i < CAST_SIZE(InputAction::TOTAL); i ++)
    {
        const InputFunction &restrict key = mKey[i];
        const InputActionData &restrict kd = inputActionData[i];
        if (kd.action != nullptr)
        {
            for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++)
            {
                const InputItem &restrict ki = key.values[i2];
                if (ki.type == type && ki.value != -1)
                {
                    actionMap[ki.value].push_back(
                        static_cast<InputActionT>(i));
                }
            }
        }
        if (kd.configField != nullptr && (kd.grp & Input::GRP_GUICHAN) != 0)
        {
            for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++)
            {
                const InputItem &restrict ki = key.values[i2];
                if (ki.type == type && ki.value != -1)
                    idMap[ki.value] = static_cast<InputActionT>(i);
            }
        }
        if (kd.configField != nullptr && (kd.grp & Input::GRP_REPEAT) != 0)
        {
            for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++)
            {
                const InputItem &restrict ki = key.values[i2];
                if (ki.type == type && ki.value != -1)
                    keyTimeMap[ki.value] = 0;
            }
        }
    }
 
    inputActionDataSorter.keys = &inputActionData[0];
    FOR_EACH (KeyToActionMapIter, it, actionMap)
    {
        KeysVector *const keys = &it->second;
        if (keys->size() > 1)
            std::sort(keys->begin(), keys->end(), inputActionDataSorter);
    }
}

References CAST_SIZE, FOR_EACH, Input::GRP_GUICHAN, Input::GRP_REPEAT, inputActionData, anonymous_namespace{inputmanager.cpp}::inputActionDataSorter, inputFunctionSize, InputActionSortFunctor::keys, restrict, and InputAction::TOTAL.

Referenced by Joystick::update(), and KeyboardConfig::update().

updateKeyString()

void InputManager::updateKeyString ( const InputFunction &  ki, const size_t  actionIdx  )

protected

Definition at line 439 of file inputmanager.cpp.

{
    std::string keyStr;
    for (size_t i = 0; i < inputFunctionSize; i ++)
    {
        const InputItem &restrict key = ki.values[i];
        std::string str;
        if (key.type == InputType::KEYBOARD)
        {
            if (key.value >= 0)
            {
                str = KeyboardConfig::getKeyShortString(
                    KeyboardConfig::getKeyName(key.value));
            }
            else if (key.value < -1)
            {
                // TRANSLATORS: short key name. must be very short.
                str = strprintf(_("key_%d"), -key.value);
            }
        }
        else if (key.type == InputType::JOYSTICK)
        {
            // TRANSLATORS: short joystick button name. muse be very short
            str = strprintf(_("JB%d"), key.value + 1);
        }
        if (!str.empty())
        {
            if (keyStr.empty())
                keyStr = str;
            else
                keyStr.append(", ").append(str);
        }
    }
 
    if (keyStr.empty())
    {
        // TRANSLATORS: unknown short key type. must be short
        mKeyStr[actionIdx] = _("u key");
    }
    else
    {
        mKeyStr[actionIdx] = STD_MOVE(keyStr);
    }
}

References _, KeyboardConfig::getKeyName(), KeyboardConfig::getKeyShortString(), inputFunctionSize, InputType::JOYSTICK, InputType::KEYBOARD, restrict, STD_MOVE, and strprintf().

Referenced by retrieve(), and unassignKey().

Field Documentation

mChatMap

StringIntMap InputManager::mChatMap

protected

Definition at line 181 of file inputmanager.h.

Referenced by retrieve().

mKey

InputFunction InputManager::mKey[static_cast< size_t >(InputAction::TOTAL)]

protected

Definition at line 183 of file inputmanager.h.

Referenced by init(), retrieve(), store(), and unassignKey().

mKeyStr

std::string InputManager::mKeyStr[static_cast< size_t >(InputAction::TOTAL)]

protected

Definition at line 184 of file inputmanager.h.

Referenced by init().

mMask

int InputManager::mMask

protected

Definition at line 178 of file inputmanager.h.

mNameMap

StringInpActionMap InputManager::mNameMap

protected

Definition at line 180 of file inputmanager.h.

Referenced by retrieve().

mNewKeyIndex

InputActionT InputManager::mNewKeyIndex

protected

Index of new key to be assigned

Definition at line 176 of file inputmanager.h.

Referenced by callbackNewKey(), getNewKeyIndex(), init(), setNewKeyIndex(), and unassignKey().

mSetupInput

Setup_Input* InputManager::mSetupInput

protected

Reference to setup window

Definition at line 174 of file inputmanager.h.

Referenced by callbackNewKey(), and setSetupInput().

---

The documentation for this class was generated from the following files:

• src/input/inputmanager.h (986a3bf)
• src/input/inputmanager.cpp (986a3bf)