Keybinds.cpp

#include "common.h"
#include "Config.h"
#include "UserInput.h"

//should match allegrow/keycodes.h
std::string keynames[] = {
    "INVALID",

    "KEY_A",
    "KEY_B",
    "KEY_C",
    "KEY_D",
    "KEY_E",
    "KEY_F",
    "KEY_G",
    "KEY_H",
    "KEY_I",
    "KEY_J",
    "KEY_K",
    "KEY_L",
    "KEY_M",
    "KEY_N",
    "KEY_O",
    "KEY_P",
    "KEY_Q",
    "KEY_R",
    "KEY_S",
    "KEY_T",
    "KEY_U",
    "KEY_V",
    "KEY_W",
    "KEY_X",
    "KEY_Y",
    "KEY_Z",

    "KEY_0",
    "KEY_1",
    "KEY_2",
    "KEY_3",
    "KEY_4",
    "KEY_5",
    "KEY_6",
    "KEY_7",
    "KEY_8",
    "KEY_9",

    "KEYPAD_0",
    "KEYPAD_1",
    "KEYPAD_2",
    "KEYPAD_3",
    "KEYPAD_4",
    "KEYPAD_5",
    "KEYPAD_6",
    "KEYPAD_7",
    "KEYPAD_8",
    "KEYPAD_9",

    "KEYF_1",
    "KEYF_2",
    "KEYF_3",
    "KEYF_4",
    "KEYF_5",
    "KEYF_6",
    "KEYF_7",
    "KEYF_8",
    "KEYF_9",
    "KEYF_10",
    "KEYF_11",
    "KEYF_12",

    "KEYS_ESCAPE",
    "KEYS_TILDE",
    "KEYS_MINUS",
    "KEYS_EQUALS",
    "KEYS_BACKSPACE",
    "KEYS_TAB",
    "KEYS_OPENBRACE",
    "KEYS_CLOSEBRACE",
    "KEYS_ENTER",
    "KEYS_SEMICOLON",
    "KEYS_QUOTE",
    "KEYS_BACKSLASH",
    "KEYS_BACKSLASH2", /* DirectInput calls this DIK_OEM_102: "< > | on UK/Germany KEYSboards" */
    "KEYS_COMMA",
    "KEYS_FULLSTOP",
    "KEYS_SLASH",
    "KEYS_SPACE",

    "KEYS_INSERT",
    "KEYS_DELETE",
    "KEYS_HOME",
    "KEYS_END",
    "KEYS_PGUP",
    "KEYS_PGDN",
    "KEYS_LEFT",
    "KEYS_RIGHT",
    "KEYS_UP",
    "KEYS_DOWN",

    "KEYPAD_SLASH",
    "KEYPAD_ASTERISK",
    "KEYPAD_MINUS",
    "KEYPAD_PLUS",
    "KEYPAD_DELETE",
    "KEYPAD_ENTER",

    "KEYS_PRINTSCREEN",
    "KEYS_PAUSE",

    "KEYS_ABNT_C1",
    "KEYS_YEN",
    "KEYS_KANA",
    "KEYS_CONVERT",
    "KEYS_NOCONVERT",
    "KEYS_AT",
    "KEYS_CIRCUMFLEX",
    "KEYS_COLON2",
    "KEYS_KANJI",

    "KEYPAD_EQUALS",    /* MacOS X */
    "KEYS_BACKQUOTE",    /* MacOS X */
    "KEYS_SEMICOLON2",    /* MacOS X */
    "KEYS_COMMAND"    /* MacOS X */

    //KEY_UNKNOWN
};

int getKeyCode(std::string& keyName){
    for(int i=0; i<ALLEGRO_KEY_UNKNOWN; i++) {
        if(keynames[i] == keyName) {
            return i;
        }
    }
    return ALLEGRO_KEY_UNKNOWN;
}

////should match allegrow/keycodes.h
//string keymodnames[] = {
//    "KEYMOD_SHIFT",
//    "KEYMOD_CTRL",
//    "KEYMOD_ALT",
//    "KEYMOD_LWIN",
//    "KEYMOD_RWIN",
//    "KEYMOD_MENU",
//    "KEYMOD_ALTGR",
//    "KEYMOD_COMMAND",
//    "KEYMOD_SCROLLLOCK",
//    "KEYMOD_NUMLOCK",
//    "KEYMOD_CAPSLOCK",
//    "KEYMOD_INALTSEQ",
//    "KEYMOD_ACCENT1",
//    "KEYMOD_ACCENT2",
//    "KEYMOD_ACCENT3",
//    "KEYMOD_ACCENT4"
//};
//
//int getKeymodCode(string& keymodName){
//    for(int i=0; i<ALLEGRO_KEY_UNKNOWN; i++) {
//        if(keymodnames[i] == keymodName) {
//            return (0x01 << i);
//        }
//    }
//    return KEYMOD_NONE;
//}

void action_noop(uint32_t keymod){
#ifdef DEBUG
    PrintMessage("unbound key pressed\n");
#endif
}

void action_invalid(uint32_t keymod){
    PrintMessage("invalid action\n");
}

