|| || || || || || || ||

---

KeyBindingsMap.h

Go to the documentation of this file.

#ifndef Impala_Visualization_KeyBindingsMap_h
#define Impala_Visualization_KeyBindingsMap_h

/*
 *******************************************************************************
    KeyBindingsMap.h:   Simple Keybindings using std::map<String,String>

    typedef std::map<String,String> KeyBindingsMap

    KeyBindings can be programmed and/or placed inside a
    Impala::Basis::CmdOptions based .ini file.

    EXAMPLES
        goNextFile    n
        goNextFile    ctrl#n
        goNextFile    pagedown
        goNextFile    ctrl#down
        goNextFile    ctrl-shift#left
        goNextFile    ctrl#f
        goNextFile    fn2
        goNextFile    ctrl#fn2

    MULTIPLE KEYBINDINGS
    Support is present to allow for the use of multiple KeyBindings:
        goNextFile        n
        goNextFile-1      N
        goNextFile-2      right
        goNextFile-3      ctrl#left

        goPrevFile        p
        goPrevFile-1      P
        goPrevFile-2      left
        goPrevFile-3      ctrl#left

        Meaning that the user can go to the next file either by typing:
            n, N, right arrow, or ctrl left arrow
        or go to the previous file by typing:
            p, P, left arrow, or ctrl right arrow

        Alternatives are counted from 1.
        So there is a basic form:
            goNextFile
        with:
            goNextFile-1 as first alternative 
            goNextFile-2 as second alternative 
            goNextFile-3 as third alternative 

    With:
        CheckKeyBinding(myKB, "goNextFile", c, state)
    or:
        CheckKeyBinding(myKB, "goNextFile-2", c, state)
    you can check for 1 exact KeyBinding.

    With:
        CheckKeyBindingExt(myKB, "goNextFile", c, state)
    you can check for a basic keyBinding plus 6 alternatives.

    MORE THAN 6 ALTERNATIVES:
    Provided you have done something like:
        InitKeyBinding(myKB, "goNextFile", "n", "N", "right", "ctrl#left", "d");
        TryInitKeyBinding(myKB, "goNextFile", "pagedown", 7);
        TryInitKeyBinding(myKB, "goNextFile", "ctrl#pagedown", 8);
    then with
        CheckKeyBindingExt(myKB, "goNextFile", c, state, 8)
    you can check for a basic keyBinding plus 8 alternatives.

    NOTE:
    In this case in an .ini file the user could:
      - add alternatives for the undefined alternatives 5 and/or 6:
            goNextFile-5    down
    or
      - overrule any of the bindings:
            goNextFile-3    shift#right
            goNextFile-8    shift#pagedown

    LIMITING NUMBER OF ALTERNATIVES:
    To allow for only a base and 1 alternative KeyBinding, which both can be
    overruled in a .ini file, in your code do NOT use
        InitKeyBinding(...)
    but instead use:
        TryInitKeyBinding(myKB, "goNextFile", "right");
        TryInitKeyBinding(myKB, "goNextFile", "shift-right", 1);

    EXAMPLE OF USE:
    In code the use of KeyBindingsMap would look something like this:
    ----------------------------------------------------------------------------
        void MyInit()
        {
            InitKeyBinding(myKB, "goNextFile", "n", "N", "right");
            InitKeyBinding(myKB, "goPrevFile", "p", "P", "left");
              // Below only if you want to support more than 6 alternatives
              // TryInitKeyBinding(myKb, "goPrevFile", "shift#left", 7);
              // TryInitKeyBinding(myKb, "goPrevFile", "ctrl-shift#left", 8);
              // Now upto 8 alternatives can be checked:
              // if (CheckKeyBindingExt(myKB, "goPrevFile", c, state, 8))
        }

        void HandleKey(int c, int state)
        {
            if (CheckKeyBindingExt(myKB, "goNextFile", c, state))
                GoNextFile();
            else if (CheckKeyBindingExt(myKB, "goPrevFile", c, state))
                GoPrevFile();
        }

        Impala::Visualization::KeyBindingsMap myKB;
    ----------------------------------------------------------------------------

    Autor: Richard van Balen
********************************************************************************
*/

#include <map>

#ifndef Impala_Basis_String_h
#include "Basis/String.h"
#endif

