C4KeyCodeEx Struct Reference

#include <C4KeyboardInput.h>

Public Member Functions
StdStrBuf	ToString (bool fHumanReadable, bool fShort) const
bool	operator< (const C4KeyCodeEx &v2) const
bool	operator== (const C4KeyCodeEx &v2) const
void	CompileFunc (StdCompiler *pComp, StdStrBuf *pOutBuf=nullptr)
	C4KeyCodeEx (C4KeyCode Key=KEY_Default, DWORD Shift=KEYS_None, bool fIsRepeated=false, int32_t deviceId=-1)
bool	IsRepeated () const
void	FixShiftKeys ()

Static Public Member Functions
static C4KeyShiftState	String2KeyShift (const StdStrBuf &sName)
static C4KeyCode	String2KeyCode (const StdStrBuf &sName)
static StdStrBuf	KeyCode2String (C4KeyCode wCode, bool fHumanReadable, bool fShort)
static StdStrBuf	KeyShift2String (C4KeyShiftState eShift)
static C4KeyCodeEx	FromC4MC (int8_t mouse_id, int32_t button, DWORD param, bool *is_down=nullptr)

Public Attributes
C4KeyCode	Key
DWORD	dwShift
int32_t	deviceId
bool	fRepeated

Detailed Description

Definition at line 201 of file C4KeyboardInput.h.

Constructor & Destructor Documentation

C4KeyCodeEx()

C4KeyCodeEx::C4KeyCodeEx	(	C4KeyCode	Key = KEY_Default,
		DWORD	Shift = KEYS_None,
		bool	fIsRepeated = false,
		int32_t	deviceId = -1
	)

Definition at line 190 of file C4KeyboardInput.cpp.

: Key(key), dwShift(Shift), fRepeated(fIsRepeated), deviceId(deviceId)
{
}

Member Function Documentation

CompileFunc()

void C4KeyCodeEx::CompileFunc	(	StdCompiler *	pComp,
		StdStrBuf *	pOutBuf = nullptr
	)

Definition at line 519 of file C4KeyboardInput.cpp.

{
    if (pComp->isDeserializer())
    {
        // reading from file
        StdStrBuf sCode;
        bool is_scan_code;
        // read shifts
        DWORD dwSetShift = 0;
        for (;;)
        {
            is_scan_code = pComp->Separator(StdCompiler::SEP_DOLLAR);
            if (!is_scan_code) pComp->NoSeparator();
            pComp->Value(mkParAdapt(sCode, StdCompiler::RCT_Idtf));
            if (is_scan_code) // scan codes start with $. Reassamble the two tokens that were split by StdCompiler
            {
                sCode.Take(FormatString("$%s", sCode.getData()));
                break;
            }
            if (!pComp->Separator(StdCompiler::SEP_PLUS)) break; // no more separator: Parse this as keyboard code
            // try to convert to shift state
            C4KeyShiftState eAddState = String2KeyShift(sCode);
            if (eAddState == KEYS_Undefined)
                pComp->excCorrupt("undefined key shift state: %s", sCode.getData());
            dwSetShift |= eAddState;
        }
        // any code given? Otherwise, keep default
        if (sCode.getLength())
        {
            // last section: convert to key code
            C4KeyCode eCode = String2KeyCode(sCode);
            if (eCode == KEY_Undefined)
            {
                if (pOutBuf)
                {
                    // unknown key, but an output buffer for unknown keys was provided. No failure; caller might resolve key.
                    eCode = KEY_Default;
                }
                else
                {
                    pComp->excCorrupt("undefined key code: %s", sCode.getData());
                }
            }
            dwShift = dwSetShift;
            Key = eCode;
            if (pOutBuf) {
                // FIXME: This function is used both, to deserialize things like CON_Right and Shift+$12
                // For CON_…, eCode and dwShift will be zero, and sCode will contain the key name.
                // For Shift+… sCode will only contain the last token. What is correct here?
                // Reading C4PlayerControlAssignment::KeyComboItem::CompileFunc suggests that setting not value for parsed combinations may be correct.
                if (eCode == 0)
                    pOutBuf->Take(std::move(sCode));
                else
                    pOutBuf->Copy(ToString(false, false));
            }
        }
    }
    else
    {
        // write shift states
        for (DWORD dwShiftCheck = KEYS_First; dwShiftCheck <= KEYS_Max; dwShiftCheck <<= 1)
            if (dwShiftCheck & dwShift)
            {
                pComp->Value(mkDecompileAdapt(KeyShift2String((C4KeyShiftState) dwShiftCheck)));
                pComp->Separator(StdCompiler::SEP_PLUS);
            }
        // write key
        pComp->Value(mkDecompileAdapt(KeyCode2String(Key, false, false)));
    }
}

