| // Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| // @dart=2.9 |
| |
| import "dart:async" show StreamSubscription, Timer; |
| import "dart:io" show Platform, ProcessSignal, exit, stdin, stdout; |
| import "dart:isolate" show RawReceivePort; |
| import "dart:typed_data" show Uint16List; |
| |
| class Application { |
| int _latestKnownTerminalColumns; |
| int _latestKnownTerminalRows; |
| RawReceivePort _preventClose; |
| StreamSubscription<List<int>> _stdinListen; |
| StreamSubscription<ProcessSignal> _sigintListen; |
| StreamSubscription<ProcessSignal> _sigwinchListen; |
| Timer _timer; |
| final Widget _widget; |
| _Output _output; |
| bool _started = false; |
| |
| Application(this._widget) { |
| _latestKnownTerminalColumns = stdout.terminalColumns; |
| _latestKnownTerminalRows = stdout.terminalLines; |
| _preventClose = new RawReceivePort(); |
| stdin.echoMode = false; |
| stdin.lineMode = false; |
| |
| _stdinListen = stdin.listen(_stdinListener); |
| _sigintListen = ProcessSignal.sigint.watch().listen((ProcessSignal signal) { |
| quit(); |
| exit(0); |
| }); |
| if (!Platform.isWindows) { |
| _sigwinchListen = |
| ProcessSignal.sigwinch.watch().listen((ProcessSignal signal) { |
| _latestKnownTerminalColumns = stdout.terminalColumns; |
| _latestKnownTerminalRows = stdout.terminalLines; |
| _repaint(); |
| }); |
| } |
| } |
| |
| void _repaint() { |
| _output = |
| new _Output(_latestKnownTerminalRows, _latestKnownTerminalColumns); |
| _widget.print(new WriteOnlyPartialOutput( |
| _output, 0, 0, _output.rows, _output.columns)); |
| _printOutput(); |
| } |
| |
| void _stdinListener(List<int> data) { |
| try { |
| if (_widget.input(this, data)) { |
| _repaint(); |
| } |
| } catch (e) { |
| quit(); |
| rethrow; |
| } |
| } |
| |
| void quit() { |
| _gotoMainScreenBuffer(); |
| _showCursor(); |
| _timer.cancel(); |
| _preventClose.close(); |
| _stdinListen.cancel(); |
| _sigintListen.cancel(); |
| _sigwinchListen?.cancel(); |
| } |
| |
| void start() { |
| if (_started) throw "Already started!"; |
| _started = true; |
| |
| _gotoAlternativeScreenBuffer(); |
| _hideCursor(); |
| _repaint(); |
| |
| _timer = new Timer.periodic(new Duration(milliseconds: 100), (t) { |
| int value = stdout.terminalColumns; |
| bool changed = false; |
| if (value != _latestKnownTerminalColumns) { |
| _latestKnownTerminalColumns = value; |
| changed = true; |
| } |
| value = stdout.terminalLines; |
| if (value != _latestKnownTerminalRows) { |
| _latestKnownTerminalRows = value; |
| changed = true; |
| } |
| |
| if (changed) { |
| _repaint(); |
| } |
| }); |
| } |
| |
| _Output _prevOutput; |
| |
| _printOutput() { |
| int currentPosRow = -1; |
| int currentPosColumn = -1; |
| StringBuffer buffer = new StringBuffer(); |
| if (_prevOutput == null || |
| _prevOutput.columns != _output.columns || |
| _prevOutput.rows != _output.rows) { |
| _clearScreenAlt(); |
| _prevOutput = null; |
| } |
| for (int row = 0; row < _output.rows; row++) { |
| for (int column = 0; column < _output.columns; column++) { |
| String char = _output.getChar(row, column); |
| int rawModifier = _output.getRawModifiers(row, column); |
| |
| if (_prevOutput != null) { |
| String prevChar = _prevOutput.getChar(row, column); |
| int prevRawModifier = _prevOutput.getRawModifiers(row, column); |
| if (prevChar == char && prevRawModifier == rawModifier) continue; |
| } |
| |
| Modifier modifier = _output.getModifier(row, column); |
| switch (modifier) { |
| case Modifier.Undefined: |
| // Do nothing. |
| break; |
| case Modifier.Bold: |
| buffer.write("${CSI}1m"); |
| break; |
| case Modifier.Italic: |
| buffer.write("${CSI}3m"); |
| break; |
| case Modifier.Underline: |
| buffer.write("${CSI}4m"); |
| break; |
| } |
| |
| ForegroundColor foregroundColor = |
| _output.getForegroundColor(row, column); |
| switch (foregroundColor) { |
| case ForegroundColor.Undefined: |
| // Do nothing. |
| break; |
| case ForegroundColor.Black: |
| buffer.write("${CSI}30m"); |
| break; |
| case ForegroundColor.Red: |
| buffer.write("${CSI}31m"); |
| break; |
| case ForegroundColor.Green: |
| buffer.write("${CSI}32m"); |
| break; |
| case ForegroundColor.Yellow: |
| buffer.write("${CSI}33m"); |
| break; |
| case ForegroundColor.Blue: |
| buffer.write("${CSI}34m"); |
| break; |
| case ForegroundColor.Magenta: |
| buffer.write("${CSI}35m"); |
| break; |
| case ForegroundColor.Cyan: |
| buffer.write("${CSI}36m"); |
| break; |
| case ForegroundColor.White: |
| buffer.write("${CSI}37m"); |
| break; |
| } |
| |
| BackgroundColor backgroundColor = |
| _output.getBackgroundColor(row, column); |
| switch (backgroundColor) { |
| case BackgroundColor.Undefined: |
| // Do nothing. |
| break; |
| case BackgroundColor.Black: |
| buffer.write("${CSI}40m"); |
| break; |
| case BackgroundColor.Red: |
| buffer.write("${CSI}41m"); |
| break; |
| case BackgroundColor.Green: |
| buffer.write("${CSI}42m"); |
| break; |
| case BackgroundColor.Yellow: |
| buffer.write("${CSI}43m"); |
| break; |
| case BackgroundColor.Blue: |
| buffer.write("${CSI}44m"); |
| break; |
| case BackgroundColor.Magenta: |
| buffer.write("${CSI}45m"); |
| break; |
| case BackgroundColor.Cyan: |
| buffer.write("${CSI}46m"); |
| break; |
| case BackgroundColor.White: |
| buffer.write("${CSI}47m"); |
| break; |
| } |
| |
| if (char != null) { |
| buffer.write(char); |
| } else { |
| buffer.write(" "); |
| } |
| |
| // End old modifier. |
| buffer.write("${CSI}0m"); |
| |
| if (currentPosRow != row || currentPosColumn != column) { |
| // 1-indexed. |
| _setCursorPosition(row + 1, column + 1); |
| } |
| stdout.write(buffer.toString()); |
| buffer.clear(); |
| currentPosRow = row; |
| currentPosColumn = column + 1; |
| } |
| } |
| |
| _prevOutput = _output; |
| } |
| |
| // "ESC [" is "Control Sequence Introducer" (CSI) according to Wikipedia |
| // (https://en.wikipedia.org/wiki/ANSI_escape_code#Escape_sequences). |
| static const String CSI = "\x1b["; |
| |
| void _setCursorPosition(int row, int column) { |
| // "CSI n ; m H": Cursor Position. |
| stdout.write("${CSI}${row};${column}H"); |
| } |
| |
| void _gotoAlternativeScreenBuffer() { |
| // "CSI ? 1049 h": Enable alternative screen buffer. |
| stdout.write("${CSI}?1049h"); |
| } |
| |
| void _gotoMainScreenBuffer() { |
| // "CSI ? 1049 l": Disable alternative screen buffer. |
| stdout.write("${CSI}?1049l"); |
| } |
| |
| void _clearScreenAlt() { |
| _setCursorPosition(0, 0); |
| // "CSI n J": Erase in Display. Clears part of the screen. |
| // If n is 0 (or missing), clear from cursor to end of screen. |
| stdout.write("${CSI}0J"); |
| _setCursorPosition(0, 0); |
| } |
| |
| void _hideCursor() { |
| // "CSI ? 25 l": DECTCEM Hides the cursor. |
| stdout.write("${CSI}?25l"); |
| } |
| |
| void _showCursor() { |
| // "CSI ? 25 h": DECTCEM Shows the cursor, from the VT320. |
| stdout.write("${CSI}?25h"); |
| } |
| } |
| |
| abstract class Widget { |
| void print(WriteOnlyOutput output); |
| bool input(Application app, List<int> data); |
| } |
| |
| class BoxedWidget extends Widget { |
| final Widget _content; |
| BoxedWidget(this._content); |
| |
| @override |
| bool input(Application app, List<int> data) { |
| return _content?.input(app, data) ?? false; |
| } |
| |
| @override |
| void print(WriteOnlyOutput output) { |
| // Corners. |
| output.setCell(0, 0, char: /*"\u250c"*/ "\u250c"); |
| output.setCell(0, output.columns - 1, char: "\u2510"); |
| output.setCell(output.rows - 1, 0, char: "\u2514"); |
| output.setCell(output.rows - 1, output.columns - 1, char: "\u2518"); |
| |
| // Top and bottom line. |
| for (int i = 1; i < output.columns - 1; i++) { |
| output.setCell(0, i, char: "\u2500"); |
| output.setCell(output.rows - 1, i, char: "\u2500"); |
| } |
| |
| // Left and right line |
| for (int i = 1; i < output.rows - 1; i++) { |
| output.setCell(i, 0, char: "\u2502"); |
| output.setCell(i, output.columns - 1, char: "\u2502"); |
| } |
| |
| // Reduce all sides by one. |
| _content?.print(new WriteOnlyPartialOutput( |
| output, 1, 1, output.rows - 2, output.columns - 2)); |
| } |
| } |
| |
| class QuitOnQWidget extends Widget { |
| Widget _contentWidget; |
| |
| QuitOnQWidget(this._contentWidget); |
| |
| @override |
| void print(WriteOnlyOutput output) { |
| _contentWidget?.print(output); |
| } |
| |
| @override |
| bool input(Application app, List<int> data) { |
| if (data.length == 1 && String.fromCharCode(data[0]) == 'q') { |
| app.quit(); |
| return false; |
| } |
| return _contentWidget?.input(app, data) ?? false; |
| } |
| } |
| |
| class WithSingleLineBottomWidget extends Widget { |
| Widget _contentWidget; |
| Widget _bottomWidget; |
| |
| WithSingleLineBottomWidget(this._contentWidget, this._bottomWidget); |
| |
| @override |
| void print(WriteOnlyOutput output) { |
| // All but the last row. |
| _contentWidget?.print(new WriteOnlyPartialOutput( |
| output, 0, 0, output.rows - 1, output.columns)); |
| |
| // Only that last row. |
| _bottomWidget?.print(new WriteOnlyPartialOutput( |
| output, output.rows - 1, 0, 1, output.columns)); |
| } |
| |
| @override |
| bool input(Application app, List<int> data) { |
| bool result = _contentWidget?.input(app, data) ?? false; |
| result |= _bottomWidget?.input(app, data) ?? false; |
| return result; |
| } |
| } |
| |
| enum Modifier { |
| Undefined, |
| Bold, |
| Italic, |
| Underline, |
| } |
| |
| enum ForegroundColor { |
| Undefined, |
| Black, |
| Red, |
| Green, |
| Yellow, |
| Blue, |
| Magenta, |
| Cyan, |
| White, |
| } |
| |
| enum BackgroundColor { |
| Undefined, |
| Black, |
| Red, |
| Green, |
| Yellow, |
| Blue, |
| Magenta, |
| Cyan, |
| White, |
| } |
| |
| class _Output implements WriteOnlyOutput { |
| final int rows; |
| final int columns; |
| final Uint16List _text; |
| final Uint16List _modifiers; |
| |
| _Output(this.rows, this.columns) |
| : _text = new Uint16List(rows * columns), |
| _modifiers = new Uint16List(rows * columns); |
| |
| int getPosition(int row, int column) { |
| return row * columns + column; |
| } |
| |
| void setCell(int row, int column, |
| {String char, |
| Modifier modifier, |
| ForegroundColor foregroundColor, |
| BackgroundColor backgroundColor}) { |
| int position = getPosition(row, column); |
| |
| if (char != null) { |
| List<int> codeUnits = char.codeUnits; |
| assert(codeUnits.length == 1); |
| _text[position] = codeUnits.single; |
| } |
| |
| int outModifier = _modifiers[position]; |
| if (modifier != null) { |
| int mask = 0x03 << 8; |
| int value = (modifier.index & 0x03) << 8; |
| outModifier &= ~mask; |
| outModifier |= value; |
| } |
| if (foregroundColor != null) { |
| int mask = 0xF << 4; |
| int value = (foregroundColor.index & 0xF) << 4; |
| outModifier &= ~mask; |
| outModifier |= value; |
| } |
| if (backgroundColor != null) { |
| int mask = 0xF; |
| int value = (backgroundColor.index & 0xF); |
| outModifier &= ~mask; |
| outModifier |= value; |
| } |
| |
| _modifiers[position] = outModifier; |
| } |
| |
| String getChar(int row, int column) { |
| int position = getPosition(row, column); |
| int char = _text[position]; |
| if (char > 0) return new String.fromCharCode(char); |
| return null; |
| } |
| |
| int getRawModifiers(int row, int column) { |
| int position = getPosition(row, column); |
| return _modifiers[position]; |
| } |
| |
| Modifier getModifier(int row, int column) { |
| int position = getPosition(row, column); |
| int modifier = _modifiers[position]; |
| int value = (modifier >> 8) & 0x3; |
| return Modifier.values[value]; |
| } |
| |
| ForegroundColor getForegroundColor(int row, int column) { |
| int position = getPosition(row, column); |
| int modifier = _modifiers[position]; |
| int value = (modifier >> 4) & 0xF; |
| return ForegroundColor.values[value]; |
| } |
| |
| BackgroundColor getBackgroundColor(int row, int column) { |
| int position = getPosition(row, column); |
| int modifier = _modifiers[position]; |
| int value = modifier & 0xF; |
| return BackgroundColor.values[value]; |
| } |
| } |
| |
| abstract class WriteOnlyOutput { |
| int get rows; |
| int get columns; |
| void setCell(int row, int column, |
| {String char, |
| Modifier modifier, |
| ForegroundColor foregroundColor, |
| BackgroundColor backgroundColor}); |
| } |
| |
| class WriteOnlyPartialOutput implements WriteOnlyOutput { |
| final WriteOnlyOutput _output; |
| final int offsetRow; |
| final int offsetColumn; |
| final int rows; |
| final int columns; |
| WriteOnlyPartialOutput(this._output, this.offsetRow, this.offsetColumn, |
| this.rows, this.columns) { |
| if (offsetRow + rows > _output.rows || |
| offsetColumn + columns > _output.columns) { |
| throw "Out of bounds"; |
| } |
| } |
| |
| @override |
| void setCell(int row, int column, |
| {String char, |
| Modifier modifier, |
| ForegroundColor foregroundColor, |
| BackgroundColor backgroundColor}) { |
| if (row >= rows || column >= columns) return; |
| _output.setCell(row + offsetRow, column + offsetColumn, |
| char: char, |
| foregroundColor: foregroundColor, |
| backgroundColor: backgroundColor); |
| } |
| } |