#ifndef Impala_Basis_CmdOptions_h
#include "Basis/CmdOptions.h"
#endif

namespace Impala {
namespace Visualization {

typedef std::map<String,String> KeyBindingsMap;

void
ParseKeyBindingStr(String& str, int& c, int& state)
{
    int     modState = 0;
    int     modIdx;
    String  modStr;

    state = c = 0;
    if ((modIdx=str.find('#'))!=String::npos)
    {
        modStr = str.substr(0,modIdx);
        if (modStr == "ctrl")
            modState |= oglControl;
        else if (modStr == "shift")
            modState |= oglShift;
        else if (modStr == "ctrl-shift" || modStr == "shift-ctrl")
            modState |= oglControl | oglShift;
    }

    state = modState;

    int     charIdx = modIdx ? modIdx+1 : 0;
    String  charStr = str.substr(charIdx);
    if (charStr.length()==1)
    {
        c = charStr[0];
        if (modState & oglControl)
        {
            c = toupper(c);
            c -= 'A'-1;
        }
    }
    else if (charStr[0] == 'f' && charStr[1] == 'n')
    {
        int fnNr = atoi(charStr.substr(2));
        c = oglFUNC(fnNr);
    }
    else if (charStr == "pageup")
        c = oglPAGEUP;
    else if (charStr == "pagedown")
        c = oglPAGEDOWN;
    else if (charStr == "up")
        c = oglUP;
    else if (charStr == "down")
        c = oglDOWN;
    else if (charStr == "right")
        c = oglRIGHT;
    else if (charStr == "left")
        c = oglLEFT;
    else if (charStr == "home")
        c = oglHOME;
    else if (charStr == "end")
        c = oglEND;
    else if (charStr == "insert")
        c = oglINSERT;
    else if (charStr == "delete")
        c = oglDELETE;
    else if (charStr == "esc")
        c = oglESC;
    else if (charStr == "space")
        c = ' ';
    else if (charStr == "\\t")
        c = '\t';
    else if (charStr == "\\n")
        c = '\n';
}

String
GetKeyBinding(String name, String dflt)
{
    CmdOptions& options = CmdOptions::GetInstance();
    String str = options.GetString(name, dflt);
    return str;
}

bool
CheckKeyBinding(KeyBindingsMap& kb, String keyStr, int c, int state)
{
    int     cVal, stateVal;
    String  str = kb[keyStr];
    ParseKeyBindingStr(str, cVal, stateVal);
    if (!stateVal && isupper(c))
        stateVal = oglShift;
    return (c==cVal && (state==stateVal));
}

bool
CheckKeyBindingExt(KeyBindingsMap& kb, String keyStr, int c, int state, int n=6)
{
    if (CheckKeyBinding(kb, keyStr, c, state))
        return true;
    for (int i=1; i<n; i++)
        if (CheckKeyBinding(kb, keyStr + "-" + MakeString(i), c, state))
            return true;
    return false;
}

void
TryInitKeyBinding(KeyBindingsMap& kb, String keyStr, String dfltStr, int n=0)
{
    if (keyStr.empty())
        return;

    String k = keyStr;
    if (n>0)
        k += "-" + MakeString(n);
    String bindStr = GetKeyBinding(k, dfltStr);
    if (!bindStr.empty())
        kb[k] = bindStr;
}

void
InitKeyBinding(KeyBindingsMap& kb, String keyStr, String dfltStr0,
               String dfltStr1="", String dfltStr2="",
               String dfltStr3="", String dfltStr4="",
               String dfltStr5="", String dfltStr6="")
{
    TryInitKeyBinding(kb, keyStr, dfltStr0, 0);
    TryInitKeyBinding(kb, keyStr, dfltStr1, 1);
    TryInitKeyBinding(kb, keyStr, dfltStr2, 2);
    TryInitKeyBinding(kb, keyStr, dfltStr3, 3);
    TryInitKeyBinding(kb, keyStr, dfltStr4, 4);
    TryInitKeyBinding(kb, keyStr, dfltStr5, 5);
    TryInitKeyBinding(kb, keyStr, dfltStr6, 6);
}

} // namespace Visualization
} // namespace Impala

#endif // Impala_Visualization_KeyBindingsMap_h

---