6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-11-22 12:33:29 +00:00
Code Issues Projects Releases Wiki Activity
0e58f7fa69
CLK/Machines/Sinclair/Keyboard/Keyboard.cpp

356 lines
13 KiB
C++
Raw Normal View History

Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
//
Completes clean-up of post-formalisation per-machine keyboard code. At least for now. Standardising on how column + row is encoded might be helpful.
2017-10-21 14:52:35 +00:00
// Keyboard.cpp
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
// Clock Signal
//
Completes clean-up of post-formalisation per-machine keyboard code. At least for now. Standardising on how column + row is encoded might be helpful.
2017-10-21 14:52:35 +00:00
// Created by Thomas Harte on 10/10/2017.
Removes all instances of the copyright symbol.
2018-05-13 19:19:52 +00:00
// Copyright 2017 Thomas Harte. All rights reserved.
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
//
Completes clean-up of post-formalisation per-machine keyboard code. At least for now. Standardising on how column + row is encoded might be helpful.
2017-10-21 14:52:35 +00:00
#include "Keyboard.hpp"
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
Add necessary header for memset.
2021-03-19 04:00:59 +00:00
#include <cstring>
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
using namespace Sinclair::ZX::Keyboard;
KeyboardMapper::KeyboardMapper(Machine machine) : machine_(machine) {}
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
Increases const correctness, marks some additional constructors as constexpr, switches std::atomic construction style.
2020-05-21 03:34:26 +00:00
uint16_t KeyboardMapper::mapped_key_for_key(Inputs::Keyboard::Key key) const {
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
#define BIND(source, dest) case Inputs::Keyboard::Key::source: return dest
Completes clean-up of post-formalisation per-machine keyboard code. At least for now. Standardising on how column + row is encoded might be helpful.
2017-10-21 14:52:35 +00:00
switch(key) {
default: break;
BIND(k0, Key0); BIND(k1, Key1); BIND(k2, Key2); BIND(k3, Key3); BIND(k4, Key4);
BIND(k5, Key5); BIND(k6, Key6); BIND(k7, Key7); BIND(k8, Key8); BIND(k9, Key9);
BIND(Q, KeyQ); BIND(W, KeyW); BIND(E, KeyE); BIND(R, KeyR); BIND(T, KeyT);
BIND(Y, KeyY); BIND(U, KeyU); BIND(I, KeyI); BIND(O, KeyO); BIND(P, KeyP);
BIND(A, KeyA); BIND(S, KeyS); BIND(D, KeyD); BIND(F, KeyF); BIND(G, KeyG);
BIND(H, KeyH); BIND(J, KeyJ); BIND(K, KeyK); BIND(L, KeyL);
BIND(Z, KeyZ); BIND(X, KeyX); BIND(C, KeyC); BIND(V, KeyV);
BIND(B, KeyB); BIND(N, KeyN); BIND(M, KeyM);
BIND(LeftShift, KeyShift); BIND(RightShift, KeyShift);
BIND(Enter, KeyEnter);
BIND(Space, KeySpace);
Adds a virtual delete key to the ZX80 and ZX81.
2020-03-01 03:51:42 +00:00
Starts to make formal Spectrum accommodations.
2021-03-19 15:06:09 +00:00
// Full stop has a key on the ZX80 and ZX81; it doesn't have a dedicated key on the Spectrum.
case Inputs::Keyboard::Key::FullStop:
if(machine_ == Machine::ZXSpectrum) {
return KeySpectrumDot;
} else {
return KeyDot;
}
break;
// Map controls and options to symbol shift, if this is a ZX Spectrum.
case Inputs::Keyboard::Key::LeftOption:
case Inputs::Keyboard::Key::RightOption:
case Inputs::Keyboard::Key::LeftControl:
case Inputs::Keyboard::Key::RightControl:
if(machine_ == Machine::ZXSpectrum) {
return KeySymbolShift;
}
break;
Adds a virtual delete key to the ZX80 and ZX81.
2020-03-01 03:51:42 +00:00
// Virtual keys follow.
BIND(Backspace, KeyDelete);
Adds a second virtual key, for break.
2020-03-01 04:11:02 +00:00
BIND(Escape, KeyBreak);
Adds virtual key for EDIT.
2020-03-03 02:44:15 +00:00
BIND(Up, KeyUp);
BIND(Down, KeyDown);
BIND(Left, KeyLeft);
BIND(Right, KeyRight);
BIND(BackTick, KeyEdit); BIND(F1, KeyEdit);
Starts to make formal Spectrum accommodations.
2021-03-19 15:06:09 +00:00
BIND(Comma, KeyComma);
Completes clean-up of post-formalisation per-machine keyboard code. At least for now. Standardising on how column + row is encoded might be helpful.
2017-10-21 14:52:35 +00:00
}
#undef BIND
Splits 'CRTMachine' into three parts: ScanProducer, AudioProducer, TimedMachine. Simultaneously cleans up some of the naming conventions and tries to make things a bit more template-compatible.
2020-04-02 03:19:34 +00:00
return MachineTypes::MappedKeyboardMachine::KeyNotMapped;
Completes clean-up of post-formalisation per-machine keyboard code. At least for now. Standardising on how column + row is encoded might be helpful.
2017-10-21 14:52:35 +00:00
}
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
CharacterMapper::CharacterMapper(Machine machine) : machine_(machine) {}
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
Increases const correctness, marks some additional constructors as constexpr, switches std::atomic construction style.
2020-05-21 03:34:26 +00:00
const uint16_t *CharacterMapper::sequence_for_character(char character) const {
Adds a genuine Spectrum mapping, tweaks timing.
2021-03-23 20:59:43 +00:00
#define KEYS(...) {__VA_ARGS__, MachineTypes::MappedKeyboardMachine::KeyEndSequence}
#define SHIFT(...) {KeyShift, __VA_ARGS__, MachineTypes::MappedKeyboardMachine::KeyEndSequence}
#define SYMSHIFT(...) {KeySymbolShift, __VA_ARGS__, MachineTypes::MappedKeyboardMachine::KeyEndSequence}
#define X {MachineTypes::MappedKeyboardMachine::KeyNotMapped}
Resolves use-after-return memory error.
2021-04-05 02:45:56 +00:00
static constexpr KeySequence spectrum_key_sequences[] = {
Adds a genuine Spectrum mapping, tweaks timing.
2021-03-23 20:59:43 +00:00
/* NUL */ X, /* SOH */ X,
/* STX */ X, /* ETX */ X,
/* EOT */ X, /* ENQ */ X,
/* ACK */ X, /* BEL */ X,
/* BS */ SHIFT(Key0), /* HT */ X,
/* LF */ KEYS(KeyEnter), /* VT */ X,
/* FF */ X, /* CR */ KEYS(KeyEnter),
/* SO */ X, /* SI */ X,
/* DLE */ X, /* DC1 */ X,
/* DC2 */ X, /* DC3 */ X,
/* DC4 */ X, /* NAK */ X,
/* SYN */ X, /* ETB */ X,
/* CAN */ X, /* EM */ X,
/* SUB */ X, /* ESC */ X,
/* FS */ X, /* GS */ X,
/* RS */ X, /* US */ X,
/* space */ KEYS(KeySpace), /* ! */ SYMSHIFT(Key1),
/* " */ SYMSHIFT(KeyP), /* # */ SYMSHIFT(Key3),
/* $ */ SYMSHIFT(Key4), /* % */ SYMSHIFT(Key5),
/* & */ SYMSHIFT(Key6), /* ' */ SYMSHIFT(Key7),
/* ( */ SYMSHIFT(Key8), /* ) */ SYMSHIFT(Key9),
/* * */ SYMSHIFT(KeyB), /* + */ SYMSHIFT(KeyK),
/* , */ SYMSHIFT(KeyN), /* - */ SYMSHIFT(KeyJ),
/* . */ SYMSHIFT(KeyM), /* / */ SYMSHIFT(KeyV),
/* 0 */ KEYS(Key0), /* 1 */ KEYS(Key1),
/* 2 */ KEYS(Key2), /* 3 */ KEYS(Key3),
/* 4 */ KEYS(Key4), /* 5 */ KEYS(Key5),
/* 6 */ KEYS(Key6), /* 7 */ KEYS(Key7),
/* 8 */ KEYS(Key8), /* 9 */ KEYS(Key9),
/* : */ SYMSHIFT(KeyZ), /* ; */ SYMSHIFT(KeyO),
/* < */ SYMSHIFT(KeyR), /* = */ SYMSHIFT(KeyL),
/* > */ SYMSHIFT(KeyT), /* ? */ SYMSHIFT(KeyC),
/* @ */ SYMSHIFT(Key2), /* A */ SHIFT(KeyA),
/* B */ SHIFT(KeyB), /* C */ SHIFT(KeyC),
/* D */ SHIFT(KeyD), /* E */ SHIFT(KeyE),
/* F */ SHIFT(KeyF), /* G */ SHIFT(KeyG),
/* H */ SHIFT(KeyH), /* I */ SHIFT(KeyI),
/* J */ SHIFT(KeyJ), /* K */ SHIFT(KeyK),
/* L */ SHIFT(KeyL), /* M */ SHIFT(KeyM),
/* N */ SHIFT(KeyN), /* O */ SHIFT(KeyO),
/* P */ SHIFT(KeyP), /* Q */ SHIFT(KeyQ),
/* R */ SHIFT(KeyR), /* S */ SHIFT(KeyS),
/* T */ SHIFT(KeyT), /* U */ SHIFT(KeyU),
/* V */ SHIFT(KeyV), /* W */ SHIFT(KeyW),
/* X */ SHIFT(KeyX), /* Y */ SHIFT(KeyY),
/* Z */ SHIFT(KeyZ), /* [ */ X,
/* \ */ X, /* ] */ X,
/* ^ */ SYMSHIFT(KeyH), /* _ */ SYMSHIFT(Key0),
/* ` */ X, /* a */ KEYS(KeyA),
/* b */ KEYS(KeyB), /* c */ KEYS(KeyC),
/* d */ KEYS(KeyD), /* e */ KEYS(KeyE),
/* f */ KEYS(KeyF), /* g */ KEYS(KeyG),
/* h */ KEYS(KeyH), /* i */ KEYS(KeyI),
/* j */ KEYS(KeyJ), /* k */ KEYS(KeyK),
/* l */ KEYS(KeyL), /* m */ KEYS(KeyM),
/* n */ KEYS(KeyN), /* o */ KEYS(KeyO),
/* p */ KEYS(KeyP), /* q */ KEYS(KeyQ),
/* r */ KEYS(KeyR), /* s */ KEYS(KeyS),
/* t */ KEYS(KeyT), /* u */ KEYS(KeyU),
/* v */ KEYS(KeyV), /* w */ KEYS(KeyW),
/* x */ KEYS(KeyX), /* y */ KEYS(KeyY),
/* z */ KEYS(KeyZ),
};
Resolves use-after-return memory error.
2021-04-05 02:45:56 +00:00
static constexpr KeySequence zx81_key_sequences[] = {
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
/* NUL */ X, /* SOH */ X,
/* STX */ X, /* ETX */ X,
/* EOT */ X, /* ENQ */ X,
/* ACK */ X, /* BEL */ X,
/* BS */ SHIFT(Key0), /* HT */ X,
/* LF */ KEYS(KeyEnter), /* VT */ X,
Makes basic typing adaptations.
2020-03-01 00:59:51 +00:00
/* FF */ X, /* CR */ KEYS(KeyEnter),
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
/* SO */ X, /* SI */ X,
/* DLE */ X, /* DC1 */ X,
/* DC2 */ X, /* DC3 */ X,
/* DC4 */ X, /* NAK */ X,
/* SYN */ X, /* ETB */ X,
/* CAN */ X, /* EM */ X,
/* SUB */ X, /* ESC */ X,
/* FS */ X, /* GS */ X,
/* RS */ X, /* US */ X,
/* space */ KEYS(KeySpace), /* ! */ X,
/* " */ SHIFT(KeyP), /* # */ X,
/* $ */ SHIFT(KeyU), /* % */ X,
/* & */ X, /* ' */ X,
/* ( */ SHIFT(KeyI), /* ) */ SHIFT(KeyO),
/* * */ SHIFT(KeyB), /* + */ SHIFT(KeyK),
/* , */ SHIFT(KeyDot), /* - */ SHIFT(KeyJ),
/* . */ KEYS(KeyDot), /* / */ SHIFT(KeyV),
/* 0 */ KEYS(Key0), /* 1 */ KEYS(Key1),
/* 2 */ KEYS(Key2), /* 3 */ KEYS(Key3),
/* 4 */ KEYS(Key4), /* 5 */ KEYS(Key5),
/* 6 */ KEYS(Key6), /* 7 */ KEYS(Key7),
/* 8 */ KEYS(Key8), /* 9 */ KEYS(Key9),
/* : */ SHIFT(KeyZ), /* ; */ SHIFT(KeyX),
/* < */ SHIFT(KeyN), /* = */ SHIFT(KeyL),
/* > */ SHIFT(KeyM), /* ? */ SHIFT(KeyC),
/* @ */ X, /* A */ KEYS(KeyA),
/* B */ KEYS(KeyB), /* C */ KEYS(KeyC),
/* D */ KEYS(KeyD), /* E */ KEYS(KeyE),
/* F */ KEYS(KeyF), /* G */ KEYS(KeyG),
/* H */ KEYS(KeyH), /* I */ KEYS(KeyI),
/* J */ KEYS(KeyJ), /* K */ KEYS(KeyK),
/* L */ KEYS(KeyL), /* M */ KEYS(KeyM),
/* N */ KEYS(KeyN), /* O */ KEYS(KeyO),
/* P */ KEYS(KeyP), /* Q */ KEYS(KeyQ),
/* R */ KEYS(KeyR), /* S */ KEYS(KeyS),
/* T */ KEYS(KeyT), /* U */ KEYS(KeyU),
/* V */ KEYS(KeyV), /* W */ KEYS(KeyW),
/* X */ KEYS(KeyX), /* Y */ KEYS(KeyY),
/* Z */ KEYS(KeyZ), /* [ */ X,
/* \ */ X, /* ] */ X,
/* ^ */ X, /* _ */ X,
/* ` */ X, /* a */ KEYS(KeyA),
/* b */ KEYS(KeyB), /* c */ KEYS(KeyC),
/* d */ KEYS(KeyD), /* e */ KEYS(KeyE),
/* f */ KEYS(KeyF), /* g */ KEYS(KeyG),
/* h */ KEYS(KeyH), /* i */ KEYS(KeyI),
/* j */ KEYS(KeyJ), /* k */ KEYS(KeyK),
/* l */ KEYS(KeyL), /* m */ KEYS(KeyM),
/* n */ KEYS(KeyN), /* o */ KEYS(KeyO),
/* p */ KEYS(KeyP), /* q */ KEYS(KeyQ),
/* r */ KEYS(KeyR), /* s */ KEYS(KeyS),
/* t */ KEYS(KeyT), /* u */ KEYS(KeyU),
/* v */ KEYS(KeyV), /* w */ KEYS(KeyW),
/* x */ KEYS(KeyX), /* y */ KEYS(KeyY),
/* z */ KEYS(KeyZ), /* { */ X,
/* | */ X, /* } */ X,
};
Resolves use-after-return memory error.
2021-04-05 02:45:56 +00:00
static constexpr KeySequence zx80_key_sequences[] = {
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
/* NUL */ X, /* SOH */ X,
/* STX */ X, /* ETX */ X,
/* EOT */ X, /* ENQ */ X,
/* ACK */ X, /* BEL */ X,
/* BS */ SHIFT(Key0), /* HT */ X,
/* LF */ KEYS(KeyEnter), /* VT */ X,
Makes basic typing adaptations.
2020-03-01 00:59:51 +00:00
/* FF */ X, /* CR */ KEYS(KeyEnter),
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
/* SO */ X, /* SI */ X,
/* DLE */ X, /* DC1 */ X,
/* DC2 */ X, /* DC3 */ X,
/* DC4 */ X, /* NAK */ X,
/* SYN */ X, /* ETB */ X,
/* CAN */ X, /* EM */ X,
/* SUB */ X, /* ESC */ X,
/* FS */ X, /* GS */ X,
/* RS */ X, /* US */ X,
/* space */ KEYS(KeySpace), /* ! */ X,
/* " */ SHIFT(KeyY), /* # */ X,
/* $ */ SHIFT(KeyU), /* % */ X,
/* & */ X, /* ' */ X,
/* ( */ SHIFT(KeyI), /* ) */ SHIFT(KeyO),
/* * */ SHIFT(KeyP), /* + */ SHIFT(KeyK),
/* , */ SHIFT(KeyDot), /* - */ SHIFT(KeyJ),
/* . */ KEYS(KeyDot), /* / */ SHIFT(KeyV),
/* 0 */ KEYS(Key0), /* 1 */ KEYS(Key1),
/* 2 */ KEYS(Key2), /* 3 */ KEYS(Key3),
/* 4 */ KEYS(Key4), /* 5 */ KEYS(Key5),
/* 6 */ KEYS(Key6), /* 7 */ KEYS(Key7),
/* 8 */ KEYS(Key8), /* 9 */ KEYS(Key9),
/* : */ SHIFT(KeyZ), /* ; */ SHIFT(KeyX),
/* < */ SHIFT(KeyN), /* = */ SHIFT(KeyL),
/* > */ SHIFT(KeyM), /* ? */ SHIFT(KeyC),
/* @ */ X, /* A */ KEYS(KeyA),
/* B */ KEYS(KeyB), /* C */ KEYS(KeyC),
/* D */ KEYS(KeyD), /* E */ KEYS(KeyE),
/* F */ KEYS(KeyF), /* G */ KEYS(KeyG),
/* H */ KEYS(KeyH), /* I */ KEYS(KeyI),
/* J */ KEYS(KeyJ), /* K */ KEYS(KeyK),
/* L */ KEYS(KeyL), /* M */ KEYS(KeyM),
/* N */ KEYS(KeyN), /* O */ KEYS(KeyO),
/* P */ KEYS(KeyP), /* Q */ KEYS(KeyQ),
/* R */ KEYS(KeyR), /* S */ KEYS(KeyS),
/* T */ KEYS(KeyT), /* U */ KEYS(KeyU),
/* V */ KEYS(KeyV), /* W */ KEYS(KeyW),
/* X */ KEYS(KeyX), /* Y */ KEYS(KeyY),
/* Z */ KEYS(KeyZ), /* [ */ X,
/* \ */ X, /* ] */ X,
/* ^ */ X, /* _ */ X,
/* ` */ X, /* a */ KEYS(KeyA),
/* b */ KEYS(KeyB), /* c */ KEYS(KeyC),
/* d */ KEYS(KeyD), /* e */ KEYS(KeyE),
/* f */ KEYS(KeyF), /* g */ KEYS(KeyG),
/* h */ KEYS(KeyH), /* i */ KEYS(KeyI),
/* j */ KEYS(KeyJ), /* k */ KEYS(KeyK),
/* l */ KEYS(KeyL), /* m */ KEYS(KeyM),
/* n */ KEYS(KeyN), /* o */ KEYS(KeyO),
/* p */ KEYS(KeyP), /* q */ KEYS(KeyQ),
/* r */ KEYS(KeyR), /* s */ KEYS(KeyS),
/* t */ KEYS(KeyT), /* u */ KEYS(KeyU),
/* v */ KEYS(KeyV), /* w */ KEYS(KeyW),
/* x */ KEYS(KeyX), /* y */ KEYS(KeyY),
/* z */ KEYS(KeyZ), /* { */ X,
/* | */ X, /* } */ X,
};
#undef KEYS
#undef SHIFT
Adds a genuine Spectrum mapping, tweaks timing.
2021-03-23 20:59:43 +00:00
#undef SYMSHIFT
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
#undef X
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
switch(machine_) {
Adds a genuine Spectrum mapping, tweaks timing.
2021-03-23 20:59:43 +00:00
case Machine::ZX80:
Resolves potential source of errors: specifying incorrect table size. (Having made exactly this mistake with the ZX Spectrum)
2021-04-24 16:10:28 +00:00
return table_lookup_sequence_for_character(zx80_key_sequences, character);
Adds a genuine Spectrum mapping, tweaks timing.
2021-03-23 20:59:43 +00:00
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
case Machine::ZX81:
Resolves potential source of errors: specifying incorrect table size. (Having made exactly this mistake with the ZX Spectrum)
2021-04-24 16:10:28 +00:00
return table_lookup_sequence_for_character(zx81_key_sequences, character);
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
Make it overt that this can't return without a value.
2021-05-04 00:31:39 +00:00
default:
Adds a genuine Spectrum mapping, tweaks timing.
2021-03-23 20:59:43 +00:00
case Machine::ZXSpectrum:
Resolves potential source of errors: specifying incorrect table size. (Having made exactly this mistake with the ZX Spectrum)
2021-04-24 16:10:28 +00:00
return table_lookup_sequence_for_character(spectrum_key_sequences, character);
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
}
Within the `Typer` framework: hatched out `CharacterMapper` as a distinct thing from the target for keypresses, better to formalise responsibility but also to make it easy cleanly to sever that stuff into its own little part.
2017-08-03 15:42:31 +00:00
}
Slightly improves ZX80 and ZX81 typing speed.
2020-03-01 03:31:45 +00:00
Increases const correctness, marks some additional constructors as constexpr, switches std::atomic construction style.
2020-05-21 03:34:26 +00:00
bool CharacterMapper::needs_pause_after_key(uint16_t key) const {
Adds a genuine Spectrum mapping, tweaks timing.
2021-03-23 20:59:43 +00:00
return key != KeyShift && !(machine_ == Machine::ZXSpectrum && key == KeySymbolShift);
Slightly improves ZX80 and ZX81 typing speed.
2020-03-01 03:31:45 +00:00
}
Factors out a little of the ZX81's keyboard logic.
2021-03-19 03:45:57 +00:00
Formally separates keyboard code. With an eye to formalising the Spectrum/ZX81/ZX80 differences.
2021-03-19 14:36:08 +00:00
Keyboard::Keyboard(Machine machine) : machine_(machine) {
Factors out a little of the ZX81's keyboard logic.
2021-03-19 03:45:57 +00:00
clear_all_keys();
}
void Keyboard::set_key_state(uint16_t key, bool is_pressed) {
const auto line = key >> 8;
// Check for special cases.
if(line > 7) {
switch(key) {
Starts to make formal Spectrum accommodations.
2021-03-19 15:06:09 +00:00
#define ShiftedKey(source, base, shift) \
case source: \
set_key_state(shift, is_pressed); \
set_key_state(base, is_pressed); \
Factors out a little of the ZX81's keyboard logic.
2021-03-19 03:45:57 +00:00
break;
Starts to make formal Spectrum accommodations.
2021-03-19 15:06:09 +00:00
ShiftedKey(KeyDelete, Key0, KeyShift);
ShiftedKey(KeyBreak, KeySpace, KeyShift);
ShiftedKey(KeyUp, Key7, KeyShift);
ShiftedKey(KeyDown, Key6, KeyShift);
ShiftedKey(KeyLeft, Key5, KeyShift);
ShiftedKey(KeyRight, Key8, KeyShift);
ShiftedKey(KeyEdit, (machine_ == Machine::ZX80) ? KeyEnter : Key1, KeyShift);
ShiftedKey(KeySpectrumDot, KeyM, KeySymbolShift);
case KeyComma:
if(machine_ == Machine::ZXSpectrum) {
// Spectrum: comma = symbol shift + n.
set_key_state(KeySymbolShift, is_pressed);
set_key_state(KeyN, is_pressed);
} else {
// ZX80/81: comma = shift + dot.
set_key_state(KeyShift, is_pressed);
set_key_state(KeyDot, is_pressed);
}
break;
Factors out a little of the ZX81's keyboard logic.
2021-03-19 03:45:57 +00:00
#undef ShiftedKey
}
} else {
if(is_pressed)
key_states_[line] &= uint8_t(~key);
else
key_states_[line] |= uint8_t(key);
}
}
void Keyboard::clear_all_keys() {
memset(key_states_, 0xff, 8);
}
uint8_t Keyboard::read(uint16_t address) {
uint8_t value = 0xff;
uint16_t mask = 0x100;
for(int c = 0; c < 8; c++) {
if(!(address & mask)) value &= key_states_[c];
mask <<= 1;
}
return value;
}
Reference in New Issue Copy Permalink