action_name_mapper actionnamemap[] = {
    {"NOOP", action_noop},
    {"ROTATE", action_incrrotation},
    {"RELOAD_SEGMENT", action_reloadsegment},
    {"PAINT", action_paintboard},
    {"TOGGLE_DESIGNATIONS", action_toggledesignations},
    {"TOGGLE_STOCKS", action_togglestockpiles},
    {"TOGGLE_ZONES", action_togglezones},
    {"TOGGLE_OCCLUSION", action_toggleocclusion},
    {"TOGGLE_FOG",action_togglefog},
    {"TOGGLE_CREATURE_MOODS", action_togglecreaturemood},
    {"TOGGLE_CREATURE_PROFS", action_togglecreatureprof},
    {"TOGGLE_CREATURE_JOBS", action_togglecreaturejob},
    {"TOGGLE_CREATURE_NAMES", action_togglecreaturenames},
    {"CHOP_WALLS", action_chopwall},
    {"CYCLE_TRACKING_MODE", action_cycletrackingmode},
    {"RESET_VIEW_OFFSET", action_resetscreen},
    {"TOGGLE_SINGLE_LAYER", action_togglesinglelayer},
    {"TOGGLE_SHADE_HIDDEN_TILES", action_toggleshadehidden},
    {"TOGGLE_SHOW_HIDDEN_TILES", action_toggleshowhidden},
    {"TOGGLE_OSD", action_toggleosd},
    {"TOGGLE_KEYBINDS", action_togglekeybinds},
    {"TOGGLE_ANNOUNCEMENTS", action_toggleannouncements},
    {"TOGGLE_DEBUG", action_toggledebug},
    {"INCR_ZOOM", action_incrzoom},
    {"DECR_ZOOM", action_decrzoom},
    {"SCREENSHOT", action_screenshot},
    {"INCR_RELOAD_TIME", action_incrreloadtime},
    {"DECR_RELOAD_TIME", action_decrreloadtime},
    {"CREDITS", action_credits},

    {"DECR_SEGMENT_X", action_decrsegmentX},
    {"INCR_SEGMENT_X", action_incrsegmentX},
    {"DECR_SEGMENT_Y", action_decrsegmentY},
    {"INCR_SEGMENT_Y", action_incrsegmentY},
    {"DECR_SEGMENT_Z", action_decrsegmentZ},
    {"INCR_SEGMENT_Z", action_incrsegmentZ},

    {"DECR_Z", action_decrZ},
    {"INCR_Z", action_incrZ},

    {"DECR_Y", action_decrY},
    {"INCR_Y", action_incrY},
    {"DECR_X", action_decrX},
    {"INCR_X", action_incrX},
    //add extra action here!

    {"INVALID", action_invalid}//this is the stop condition
};

void (*actionkeymap[ALLEGRO_KEY_UNKNOWN])(uint32_t);
bool actionrepeatmap[ALLEGRO_KEY_UNKNOWN];

void parseKeymapLine( std::string line )
{
    auto ll = trim_line(line);
    if (!ll) return;
    line = *ll;

    //second-last character should tell us if this is a repeating action
    auto c = line[ line.length() -2 ];

    for(int i=0; actionnamemap[i].func != action_invalid; i++) {
        if(line.find(actionnamemap[i].name)!=std::string::npos) {
            for(int j=0; j<ALLEGRO_KEY_UNKNOWN; j++){
                if(line.find(keynames[j])!=std::string::npos) {
                    actionkeymap[j] = actionnamemap[i].func;
                    if( c == '*' ) {
                        actionrepeatmap[j] = true;
#ifdef DEBUG
                    PrintMessage("successfully mapped: op:%i key:%i repeatable\n",i,j);
                    } else {
                    PrintMessage("successfully mapped: op:%i key:%i\n",i,j);
#endif
                    }
                    break;
                }
            }
            break;
        }
    }
}

bool loadKeymapFile(){
    std::string line;
    std::filesystem::path path = std::filesystem::path{} / "dfhack-config" / "stonesense" / "keybinds.txt";
    std::ifstream myfile (path);

    if (myfile.is_open() == false) {
        LogError( "cannot find keybinds file\n" );
        return false;
    }

    //initialize the keymap to all noops
    for(int i=0; i<ALLEGRO_KEY_UNKNOWN; i++) {
        actionkeymap[i] = action_noop;
        actionrepeatmap[i] = false;
    }

    while ( !myfile.eof() ) {
        getline (myfile,line);
        parseKeymapLine( line );
    }
    //close file, etc.
    myfile.close();
    return true;
}

bool isRepeatable(int32_t keycode)
{
    return actionrepeatmap[keycode];
}

bool doKey(int32_t keycode, uint32_t keymodcode)
{
    if(keycode>0 && keycode<ALLEGRO_KEY_UNKNOWN) {
        actionkeymap[keycode](keymodcode);
        return true;
    }
    return false;
}

bool getKeyStrings(int32_t keycode, std::string*& keyname, std::string*& actionname){
    keyname = actionname = NULL;
    if(keycode>0 && keycode<ALLEGRO_KEY_UNKNOWN) {
        keyname = &keynames[keycode];
        void* action = (void*) actionkeymap[keycode];
        if(action == (void*) action_noop){
            return false;
        }
        for(int i=0; actionnamemap[i].func != action_invalid; i++) {
            if(action == (void*) actionnamemap[i].func) {
                actionname = &(actionnamemap[i].name);
                return true;
            }
        }
    }
    return false;
}