Files

107 lines
3.8 KiB
C++

#pragma once
#include <algorithm>
#include <array>
#include <cstdint>
#include <vector>
namespace VCC::Mac {
using TerminalGrid = std::array<std::array<char, 80>, 24>;
// Encode an addressed terminal screen for the stock NitrOS-9 telnet client's
// output path, which passes ordinary bytes straight through to CoWin.
class DriveWireTerminalOutput {
public:
static constexpr std::size_t maxDrawBytes = 2010;
void draw(const TerminalGrid& cells, int x, int y, bool cursorVisible,
bool clear, std::vector<std::uint8_t>& out) {
const auto start = out.size();
if (clear || !known) {
out.push_back(0x0c);
for (auto& row : painted) row.fill(' ');
cursorX = cursorY = -1;
visibilityKnown = false;
known = true;
}
constexpr int bottom = 23;
for (int row = 0; row < bottom - 1; ++row) {
paintRow(row, cells[row], out);
}
// GRFDRV wraps immediately after the last column. To write the
// bottom-right cell without scrolling away the first line, prepare
// the last row one line up and move it down with CoWin's insert-line.
// Ordinary changes elsewhere on the bottom row avoid that extra work.
if (glyph(cells[bottom].back()) != painted[bottom].back()) {
paintRow(bottom - 1, cells[bottom], out);
position(0, bottom - 1, out);
out.insert(out.end(), {0x1f, 0x30});
painted[bottom] = painted[bottom - 1];
painted[bottom - 1].fill(' ');
} else {
paintRow(bottom, cells[bottom], out);
}
paintRow(bottom - 1, cells[bottom - 1], out);
// CoWin may move the cursor on a write, including automatic wrapping.
// Reposition it even when the logical position itself didn't change.
x = std::clamp(x, 0, 79);
y = std::clamp(y, 0, 23);
if (out.size() != start || x != cursorX || y != cursorY) {
position(x, y, out);
cursorX = x;
cursorY = y;
}
if (!visibilityKnown || visible != cursorVisible) {
out.insert(out.end(), {0x05, static_cast<std::uint8_t>(cursorVisible ? 0x21 : 0x20)});
visible = cursorVisible;
visibilityKnown = true;
}
}
private:
using Row = TerminalGrid::value_type;
TerminalGrid painted{};
int cursorX = -1, cursorY = -1;
bool known = false, visibilityKnown = false, visible = true;
static char glyph(char ch) {
const auto byte = static_cast<unsigned char>(ch);
return byte >= 0x20 && byte <= 0x7e ? ch : '?';
}
static void position(int x, int y, std::vector<std::uint8_t>& out) {
out.insert(out.end(), {0x02, static_cast<std::uint8_t>(0x20 + x),
static_cast<std::uint8_t>(0x20 + y)});
}
void paintRow(int row, const Row& desired, std::vector<std::uint8_t>& out) {
auto& current = painted[row];
std::size_t x = 0;
while (x < desired.size()) {
if (current[x] == glyph(desired[x])) {
++x;
continue;
}
const auto first = x;
position(static_cast<int>(x), row, out);
auto lastChange = x;
// Repaint short gaps: an absolute cursor move costs three bytes.
// Even an alternating pattern costs at most 83 bytes per row.
while (x < desired.size() && x - lastChange <= 4) {
if (current[x] != glyph(desired[x])) lastChange = x;
++x;
}
for (auto column = first; column <= lastChange; ++column) {
current[column] = glyph(desired[column]);
out.push_back(static_cast<std::uint8_t>(current[column]));
}
}
}
};
} // namespace VCC::Mac