References StdStrBuf::Copy(), dwShift, StdCompiler::excCorrupt(), FormatString(), StdStrBuf::getData(), StdStrBuf::getLength(), StdCompiler::isDeserializer(), Key, KEY_Default, KEY_Undefined, KeyCode2String(), KEYS_First, KEYS_Max, KEYS_Undefined, KeyShift2String(), mkDecompileAdapt(), mkParAdapt(), StdCompiler::NoSeparator(), StdCompiler::RCT_Idtf, StdCompiler::SEP_DOLLAR, StdCompiler::SEP_PLUS, StdCompiler::Separator(), String2KeyCode(), String2KeyShift(), StdStrBuf::Take(), ToString(), and StdCompiler::Value().

Here is the call graph for this function:

FixShiftKeys()

void C4KeyCodeEx::FixShiftKeys

(

)

Definition at line 233 of file C4KeyboardInput.cpp.

{
    // reduce stuff like Ctrl+RightCtrl to simply RightCtrl
    if ((dwShift & KEYS_Alt) && (Key == K_ALT_L || Key == K_ALT_R)) dwShift &= ~KEYS_Alt;
    if ((dwShift & KEYS_Control) && (Key == K_CONTROL_L || Key == K_CONTROL_R)) dwShift &= ~KEYS_Control;
    if ((dwShift & KEYS_Shift) && (Key == K_SHIFT_L || Key == K_SHIFT_R)) dwShift &= ~KEYS_Shift;
}

References dwShift, Key, KEYS_Alt, KEYS_Control, and KEYS_Shift.

Referenced by C4Game::DoKeyboardInput().

Here is the caller graph for this function:

FromC4MC()

C4KeyCodeEx C4KeyCodeEx::FromC4MC ( int8_t  mouse_id, int32_t  button, DWORD  param, bool *  is_down = nullptr  )

static

Definition at line 195 of file C4KeyboardInput.cpp.

{
    bool dummy;
    if (!is_down)
        is_down = &dummy;
    *is_down = true;
    C4KeyCode mouseevent_code;
    int wheel_dir = 0;
    if (iButton == C4MC_Button_Wheel) wheel_dir = (short)(dwKeyParam >> 16);
    switch (iButton)
    {
    case C4MC_Button_None: mouseevent_code = KEY_MOUSE_Move; break;
    case C4MC_Button_LeftDown: mouseevent_code = KEY_MOUSE_ButtonLeft; break;
    case C4MC_Button_LeftUp: mouseevent_code = KEY_MOUSE_ButtonLeft; *is_down = false; break;
    case C4MC_Button_LeftDouble: mouseevent_code = KEY_MOUSE_ButtonLeftDouble; break;
    case C4MC_Button_RightDown: mouseevent_code = KEY_MOUSE_ButtonRight; break;
    case C4MC_Button_RightDouble: mouseevent_code = KEY_MOUSE_ButtonRightDouble; break;
    case C4MC_Button_RightUp: mouseevent_code = KEY_MOUSE_ButtonRight; *is_down = false; break;
    case C4MC_Button_MiddleDown: mouseevent_code = KEY_MOUSE_ButtonMiddle; break;
    case C4MC_Button_MiddleUp: mouseevent_code = KEY_MOUSE_ButtonMiddle; *is_down = false; break;
    case C4MC_Button_MiddleDouble: mouseevent_code = KEY_MOUSE_ButtonMiddleDouble; break;
    case C4MC_Button_X1Down: mouseevent_code = KEY_MOUSE_ButtonX1; break;
    case C4MC_Button_X1Up: mouseevent_code = KEY_MOUSE_ButtonX1; *is_down = false; break;
    case C4MC_Button_X1Double: mouseevent_code = KEY_MOUSE_ButtonX1Double; break;
    case C4MC_Button_X2Down: mouseevent_code = KEY_MOUSE_ButtonX2; break;
    case C4MC_Button_X2Up: mouseevent_code = KEY_MOUSE_ButtonX2; *is_down = false; break;
    case C4MC_Button_X2Double: mouseevent_code = KEY_MOUSE_ButtonX2Double; break;
    case C4MC_Button_Wheel:
        if (!wheel_dir) assert("Attempted to record mouse wheel movement without a direction");
        mouseevent_code = (wheel_dir > 0) ? KEY_MOUSE_Wheel1Up : KEY_MOUSE_Wheel1Down; break;
    }
    C4KeyCodeEx key{KEY_Mouse(mouse_id, mouseevent_code), KEYS_None};
    if (dwKeyParam & MK_CONTROL) key.dwShift |= KEYS_Control;
    if (dwKeyParam & MK_SHIFT) key.dwShift |= KEYS_Shift;
    if (dwKeyParam & MK_ALT) key.dwShift |= KEYS_Alt;
    return key;
}

