964 lines
28 KiB
C++
964 lines
28 KiB
C++
/*
|
|
TessesFramework a library to make C++ easier for me, used in CrossLang:
|
|
https://git.tesses.org/tesses50/crosslang Copyright (C) 2026 Mike Nolan
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "TessesFramework/Console.hpp"
|
|
#include "TessesFramework/Http/HttpUtils.hpp"
|
|
#include "TessesFramework/Text/StringConverter.hpp"
|
|
|
|
#if __has_include(<termios.h>)
|
|
#include <sys/ioctl.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
#if defined(_WIN32)
|
|
#include <cstdlib>
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
#include <limits>
|
|
|
|
namespace Tesses::Framework {
|
|
|
|
class ConsoleHelpers {
|
|
|
|
bool canon;
|
|
bool echo;
|
|
bool signals;
|
|
|
|
#if defined(_WIN32)
|
|
WORD colorFlags;
|
|
|
|
#endif
|
|
|
|
public:
|
|
ConsoleHelpers() {
|
|
canon = Console::GetCanonical();
|
|
echo = Console::GetEcho();
|
|
signals = Console::GetSignals();
|
|
#if defined(_WIN32)
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return;
|
|
CONSOLE_SCREEN_BUFFER_INFO bi;
|
|
|
|
GetConsoleScreenBufferInfo(hConsole, &bi);
|
|
|
|
colorFlags = bi.wAttributes;
|
|
|
|
#endif
|
|
}
|
|
|
|
void reset() {
|
|
#if defined(_WIN32)
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return;
|
|
SetConsoleTextAttribute(hConsole, colorFlags);
|
|
#else
|
|
if (Console::IsTTY()) {
|
|
printf("\x1b[0m");
|
|
fflush(stdout);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
~ConsoleHelpers() {
|
|
Console::SetCanonical(canon);
|
|
Console::SetEcho(echo);
|
|
Console::SetSignals(signals);
|
|
reset();
|
|
}
|
|
};
|
|
ConsoleHelpers consoleHelpers;
|
|
|
|
size_t Console::List(std::vector<std::string> &strs) {
|
|
if (!IsTTY())
|
|
return std::string::npos;
|
|
|
|
auto echo = Console::GetEcho();
|
|
auto canonical = Console::GetCanonical();
|
|
Console::SetEcho(false);
|
|
Console::SetCanonical(false);
|
|
size_t i = 0;
|
|
while (true) {
|
|
Console::Clear();
|
|
auto size = Console::GetSize();
|
|
// Console::SetBackgroundColor(ConsoleColor::CC_WHITE,true);
|
|
// Console::SetForegroundColor(ConsoleColor::CC_BLACK,true);
|
|
|
|
size_t page = size.second == 0 ? 0 : (i / (size.second));
|
|
size_t offsetInPage = size.second == 0 ? 0 : (i % (size.second));
|
|
|
|
for (int item = 0; item < size.second; ++item) {
|
|
if (item == offsetInPage) {
|
|
Console::SetInvertedColors(true);
|
|
} else {
|
|
Console::SetInvertedColors(false);
|
|
}
|
|
|
|
size_t myOffset = (size_t)item + page * (size.second);
|
|
|
|
if (myOffset < strs.size()) {
|
|
if (item == size.second - 1) {
|
|
Console::Write(strs[myOffset]);
|
|
} else {
|
|
Console::WriteLine(strs[myOffset]);
|
|
}
|
|
}
|
|
}
|
|
|
|
Console::SetInvertedColors(false);
|
|
|
|
int code = Console::Read();
|
|
|
|
if (code == 10)
|
|
break;
|
|
if (code == -1)
|
|
break;
|
|
|
|
if (code == 27) {
|
|
code = Console::Read();
|
|
if (code == 91) {
|
|
code = Console::Read();
|
|
if (code == 65) {
|
|
i--;
|
|
if (i >= strs.size())
|
|
i = strs.size() - 1;
|
|
} else if (code == 66) {
|
|
i++;
|
|
if (i >= strs.size())
|
|
i = 0;
|
|
} else if (code == -1)
|
|
break;
|
|
} else if (code == -1)
|
|
break;
|
|
}
|
|
}
|
|
Console::SetEcho(echo);
|
|
Console::SetCanonical(canonical);
|
|
Console::SetInvertedColors(false);
|
|
return i;
|
|
}
|
|
|
|
void Console::Reset() { consoleHelpers.reset(); }
|
|
|
|
#if defined(_WIN32)
|
|
static bool vt100_inverted = false;
|
|
static void _setcol(ConsoleColor col, bool alt, bool bg) {
|
|
if (bg) {
|
|
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return;
|
|
CONSOLE_SCREEN_BUFFER_INFO bi;
|
|
|
|
GetConsoleScreenBufferInfo(hConsole, &bi);
|
|
|
|
bi.wAttributes &= ~(BACKGROUND_RED | BACKGROUND_GREEN |
|
|
BACKGROUND_BLUE | BACKGROUND_INTENSITY);
|
|
|
|
if (col == ConsoleColor::CC_RED || col == ConsoleColor::CC_YELLOW ||
|
|
col == ConsoleColor::CC_MAGENTA || col == ConsoleColor::CC_WHITE)
|
|
bi.wAttributes |= BACKGROUND_RED;
|
|
|
|
if (col == ConsoleColor::CC_GREEN || col == ConsoleColor::CC_YELLOW ||
|
|
col == ConsoleColor::CC_CYAN || col == ConsoleColor::CC_WHITE)
|
|
bi.wAttributes |= BACKGROUND_GREEN;
|
|
|
|
if (col == ConsoleColor::CC_BLUE || col == ConsoleColor::CC_CYAN ||
|
|
col == ConsoleColor::CC_MAGENTA || col == ConsoleColor::CC_WHITE)
|
|
bi.wAttributes |= BACKGROUND_BLUE;
|
|
|
|
if (alt)
|
|
bi.wAttributes |= BACKGROUND_INTENSITY;
|
|
|
|
SetConsoleTextAttribute(hConsole, bi.wAttributes);
|
|
} else {
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return;
|
|
CONSOLE_SCREEN_BUFFER_INFO bi;
|
|
|
|
GetConsoleScreenBufferInfo(hConsole, &bi);
|
|
|
|
bi.wAttributes &= ~(FOREGROUND_RED | FOREGROUND_GREEN |
|
|
FOREGROUND_BLUE | FOREGROUND_INTENSITY);
|
|
|
|
if (col == ConsoleColor::CC_RED || col == ConsoleColor::CC_YELLOW ||
|
|
col == ConsoleColor::CC_MAGENTA || col == ConsoleColor::CC_WHITE)
|
|
bi.wAttributes |= FOREGROUND_RED;
|
|
|
|
if (col == ConsoleColor::CC_GREEN || col == ConsoleColor::CC_YELLOW ||
|
|
col == ConsoleColor::CC_CYAN || col == ConsoleColor::CC_WHITE)
|
|
bi.wAttributes |= FOREGROUND_GREEN;
|
|
|
|
if (col == ConsoleColor::CC_BLUE || col == ConsoleColor::CC_CYAN ||
|
|
col == ConsoleColor::CC_MAGENTA || col == ConsoleColor::CC_WHITE)
|
|
bi.wAttributes |= FOREGROUND_BLUE;
|
|
|
|
if (alt)
|
|
bi.wAttributes |= FOREGROUND_INTENSITY;
|
|
|
|
SetConsoleTextAttribute(hConsole, bi.wAttributes);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void Console::SetForegroundColor(ConsoleColor col, bool alt) {
|
|
|
|
if (!IsTTY())
|
|
return;
|
|
|
|
#if defined(_WIN32)
|
|
|
|
_setcol(col, alt, vt100_inverted);
|
|
|
|
#else
|
|
if (alt) {
|
|
printf("\x1b[%im", ((int)col) + 90); // this should be Write
|
|
} else {
|
|
printf("\x1b[%im", ((int)col) + 30); // this too
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void Console::SetBackgroundColor(ConsoleColor col, bool alt) {
|
|
if (!IsTTY())
|
|
return;
|
|
|
|
#if defined(_WIN32)
|
|
_setcol(col, alt, !vt100_inverted);
|
|
#else
|
|
if (alt) {
|
|
printf("\x1b[%im", ((int)col) + 100); // this should be Write
|
|
} else {
|
|
printf("\x1b[%im", ((int)col) + 40); // this too
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void Console::SetInvertedColors(bool inverted) {
|
|
if (!IsTTY())
|
|
return;
|
|
#if defined(_WIN32)
|
|
if (inverted != vt100_inverted) {
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return;
|
|
CONSOLE_SCREEN_BUFFER_INFO bi;
|
|
|
|
GetConsoleScreenBufferInfo(hConsole, &bi);
|
|
|
|
bi.wAttributes =
|
|
(bi.wAttributes & 0xFF00) |
|
|
((bi.wAttributes & (FOREGROUND_RED | FOREGROUND_GREEN |
|
|
FOREGROUND_BLUE | FOREGROUND_INTENSITY))
|
|
<< 4) |
|
|
((bi.wAttributes & (BACKGROUND_RED | BACKGROUND_GREEN |
|
|
BACKGROUND_BLUE | BACKGROUND_INTENSITY)) >>
|
|
4);
|
|
|
|
SetConsoleTextAttribute(hConsole, bi.wAttributes);
|
|
}
|
|
|
|
vt100_inverted = inverted;
|
|
#else
|
|
if (inverted)
|
|
Write("\x1b[7m");
|
|
else
|
|
Write("\x1b[27m");
|
|
|
|
Flush();
|
|
#endif
|
|
}
|
|
|
|
bool Console::SetEcho(bool echo) {
|
|
if (!IsTTY())
|
|
return false;
|
|
#if __has_include(<termios.h>)
|
|
struct termios raw;
|
|
if (tcgetattr(0, &raw) != 0)
|
|
return false;
|
|
if (echo) {
|
|
raw.c_lflag |= ECHO;
|
|
} else {
|
|
raw.c_lflag &= ~(ECHO);
|
|
}
|
|
|
|
if (tcsetattr(0, TCSAFLUSH, &raw) != 0)
|
|
return false;
|
|
|
|
#elif defined(_WIN32)
|
|
HANDLE hConsole = GetStdHandle(STD_INPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return false;
|
|
DWORD dwMode;
|
|
|
|
if (!GetConsoleMode(hConsole, &dwMode))
|
|
return false;
|
|
if (echo)
|
|
dwMode |= ENABLE_ECHO_INPUT;
|
|
else
|
|
dwMode &= ~(ENABLE_ECHO_INPUT);
|
|
if (SetConsoleMode(hConsole, dwMode))
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Console::GetEcho() {
|
|
if (!IsTTY())
|
|
return false;
|
|
#if __has_include(<termios.h>)
|
|
|
|
struct termios raw;
|
|
if (tcgetattr(0, &raw) != 0)
|
|
return true;
|
|
return (raw.c_lflag & ECHO) > 0;
|
|
#elif defined(_WIN32)
|
|
HANDLE hConsole = GetStdHandle(STD_INPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return false;
|
|
DWORD dwMode;
|
|
|
|
if (GetConsoleMode(hConsole, &dwMode)) {
|
|
return (dwMode & ENABLE_ECHO_INPUT) != 0;
|
|
}
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
bool Console::GetCanonical() {
|
|
if (!IsTTY())
|
|
return false;
|
|
#if __has_include(<termios.h>)
|
|
struct termios raw;
|
|
if (tcgetattr(0, &raw) != 0)
|
|
return false;
|
|
return (raw.c_lflag & ICANON) > 0;
|
|
#elif defined(_WIN32)
|
|
HANDLE hConsole = GetStdHandle(STD_INPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return false;
|
|
DWORD dwMode;
|
|
|
|
if (GetConsoleMode(hConsole, &dwMode)) {
|
|
return (dwMode & ENABLE_LINE_INPUT) != 0;
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Console::SetCanonical(bool can) {
|
|
if (!IsTTY())
|
|
return false;
|
|
#if __has_include(<termios.h>)
|
|
struct termios raw;
|
|
if (tcgetattr(0, &raw) != 0)
|
|
return false;
|
|
if (can) {
|
|
raw.c_lflag |= ICANON;
|
|
} else {
|
|
raw.c_lflag &= ~(ICANON);
|
|
}
|
|
|
|
if (tcsetattr(0, TCSAFLUSH, &raw) != 0)
|
|
return false;
|
|
|
|
#elif defined(_WIN32)
|
|
HANDLE hConsole = GetStdHandle(STD_INPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return false;
|
|
DWORD dwMode;
|
|
|
|
if (!GetConsoleMode(hConsole, &dwMode))
|
|
return false;
|
|
if (can)
|
|
dwMode |= ENABLE_LINE_INPUT;
|
|
else
|
|
dwMode &= ~(ENABLE_LINE_INPUT);
|
|
if (SetConsoleMode(hConsole, dwMode))
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
bool Console::GetSignals() {
|
|
if (!IsTTY())
|
|
return true;
|
|
#if __has_include(<termios.h>)
|
|
struct termios raw;
|
|
if (tcgetattr(0, &raw) != 0)
|
|
return false;
|
|
return (raw.c_lflag & ISIG) > 0;
|
|
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Console::SetSignals(bool sig) {
|
|
if (!IsTTY())
|
|
return false;
|
|
#if __has_include(<termios.h>)
|
|
struct termios raw;
|
|
if (tcgetattr(0, &raw) != 0)
|
|
return false;
|
|
if (sig) {
|
|
raw.c_lflag |= ISIG;
|
|
} else {
|
|
raw.c_lflag &= ~(ISIG);
|
|
}
|
|
|
|
if (tcsetattr(0, TCSAFLUSH, &raw) != 0)
|
|
return false;
|
|
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
// ISIG
|
|
|
|
std::string Console::ReadPassword() {
|
|
bool echo = GetEcho();
|
|
if (!SetEcho(false)) {
|
|
Write("\nWARN: the password will be visible: ");
|
|
}
|
|
std::string text = ReadLine();
|
|
SetEcho(echo);
|
|
Write("\n");
|
|
|
|
return text;
|
|
}
|
|
|
|
#if defined(_WIN32)
|
|
thread_local std::string key;
|
|
thread_local int keyOffset = -1;
|
|
#endif
|
|
|
|
int Console::Read() {
|
|
#if defined(WIN32)
|
|
if (keyOffset >= 0 && keyOffset < key.size()) {
|
|
return (int)key[keyOffset++];
|
|
} else {
|
|
keyOffset = -1;
|
|
}
|
|
if (!Console::GetCanonical()) {
|
|
|
|
HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
|
|
if (hIn == INVALID_HANDLE_VALUE)
|
|
return -1;
|
|
|
|
DWORD nRead;
|
|
|
|
INPUT_RECORD ir;
|
|
|
|
while (ReadConsoleInputW(hIn, &ir, 1, &nRead)) {
|
|
if (nRead == 0)
|
|
return -1;
|
|
if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown) {
|
|
if (ir.Event.KeyEvent.wVirtualKeyCode == VK_UP) {
|
|
key = {27, 91, 65};
|
|
keyOffset = 1;
|
|
return key[0];
|
|
} else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_DOWN) {
|
|
key = {27, 91, 66};
|
|
keyOffset = 1;
|
|
return key[0];
|
|
} else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_LEFT) {
|
|
key = {27, 91, 68};
|
|
keyOffset = 1;
|
|
return key[0];
|
|
} else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_RIGHT) {
|
|
key = {27, 91, 67};
|
|
keyOffset = 1;
|
|
return key[0];
|
|
} else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) {
|
|
return 27;
|
|
} else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_DELETE) {
|
|
key = {27, 91, 51, 126};
|
|
keyOffset = 1;
|
|
return key[0];
|
|
} else if (ir.Event.KeyEvent.wVirtualKeyCode == VK_RETURN) {
|
|
return 10;
|
|
}
|
|
|
|
else if (ir.Event.KeyEvent.uChar.UnicodeChar != 0) {
|
|
if (ir.Event.KeyEvent.uChar.UnicodeChar <= 127) {
|
|
return (int)ir.Event.KeyEvent.uChar.UnicodeChar;
|
|
} else if (ir.Event.KeyEvent.uChar.UnicodeChar >= 0xD800 &&
|
|
ir.Event.KeyEvent.uChar.UnicodeChar <= 0xDBFF) {
|
|
|
|
std::u16string str = {
|
|
{(char16_t)ir.Event.KeyEvent.uChar.UnicodeChar, 0}};
|
|
while (ReadConsoleInputW(hIn, &ir, 1, &nRead)) {
|
|
if (ir.EventType == KEY_EVENT &&
|
|
ir.Event.KeyEvent.bKeyDown) {
|
|
|
|
if (nRead == 0)
|
|
return -1;
|
|
if (ir.Event.KeyEvent.uChar.UnicodeChar >=
|
|
0xDC00 &&
|
|
ir.Event.KeyEvent.uChar.UnicodeChar <=
|
|
0xDFFF) {
|
|
str[1] =
|
|
(char16_t)
|
|
ir.Event.KeyEvent.uChar.UnicodeChar;
|
|
break;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
key.clear();
|
|
keyOffset = 1;
|
|
Tesses::Framework::Text::StringConverter::UTF8::
|
|
FromUTF16(key, str);
|
|
if (!key.empty())
|
|
return key[0];
|
|
return -1;
|
|
|
|
} else if (ir.Event.KeyEvent.uChar.UnicodeChar > 127) {
|
|
// normal unicode char
|
|
key.clear();
|
|
keyOffset = 1;
|
|
|
|
std::u16string str = {
|
|
{(char16_t)ir.Event.KeyEvent.uChar.UnicodeChar}};
|
|
|
|
Tesses::Framework::Text::StringConverter::UTF8::
|
|
FromUTF16(key, str);
|
|
|
|
if (!key.empty())
|
|
return key[0];
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
} else {
|
|
WCHAR chr;
|
|
DWORD chrRead;
|
|
HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
|
|
if (hIn == INVALID_HANDLE_VALUE)
|
|
return -1;
|
|
if (ReadConsoleW(hIn, &chr, 1, &chrRead, NULL)) {
|
|
if (chrRead == 0)
|
|
return -1;
|
|
|
|
if (chr <= 127)
|
|
return (int)chr;
|
|
else if (chr >= 0xD800 && chr <= 0xDBFF) {
|
|
std::u16string str = {{(char16_t)chr, 0}};
|
|
|
|
if (ReadConsoleW(hIn, &chr, 1, &chrRead, NULL)) {
|
|
if (chrRead == 0)
|
|
return -1;
|
|
if (chr >= 0xDC00 && chr <= 0xDFFF) {
|
|
str[1] = (char16_t)chr;
|
|
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
key.clear();
|
|
keyOffset = 1;
|
|
Tesses::Framework::Text::StringConverter::UTF8::FromUTF16(key,
|
|
str);
|
|
if (!key.empty())
|
|
return key[0];
|
|
return -1;
|
|
} else if (chr > 127) {
|
|
// normal unicode char
|
|
key.clear();
|
|
keyOffset = 1;
|
|
|
|
std::u16string str = {{(char16_t)chr}};
|
|
|
|
Tesses::Framework::Text::StringConverter::UTF8::FromUTF16(key,
|
|
str);
|
|
|
|
if (!key.empty())
|
|
return key[0];
|
|
return -1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
#else
|
|
int res = fgetc(stdin);
|
|
if (res == EOF)
|
|
return -1; // make sure it's -1
|
|
return res;
|
|
#endif
|
|
}
|
|
|
|
std::string Console::ReadLine() {
|
|
std::string text;
|
|
int c = Read();
|
|
while (c != '\n' && c != -1) {
|
|
text += (char)c;
|
|
|
|
c = Read();
|
|
}
|
|
if (!text.empty() && text.back() == '\r')
|
|
text.resize(text.size() - 1);
|
|
return text;
|
|
}
|
|
#if defined(_WIN32)
|
|
void writeTextWin32(HANDLE hndl, const std::string &text) {
|
|
std::u16string str = {};
|
|
|
|
Text::StringConverter::UTF16::FromUTF8(str, text);
|
|
|
|
auto buff = str.data();
|
|
DWORD left = (DWORD)str.size();
|
|
|
|
DWORD read = 0;
|
|
do {
|
|
|
|
if (WriteConsoleW(hndl, buff, left, &read, NULL)) {
|
|
buff += read;
|
|
left -= read;
|
|
}
|
|
} while (read > 0);
|
|
}
|
|
#else
|
|
void writeTextUnix(FILE *f, std::string_view view) {
|
|
size_t left = view.size();
|
|
const char *ptr = view.data();
|
|
size_t read = 0;
|
|
do {
|
|
read = fwrite(ptr, 1, left, f);
|
|
ptr += read;
|
|
left -= read;
|
|
} while (read != 0);
|
|
}
|
|
#endif
|
|
void Console::WriteToStream(std::string_view view, bool isStderr) {
|
|
#if defined(_WIN32)
|
|
HANDLE hOut = GetStdHandle(isStderr ? STD_ERROR_HANDLE : STD_OUTPUT_HANDLE);
|
|
if (hOut == INVALID_HANDLE_VALUE)
|
|
return;
|
|
std::string text;
|
|
|
|
for (size_t i = 0; i < view.size(); ++i) {
|
|
if (view[i] == '\x1b') {
|
|
if (!text.empty()) {
|
|
writeTextWin32(hOut, text);
|
|
// fwrite(text.c_str(), 1, text.size(), f);
|
|
text.clear();
|
|
}
|
|
i++;
|
|
if (i < view.size()) {
|
|
if (view[i] == '[') {
|
|
i++;
|
|
for (; i < view.size(); ++i) {
|
|
text += view[i];
|
|
if (view[i] >= 0x40 && view[i] <= 0x7e)
|
|
break;
|
|
}
|
|
if (text.size() > 0 && text.back() == 'H') {
|
|
MoveToHome();
|
|
}
|
|
if (text.size() > 0 && text.back() == 'J') {
|
|
if (text[0] == '2') {
|
|
ClearRetainPosition(
|
|
ClearBehaviour::CB_ENTIRESCREEN);
|
|
}
|
|
|
|
if (text[0] == '1') {
|
|
ClearRetainPosition(
|
|
ClearBehaviour::CB_CURSORANDABOVE);
|
|
}
|
|
if (text[0] == '0') {
|
|
ClearRetainPosition(
|
|
ClearBehaviour::CB_CURSORANDBELOW);
|
|
}
|
|
}
|
|
|
|
if (text.size() > 0 && text.back() == 'm') {
|
|
if (text.size() == 1) {
|
|
consoleHelpers.reset();
|
|
} else {
|
|
try {
|
|
auto num =
|
|
std::stol(text.substr(0, text.size() - 1));
|
|
if (num == 0)
|
|
consoleHelpers.reset();
|
|
if (num == 7)
|
|
Console::SetInvertedColors(true);
|
|
if (num == 27)
|
|
Console::SetInvertedColors(false);
|
|
if (num >= 30 && num <= 37) {
|
|
SetForegroundColor((ConsoleColor)(num - 30),
|
|
false);
|
|
} else if (num >= 40 && num <= 47) {
|
|
SetBackgroundColor((ConsoleColor)(num - 40),
|
|
false);
|
|
} else if (num >= 90 && num <= 97) {
|
|
SetForegroundColor((ConsoleColor)(num - 90),
|
|
true);
|
|
} else if (num >= 100 && num <= 107) {
|
|
SetBackgroundColor(
|
|
(ConsoleColor)(num - 100), true);
|
|
}
|
|
} catch (...) {
|
|
}
|
|
}
|
|
}
|
|
|
|
text.clear();
|
|
|
|
} else {
|
|
text += "\x1B";
|
|
text += view[i];
|
|
}
|
|
}
|
|
|
|
} else if (view[i] == '\n') {
|
|
text += "\r\n";
|
|
|
|
writeTextWin32(hOut, text);
|
|
text.clear();
|
|
} else {
|
|
text += view[i];
|
|
}
|
|
}
|
|
|
|
if (!text.empty()) {
|
|
|
|
writeTextWin32(hOut, text);
|
|
text.clear();
|
|
}
|
|
|
|
#else
|
|
writeTextUnix(isStderr ? stderr : stdout, view);
|
|
#endif
|
|
}
|
|
|
|
void Console::Write(std::string text) { WriteToStream(text, false); }
|
|
void Console::WriteLine(std::string text) {
|
|
Write(text);
|
|
Write("\n");
|
|
}
|
|
|
|
void Console::WriteLineView(std::string_view view) {
|
|
std::string lf = "\n";
|
|
WriteToStream(view, false);
|
|
WriteToStream(lf, false);
|
|
}
|
|
void Console::WriteView(std::string_view view) { WriteToStream(view, false); }
|
|
void Console::Error(std::string text) { WriteToStream(text, true); }
|
|
void Console::ErrorLine(std::string text) {
|
|
Error(text);
|
|
Error("\n");
|
|
}
|
|
|
|
void Console::ErrorLineView(std::string_view view) {
|
|
std::string lf = "\n";
|
|
WriteToStream(view, true);
|
|
WriteToStream(lf, true);
|
|
}
|
|
void Console::ErrorView(std::string_view view) { WriteToStream(view, true); }
|
|
bool Console::IsTTY() {
|
|
#if defined(_WIN32)
|
|
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hOut == INVALID_HANDLE_VALUE)
|
|
return false;
|
|
DWORD tmp;
|
|
if (GetConsoleMode(hOut, &tmp))
|
|
return true;
|
|
#elif __has_include(<termios.h>)
|
|
if (isatty(STDOUT_FILENO))
|
|
return true;
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
|
|
void Console::ProgressBar(double pdbl) {
|
|
bool showBar = IsTTY();
|
|
if (pdbl < 0)
|
|
pdbl = 0;
|
|
if (pdbl > 1)
|
|
pdbl = 1;
|
|
|
|
WriteView("\r");
|
|
if (showBar) {
|
|
auto sz = GetSize();
|
|
|
|
int totalBlocks = sz.first - 10;
|
|
if (totalBlocks > 0) {
|
|
WriteView("[\033[0;32m");
|
|
int i;
|
|
int off = pdbl * totalBlocks;
|
|
for (int i = 0; i < totalBlocks; i++) {
|
|
if (i < off)
|
|
WriteView("=");
|
|
else
|
|
WriteView(" ");
|
|
}
|
|
|
|
WriteView("\033[0m] ");
|
|
}
|
|
}
|
|
|
|
std::string mesg = Http::HttpUtils::LeftPad(
|
|
std::to_string((int)(pdbl * 100)) + "%", 4, ' ');
|
|
WriteView(mesg);
|
|
Flush();
|
|
}
|
|
void Console::ProgressBar(int v) { ProgressBar((double)v / 100.0); }
|
|
|
|
std::pair<int, int> Console::GetSize() {
|
|
if (!Console::IsTTY())
|
|
return std::pair<int, int>(0, 0);
|
|
|
|
#if __has_include(<termios.h>)
|
|
struct winsize ws;
|
|
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0) {
|
|
return std::make_pair<int, int>(ws.ws_col, ws.ws_row);
|
|
}
|
|
#elif defined(_WIN32)
|
|
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hConsole == INVALID_HANDLE_VALUE)
|
|
return std::make_pair<int, int>(0, 0);
|
|
CONSOLE_SCREEN_BUFFER_INFO bi;
|
|
|
|
GetConsoleScreenBufferInfo(hConsole, &bi);
|
|
|
|
return std::make_pair<int, int>(bi.srWindow.Right - bi.srWindow.Left + 1,
|
|
bi.srWindow.Bottom - bi.srWindow.Top + 1);
|
|
#endif
|
|
|
|
return std::make_pair<int, int>(0, 0);
|
|
}
|
|
|
|
void Console::SetPosition(int x, int y) {
|
|
if (!IsTTY())
|
|
return;
|
|
#if __has_include(<termios.h>)
|
|
printf("\x1B[%i;%iH", y + 1, x + 1);
|
|
#elif defined(_WIN32)
|
|
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hOut == INVALID_HANDLE_VALUE)
|
|
return;
|
|
COORD coord = {(SHORT)x, (SHORT)y};
|
|
SetConsoleCursorPosition(hOut, coord);
|
|
#else
|
|
printf("\x1B[%i;%iH", y + 1, x + 1);
|
|
Flush();
|
|
#endif
|
|
}
|
|
|
|
void Console::Flush() { fflush(stdout); }
|
|
|
|
void Console::Clear() {
|
|
ClearRetainPosition(ClearBehaviour::CB_ENTIRESCREEN);
|
|
MoveToHome();
|
|
}
|
|
|
|
void Console::ClearRetainPosition(ClearBehaviour cb) {
|
|
#if __has_include(<termios.h>)
|
|
if (isatty(STDOUT_FILENO)) {
|
|
printf("\x1b[%iJ", (int)cb);
|
|
Flush();
|
|
}
|
|
#elif defined(_WIN32)
|
|
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hOut == INVALID_HANDLE_VALUE)
|
|
return;
|
|
CONSOLE_SCREEN_BUFFER_INFO bi;
|
|
|
|
GetConsoleScreenBufferInfo(hOut, &bi);
|
|
|
|
switch (cb) {
|
|
case ClearBehaviour::CB_CURSORANDABOVE: {
|
|
COORD home = {0, 0};
|
|
|
|
DWORD cells =
|
|
((bi.dwCursorPosition.Y) * bi.dwSize.X) + bi.dwCursorPosition.X + 1;
|
|
DWORD written;
|
|
|
|
FillConsoleOutputCharacter(hOut, ' ', cells, home, &written);
|
|
FillConsoleOutputAttribute(hOut, bi.wAttributes, cells, home, &written);
|
|
|
|
} break;
|
|
case ClearBehaviour::CB_CURSORANDBELOW: {
|
|
if (bi.dwCursorPosition.X == 0) {
|
|
COORD home = bi.dwCursorPosition;
|
|
DWORD cells = bi.dwSize.X * (bi.dwSize.Y - bi.dwCursorPosition.Y);
|
|
DWORD written;
|
|
|
|
FillConsoleOutputCharacter(hOut, ' ', cells, home, &written);
|
|
FillConsoleOutputAttribute(hOut, bi.wAttributes, cells, home,
|
|
&written);
|
|
} else {
|
|
COORD home = bi.dwCursorPosition;
|
|
DWORD cells = bi.dwSize.X - home.X;
|
|
DWORD written;
|
|
|
|
FillConsoleOutputCharacter(hOut, ' ', cells, home, &written);
|
|
FillConsoleOutputAttribute(hOut, bi.wAttributes, cells, home,
|
|
&written);
|
|
|
|
if (home.Y + 1 < bi.dwSize.Y) {
|
|
home = {0, (SHORT)(bi.dwCursorPosition.Y + 1)};
|
|
cells = bi.dwSize.X * (bi.dwSize.Y - home.Y);
|
|
|
|
FillConsoleOutputCharacter(hOut, ' ', cells, home, &written);
|
|
FillConsoleOutputAttribute(hOut, bi.wAttributes, cells, home,
|
|
&written);
|
|
}
|
|
}
|
|
} break;
|
|
case ClearBehaviour::CB_ENTIRESCREEN: {
|
|
COORD home = {0, 0};
|
|
|
|
DWORD cells = bi.dwSize.X * bi.dwSize.Y;
|
|
DWORD written;
|
|
|
|
FillConsoleOutputCharacter(hOut, ' ', cells, home, &written);
|
|
FillConsoleOutputAttribute(hOut, bi.wAttributes, cells, home, &written);
|
|
} break;
|
|
}
|
|
|
|
#else
|
|
printf("\x1b[%iJ", (int)cb);
|
|
Flush();
|
|
#endif
|
|
}
|
|
void Console::MoveToHome() {
|
|
#if __has_include(<termios.h>)
|
|
if (isatty(STDOUT_FILENO)) {
|
|
Write("\x1b[H");
|
|
Flush();
|
|
}
|
|
#elif defined(_WIN32)
|
|
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if (hOut == INVALID_HANDLE_VALUE)
|
|
return;
|
|
SetConsoleCursorPosition(hOut, {0, 0});
|
|
#else
|
|
Write("\x1b[H");
|
|
Flush();
|
|
#endif
|
|
}
|
|
} // namespace Tesses::Framework
|