forks
/
arsd
mirror of https://github.com/adamdruppe/arsd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
arsd/terminal.d

1647 lines
43 KiB
D
Raw Blame History

/**
* Module for supporting cursor and color manipulation on the console.
*
* The main interface for this module is the Terminal struct, which
* encapsulates the functions of the terminal. Creating an instance of
* this struct will perform console initialization; when the struct
* goes out of scope, any changes in console settings will be automatically
* reverted.
*/
module terminal;
// parts of this were taken from Robik's ConsoleD
// https://github.com/robik/ConsoleD/blob/master/consoled.d
// Uncomment this line to get a main() to demonstrate this module's
// capabilities.
//version = Demo
version(Windows) {
import core.sys.windows.windows;
import std.string : toStringz;
private {
enum RED_BIT = 4;
enum GREEN_BIT = 2;
enum BLUE_BIT = 1;
}
}
version(Posix) {
import core.sys.posix.termios;
import core.sys.posix.unistd;
import unix = core.sys.posix.unistd;
import core.sys.posix.sys.types;
import core.sys.posix.sys.time;
import core.stdc.stdio;
private {
enum RED_BIT = 1;
enum GREEN_BIT = 2;
enum BLUE_BIT = 4;
}
extern(C) int ioctl(int, int, ...);
enum int TIOCGWINSZ = 0x5413;
struct winsize {
ushort ws_row;
ushort ws_col;
ushort ws_xpixel;
ushort ws_ypixel;
}
// I'm taking this from the minimal termcap from my Slackware box (which I use as my /etc/termcap) and just taking the most commonly used ones (for me anyway).
// this way we'll have some definitions for 99% of typical PC cases even without any help from the local operating system
enum string builtinTermcap = `
# Generic VT entry.
vg|vt-generic|Generic VT entries:\
:bs:mi:ms:pt:xn:xo:it#8:\
:RA=\E[?7l:SA=\E?7h:\
:bl=^G:cr=^M:ta=^I:\
:cm=\E[%i%d;%dH:\
:le=^H:up=\E[A:do=\E[B:nd=\E[C:\
:LE=\E[%dD:RI=\E[%dC:UP=\E[%dA:DO=\E[%dB:\
:ho=\E[H:cl=\E[H\E[2J:ce=\E[K:cb=\E[1K:cd=\E[J:sf=\ED:sr=\EM:\
:ct=\E[3g:st=\EH:\
:cs=\E[%i%d;%dr:sc=\E7:rc=\E8:\
:ei=\E[4l:ic=\E[@:IC=\E[%d@:al=\E[L:AL=\E[%dL:\
:dc=\E[P:DC=\E[%dP:dl=\E[M:DL=\E[%dM:\
:so=\E[7m:se=\E[m:us=\E[4m:ue=\E[m:\
:mb=\E[5m:mh=\E[2m:md=\E[1m:mr=\E[7m:me=\E[m:\
:sc=\E7:rc=\E8:kb=\177:\
:ku=\E[A:kd=\E[B:kr=\E[C:kl=\E[D:
# Slackware 3.1 linux termcap entry (Sat Apr 27 23:03:58 CDT 1996):
lx|linux|console|con80x25|LINUX System Console:\
:do=^J:co#80:li#25:cl=\E[H\E[J:sf=\ED:sb=\EM:\
:le=^H:bs:am:cm=\E[%i%d;%dH:nd=\E[C:up=\E[A:\
:ce=\E[K:cd=\E[J:so=\E[7m:se=\E[27m:us=\E[36m:ue=\E[m:\
:md=\E[1m:mr=\E[7m:mb=\E[5m:me=\E[m:is=\E[1;25r\E[25;1H:\
:ll=\E[1;25r\E[25;1H:al=\E[L:dc=\E[P:dl=\E[M:\
:it#8:ku=\E[A:kd=\E[B:kr=\E[C:kl=\E[D:kb=^H:ti=\E[r\E[H:\
:ho=\E[H:kP=\E[5~:kN=\E[6~:kH=\E[4~:kh=\E[1~:kD=\E[3~:kI=\E[2~:\
:k1=\E[[A:k2=\E[[B:k3=\E[[C:k4=\E[[D:k5=\E[[E:k6=\E[17~:\
:k7=\E[18~:k8=\E[19~:k9=\E[20~:k0=\E[21~:K1=\E[1~:K2=\E[5~:\
:K4=\E[4~:K5=\E[6~:\
:pt:sr=\EM:vt#3:xn:km:bl=^G:vi=\E[?25l:ve=\E[?25h:vs=\E[?25h:\
:sc=\E7:rc=\E8:cs=\E[%i%d;%dr:\
:r1=\Ec:r2=\Ec:r3=\Ec:
# Some other, commonly used linux console entries.
lx|con80x28:co#80:li#28:tc=linux:
lx|con80x43:co#80:li#43:tc=linux:
lx|con80x50:co#80:li#50:tc=linux:
lx|con100x37:co#100:li#37:tc=linux:
lx|con100x40:co#100:li#40:tc=linux:
lx|con132x43:co#132:li#43:tc=linux:
# vt102 - vt100 + insert line etc. VT102 does not have insert character.
v2|vt102|DEC vt102 compatible:\
:co#80:li#24:\
:ic@:IC@:\
:is=\E[m\E[?1l\E>:\
:rs=\E[m\E[?1l\E>:\
:eA=\E)0:as=^N:ae=^O:ac=aaffggjjkkllmmnnooqqssttuuvvwwxx:\
:ks=:ke=:\
:k1=\EOP:k2=\EOQ:k3=\EOR:k4=\EOS:\
:tc=vt-generic:
# vt100 - really vt102 without insert line, insert char etc.
vt|vt100|DEC vt100 compatible:\
:im@:mi@:al@:dl@:ic@:dc@:AL@:DL@:IC@:DC@:\
:tc=vt102:
# Entry for an xterm. Insert mode has been disabled.
vs|xterm|xterm-color|vs100|xterm terminal emulator (X Window System):\
:am:bs:mi@:km:co#80:li#55:\
:im@:ei@:\
:ct=\E[3k:ue=\E[m:\
:is=\E[m\E[?1l\E>:\
:rs=\E[m\E[?1l\E>:\
:eA=\E)0:as=^N:ae=^O:ac=aaffggjjkkllmmnnooqqssttuuvvwwxx:\
:kI=\E[2~:kD=\E[3~:kP=\E[5~:kN=\E[6~:\
:k1=\EOP:k2=\EOQ:k3=\EOR:k4=\EOS:k5=\E[15~:\
:k6=\E[17~:k7=\E[18~:k8=\E[19~:k9=\E[20~:k0=\E[21~:\
:F1=\E[23~:F2=\E[24~:\
:kh=\E[H:kH=\E[F:\
:ks=:ke=:\
:te=\E[2J\E[?47l\E8:ti=\E7\E[?47h:\
:tc=vt-generic:
#rxvt, added by me
rxvt|rxvt-unicode:\
:am:bs:mi@:km:co#80:li#55:\
:im@:ei@:\
:ct=\E[3k:ue=\E[m:\
:is=\E[m\E[?1l\E>:\
:rs=\E[m\E[?1l\E>:\
:eA=\E)0:as=^N:ae=^O:ac=aaffggjjkkllmmnnooqqssttuuvvwwxx:\
:kI=\E[2~:kD=\E[3~:kP=\E[5~:kN=\E[6~:\
:k1=\E[11~:k2=\E[12~:k3=\E[13~:k4=\E[14~:k5=\E[15~:\
:k6=\E[17~:k7=\E[18~:k8=\E[19~:k9=\E[20~:k0=\E[21~:\
:F1=\E[23~:F2=\E[24~:\
:kh=\E[7~:kH=\E[8~:\
:ks=:ke=:\
:te=\E[2J\E[?47l\E8:ti=\E7\E[?47h:\
:tc=vt-generic:
# Some other entries for the same xterm.
v2|xterms|vs100s|xterm small window:\
:co#80:li#24:tc=xterm:
vb|xterm-bold|xterm with bold instead of underline:\
:us=\E[1m:tc=xterm:
vi|xterm-ins|xterm with insert mode:\
:mi:im=\E[4h:ei=\E[4l:tc=xterm:
Eterm|Eterm Terminal Emulator (X11 Window System):\
:am:bw:eo:km:mi:ms:xn:xo:\
:co#80:it#8:li#24:lm#0:pa#64:Co#8:AF=\E[3%dm:AB=\E[4%dm:op=\E[39m\E[49m:\
:AL=\E[%dL:DC=\E[%dP:DL=\E[%dM:DO=\E[%dB:IC=\E[%d@:\
:K1=\E[7~:K2=\EOu:K3=\E[5~:K4=\E[8~:K5=\E[6~:LE=\E[%dD:\
:RI=\E[%dC:UP=\E[%dA:ae=^O:al=\E[L:as=^N:bl=^G:cd=\E[J:\
:ce=\E[K:cl=\E[H\E[2J:cm=\E[%i%d;%dH:cr=^M:\
:cs=\E[%i%d;%dr:ct=\E[3g:dc=\E[P:dl=\E[M:do=\E[B:\
:ec=\E[%dX:ei=\E[4l:ho=\E[H:i1=\E[?47l\E>\E[?1l:ic=\E[@:\
:im=\E[4h:is=\E[r\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l\E[4l:\
:k1=\E[11~:k2=\E[12~:k3=\E[13~:k4=\E[14~:k5=\E[15~:\
:k6=\E[17~:k7=\E[18~:k8=\E[19~:k9=\E[20~:kD=\E[3~:\
:kI=\E[2~:kN=\E[6~:kP=\E[5~:kb=^H:kd=\E[B:ke=:kh=\E[7~:\
:kl=\E[D:kr=\E[C:ks=:ku=\E[A:le=^H:mb=\E[5m:md=\E[1m:\
:me=\E[m\017:mr=\E[7m:nd=\E[C:rc=\E8:\
:sc=\E7:se=\E[27m:sf=^J:so=\E[7m:sr=\EM:st=\EH:ta=^I:\
:te=\E[2J\E[?47l\E8:ti=\E7\E[?47h:ue=\E[24m:up=\E[A:\
:us=\E[4m:vb=\E[?5h\E[?5l:ve=\E[?25h:vi=\E[?25l:\
:ac=``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~:
# DOS terminal emulator such as Telix or TeleMate.
# This probably also works for the SCO console, though it's incomplete.
an|ansi|ansi-bbs|ANSI terminals (emulators):\
:co#80:li#24:am:\
:is=:rs=\Ec:kb=^H:\
:as=\E[m:ae=:eA=:\
:ac=0\333+\257,\256.\031-\030a\261f\370g\361j\331k\277l\332m\300n\305q\304t\264u\303v\301w\302x\263~\025:\
:kD=\177:kH=\E[Y:kN=\E[U:kP=\E[V:kh=\E[H:\
:k1=\EOP:k2=\EOQ:k3=\EOR:k4=\EOS:k5=\EOT:\
:k6=\EOU:k7=\EOV:k8=\EOW:k9=\EOX:k0=\EOY:\
:tc=vt-generic:
`;
}
enum Bright = 0x08;
/// Defines the list of standard colors understood by Terminal.
enum Color : ushort {
black = 0, /// .
red = RED_BIT, /// .
green = GREEN_BIT, /// .
yellow = red | green, /// .
blue = BLUE_BIT, /// .
magenta = red | blue, /// .
cyan = blue | green, /// .
white = red | green | blue /// .
}
/// When capturing input, what events are you interested in?
///
/// Note: these flags can be OR'd together to select more than one option at a time.
enum ConsoleInputFlags {
raw = 0, /// raw input returns keystrokes immediately, without line buffering
echo = 1, /// do you want to automatically echo input back to the user?
mouse = 2, /// capture mouse events
paste = 4, /// capture paste events (note: without this, paste can come through as keystrokes)
}
/// Defines how terminal output should be handled.
enum ConsoleOutputType {
linear = 0, /// do you want output to work one line at a time?
cellular = 1, /// or do you want access to the terminal screen as a grid of characters?
//truncatedCellular = 3, /// cellular, but instead of wrapping output to the next line automatically, it will truncate at the edges
}
/// Some methods will try not to send unnecessary commands to the screen. You can override their judgement using a ForceOption parameter, if present
enum ForceOption {
automatic = 0, /// automatically decide what to do (best, unless you know for sure it isn't right)
neverSend = -1, /// never send the data. This will only update Terminal's internal state. Use with caution because this can
alwaysSend = 1, /// always send the data, even if it doesn't seem necessary
}
// we could do it with termcap too, getenv("TERMCAP") then split on : and replace \E with \033 and get the pieces
/// Encapsulates the I/O capabilities of a terminal.
///
/// Warning: do not write out escape sequences to the terminal. This won't work
/// on Windows and will confuse Terminal's internal state on Posix.
struct Terminal {
@disable this();
@disable this(this);
private ConsoleOutputType type;
version(Posix) {
bool terminalInFamily(string[] terms...) {
import std.process;
import std.string;
auto term = getenv("TERM");
foreach(t; terms)
if(indexOf(term, t) != -1)
return true;
return false;
}
static string[string] termcapDatabase;
static void readTermcapFile(bool useBuiltinTermcap = false) {
import std.file;
import std.stdio;
import std.string;
if(!exists("/etc/termcap"))
useBuiltinTermcap = true;
string current;
void commitCurrentEntry() {
if(current is null)
return;
string names = current;
auto idx = indexOf(names, ":");
if(idx != -1)
names = names[0 .. idx];
foreach(name; split(names, "|"))
termcapDatabase[name] = current;
current = null;
}
void handleTermcapLine(in char[] line) {
if(line.length == 0) { // blank
commitCurrentEntry();
return; // continue
}
if(line[0] == '#') // comment
return; // continue
size_t termination = line.length;
if(line[$-1] == '\\')
termination--; // cut off the \\
current ~= strip(line[0 .. termination]);
// termcap entries must be on one logical line, so if it isn't continued, we know we're done
if(line[$-1] != '\\')
commitCurrentEntry();
}
if(useBuiltinTermcap) {
foreach(line; splitLines(builtinTermcap)) {
handleTermcapLine(line);
}
} else {
foreach(line; File("/etc/termcap").byLine()) {
handleTermcapLine(line);
}
}
}
static string getTermcapDatabase(string terminal) {
import std.string;
if(termcapDatabase is null)
readTermcapFile();
auto data = terminal in termcapDatabase;
if(data is null)
return null;
auto tc = *data;
auto more = indexOf(tc, ":tc=");
if(more != -1) {
auto tcKey = tc[more + ":tc=".length .. $];
auto end = indexOf(tcKey, ":");
if(end != -1)
tcKey = tcKey[0 .. end];
tc = getTermcapDatabase(tcKey) ~ tc;
}
return tc;
}
string[string] termcap;
void readTermcap() {
import std.process;
import std.string;
import std.array;
string termcapData = getenv("TERMCAP");
if(termcapData.length == 0) {
termcapData = getTermcapDatabase(getenv("TERM"));
}
auto e = replace(termcapData, "\\\n", "\n");
termcap = null;
foreach(part; split(e, ":")) {
// FIXME: handle numeric things too
auto things = split(part, "=");
if(things.length)
termcap[things[0]] =
things.length > 1 ? things[1] : null;
}
}
string findSequenceInTermcap(in char[] sequenceIn) {
char[10] sequenceBuffer;
char[] sequence;
if(sequenceIn.length > 0 && sequenceIn[0] == '\033') {
assert(sequenceIn.length < sequenceBuffer.length - 1);
sequenceBuffer[1 .. sequenceIn.length + 1] = sequenceIn[];
sequenceBuffer[0] = '\\';
sequenceBuffer[1] = 'E';
sequence = sequenceBuffer[0 .. sequenceIn.length + 1];
} else {
sequence = sequenceBuffer[1 .. sequenceIn.length + 1];
}
import std.array;
foreach(k, v; termcap)
if(v == sequence)
return k;
return null;
}
string getTermcap(string key) {
auto k = key in termcap;
if(k !is null) return *k;
return null;
}
// Looks up a termcap item and tries to execute it. Returns false on failure
bool doTermcap(T...)(string key, T t) {
import std.conv;
auto fs = getTermcap(key);
if(fs is null)
return false;
int swapNextTwo = 0;
R getArg(R)(int idx) {
if(swapNextTwo == 2) {
idx ++;
swapNextTwo--;
} else if(swapNextTwo == 1) {
idx --;
swapNextTwo--;
}
foreach(i, arg; t) {
if(i == idx)
return to!R(arg);
}
assert(0, to!string(idx) ~ " is out of bounds working " ~ fs);
}
char[256] buffer;
int bufferPos = 0;
void addChar(char c) {
import std.exception;
enforce(bufferPos < buffer.length);
buffer[bufferPos++] = c;
}
void addString(in char[] c) {
import std.exception;
enforce(bufferPos + c.length < buffer.length);
buffer[bufferPos .. bufferPos + c.length] = c[];
bufferPos += c.length;
}
void addInt(int c, int minSize) {
import std.string;
auto str = format("%0"~(minSize ? to!string(minSize) : "")~"d", c);
addString(str);
}
bool inPercent;
int argPosition = 0;
int incrementParams = 0;
bool skipNext;
bool nextIsChar;
bool inBackslash;
foreach(char c; fs) {
if(inBackslash) {
if(c == 'E')
addChar('\033');
else
addChar(c);
inBackslash = false;
} else if(nextIsChar) {
if(skipNext)
skipNext = false;
else
addChar(cast(char) (c + getArg!int(argPosition) + (incrementParams ? 1 : 0)));
if(incrementParams) incrementParams--;
argPosition++;
inPercent = false;
} else if(inPercent) {
switch(c) {
case '%':
addChar('%');
inPercent = false;
break;
case '2':
case '3':
case 'd':
if(skipNext)
skipNext = false;
else
addInt(getArg!int(argPosition) + (incrementParams ? 1 : 0),
c == 'd' ? 0 : (c - '0')
);
if(incrementParams) incrementParams--;
argPosition++;
inPercent = false;
break;
case '.':
if(skipNext)
skipNext = false;
else
addChar(cast(char) (getArg!int(argPosition) + (incrementParams ? 1 : 0)));
if(incrementParams) incrementParams--;
argPosition++;
break;
case '+':
nextIsChar = true;
inPercent = false;
break;
case 'i':
incrementParams = 2;
inPercent = false;
break;
case 's':
skipNext = true;
inPercent = false;
break;
case 'b':
argPosition--;
inPercent = false;
break;
case 'r':
swapNextTwo = 2;
inPercent = false;
break;
// FIXME: there's more
// http://www.gnu.org/software/termutils/manual/termcap-1.3/html_mono/termcap.html
default:
assert(0, "not supported " ~ c);
}
} else {
if(c == '%')
inPercent = true;
else if(c == '\\')
inBackslash = true;
else
addChar(c);
}
}
writeStringRaw(buffer[0 .. bufferPos]);
return true;
}
}
version(Posix)
/**
* Constructs an instance of Terminal representing the capabilities of
* the current terminal.
*/
this(ConsoleOutputType type) {
readTermcap();
this.type = type;
if(type == ConsoleOutputType.cellular) {
doTermcap("ti");
moveTo(0, 0, ForceOption.alwaysSend); // we need to know where the cursor is for some features to work, and moving it is easier than querying it
}
}
version(Windows)
HANDLE hConsole;
version(Windows)
/// ditto
this(ConsoleOutputType type) {
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
}
version(Posix)
~this() {
if(type == ConsoleOutputType.cellular) {
doTermcap("te");
}
reset();
flush();
}
int _currentForeground = Color.black; // FIXME: this isn't necessarily right
int _currentBackground = Color.white;
/// Changes the current color. See enum Color for the values.
void color(int foreground, int background, ForceOption force = ForceOption.automatic) {
if(force != ForceOption.neverSend) {
version(Windows) {
// assuming a dark background on windows, so LowContrast == dark which means the bit is NOT set on hardware
/*
foreground ^= LowContrast;
background ^= LowContrast;
*/
SetConsoleTextAttribute(
GetStdHandle(STD_OUTPUT_HANDLE),
cast(ushort)((background << 4) | foreground));
} else {
import std.process;
// I started using this envvar for my text editor, but now use it elsewhere too
// if we aren't set to dark, assume light
/*
if(getenv("ELVISBG") == "dark") {
// LowContrast on dark bg menas
} else {
foreground ^= LowContrast;
background ^= LowContrast;
}
*/
import std.string;
if(force == ForceOption.alwaysSend || foreground != _currentForeground || background != _currentBackground) {
writeStringRaw(format("\033[%dm\033[3%dm\033[4%dm",
(foreground & Bright) ? 1 : 0,
cast(int) foreground & ~Bright,
cast(int) background & ~Bright));
}
}
}
_currentForeground = foreground;
_currentBackground = background;
}
/// Returns the terminal to normal output colors
void reset() {
version(Windows)
SetConsoleTextAttribute(
GetStdHandle(STD_OUTPUT_HANDLE),
cast(ushort)((Color.black << 4) | Color.white));
else
writeStringRaw("\033[0m");
}
// FIXME: add moveRelative
/// The current x position of the output cursor. 0 == leftmost column
@property int cursorX() {
return _cursorX;
}
/// The current y position of the output cursor. 0 == topmost row
@property int cursorY() {
return _cursorY;
}
private int _cursorX;
private int _cursorY;
/// Moves the output cursor to the given position. (0, 0) is the upper left corner of the screen. The force parameter can be used to force an update, even if Terminal doesn't think it is necessary
void moveTo(int x, int y, ForceOption force = ForceOption.automatic) {
if(force != ForceOption.neverSend && (force == ForceOption.alwaysSend || x != _cursorX || y != _cursorY)) {
version(Posix)
doTermcap("cm", y, x);
else version(Windows) {
COORD coord = {cast(short) x, cast(short) y};
SetConsoleCursorPosition(hConsole, coord);
} else static assert(0);
}
_cursorX = x;
_cursorY = y;
}
/*
// alas this doesn't work due to a bunch of delegate context pointer and postblit problems
// instead of using: auto input = terminal.captureInput(flags)
// use: auto input = RealTimeConsoleInput(&terminal, flags);
/// Gets real time input, disabling line buffering
RealTimeConsoleInput captureInput(ConsoleInputFlags flags) {
return RealTimeConsoleInput(&this, flags);
}
*/
/// Changes the terminal's title
void setTitle(string t) {
version(Windows) {
SetConsoleTitleA(toStringz(t));
} else {
import std.string;
if(terminalInFamily("xterm", "rxvt", "screen"))
writeStringRaw(format("\033]0;%s\007", t));
}
}
/// Flushes your updates to the terminal.
/// It is important to call this when you are finished writing for now if you are using the version=with_eventloop
void flush() {
version(Posix) {
ssize_t written;
while(writeBuffer.length) {
written = unix.write(1 /*this.fd*/, writeBuffer.ptr, writeBuffer.length);
if(written < 0)
throw new Exception("write failed for some reason");
writeBuffer = writeBuffer[written .. $];
}
}
// not buffering right now on Windows, since it probably isn't on ssh anyway
}
int[] getSize() {
version(Windows) {
CONSOLE_SCREEN_BUFFER_INFO info;
GetConsoleScreenBufferInfo( hConsole, &info );
int cols, rows;
cols = (info.srWindow.Right - info.srWindow.Left + 1);
rows = (info.srWindow.Bottom - info.srWindow.Top + 1);
return [cols, rows];
} else {
winsize w;
ioctl(0, TIOCGWINSZ, &w);
return [w.ws_col, w.ws_row];
}
}
void updateSize() {
auto size = getSize();
_width = size[0];
_height = size[1];
}
private int _width;
private int _height;
/// The current width of the terminal (the number of columns)
@property int width() {
if(_width == 0 || _height == 0)
updateSize();
return _width;
}
/// The current height of the terminal (the number of rows)
@property int height() {
if(_width == 0 || _height == 0)
updateSize();
return _height;
}
/*
void write(T...)(T t) {
foreach(arg; t) {
writeStringRaw(to!string(arg));
}
}
*/
/// Writes to the terminal at the current cursor position.
void writef(T...)(string f, T t) {
import std.string;
writePrintableString(format(f, t));
}
/// ditto
void writefln(T...)(string f, T t) {
writef(f ~ "\n", t);
}
/// ditto
void write(T...)(T t) {
import std.conv;
string data;
foreach(arg; t) {
data ~= to!string(arg);
}
writePrintableString(data);
}
/// ditto
void writeln(T...)(T t) {
write(t, "\n");
}
/+
/// A combined moveTo and writef that puts the cursor back where it was before when it finishes the write.
/// Only works in cellular mode.
/// Might give better performance than moveTo/writef because if the data to write matches the internal buffer, it skips sending anything (to override the buffer check, you can use moveTo and writePrintableString with ForceOption.alwaysSend)
void writefAt(T...)(int x, int y, string f, T t) {
import std.string;
auto toWrite = format(f, t);
auto oldX = _cursorX;
auto oldY = _cursorY;
writeAtWithoutReturn(x, y, toWrite);
moveTo(oldX, oldY);
}
void writeAtWithoutReturn(int x, int y, in char[] data) {
moveTo(x, y);
writeStringRaw(toWrite, ForceOption.alwaysSend);
}
+/
void writePrintableString(in char[] s, ForceOption force = ForceOption.automatic) {
// an escape character is going to mess things up. Actually any non-printable character could, but meh
// assert(s.indexOf("\033") == -1);
// tracking cursor position
foreach(ch; s) {
switch(ch) {
case '\n':
_cursorX = 0;
_cursorY++;
break;
case '\t':
_cursorX ++;
_cursorX += _cursorX % 8; // FIXME: get the actual tabstop, if possible
break;
default:
_cursorX++;
}
if(_cursorX >= width) {
_cursorX = 0;
_cursorY++;
}
if(_cursorY == height)
_cursorY--;
/+
auto index = getIndex(_cursorX, _cursorY);
if(data[index] != ch) {
data[index] = ch;
}
+/
}
writeStringRaw(s);
}
deprecated alias writePrintableString writeString; /// use write() or writePrintableString instead
private string writeBuffer;
private void writeStringRaw(in char[] s) {
// FIXME: make sure all the data is sent, check for errors
version(Posix) {
writeBuffer ~= s; // buffer it to do everything at once in flush() calls
} else version(Windows) {
DWORD written;
/* FIXME: WriteConsoleW */
WriteConsoleA(hConsole, s.ptr, s.length, &written, null);
} else static assert(0);
}
/// Clears the screen.
void clear() {
version(Posix) {
doTermcap("cl");
} else version(Windows) {
// TBD: copy the code from here and test it:
// http://support.microsoft.com/kb/99261
assert(0, "clear not yet implemented");
}
_cursorX = 0;
_cursorY = 0;
}
}
/+
struct ConsoleBuffer {
int cursorX;
int cursorY;
int width;
int height;
dchar[] data;
void actualize(Terminal* t) {
auto writer = t.getBufferedWriter();
this.copyTo(&(t.onScreen));
}
void copyTo(ConsoleBuffer* buffer) {
buffer.cursorX = this.cursorX;
buffer.cursorY = this.cursorY;
buffer.width = this.width;
buffer.height = this.height;
buffer.data[] = this.data[];
}
}
+/
/**
* Encapsulates the stream of input events received from the terminal input.
*/
struct RealTimeConsoleInput {
@disable this();
@disable this(this);
version(Posix) {
private int fd;
private termios old;
ubyte[128] hack;
// apparently termios isn't the size druntime thinks it is (at least on 32 bit, sometimes)....
// tcgetattr smashed other variables in here too that could create random problems
// so this hack is just to give some room for that to happen without destroying the rest of the world
}
version(Windows) {
private DWORD oldInput;
private DWORD oldOutput;
HANDLE inputHandle;
}
private ConsoleInputFlags flags;
private Terminal* terminal;
private void delegate()[] destructor;
/// To capture input, you need to provide a terminal and some flags.
public this(Terminal* terminal, ConsoleInputFlags flags) {
this.flags = flags;
this.terminal = terminal;
version(Windows) {
inputHandle = GetStdHandle(STD_INPUT_HANDLE);
GetConsoleMode(inputHandle, &oldInput);
DWORD mode = 0;
mode |= ENABLE_PROCESSED_INPUT /* 0x01 */; // this gives Ctrl+C which we probably want to be similar to linux
mode |= ENABLE_WINDOW_INPUT /* 0208 */; // gives size etc
if(flags & ConsoleInputFlags.echo)
mode |= ENABLE_ECHO_INPUT; // 0x4
if(flags & ConsoleInputFlags.mouse)
mode |= ENABLE_MOUSE_INPUT; // 0x10
// if(flags & ConsoleInputFlags.raw) // FIXME: maybe that should be a separate flag for ENABLE_LINE_INPUT
SetConsoleMode(inputHandle, mode);
destructor ~= { SetConsoleMode(inputHandle, oldInput); };
GetConsoleMode(terminal.hConsole, &oldOutput);
mode = 0;
// we want this to match linux too
mode |= ENABLE_PROCESSED_OUTPUT; /* 0x01 */
mode |= ENABLE_WRAP_AT_EOL_OUTPUT; /* 0x02 */
SetConsoleMode(terminal.hConsole, mode);
destructor ~= { SetConsoleMode(terminal.hConsole, oldOutput); };
// FIXME: change to UTF8 as well
}
version(Posix) {
this.fd = 0; // stdin
tcgetattr(fd, &old);
auto n = old;
auto f = ICANON;
if(!(flags & ConsoleInputFlags.echo))
f |= ECHO;
n.c_lflag &= ~f;
tcsetattr(fd, TCSANOW, &n);
// some weird bug breaks this, https://github.com/robik/ConsoleD/issues/3
//destructor ~= { tcsetattr(fd, TCSANOW, &old); };
if(flags & ConsoleInputFlags.mouse) {
if(terminal.terminalInFamily("xterm", "rxvt", "screen", "linux")) {
terminal.writeStringRaw("\033[?1000h"); // this is vt200 mouse, supported by xterm and linux + gpm
destructor ~= { terminal.writeStringRaw("\033[?1000l"); };
}
}
if(flags & ConsoleInputFlags.paste) {
if(terminal.terminalInFamily("xterm", "rxvt", "screen")) {
terminal.writeStringRaw("\033[?2004h"); // bracketed paste mode
destructor ~= { terminal.writeStringRaw("\033[?2004l"); };
}
}
// try to ensure the terminal is in UTF-8 mode
if(terminal.terminalInFamily("xterm", "screen", "linux")) {
terminal.writeStringRaw("\033%G");
}
terminal.flush();
}
version(with_eventloop) {
import arsd.eventloop;
version(Windows)
auto listenTo = inputHandle;
else version(Posix)
auto listenTo = this.fd;
else static assert(0, "idk about this OS");
addFileEventListeners(listenTo, &eventListener, null, null);
destructor ~= { removeFileEventListeners(listenTo); };
addOnIdle(&terminal.flush);
destructor ~= { removeOnIdle(&terminal.flush); };
}
}
version(with_eventloop) {
import arsd.eventloop;
void eventListener(OsFileHandle fd) {
auto queue = readNextEvents();
foreach(event; queue)
send(event);
}
}
~this() {
// the delegate thing doesn't actually work for this... for some reason
version(Posix)
tcsetattr(fd, TCSANOW, &old);
// we're just undoing everything the constructor did, in reverse order, same criteria
foreach_reverse(d; destructor)
d();
}
/// Returns true if there is input available now
bool kbhit() {
return timedCheckForInput(0);
}
/// Check for input, waiting no longer than the number of milliseconds
bool timedCheckForInput(int milliseconds) {
version(Windows) {
auto response = WaitForSingleObject(terminal.hConsole, milliseconds);
if(response == 0)
return true; // the object is ready
return false;
} else version(Posix) {
timeval tv;
tv.tv_sec = 0;
tv.tv_usec = milliseconds * 1000;
fd_set fs;
FD_ZERO(&fs);
FD_SET(fd, &fs);
select(fd + 1, &fs, null, null, &tv);
return FD_ISSET(fd, &fs);
}
}
/// Get one character from the terminal
char getch() {
import core.stdc.stdio;
return cast(char) fgetc(stdin);
}
//char[128] inputBuffer;
//int inputBufferPosition;
version(Posix)
int nextRaw() {
char[1] buf;
auto ret = read(fd, buf.ptr, buf.length);
if(ret == 0)
return 0; // input closed
if(ret == -1)
throw new Exception("read failed");
//terminal.writef("RAW READ: %d\n", buf[0]);
if(ret == 1)
return buf[0];
else
assert(0); // read too much, should be impossible
}
version(Posix)
dchar nextChar(int starting) {
if(starting <= 127)
return cast(dchar) starting;
char[6] buffer;
int pos = 0;
buffer[pos++] = cast(char) starting;
// see the utf-8 encoding for details
int remaining = 0;
ubyte magic = starting & 0xff;
while(magic & 0b1000_000) {
remaining++;
magic <<= 1;
}
while(remaining && pos < buffer.length) {
buffer[pos++] = cast(char) nextRaw();
remaining--;
}
import std.utf;
size_t throwAway; // it insists on the index but we don't care
return decode(buffer, throwAway);
}
// character event
// non-character key event
// paste event
// mouse event
// size event maybe, and if appropriate focus events
/// Returns the next event.
///
/// Experimental: It is also possible to integrate this into
/// a generic event loop, currently under -version=with_eventloop and it will
/// require the module arsd.eventloop (Linux only at this point)
InputEvent nextEvent() {
if(inputQueue.length) {
auto e = inputQueue[0];
inputQueue = inputQueue[1 .. $];
return e;
}
auto more = readNextEvents();
while(!more.length)
more = readNextEvents();
assert(more.length);
auto e = more[0];
inputQueue = more[1 .. $];
return e;
}
InputEvent* peekNextEvent() {
if(inputQueue.length)
return &(inputQueue[0]);
return null;
}
enum InjectionPosition { head, tail }
void injectEvent(InputEvent ev, InjectionPosition where) {
final switch(where) {
case InjectionPosition.head:
inputQueue = ev ~ inputQueue;
break;
case InjectionPosition.tail:
inputQueue ~= ev;
break;
}
}
InputEvent[] inputQueue;
version(Windows)
InputEvent[] readNextEvents() {
terminal.flush(); // make sure all output is sent out before waiting for anything
INPUT_RECORD[32] buffer;
DWORD actuallyRead;
// FIXME: ReadConsoleInputW
auto success = ReadConsoleInputA(inputHandle, buffer.ptr, buffer.length, &actuallyRead);
if(success == 0)
throw new Exception("ReadConsoleInput");
InputEvent[] newEvents;
foreach(record; buffer[0 .. actuallyRead]) {
switch(record.EventType) {
case KEY_EVENT:
auto ev = record.KeyEvent;
CharacterEvent e;
NonCharacterKeyEvent ne;
e.eventType = ev.bKeyDown ? CharacterEvent.Type.Pressed : CharacterEvent.Type.Released;
ne.eventType = ev.bKeyDown ? NonCharacterKeyEvent.Type.Pressed : NonCharacterKeyEvent.Type.Released;
// FIXME standardize
e.modifierState = ev.dwControlKeyState;
ne.modifierState = ev.dwControlKeyState;
if(ev.UnicodeChar) {
e.character = cast(dchar) cast(wchar) ev.UnicodeChar;
newEvents ~= InputEvent(e);
} else {
// FIXME actually translate
ne.key = cast(NonCharacterKeyEvent.Key) ev.wVirtualKeyCode;
newEvents ~= InputEvent(ne);
}
break;
case MOUSE_EVENT:
auto ev = record.MouseEvent;
MouseEvent e;
e.modifierState = ev.dwControlKeyState;
e.x = ev.dwMousePosition.X;
e.y = ev.dwMousePosition.Y;
switch(ev.dwEventFlags) {
case 0:
//press
e.eventType = MouseEvent.Type.Pressed;
e.buttons = ev.dwButtonState;
break;
case MOUSE_MOVED:
e.eventType = MouseEvent.Type.Moved;
e.buttons = ev.dwButtonState;
break;
case 0x0004/*MOUSE_WHEELED*/:
e.eventType = MouseEvent.Type.Pressed;
if(ev.dwButtonState > 0)
e.buttons = MouseEvent.Button.ScrollDown;
else
e.buttons = MouseEvent.Button.ScrollUp;
break;
}
newEvents ~= InputEvent(e);
break;
case WINDOW_BUFFER_SIZE_EVENT:
auto ev = record.WindowBufferSizeEvent;
// FIXME
break;
default:
// ignore
}
}
return newEvents;
}
version(Posix)
InputEvent[] readNextEvents() {
terminal.flush(); // make sure all output is sent out before we try to get input
InputEvent[] charPressAndRelease(dchar character) {
return [
InputEvent(CharacterEvent(CharacterEvent.Type.Pressed, character, 0)),
InputEvent(CharacterEvent(CharacterEvent.Type.Released, character, 0)),
];
}
InputEvent[] keyPressAndRelease(NonCharacterKeyEvent.Key key) {
return [
InputEvent(NonCharacterKeyEvent(NonCharacterKeyEvent.Type.Pressed, key, 0)),
InputEvent(NonCharacterKeyEvent(NonCharacterKeyEvent.Type.Released, key, 0)),
];
}
// this assumes you just read "\033["
char[] readEscapeSequence() {
char[30] sequence;
int sequenceLength = 2;
sequence[0] = '\033';
sequence[1] = '[';
while(sequenceLength < sequence.length) {
auto n = nextRaw();
sequence[sequenceLength++] = cast(char) n;
if(n >= 0x40)
break;
}
return sequence[0 .. sequenceLength];
}
InputEvent[] translateTermcapName(string cap) {
switch(cap) {
//case "k0":
//return keyPressAndRelease(NonCharacterKeyEvent.Key.F1);
case "k1":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F1);
case "k2":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F2);
case "k3":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F3);
case "k4":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F4);
case "k5":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F5);
case "k6":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F6);
case "k7":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F7);
case "k8":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F8);
case "k9":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F9);
case "k;":
case "k0":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F10);
case "F1":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F11);
case "F2":
return keyPressAndRelease(NonCharacterKeyEvent.Key.F12);
case "kb":
return charPressAndRelease('\b');
case "kD":
return keyPressAndRelease(NonCharacterKeyEvent.Key.Delete);
case "kd":
case "do":
return keyPressAndRelease(NonCharacterKeyEvent.Key.DownArrow);
case "ku":
case "up":
return keyPressAndRelease(NonCharacterKeyEvent.Key.UpArrow);
case "kl":
return keyPressAndRelease(NonCharacterKeyEvent.Key.LeftArrow);
case "kr":
case "nd":
return keyPressAndRelease(NonCharacterKeyEvent.Key.RightArrow);
case "kN":
return keyPressAndRelease(NonCharacterKeyEvent.Key.PageDown);
case "kP":
return keyPressAndRelease(NonCharacterKeyEvent.Key.PageUp);
case "kh":
return keyPressAndRelease(NonCharacterKeyEvent.Key.Home);
case "kH":
return keyPressAndRelease(NonCharacterKeyEvent.Key.End);
case "kI":
return keyPressAndRelease(NonCharacterKeyEvent.Key.Insert);
default:
// don't know it, just ignore
//import std.stdio;
//writeln(cap);
}
return null;
}
InputEvent[] doEscapeSequence(in char[] sequence) {
switch(sequence) {
case "\033[200~":
// bracketed paste begin
// we want to keep reading until
// "\033[201~":
// and build a paste event out of it
string data;
for(;;) {
auto n = nextRaw();
if(n == '\033') {
n = nextRaw();
if(n == '[') {
auto esc = readEscapeSequence();
if(esc == "\033[201~") {
// complete!
break;
} else {
// was something else apparently, but it is pasted, so keep it
data ~= esc;
}
} else {
data ~= '\033';
data ~= cast(char) n;
}
} else {
data ~= cast(char) n;
}
}
return [InputEvent(PasteEvent(data))];
break;
case "\033[M":
// mouse event
auto buttonCode = nextRaw();
// nextChar is commented because i'm not using UTF-8 mouse mode
// cuz i don't think it is as widely supported
auto x = cast(int) (/*nextChar*/(nextRaw())) - 33; /* they encode value + 32, but make upper left 1,1. I want it to be 0,0 */
auto y = cast(int) (/*nextChar*/(nextRaw())) - 33; /* ditto */
bool isRelease = (buttonCode & 0b11) == 3;
int buttonNumber;
if(!isRelease) {
buttonNumber = (buttonCode & 0b11);
if(buttonCode & 64)
buttonNumber += 3; // button 4 and 5 are sent as like button 1 and 2, but code | 64
// so button 1 == button 4 here
// note: buttonNumber == 0 means button 1 at this point
buttonNumber++; // hence this
}
auto modifiers = buttonCode & (0b0001_1100);
// 4 == shift
// 8 == meta
// 16 == control
MouseEvent m;
m.eventType = isRelease ? MouseEvent.Type.Released : MouseEvent.Type.Pressed;
if(buttonNumber == 0)
m.buttons = 0; // we don't actually know
else
m.buttons = 1 << (buttonNumber - 1); // I prefer flags so that's how we do it
m.x = x;
m.y = y;
m.modifierState = modifiers; // FIXME, standardize
return [InputEvent(m)];
break;
default:
// look it up in the termcap key database
auto cap = terminal.findSequenceInTermcap(sequence);
if(cap !is null)
return translateTermcapName(cap);
}
return null;
}
auto c = nextRaw();
if(c == '\033') {
if(timedCheckForInput(50)) {
// escape sequence
c = nextRaw();
if(c == '[') { // CSI, ends on anything >= 'A'
return doEscapeSequence(readEscapeSequence());
} else if(c == 'O') {
// could be xterm function key
auto n = nextRaw();
char[3] thing;
thing[0] = '\033';
thing[1] = 'O';
thing[2] = cast(char) n;
auto cap = terminal.findSequenceInTermcap(thing);
if(cap is null) {
return charPressAndRelease('\033') ~
charPressAndRelease('O') ~
charPressAndRelease(thing[2]);
} else {
return translateTermcapName(cap);
}
} else {
// I don't know, probably unsupported terminal or just quick user input or something
return charPressAndRelease('\033') ~ charPressAndRelease(nextChar(c));
}
} else {
// user hit escape (or super slow escape sequence, but meh)
return keyPressAndRelease(NonCharacterKeyEvent.Key.escape);
}
} else {
// FIXME: what if it is neither? we should check the termcap
return charPressAndRelease(nextChar(c));
}
}
}
/// Input event for characters
struct CharacterEvent {
/// .
enum Type {
Released, /// .
Pressed /// .
}
Type eventType; /// .
dchar character; /// .
uint modifierState; /// .
}
struct NonCharacterKeyEvent {
/// .
enum Type {
Released, /// .
Pressed /// .
}
Type eventType; /// .
// these match Windows virtual key codes numerically for simplicity of translation there
//http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731%28v=vs.85%29.aspx
/// .
enum Key : int {
escape = 0x1b, /// .
F1 = 0x70, /// .
F2 = 0x71, /// .
F3 = 0x72, /// .
F4 = 0x73, /// .
F5 = 0x74, /// .
F6 = 0x75, /// .
F7 = 0x76, /// .
F8 = 0x77, /// .
F9 = 0x78, /// .
F10 = 0x79, /// .
F11 = 0x7A, /// .
F12 = 0x7B, /// .
LeftArrow = 0x25, /// .
RightArrow = 0x27, /// .
UpArrow = 0x26, /// .
DownArrow = 0x28, /// .
Insert = 0x2d, /// .
Delete = 0x2e, /// .
Home = 0x24, /// .
End = 0x23, /// .
PageUp = 0x21, /// .
PageDown = 0x22, /// .
}
Key key; /// .
uint modifierState; /// .
}
/// .
struct PasteEvent {
string pastedText; /// .
}
/// .
struct MouseEvent {
/// .
enum Type {
Released, /// .
Pressed, /// .
Clicked, /// .
Moved /// .
}
Type eventType; /// .
/// .
enum Button : uint {
None = 0, /// .
Left = 1, /// .
Middle = 4, /// .
Right = 2, /// .
ScrollUp = 8, /// .
ScrollDown = 16 /// .
}
uint buttons; /// A mask of Button
int x; /// 0 == left side
int y; /// 0 == top
uint modifierState; /// shift, ctrl, alt, meta, altgr
}
interface CustomEvent {}
/// GetNextEvent returns this. Check the type, then use get to get the more detailed input
struct InputEvent {
/// .
enum Type {
CharacterEvent, ///.
NonCharacterKeyEvent, /// .
PasteEvent, /// .
MouseEvent, /// .
CustomEvent
}
/// .
@property Type type() { return t; }
/// .
@property auto get(Type T)() {
if(type != T)
throw new Exception("Wrong event type");
static if(T == Type.CharacterEvent)
return characterEvent;
else static if(T == Type.NonCharacterKeyEvent)
return nonCharacterKeyEvent;
else static if(T == Type.PasteEvent)
return pasteEvent;
else static if(T == Type.MouseEvent)
return mouseEvent;
else static if(T == Type.CustomEvent)
return customEvent;
else static assert(0, "Type " ~ T.stringof ~ " not added to the get function");
}
private {
this(CharacterEvent c) {
t = Type.CharacterEvent;
characterEvent = c;
}
this(NonCharacterKeyEvent c) {
t = Type.NonCharacterKeyEvent;
nonCharacterKeyEvent = c;
}
this(PasteEvent c) {
t = Type.PasteEvent;
pasteEvent = c;
}
this(MouseEvent c) {
t = Type.MouseEvent;
mouseEvent = c;
}
this(CustomEvent c) {
t = Type.CustomEvent;
customEvent = c;
}
Type t;
union {
CharacterEvent characterEvent;
NonCharacterKeyEvent nonCharacterKeyEvent;
PasteEvent pasteEvent;
MouseEvent mouseEvent;
CustomEvent customEvent;
}
}
}
version(Demo)
void main() {
auto terminal = Terminal(ConsoleOutputType.linear);
terminal.setTitle("Basic I/O");
auto input = RealTimeConsoleInput(&terminal, ConsoleInputFlags.raw | ConsoleInputFlags.mouse | ConsoleInputFlags.paste);
terminal.color(Color.green | Bright, Color.black);
terminal.write("test some long string to see if it wraps or what because i dont really know what it is going to do so i just want to test i think it will wrap but gotta be sure lolololololololol");
terminal.writefln("%d %d", terminal.cursorX, terminal.cursorY);
int centerX = terminal.width / 2;
int centerY = terminal.height / 2;
bool timeToBreak = false;
void handleEvent(InputEvent event) {
terminal.writef("%s\n", event.type);
final switch(event.type) {
case InputEvent.Type.CharacterEvent:
auto ev = event.get!(InputEvent.Type.CharacterEvent);
terminal.writef("\t%s\n", ev);
if(ev.character == 'Q') {
timeToBreak = true;
version(with_eventloop) {
import arsd.eventloop;
exit();
}
}
if(ev.character == 'C')
terminal.clear();
break;
case InputEvent.Type.NonCharacterKeyEvent:
terminal.writef("\t%s\n", event.get!(InputEvent.Type.NonCharacterKeyEvent));
break;
case InputEvent.Type.PasteEvent:
terminal.writef("\t%s\n", event.get!(InputEvent.Type.PasteEvent));
break;
case InputEvent.Type.MouseEvent:
terminal.writef("\t%s\n", event.get!(InputEvent.Type.MouseEvent));
break;
case InputEvent.Type.CustomEvent:
break;
}
terminal.writefln("%d %d", terminal.cursorX, terminal.cursorY);
/*
if(input.kbhit()) {
auto c = input.getch();
if(c == 'q' || c == 'Q')
break;
terminal.moveTo(centerX, centerY);
terminal.writef("%c", c);
terminal.flush();
}
usleep(10000);
*/
}
version(with_eventloop) {
import arsd.eventloop;
addListener(&handleEvent);
loop();
} else {
loop: while(true) {
auto event = input.nextEvent();
handleEvent(event);
if(timeToBreak)
break loop;
}
}
}
Reference in New Issue View Git Blame Copy Permalink