References C4MC_Button_LeftDouble, C4MC_Button_LeftDown, C4MC_Button_LeftUp, C4MC_Button_MiddleDouble, C4MC_Button_MiddleDown, C4MC_Button_MiddleUp, C4MC_Button_None, C4MC_Button_RightDouble, C4MC_Button_RightDown, C4MC_Button_RightUp, C4MC_Button_Wheel, C4MC_Button_X1Double, C4MC_Button_X1Down, C4MC_Button_X1Up, C4MC_Button_X2Double, C4MC_Button_X2Down, C4MC_Button_X2Up, KEY_Mouse(), KEY_MOUSE_ButtonLeft, KEY_MOUSE_ButtonLeftDouble, KEY_MOUSE_ButtonMiddle, KEY_MOUSE_ButtonMiddleDouble, KEY_MOUSE_ButtonRight, KEY_MOUSE_ButtonRightDouble, KEY_MOUSE_ButtonX1, KEY_MOUSE_ButtonX1Double, KEY_MOUSE_ButtonX2, KEY_MOUSE_ButtonX2Double, KEY_MOUSE_Move, KEY_MOUSE_Wheel1Down, KEY_MOUSE_Wheel1Up, KEYS_Alt, KEYS_Control, KEYS_None, and KEYS_Shift.

Referenced by C4PlayerControl::DoMouseInput().

Here is the call graph for this function:

Here is the caller graph for this function:

IsRepeated()

bool C4KeyCodeEx::IsRepeated ( ) const

inline

Definition at line 235 of file C4KeyboardInput.h.

{ return fRepeated; }

References fRepeated.

KeyCode2String()

StdStrBuf C4KeyCodeEx::KeyCode2String ( C4KeyCode  wCode, bool  fHumanReadable, bool  fShort  )

static

Definition at line 364 of file C4KeyboardInput.cpp.

