UnicodeKeymap.hh

Go to the documentation of this file.

#ifndef UNICODEKEYMAP_HH
#define UNICODEKEYMAP_HH
 
#include "CommandException.hh"
#include "MsxChar2Unicode.hh"
#include "openmsx.hh"
#include <cassert>
#include <optional>
#include <string_view>
#include <vector>
 
namespace openmsx {
 
class KeyMatrixPosition final {
        static constexpr unsigned INVALID = 0xFF;
 
public:
        static constexpr unsigned NUM_ROWS = 16;
        static constexpr unsigned NUM_COLS = 8;
        static constexpr unsigned NUM_ROWCOL = 1 << 7;
 
        constexpr KeyMatrixPosition() = default;
 
        constexpr KeyMatrixPosition(byte rowCol_)
                : KeyMatrixPosition(rowCol_ >> 4, rowCol_ & 0x0F)
        {
        }
 
        constexpr KeyMatrixPosition(unsigned row, unsigned col)
                : rowCol((row << 3) | col)
        {
                assert(row < NUM_ROWS);
                assert(col < NUM_COLS);
                assert(isValid());
        }
 
        [[nodiscard]] constexpr bool isValid() const {
                return rowCol != INVALID;
        }
 
        [[nodiscard]] constexpr unsigned getRow() const {
                assert(isValid());
                return rowCol >> 3;
        }
 
        [[nodiscard]] constexpr unsigned getColumn() const {
                assert(isValid());
                return rowCol & 0x07;
        }
 
        [[nodiscard]] constexpr byte getRowCol() const {
                assert(isValid());
                return rowCol;
        }
 
        [[nodiscard]] constexpr unsigned getMask() const {
                assert(isValid());
                return 1 << getColumn();
        }
 
        [[nodiscard]] constexpr bool operator==(const KeyMatrixPosition&) const = default;
 
private:
        byte rowCol = INVALID;
};
 
class UnicodeKeymap
{
public:
        struct KeyInfo {
                enum Modifier { SHIFT, CTRL, GRAPH, CAPS, CODE, NUM_MODIFIERS };
                // Modifier masks:
                static constexpr byte SHIFT_MASK = 1 << SHIFT;
                static constexpr byte CTRL_MASK  = 1 << CTRL;
                static constexpr byte GRAPH_MASK = 1 << GRAPH;
                static constexpr byte CAPS_MASK  = 1 << CAPS;
                static constexpr byte CODE_MASK  = 1 << CODE;
 
                constexpr KeyInfo() = default;
                constexpr KeyInfo(KeyMatrixPosition pos_, byte modmask_)
                        : pos(pos_), modmask(modmask_)
                {
                        assert(pos.isValid());
                }
                [[nodiscard]] constexpr bool isValid() const {
                        return pos.isValid();
                }
                KeyMatrixPosition pos;
                byte modmask = 0;
        };
 
        explicit UnicodeKeymap(std::string_view keyboardType);
 
        [[nodiscard]] KeyInfo get(unsigned unicode) const;
        [[nodiscard]] KeyInfo getDeadkey(unsigned n) const;
 
        [[nodiscard]] byte getRelevantMods(const KeyInfo& keyInfo) const {
                return relevantMods[keyInfo.pos.getRowCol()];
        }
 
        [[nodiscard]] const MsxChar2Unicode& getMsxChars() const {
                if (!msxChars) throw CommandException("Missing MSX-Video-characterset file"); // TODO make this required for MSX/SVI machines
                return *msxChars;
        }
 
private:
        static constexpr unsigned NUM_DEAD_KEYS = 3;
 
        void parseUnicodeKeymapfile(std::string_view data);
 
private:
        struct Entry {
                unsigned unicode;
                KeyInfo keyInfo;
        };
        std::vector<Entry> mapdata; // sorted on unicode
 
        byte relevantMods[KeyMatrixPosition::NUM_ROWCOL];
        KeyInfo deadKeys[NUM_DEAD_KEYS];
 
        std::optional<MsxChar2Unicode> msxChars; // TODO should this be required for MSX/SVI machines?
};
 
} // namespace openmsx
 
#endif