{
    // Gamepad keys
    if (Key_IsGamepad(wCode))
    {
        if (fHumanReadable)
        {
            switch (Key_GetGamepadEvent(wCode))
            {
            case KEY_CONTROLLER_ButtonA             : return StdStrBuf("{{@Ico:A}}");
            case KEY_CONTROLLER_ButtonB             : return StdStrBuf("{{@Ico:B}}");
            case KEY_CONTROLLER_ButtonX             : return StdStrBuf("{{@Ico:X}}");
            case KEY_CONTROLLER_ButtonY             : return StdStrBuf("{{@Ico:Y}}");
            case KEY_CONTROLLER_ButtonBack          : return StdStrBuf("{{@Ico:Back}}");
            case KEY_CONTROLLER_ButtonGuide         : return StdStrBuf("Guide");
            case KEY_CONTROLLER_ButtonStart         : return StdStrBuf("{{@Ico:Start}}");
            case KEY_CONTROLLER_ButtonLeftStick     : return StdStrBuf("{{@Ico:LeftStick}}");
            case KEY_CONTROLLER_ButtonRightStick    : return StdStrBuf("{{@Ico:RightStick}}");
            case KEY_CONTROLLER_ButtonLeftShoulder  : return StdStrBuf("{{@Ico:LeftShoulder}}");
            case KEY_CONTROLLER_ButtonRightShoulder : return StdStrBuf("{{@Ico:RightShoulder}}");
            case KEY_CONTROLLER_ButtonDpadUp        : return StdStrBuf("{{@Ico:DpadUp}}");
            case KEY_CONTROLLER_ButtonDpadDown      : return StdStrBuf("{{@Ico:DpadDown}}");
            case KEY_CONTROLLER_ButtonDpadLeft      : return StdStrBuf("{{@Ico:DpadLeft}}");
            case KEY_CONTROLLER_ButtonDpadRight     : return StdStrBuf("{{@Ico:DpadRight}}");
            case KEY_CONTROLLER_AnyButton           : return StdStrBuf("Any Button");
            case KEY_CONTROLLER_AxisLeftXLeft       : return StdStrBuf("{{@Ico:LeftStick}} Left");
            case KEY_CONTROLLER_AxisLeftXRight      : return StdStrBuf("{{@Ico:LeftStick}} Right");
            case KEY_CONTROLLER_AxisLeftYUp         : return StdStrBuf("{{@Ico:LeftStick}} Up");
            case KEY_CONTROLLER_AxisLeftYDown       : return StdStrBuf("{{@Ico:LeftStick}} Down");
            case KEY_CONTROLLER_AxisRightXLeft      : return StdStrBuf("{{@Ico:RightStick}} Left");
            case KEY_CONTROLLER_AxisRightXRight     : return StdStrBuf("{{@Ico:RightStick}} Right");
            case KEY_CONTROLLER_AxisRightYUp        : return StdStrBuf("{{@Ico:RightStick}} Up");
            case KEY_CONTROLLER_AxisRightYDown      : return StdStrBuf("{{@Ico:RightStick}} Down");
            case KEY_CONTROLLER_AxisTriggerLeft     : return StdStrBuf("{{@Ico:LeftTrigger}}");
            case KEY_CONTROLLER_AxisTriggerRight    : return StdStrBuf("{{@Ico:RightTrigger}}");
            }
        }
        else
        {
            // A linear search in our small map is probably fast enough.
            auto it = std::find_if(controllercodes.begin(), controllercodes.end(), [wCode](const auto &p)
            {
                return p.second == Key_GetGamepadEvent(wCode);
            });
            if (it != controllercodes.end())
                return FormatString("Controller%s", it->first.c_str());
        }
        return StdStrBuf("Unknown");
    }
 
    // Mouse keys
    if (Key_IsMouse(wCode))
    {
        int mouse_id = Key_GetMouse(wCode);
        int mouse_event = Key_GetMouseEvent(wCode);
        const char *mouse_str = "Mouse";
        switch (mouse_event)
        {
        case KEY_MOUSE_Move:              return FormatString("%s%dMove", mouse_str, mouse_id);
        case KEY_MOUSE_Wheel1Up:          return FormatString("%s%dWheel1Up", mouse_str, mouse_id);
        case KEY_MOUSE_Wheel1Down:        return FormatString("%s%dWheel1Down", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonLeft:        return FormatString("%s%dLeft", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonRight:       return FormatString("%s%dRight", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonMiddle:      return FormatString("%s%dMiddle", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonX1:          return FormatString("%s%dX1", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonX2:          return FormatString("%s%dX2", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonLeftDouble:  return FormatString("%s%dLeftDouble", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonRightDouble: return FormatString("%s%dRightDouble", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonMiddleDouble:return FormatString("%s%dMiddleDouble", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonX1Double:    return FormatString("%s%dX1Double", mouse_str, mouse_id);
        case KEY_MOUSE_ButtonX2Double:    return FormatString("%s%dX2Double", mouse_str, mouse_id);
        default:
            // extended mouse button
        {
            uint8_t btn = Key_GetMouseEvent(wCode);
            if (btn >= KEY_MOUSE_Button1Double)
                return FormatString("%s%dButton%dDouble", mouse_str, mouse_id, int(btn-KEY_MOUSE_Button1Double));
            else
                return FormatString("%s%dButton%d", mouse_str, mouse_id, int(btn-KEY_MOUSE_Button1));
        }
        }
    }
 
    // it's a keyboard key
    if (!fHumanReadable) {
        // for config files and such: dump scancode
        return FormatString("$%x", static_cast<unsigned int>(wCode));
    }
#if defined(USE_WIN32_WINDOWS)
 
    // Query map
    const C4KeyCodeMapEntry *pCheck = KeyCodeMap;
    while (pCheck->szName)
        if (wCode == pCheck->wCode) return StdStrBuf((pCheck->szShortName && fShort) ? pCheck->szShortName : pCheck->szName); else ++pCheck;
 
//  TODO: Works?
//  StdStrBuf Name; Name.SetLength(1000);
//  int res = GetKeyNameText(wCode, Name.getMData(), Name.getSize());
//  if(!res)
//    // not found: Compose as direct code
//    return FormatString("\\x%x", (DWORD) wCode);
//  // Set size
//  Name.SetLength(res);
//  return Name;
 
    wchar_t buf[100];
    int len = GetKeyNameText(wCode<<16, buf, 100);
    if (len > 0) {
        // buf is nullterminated name
        return StdStrBuf(buf);
    }
#elif defined (USE_COCOA)
    // query map
    const C4KeyCodeMapEntry *pCheck = KeyCodeMap;
    while (pCheck->szName)
            if (wCode == pCheck->wCode) return StdStrBuf((pCheck->szShortName && fShort) ? pCheck->szShortName : pCheck->szName); else ++pCheck;
    // not found: Compose as direct code
    return FormatString("\\x%x", static_cast<unsigned int>(wCode));
#elif defined(USE_SDL_MAINLOOP)
    StdStrBuf buf;
    auto name = KeycodeToString(wCode);
    if (name) buf.Copy(name);
    if (!buf.getLength()) buf.Format("\\x%lx", wCode);
    return buf;
#endif
    return FormatString("$%x", static_cast<unsigned int>(wCode));
}

References KEY_CONTROLLER_AnyButton, KEY_CONTROLLER_AxisLeftXLeft, KEY_CONTROLLER_AxisLeftXRight, KEY_CONTROLLER_AxisLeftYDown, KEY_CONTROLLER_AxisLeftYUp, KEY_CONTROLLER_AxisRightXLeft, KEY_CONTROLLER_AxisRightXRight, KEY_CONTROLLER_AxisRightYDown, KEY_CONTROLLER_AxisRightYUp, KEY_CONTROLLER_AxisTriggerLeft, KEY_CONTROLLER_AxisTriggerRight, KEY_CONTROLLER_ButtonA, KEY_CONTROLLER_ButtonB, KEY_CONTROLLER_ButtonBack, KEY_CONTROLLER_ButtonDpadDown, KEY_CONTROLLER_ButtonDpadLeft, KEY_CONTROLLER_ButtonDpadRight, KEY_CONTROLLER_ButtonDpadUp, KEY_CONTROLLER_ButtonGuide, KEY_CONTROLLER_ButtonLeftShoulder, KEY_CONTROLLER_ButtonLeftStick, KEY_CONTROLLER_ButtonRightShoulder, KEY_CONTROLLER_ButtonRightStick, KEY_CONTROLLER_ButtonStart, KEY_CONTROLLER_ButtonX, KEY_CONTROLLER_ButtonY, Key_GetGamepadEvent(), and Key_IsGamepad().

Referenced by CompileFunc(), and ToString().

Here is the call graph for this function:

Here is the caller graph for this function:

KeyShift2String()

StdStrBuf C4KeyCodeEx::KeyShift2String ( C4KeyShiftState  eShift )

static

Definition at line 61 of file C4KeyboardInput.cpp.

{
    // query map
    const C4KeyShiftMapEntry *pCheck = KeyShiftMap;
    while (pCheck->szName)
            if (eShift == pCheck->eShift) break; else ++pCheck;
    return StdStrBuf(pCheck->szName);
}

References C4KeyShiftMapEntry::eShift, KeyShiftMap, and C4KeyShiftMapEntry::szName.

Referenced by CompileFunc(), and ToString().

Here is the caller graph for this function:

operator<()

bool C4KeyCodeEx::operator< ( const C4KeyCodeEx &  v2 ) const

inline

Definition at line 220 of file C4KeyboardInput.h.

    {
        return Key < v2.Key || (Key == v2.Key && dwShift < v2.dwShift);
    }

References dwShift, and Key.

operator==()

bool C4KeyCodeEx::operator== ( const C4KeyCodeEx &  v2 ) const

inline

Definition at line 225 of file C4KeyboardInput.h.

    {
        return Key == v2.Key && dwShift == v2.dwShift;
    }

References dwShift, and Key.

String2KeyCode()

C4KeyCode C4KeyCodeEx::String2KeyCode ( const StdStrBuf &  sName )

static

Definition at line 279 of file C4KeyboardInput.cpp.

{
    // direct key code, e.g. "$e" (Backspace)?
    if (sName.getLength() > 1)
    {
        unsigned int dwRVal;
        if (sscanf(sName.getData(), R"(\x%x)", &dwRVal) == 1) return dwRVal;
        // scan code
        if (*sName.getData() == '$') return GetKeyByScanCode(sName.getData());
        // direct gamepad code
        std::regex controller_re(R"/(^Controller(\w+)$)/");
        std::cmatch matches;
        if (std::regex_match(sName.getData(), matches, controller_re))
        {
            auto keycode_it = controllercodes.find(matches[1].str());
            if (keycode_it != controllercodes.end())
                return KEY_Gamepad(keycode_it->second);
            else
                return KEY_Undefined;
 
        }
        bool is_mouse_key;
#ifdef _WIN32
        is_mouse_key = !strnicmp(sName.getData(), "Mouse", 5);
#else
        is_mouse_key = !strncasecmp(sName.getData(), "Mouse", 5);
#endif
        if (is_mouse_key)
        {
            // skip Mouse/GameMouse
            const char *key_str = sName.getData()+5;
            int mouse_id;
            if (sscanf(key_str, "%d",  &mouse_id) == 1)
            {
                // skip number
                while (isdigit(*key_str)) ++key_str;
                // check for known mouse events (e.g. Mouse0Move or GameMouse0Wheel)
                if (!stricmp(key_str, "Move")) return KEY_Mouse(mouse_id, KEY_MOUSE_Move);
                if (!stricmp(key_str, "Wheel1Up")) return KEY_Mouse(mouse_id, KEY_MOUSE_Wheel1Up);
                if (!stricmp(key_str, "Wheel1Down")) return KEY_Mouse(mouse_id, KEY_MOUSE_Wheel1Down);
                // check for known mouse button events
                if (SEqualNoCase(key_str, "Button", 6)) // e.g. Mouse0ButtonLeft or GameMouse0ButtonRightDouble (This line is left here to not break anything, the buttons are now named Mouse0Left)
                    key_str += 6;
                uint8_t mouseevent_id = 0;
                if (SEqualNoCase(key_str, "Left",4)) { mouseevent_id=KEY_MOUSE_ButtonLeft; key_str += 4; }
                else if (SEqualNoCase(key_str, "Right",5)) { mouseevent_id=KEY_MOUSE_ButtonRight; key_str += 5; }
                else if (SEqualNoCase(key_str, "Middle",6)) { mouseevent_id=KEY_MOUSE_ButtonMiddle; key_str += 6; }
                else if (SEqualNoCase(key_str, "X1",2)) { mouseevent_id=KEY_MOUSE_ButtonX1; key_str += 2; }
                else if (SEqualNoCase(key_str, "X2",2)) { mouseevent_id=KEY_MOUSE_ButtonX2; key_str += 2; }
                else if (isdigit(*key_str))
                {
                    // indexed mouse button (e.g. Mouse0Button4 or Mouse0Button4Double)
                    int button_index;
                    if (sscanf(key_str, "%d",  &button_index) == 1)
                    {
                        mouseevent_id=static_cast<uint8_t>(KEY_MOUSE_Button1+button_index);
                        while (isdigit(*key_str)) ++key_str;
                    }
                }
                if (mouseevent_id)
                {
                    // valid event if finished or followed by "Double"
                    if (!*key_str) return KEY_Mouse(mouse_id, mouseevent_id);
                    if (!stricmp(key_str, "Double")) return KEY_Mouse(mouse_id, mouseevent_id+(KEY_MOUSE_Button1Double-KEY_MOUSE_Button1));
                    // invalid mouse key...
                }
            }
        }
 
    }
    // query map
    const C4KeyCodeMapEntry *pCheck = KeyCodeMap;
    while (pCheck->szName) {
        if (SEqualNoCase(sName.getData(), pCheck->szName)) {
            return(pCheck->wCode);
        }
        ++pCheck;
    }
#if defined(USE_SDL_MAINLOOP)
    SDL_Scancode s = SDL_GetScancodeFromName(sName.getData());
    if (s != SDL_SCANCODE_UNKNOWN) return s;
#endif
    return KEY_Undefined;
}

References StdStrBuf::getData(), and StdStrBuf::getLength().

Referenced by CompileFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

String2KeyShift()

C4KeyShiftState C4KeyCodeEx::String2KeyShift ( const StdStrBuf &  sName )

static

Definition at line 52 of file C4KeyboardInput.cpp.

{
    // query map
    const C4KeyShiftMapEntry *pCheck = KeyShiftMap;
    while (pCheck->szName)
            if (SEqualNoCase(sName.getData(), pCheck->szName)) break; else ++pCheck;
    return pCheck->eShift;
}

References C4KeyShiftMapEntry::eShift, StdStrBuf::getData(), KeyShiftMap, SEqualNoCase(), and C4KeyShiftMapEntry::szName.

Referenced by CompileFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

ToString()

StdStrBuf C4KeyCodeEx::ToString	(	bool	fHumanReadable,
		bool	fShort
	)		const

Definition at line 492 of file C4KeyboardInput.cpp.

{
    static StdStrBuf sResult;
    sResult.Clear();
    // Add shift
    for (DWORD dwShiftCheck = KEYS_First; dwShiftCheck <= KEYS_Max; dwShiftCheck <<= 1)
        if (dwShiftCheck & dwShift)
        {
            sResult.Append(KeyShift2String((C4KeyShiftState) dwShiftCheck));
            sResult.AppendChar('+');
        }
    // Add key
    if (sResult.getLength())
    {
        sResult.Append(KeyCode2String(Key, fHumanReadable, fShort));
        return sResult;
    }
    else
    {
        return KeyCode2String(Key, fHumanReadable, fShort);
    }
}

References StdStrBuf::Append(), StdStrBuf::AppendChar(), StdStrBuf::Clear(), dwShift, StdStrBuf::getLength(), Key, KeyCode2String(), KEYS_First, KEYS_Max, and KeyShift2String().

Referenced by CompileFunc(), and C4KeyboardInput::GetKeyCodeNameByKeyName().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

deviceId

int32_t C4KeyCodeEx::deviceId

Definition at line 206 of file C4KeyboardInput.h.

dwShift

DWORD C4KeyCodeEx::dwShift

Definition at line 204 of file C4KeyboardInput.h.

Referenced by CompileFunc(), C4KeyboardInput::DoInput(), FixShiftKeys(), C4PlayerControlAssignmentSet::GetAssignmentsByKey(), operator<(), operator==(), and ToString().

fRepeated

bool C4KeyCodeEx::fRepeated

Definition at line 210 of file C4KeyboardInput.h.

Referenced by IsRepeated().

Key

C4KeyCode C4KeyCodeEx::Key

Definition at line 203 of file C4KeyboardInput.h.

Referenced by C4CustomKey::C4CustomKey(), CompileFunc(), C4KeyboardInput::DoInput(), FixShiftKeys(), C4PlayerControlAssignmentSet::GetAssignmentsByKey(), C4PlayerControlAssignment::IsComboMatched(), operator<(), operator==(), C4PlayerControlAssignment::ResolveRefs(), and ToString().

---

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

• C4KeyboardInput.h
• C4KeyboardInput.cpp