AuroraRuntime/Source/Console/ConsoleTTY/ConsoleTTY.cpp

2453 lines
66 KiB
C++

/***
Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.
File: ConsoleTTY.cpp
Date: 2022-5-11
Author: Reece
***/
#define I_REALLY_NEED_WIDECHAR_PUBAPI // bc linux
#include <Source/RuntimeInternal.hpp>
#include <Source/Console/Console.hpp>
#include "ConsoleTTY.hpp"
#include <Source/Console/ConsoleStd/ConsoleStd.hpp>
#if defined(AURORA_IS_MODERNNT_DERIVED)
#include "ConsoleTTY.NT.hpp"
#endif
#if defined(AURORA_IS_POSIX_DERIVED)
#include "ConsoleTTY.Unix.hpp"
#endif
#if defined(AURORA_COMPILER_CLANG)
// warning: enumeration values 'kEnumCount' and 'kEnumInvalid' not handled in switch [-Wswitch
#pragma clang diagnostic ignored "-Wswitch"
// Yea, I don't give a shit.
#endif
#include "../ColorConvert.hpp"
namespace Aurora::Console::ConsoleTTY
{
static AuThreads::ThreadUnique_t gConsoleTTYThread;
static bool gMultiThreadTTY { true };
static bool gBuggyFastAppend { false };
#if 1
AuUInt32 GuessWidth(const AuString &referenceLine)
{
return AuUInt32(AuLocale::ConvertFromUTF8(referenceLine).size());
}
TTYConsoleField::TTYConsoleField(TTYConsole *pParent) :
pParent(pParent)
{
}
void TTYConsoleField::AddString(const AuString &input)
{
if (this->highlightStartInBytes)
{
this->Backspace();
}
if (this->noncanonicalCursorPosInBytes == this->inputField.size())
{
this->inputField += input;
}
else
{
auto itr = this->inputField.begin();
std::advance(itr, this->noncanonicalCursorPosInBytes);
this->inputField.insert(itr, input.begin(), input.end());
}
this->noncanonicalCursorPos += GuessWidth(input);
this->noncanonicalCursorPosInBytes += (int)input.size();
}
void TTYConsoleField::DoUnselectTick()
{
auto lastState = this->highlightStartInBytes.HasValue();
this->bIsSelecting = false;
AuResetMember(this->highlightEndInBytes);
AuResetMember(this->highlightEndInPos);
AuResetMember(this->highlightStartInBytes);
AuResetMember(this->highlightStart);
if (lastState)
{
this->pParent->SignalRedraw();
}
}
void TTYConsoleField::WriteBuffered(TTYConsole *pConsole, AuPair<AuUInt32, AuUInt32> pos)
{
if (this->highlightStartInBytes)
{
auto sViewZero = this->highlightStartInBytes.value() >= this->inputField.size() ?
this->inputField :
this->inputField.substr(0, this->highlightStartInBytes.value());
auto sViewOne = this->highlightStartInBytes.value() >= this->inputField.size() ? "" :
this->highlightEndInBytes.value() > this->inputField.size() ? "" :
this->inputField.substr(this->highlightStartInBytes.value(),
this->highlightEndInBytes.value() - this->highlightStartInBytes.value());
auto sViewTwo = this->highlightEndInBytes.value() < this->inputField.size() ?
this->inputField.substr(this->highlightEndInBytes.value()) :
"";
pConsole->WriteBufferedEx({ pos.first, pos.second }, AuConsole::EAnsiColor::eWhite, sViewZero);
pConsole->WriteBufferedEx({ pos.first + GuessWidth(sViewZero), pos.second }, AuConsole::EAnsiColor::eGreen, sViewOne);
pConsole->WriteBufferedEx({ pos.first + GuessWidth(sViewZero) + GuessWidth(sViewOne), pos.second }, AuConsole::EAnsiColor::eWhite, sViewTwo);
}
else
{
pConsole->WriteBuffered(pos, this->inputField);
}
}
void TTYConsoleField::Clear()
{
AuResetMember(this->highlightStartInBytes);
AuResetMember(this->highlightEndInBytes);
AuResetMember(this->highlightEndInPos);
AuResetMember(this->highlightStart);
AuResetMember(this->highlightChars);
this->inputField.clear();
this->noncanonicalCursorPos = 0;
this->noncanonicalCursorPosInBytes = 0;
}
bool TTYConsoleField::Backspace()
{
if (this->highlightStartInBytes)
{
int idx = highlightStartInBytes.value();
int endCnt = highlightEndInBytes.value() - idx;
auto sViewZero = this->inputField.substr(0, this->highlightStartInBytes.value());
auto sViewTwo = this->highlightEndInBytes.value() < this->inputField.size() ?
this->inputField.substr(this->highlightEndInBytes.value()) :
"";
this->inputField = sViewZero + sViewTwo;
this->noncanonicalCursorPos = this->highlightStart.value();
this->noncanonicalCursorPosInBytes = this->highlightStartInBytes.value();
DoUnselectTick();
}
else
{
if (this->noncanonicalCursorPosInBytes <= 0)
{
return false;
}
int idx = AuLocale::Encoding::CountUTF8Length({ this->inputField.data(), AuUInt(this->noncanonicalCursorPosInBytes - 1) }, true);
int endCnt = AuLocale::Encoding::CountUTF8Length({ this->inputField.data() + idx, this->inputField.size() - idx }, true);
if (!endCnt)
{
this->inputField.resize(idx);
}
else
{
auto suffix = inputField.substr(noncanonicalCursorPosInBytes);
this->inputField.resize(idx);
this->inputField += suffix;
}
this->noncanonicalCursorPos--;
this->noncanonicalCursorPosInBytes = idx;
}
return true;
}
void TTYConsoleField::DirectionalArrow(int iDirection, bool bShift, bool bControl)
{
if (this->bIsSelecting)
{
if (this->iLastDirection != iDirection)
{
this->iLastDirection = iDirection;
DoUnselectTick();
}
}
else if (bShift)
{
this->iLastDirection = iDirection;
}
this->bIsSelecting = bShift;
auto noncanonicalCursorPos = this->highlightStart ? this->highlightStart.value() : this->noncanonicalCursorPos;
auto noncanonicalCursorPosInBytes = this->highlightStart ? this->highlightStartInBytes.value() : this->noncanonicalCursorPosInBytes;
auto getCurrentChar = [=](int iOffset) -> int
{
auto uIndex = this->noncanonicalCursorPosInBytes + iOffset;
if (uIndex >= this->inputField.size()) return 4;
if (!(bool)isascii(this->inputField[uIndex]))
{
return 2;
}
if ((bool)::isupper(this->inputField[uIndex]))
{
return 1;
}
if (this->inputField[uIndex] == ' ' ||
this->inputField[uIndex] == '(' ||
this->inputField[uIndex] == ')' ||
this->inputField[uIndex] == ',')
{
return 0;
}
if ((bool)::isalpha(this->inputField[uIndex]))
{
return 6;
}
return 5;
};
bool bTickAgain {};
do
{
int iCurState;
int iNextState;
if (iDirection == 1)
{
iCurState = getCurrentChar(0);
Right();
iNextState = getCurrentChar(0);
}
else
{
iCurState = getCurrentChar(-1);
Left();
iNextState = getCurrentChar(-1);
}
if (bControl)
{
bTickAgain = iNextState == iCurState;
bTickAgain &= (((bool)this->noncanonicalCursorPos) &&
(this->noncanonicalCursorPosInBytes < this->inputField.size()));
}
}
while (bTickAgain);
if (this->bIsSelecting)
{
auto uEnd1 = AuMax(this->noncanonicalCursorPos, noncanonicalCursorPos);
auto uEnd2 = AuMax(this->noncanonicalCursorPosInBytes, noncanonicalCursorPosInBytes);
if (this->highlightEndInPos)
{
uEnd1 = AuMax(uEnd1, this->highlightEndInPos.value());
}
if (this->highlightEndInBytes)
{
uEnd2 = AuMax(uEnd1, this->highlightEndInBytes.value());
}
auto uStart1 = AuMin(this->noncanonicalCursorPos, noncanonicalCursorPos);
auto uStart2 = AuMin(this->noncanonicalCursorPosInBytes, noncanonicalCursorPosInBytes);
this->highlightStartInBytes = uStart2;
this->highlightEndInBytes = uEnd2;
this->highlightEndInPos = uEnd1;
this->highlightStart = uStart1;
this->highlightChars = AuLocale::Encoding::CountUTF8Length({ this->inputField.data() + uStart2, (AuUInt)uEnd2 - uStart2 }, false);
this->pParent->SignalRedraw();
}
else
{
DoUnselectTick();
}
}
void TTYConsoleField::Left()
{
if (this->noncanonicalCursorPosInBytes == 0)
{
return;
}
int idx = AuLocale::Encoding::CountUTF8Length({ this->inputField.data(), AuUInt(this->noncanonicalCursorPosInBytes - 1) },
true);
this->noncanonicalCursorPos--;
this->noncanonicalCursorPosInBytes = idx;
}
void TTYConsoleField::Right()
{
if (this->inputField.size() <= this->noncanonicalCursorPosInBytes)
{
return;
}
auto uAddend = AuLocale::Encoding::IterateUTF8({ &this->inputField[this->noncanonicalCursorPosInBytes],
this->inputField.size() - this->noncanonicalCursorPosInBytes });
this->noncanonicalCursorPos++;
this->noncanonicalCursorPosInBytes += uAddend;
}
TTYConsole::TTYConsole() :
inputField(this)
{
}
bool TTYConsole::IsShowingHintLine()
{
return false;
//return this->inputField.inputField.size();
}
void TTYConsole::Init()
{
this->HistorySetFile();
this->HistoryLoad();
}
void TTYConsole::Deinit()
{
this->End();
this->HistoryAppendChanges();
}
bool TTYConsole::Start()
{
if (!ConsoleStd::IsStdOutTTY())
{
return false;
}
gTTYConsoleEnabled = true;
#if defined(AURORA_IS_MODERNNT_DERIVED)
this->oldCP = GetConsoleOutputCP();
SetConsoleOutputCP(CP_UTF8);
#endif
#if defined(AURORA_IS_POSIX_DERIVED)
TTYWrite("\033[?1049h");
#endif
if (NoncanonicalMode())
{
ConsoleStd::EnterNoncanonicalMode();
}
#if defined(AURORA_IS_MODERNNT_DERIVED)
if (IsWin32UxMode())
{
UXModeStart();
}
#endif
return true;
}
void TTYConsole::End()
{
if (!AuExchange(gTTYConsoleEnabled, false))
{
return;
}
if (NoncanonicalMode())
{
ConsoleStd::LeaveNoncanonicalMode();
}
TTYClearScreen();
TTYClearLine(EAnsiColor::eReset);
#if defined(AURORA_IS_POSIX_DERIVED)
TTYWrite("\033[?1049l");
#endif
#if defined(AURORA_IS_MODERNNT_DERIVED)
SetConsoleOutputCP(this->oldCP);
#endif
if (!UTF8())
{
TTYWrite("\033(B");
}
#if defined(AURORA_IS_POSIX_DERIVED)
ConsoleStd::Unlock(); // just really making sure
#endif
ConsoleStd::Flush();
}
void TTYConsole::BufferMessage(const AuConsole::ConsoleMessage &msg)
{
AU_LOCK_GUARD(this->messageLock);
AuConsole::ConsoleMessage msg2(msg);
msg2.line = msg.ToConsole();
AuTryInsert(this->messagesPending, msg2); // TODO: !
}
void TTYConsole::BufferMessage(const AuConsole::ConsoleMessage &msg, const AuString &input)
{
AU_LOCK_GUARD(this->messageLock);
AuConsole::ConsoleMessage msg2(msg);
msg2.line = input;
AuTryInsert(this->messagesPending, msg2); // TODO: !
}
void TTYConsole::NoncanonicalTick()
{
ConsoleStd::NoncanonicalTick();
auto inputs = ConsoleStd::DequeueNoncanonicalInput();
if (inputs.size() && PermitDoubleBuffering())
{
BeginBuffering();
}
for (auto &input : inputs)
{
//AuLogDbg("[HANDLE] Key Stroke: {}, {}, {}. control: {}, alt: {}, shift: {}", ConsoleStd::ENoncanonicalInputToString(input.type), input.scrollDeltaY, input.string, input.isControlSequence, input.isAltSequence, input.isShiftSequence);
switch (input.type)
{
case ConsoleStd::ENoncanonicalInput::eInput:
{
NoncanonicalOnString(input.string);
break;
}
case ConsoleStd::ENoncanonicalInput::eBackspace:
{
NoncanonicalOnBackspace();
break;
}
case ConsoleStd::ENoncanonicalInput::eEnter:
{
NoncanonicalOnEnter();
break;
}
case ConsoleStd::ENoncanonicalInput::eArrowLeft:
{
NoncanonicalOnLeft(input.bIsShiftSequence || input.bIsAltSequence, input.bIsControlSequence);
break;
}
case ConsoleStd::ENoncanonicalInput::eArrowRight:
{
NoncanonicalOnRight(input.bIsShiftSequence || input.bIsAltSequence, input.bIsControlSequence);
break;
}
case ConsoleStd::ENoncanonicalInput::ePageDown:
{
NoncanonicalOnPageDown();
break;
}
case ConsoleStd::ENoncanonicalInput::ePageUp:
{
NoncanonicalOnPageUp();
break;
}
case ConsoleStd::ENoncanonicalInput::eArrowDown:
{
if (this->inputField.noncanonicalCursorPosInBytes == 0 ||
this->GetHintLines() == 0 ||
this->inputField.noncanonicalCursorPosInBytes == this->inputField.inputField.size())
{
NoncanonicalOnHistoryDown();
}
else
{
NoncanonicalOnMenuDown();
}
break;
}
case ConsoleStd::ENoncanonicalInput::eArrowUp:
{
if (this->inputField.noncanonicalCursorPosInBytes == 0 ||
this->GetHintLines() == 0 ||
this->inputField.noncanonicalCursorPosInBytes == this->inputField.inputField.size())
{
NoncanonicalOnHistoryUp();
}
else
{
NoncanonicalOnMenuUp();
}
break;
}
case ConsoleStd::ENoncanonicalInput::eScroll:
{
if (abs(input.iScrollDeltaY) == 1)
{
input.iScrollDeltaY = input.iScrollDeltaY * 3;
}
Scroll(input.iScrollDeltaY);
break;
}
default:
{
AuLogDbg("Key Stroke: {}, {}, {}", ConsoleStd::ENoncanonicalInputToString(input.type), input.iScrollDeltaY, input.string);
}
};
}
if (inputs.size() && PermitDoubleBuffering())
{
EndBuffering();
}
}
void TTYConsole::NoncanonicalOnString(const AuString &input)
{
inputField.AddString(input);
RedrawInput(true);
NoncanonicalSetCursor();
}
void TTYConsole::NoncanonicalOnLeft(bool bShift, bool bControl)
{
inputField.DirectionalArrow(-1, bShift, bControl);
NoncanonicalSetCursor();
}
void TTYConsole::NoncanonicalOnRight(bool bShift, bool bControl)
{
inputField.DirectionalArrow(1, bShift, bControl);
NoncanonicalSetCursor();
}
void TTYConsole::NoncanonicalOnBackspace()
{
if (!inputField.Backspace())
{
return;
}
RedrawInput(true);
NoncanonicalSetCursor();
}
bool TTYConsole::IsWin32UxMode()
{
return true;
}
void TTYConsole::UXModeStart()
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
LeaveScrollMode();
#endif
}
void TTYConsole::UXModeFlip()
{
if (AuExchange(uxModeFlipped, true))
{
return;
}
if (!IsWin32UxMode())
{
return;
}
#if defined(AURORA_IS_MODERNNT_DERIVED)
EnterScrollMode();
#endif
}
void EnterScrollMode()
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
DWORD mode;
HANDLE stream = GetStdHandle(STD_INPUT_HANDLE);
HANDLE handles2[2];
GetConsoleHandles(handles2);
{
GetConsoleMode(stream, &mode);
mode &= ~(ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS);
SetConsoleMode(stream, mode);
}
{
if (handles2[0] != INVALID_HANDLE_VALUE)
{
GetConsoleMode(handles2[0], &mode);
mode &= ~(ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS);
SetConsoleMode(handles2[0], mode);
}
}
{
if (handles2[1] != INVALID_HANDLE_VALUE)
{
GetConsoleMode(handles2[1], &mode);
mode &= ~(ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS);
SetConsoleMode(handles2[1], mode);
}
}
AuStaticCast<TTYConsole>(GetTTYConsole())->uxModeFlipped = true;
#endif
}
void LeaveScrollMode()
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
DWORD mode;
HANDLE stream = GetStdHandle(STD_INPUT_HANDLE);
HANDLE handles2[2];
GetConsoleHandles(handles2);
{
GetConsoleMode(stream, &mode);
mode |= ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS;
SetConsoleMode(stream, mode);
}
{
if (handles2[0] != INVALID_HANDLE_VALUE)
{
GetConsoleMode(handles2[0], &mode);
mode |= ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS;
SetConsoleMode(handles2[0], mode);
}
}
{
if (handles2[1] != INVALID_HANDLE_VALUE)
{
GetConsoleMode(handles2[1], &mode);
mode |= ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS;
SetConsoleMode(handles2[1], mode);
}
}
AuStaticCast<TTYConsole>(GetTTYConsole())->uxModeFlipped = true; // TODO?
#endif
}
void TTYConsole::NoncanonicalOnEnter()
{
AU_LOCK_GUARD(this->historyLock->AsWritable());
if (this->inputField.inputField.size())
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
if (this->inputField.inputField == "!s")
{
EnterScrollMode();
}
else if (this->inputField.inputField == "!c")
{
LeaveScrollMode();
}
else
#endif
if (this->inputField.inputField == "!b")
{
this->iScrollPos = -1;
this->bTriggerRedraw = true;
}
else if (this->inputField.inputField == "!t")
{
this->iScrollPos = 0;
this->bTriggerRedraw = true;
}
else
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
if (this->inputField.inputField == "help")
{
AuLogInfo("ConsoleTTY: Type !s to enter scroll mode, type !c to enter host-os controlled copy/paste mode (quick-edit)");
}
#endif
#if defined(AURORA_IS_POSIX_DERIVED)
if (this->inputField.inputField == "help")
{
AuLogInfo("ConsoleTTY: Hold control + arrow key up/down to scroll.");
}
#endif
if (this->inputField.inputField == "help")
{
AuLogInfo("ConsoleTTY: use the command !t to scroll to the top, the command !b to lock-scroll to the bottom.");
}
AuConsole::DispatchRawLine(this->inputField.inputField);
}
}
AuTryInsert(this->history, this->inputField.inputField);
this->inputField.Clear();
OnEnter();
}
void TTYConsole::NoncanonicalOnMenuLeft()
{
}
void TTYConsole::NoncanonicalOnMenuRight()
{
}
void TTYConsole::NoncanonicalOnMenuUp()
{
}
void TTYConsole::NoncanonicalOnMenuDown()
{
}
void TTYConsole::NoncanonicalOnHistoryUp()
{
bool locked {};
if (this->history.empty())
{
return;
}
if (this->inputField.noncanonicalCursorPos == 0 ||
this->inputField.noncanonicalCursorPosInBytes == this->inputField.inputField.size())
{
locked = true;
}
if (this->iHistoryPos == -1)
{
this->iHistoryPos = this->history.size();
}
this->iHistoryPos--;
if (this->iHistoryPos < 0)
{
this->iHistoryPos = 0;
}
this->inputField.inputField = this->history[this->iHistoryPos];
HistoryUpdateCursor();
if (locked)
{
this->inputField.noncanonicalCursorPos = GuessWidth(this->inputField.inputField);
this->inputField.noncanonicalCursorPosInBytes = (int)this->inputField.inputField.size();
NoncanonicalSetCursor();
}
this->inputField.DoUnselectTick();
}
void TTYConsole::NoncanonicalOnHistoryDown()
{
AU_LOCK_GUARD(this->historyLock->AsReadable());
bool locked {};
if (this->history.empty())
{
return;
}
if (this->inputField.noncanonicalCursorPos == 0 ||
this->inputField.noncanonicalCursorPosInBytes == this->inputField.inputField.size())
{
locked = true;
}
if (this->iHistoryPos == -1)
{
return;
}
this->iHistoryPos++;
if (this->iHistoryPos >= this->history.size())
{
this->iHistoryPos = -1;
this->inputField.inputField.clear();
}
else
{
this->inputField.inputField = this->history[this->iHistoryPos];
}
HistoryUpdateCursor();
if (locked)
{
this->inputField.noncanonicalCursorPos = GuessWidth(this->inputField.inputField);
this->inputField.noncanonicalCursorPosInBytes = (int)this->inputField.inputField.size();
NoncanonicalSetCursor();
}
this->inputField.DoUnselectTick();
}
void TTYConsole::HistoryUpdateCursor()
{
this->inputField.noncanonicalCursorPos = AuMin<AuUInt32>(this->inputField.noncanonicalCursorPos, GuessWidth(this->inputField.inputField));
this->inputField.noncanonicalCursorPosInBytes = AuMin<AuUInt32>(this->inputField.noncanonicalCursorPosInBytes, AuUInt32(this->inputField.inputField.size()));
RedrawInput(true);
NoncanonicalSetCursor();
}
void TTYConsole::HistorySetFile()
{
AuString path;
AuProcess::GetProcFullPath(path);
auto hash = AuFnv1a64Runtime(path.data(), path.size());
AuIOFS::NormalizePath(this->historyFileName, fmt::format("~/TTYHistory/{}.txt", hash));
}
AuString TTYConsole::HistoryGetFile()
{
return this->historyFileName;
}
void TTYConsole::HistoryAppendChanges()
{
if (!this->historyLock)
{
return;
}
AU_LOCK_GUARD(this->historyLock->AsWritable());
if (this->history.size() <= this->iHistoryWritePos)
{
return;
}
auto file = AuIOFS::OpenUnique(this->historyFileName, AuIOFS::EFileOpenMode::eReadWrite);
if (!file)
{
SysPushErrorIO(this->historyFileName);
return;
}
file->SetOffset(file->GetLength());
AuString buffer;
auto line = AuLocale::NewLine();
line.reserve(4096);
for (int i = this->iHistoryWritePos; i < this->history.size(); i++)
{
buffer += (i == 0 ? "" : line);
buffer += this->history[i];
}
AuUInt bytesWritten;
file->Write(AuMemoryViewStreamRead(AuMemory::MemoryViewRead(buffer), bytesWritten));
this->iHistoryWritePos = this->history.size();
}
void TTYConsole::HistoryLoad()
{
AU_LOCK_GUARD(this->historyLock->AsWritable());
if (this->historyFileName.empty())
{
return;
}
if (!AuIOFS::FileExists(this->historyFileName))
{
return;
}
AuString buffer;
if (!AuIOFS::ReadString(this->historyFileName, buffer))
{
return;
}
AuParse::SplitNewlines(buffer, [&](const AuString &in)
{
this->history.push_back(in);
});
this->iHistoryWritePos = this->history.size();
}
void TTYConsole::NoncanonicalOnPageUp()
{
this->Scroll(this->GetLogBoxLines());
}
void TTYConsole::NoncanonicalOnPageDown()
{
this->Scroll(-this->GetLogBoxLines());
}
void TTYConsole::Scroll(int delta)
{
auto maxLines = GetLogBoxLines();
if (this->screenBuffer.size() <= maxLines)
{
this->iScrollPos = -1;
return;
}
if (this->iScrollPos == -1)
{
this->iScrollPos = AuMax<AuUInt32>(this->screenBuffer.size() - maxLines, 0);
}
this->iScrollPos -= delta;
if (this->iScrollPos < 0)
{
this->iScrollPos = 0;
}
if (this->screenBuffer.size() - maxLines < this->iScrollPos )
{
this->iScrollPos = -1;
}
this->bTriggerRedraw = true;
}
void TTYConsole::PumpHistory()
{
static Aurora::Utility::RateLimiter limiter;
if (!limiter.nextTriggerTime)
{
limiter.noCatchUp = true;
limiter.SetNextStep(AuMSToNS<AuUInt64>(10'000));
}
if (!limiter.CheckExchangePass())
{
return;
}
HistoryAppendChanges();
}
void TTYConsole::Pump()
{
//SysBenchmark("Console TTY pump");
if (!gTTYConsoleEnabled)
{
return;
}
if (NoncanonicalMode())
{
//SysBenchmark("NoncanonicalTick");
NoncanonicalTick();
}
{
//SysBenchmark("flush (redraw)");
Flush();
}
{
//SysBenchmark("history");
PumpHistory();
}
}
void TTYConsole::OnEnter()
{
this->iHistoryPos = -1;
auto line = this->currentHeight;
this->inputField.Clear();
this->RedrawInput(true);
this->NoncanonicalSetCursor();
}
void TTYConsole::Flush()
{
AU_LOCK_GUARD(this->messageLock);
RedrawWindow();
}
bool TTYConsole::RegenerateBuffer(bool resChanged, bool &forceRedrawIfFalse)
{
auto messagesPending = AuExchange(this->messagesPending, {});
bool bShouldRegenerateStringArary {};
bool widthChanged = this->oldWidth != this->currentWidth;
bool sizeChanged = widthChanged || this->currentHeight != this->oldHeight;
// ew
auto maxLines = GetLogBoxLines();
int maxWidth = this->currentWidth - int(GetRightBorder()) - int(GetLeftBorder()) - int(this->leftLogPadding) - this->rightLogPadding;
// Word-wrap cancer
if (this->bScreenBufferDoesntMap)
{
if (resChanged)
{
bShouldRegenerateStringArary = widthChanged;
}
}
else
{
if (resChanged)
{
for (auto &[color, message] : this->screenBuffer)
{
int anyLineRemoveEsc = message.rfind('\x1b', 0) == 0;
if (message.size() - (anyLineRemoveEsc * 7) > maxWidth)
{
bShouldRegenerateStringArary = true;
break;
}
}
}
}
// Unsafe insert
this->messages.insert(this->messages.end(), messagesPending.begin(), messagesPending.end());
if (this->messages.size() > 10000)
{
this->messages.erase(this->messages.begin(), this->messages.end() - 10000);
}
// Insert console message while attempting to preserve the intention of word-wrapping
auto addMessages = [&](const AuList<AuConsole::ConsoleMessage> &messages)
{
for (auto &message : messages)
{
auto str = message.line; // Note: we replaced the line in BufferMessage
while (str.size())
{
int XOffset = GetLeftBorder() + this->leftLogPadding;
auto itr = str.npos;
itr = str.find('\t');
while (itr != str.npos)
{
auto suffix = str.substr(itr + 1);
str = str.substr(0, itr);
AuString padding(4 - (itr % 4), ' ');
str += padding;
str += suffix;
itr = str.find('\t', itr);
}
int anyLineRemoveEsc = str.rfind('\x1b', 0) == 0;
int idx = AuLocale::Encoding::CountUTF8Length({str.data(), AuMin<AuUInt>(str.size(), maxWidth + (anyLineRemoveEsc * 7))}, true);
auto append = str.substr(0, idx);
AuTryInsert(this->screenBuffer, AuMakePair(message.color, append));
str = str.substr(idx);
this->bScreenBufferDoesntMap |= bool(str.size());
}
}
if (this->screenBuffer.size() > maxLines)
{
UXModeFlip();
}
};
if (bShouldRegenerateStringArary)
{
// Recalculate our AuString array of lines
this->screenBuffer.clear();
addMessages(this->messages);
// Redraw entire screenbuffer
return true;
}
else
{
// Fast path - just append the damn changes
int oldSize = this->screenBuffer.size();
addMessages(messagesPending);
auto bannerLines = this->GetBannerLines();
auto indexBeforePadding = this->GetTopBorder() + this->GetBannerFootBorder() + (bannerLines ? this->topLogPadding + bannerLines : 0) ;
auto startIndex = this->topLogPaddingExtra + indexBeforePadding;
int drawPos = {};
auto delta = this->screenBuffer.size() - oldSize;
if (iScrollPos == -1)
{
if (this->screenBuffer.size() > maxLines)
{
// TODO (Reece): Removing optimization bc it was broken. This is a nightmare.
if (!gBuggyFastAppend)
{
static bool bSingleShot {};
if (!AuExchange(bSingleShot, true))
{
EnterScrollMode();
}
auto indexBeforePadding = (this->GetBannerFootBorder() ? 1 + this->topLogPadding : 0) + this->topLogPaddingExtra;
auto startIndex = this->GetTopBorder() + this->GetBannerLines() + indexBeforePadding;
for (int i = startIndex; i < this->currentHeight; i++)
{
this->BlankLine(i);
}
this->screenBuffer.clear();
addMessages(this->messages);
return true;
}
else
{
// this is still buggy as shit but we NEEEEED it
// youll notice whitespace appear as soon as we start overflowing but eh
for (int i = startIndex + maxLines; i < this->currentHeight; i++)
{
this->BlankLine(i);
}
TTYScrollBuffer(delta);
for (int i = indexBeforePadding; i < startIndex; i++)
{
this->BlankLine(i);
}
forceRedrawIfFalse = true;
drawPos = startIndex + maxLines - delta;
}
}
else
{
drawPos = startIndex + oldSize;
}
}
else
{
return false;
}
if (delta >= this->GetLogBoxLines())
{
return true;
}
else
{
for (int i = 0; i < delta; i++)
{
auto &[color, message] = this->screenBuffer[i + oldSize];
WriteBufferedEx({GetLeftBorder() + this->leftLogPadding, i + drawPos}, color, message);
}
}
return false || resChanged;
}
}
bool TTYConsole::UTF8()
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
return true;
#else
return AuLocale::GetLocale().codepage == AuLocale::ECodePage::eUTF8;
#endif
}
bool TTYConsole::RedrawWindow()
{
bool bTryAgain {};
bool bRedrawn = {};
bool bRefresh {};
do
{
bTryAgain = false;
bool bWarmed {};
#if defined(AURORA_IS_MODERNNT_DERIVED)
bWarmed = WarmBuffering();
#endif
auto pos = TTYScreenSize();
bool bChangedWidth = currentWidth != pos.first;
bool bChangedHeight = currentHeight != pos.second;
bool bChangedSize = bChangedWidth || bChangedHeight || bWarmed;
bool bRedrawWindowRequired = this->bTriggerRedraw;
bool bHasMesasgesPending = messagesPending.size() || this->bTriggerRedraw;
auto currentHash = AuFnv1a64Runtime(inputField.inputField.data(), inputField.inputField.size());
bool bInputChanged = NoncanonicalMode() && (lastInputHash != currentHash && lastInputHash != 0);
lastInputHash = currentHash;
oldWidth = currentWidth;
oldHeight = currentHeight;
currentWidth = pos.first;
currentHeight = pos.second;
if (currentWidth < 0)
{
bTryAgain = true;
continue;
}
bool redrawEntireBox {};
if (bChangedSize || bRedrawWindowRequired || bHasMesasgesPending)
{
bRedrawn = true;
if (PermitDoubleBuffering())
{
BeginBuffering();
}
if (NoncanonicalMode())
{
}
else
{
TTYStorePos();
}
if (bChangedSize || this->bTriggerRedraw)
{
TTYClearScreen();
bRefresh = true;
redrawEntireBox = true;
}
}
if (bChangedSize || bHasMesasgesPending)
{
bool redrawBox {};
bRefresh = bChangedSize || this->bTriggerRedraw;
if (RegenerateBuffer(bChangedSize, redrawBox) || this->bTriggerRedraw)
{
bRefresh = true;
redrawEntireBox = true;
RedrawLogBox();
}
bRefresh |= redrawBox;
}
if (redrawEntireBox)
{
RedrawLogBox();
}
if (bRefresh)
{
RedrawBanner();
RedrawBorders();
}
if (bRedrawn || bRefresh)
{
RedrawInput(NoncanonicalMode());
this->NoncanonicalSetCursor();
TTYStorePos();
}
if (bRedrawn || bRefresh)
{
RedrawHintLine();
}
#if 0
DebugLogArea();
#endif
if (bRedrawn || bRefresh)
{
if (NoncanonicalMode())
{
NoncanonicalSetCursor();
}
else
{
TTYRestorePos();
}
{
// Account for race conditions of size-change during draw
if (PermitDoubleBuffering())
{
bTryAgain = !EndBuffering();
}
}
}
this->bTriggerRedraw = false;
}
while (bTryAgain && false);
return bRedrawn;
}
void TTYConsole::DebugLogArea()
{
auto lines = this->GetLogBoxLines();
auto start = this->GetTopBorder() +
(this->GetBannerLines() ? this->GetBannerLines() + 1 : 0) +
(this->GetBannerFootBorder() ? this->topLogPadding : 0) +
this->topLogPaddingExtra;
AuString blank(this->currentWidth - GetRightBorder() - GetLeftBorder() - this->leftLogPadding - this->rightLogPadding, '~');
for (int i = 0; i < lines; i++)
{
WriteBuffered({GetLeftBorder() + this->leftLogPadding, i + start}, blank);
}
}
void TTYConsole::WriteLine(int Y, const AuString &in)
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
RecordFunction(std::bind(&TTYConsole::WriteLine, this, Y, std::string(in)));
#endif
if (in.empty())
{
return;
}
int XOffset {};
XOffset = GetLeftBorder();
#if defined(AURORA_IS_MODERNNT_DERIVED)
DWORD idc;
auto line2 = AuLocale::ConvertFromUTF8(in);
SetConsoleCursorPosition(GetTTYHandle(), COORD { AuStaticCast<short>(XOffset), AuStaticCast<short>(Y) });
WriteConsoleW(GetTTYHandle(), line2.data(), AuUInt32(line2.size()), &idc, NULL);
#else
TTYSetPos({XOffset, Y});
ConsoleStd::WriteStdOutBlocking2(in.data(), in.size());
#endif
}
void TTYConsole::BlankBordersLine(int Y)
{
AuString bar;
if (UTF8())
{
bar = "\xe2\x94\x82";
}
else
{
bar = "\033(0x\033(B";
}
WriteBuffered({0, Y}, bar);
WriteBuffered({this->currentWidth - 1, Y}, bar);
}
void TTYConsole::BlankLine(int Y, bool borders)
{
TTYSetPos({0, Y});
TTYClearLine(EAnsiColor::eReset);
BlankBordersLine(Y);
}
void TTYConsole::WriteBuffered(AuPair<AuUInt32, AuUInt32> pos, const AuString &in)
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
RecordFunction(std::bind(&TTYConsole::WriteBuffered, this, pos, std::string(in)));
#endif
if (in.empty())
{
return;
}
#if defined(AURORA_IS_MODERNNT_DERIVED)
DWORD idc;
auto line2 = AuLocale::ConvertFromUTF8(in);
SetConsoleCursorPosition(GetTTYHandle(), COORD { AuStaticCast<short>(pos.first), AuStaticCast<short>(pos.second) });
WriteConsoleW(GetTTYHandle(), line2.data(), AuUInt32(line2.size()), &idc, NULL);
#else
TTYSetPos(pos);
ConsoleStd::WriteStdOutBlocking2(in.data(), in.size());
#endif
}
void TTYConsole::WriteBufferedEx(AuPair<AuUInt32, AuUInt32> pos, EAnsiColor color, const AuString &in)
{
#if defined(AURORA_IS_MODERNNT_DERIVED)
RecordFunction(std::bind(&TTYConsole::WriteBufferedEx, this, pos, color, std::string(in)));
#endif
if (in.empty())
{
return;
}
#if defined(AURORA_IS_MODERNNT_DERIVED)
DWORD idc;
{
auto hConsole = GetTTYHandle();
DWORD attrib {};
if (color != EAnsiColor::eEnumCount)
{
attrib |= kAnsiColorForegroundToNT[AuStaticCast<AuUInt>(color)];
}
else
{
attrib = FOREGROUND_WHITE;
}
auto line2 = AuLocale::ConvertFromUTF8(in);
SetConsoleTextAttribute(hConsole, attrib);
SetConsoleCursorPosition(GetTTYHandle(), COORD { AuStaticCast<short>(pos.first), AuStaticCast<short>(pos.second) });
WriteConsoleW(hConsole, line2.data(), AuUInt32(line2.size()), &idc, NULL);
SetConsoleTextAttribute(hConsole, FOREGROUND_WHITE);
}
//WriteConsoleA(GetTTYHandle(), in.data(), AuUInt32(in.size()), &idc, NULL);
#else
TTYSetPos(pos);
AuString writeLine;
const char *pAnsiCode =
static_cast<EAnsiColor>(color) <= EAnsiColor::eEnumCount ?
kAnsiColorForegroundToVirtualEscape[static_cast<AuUInt>(color)] :
"";
writeLine = pAnsiCode + in + kAnsiColorForegroundToVirtualEscape[static_cast<AuUInt>(EAnsiColor::eReset)];
ConsoleStd::WriteStdOutBlocking2(writeLine.data(), writeLine.size());
#endif
}
void TTYConsole::RedrawBorders()
{
TTYSetPos({});
AuString start;
AuString end;
AuString bar;
AuString startLine;
AuString midLine;
AuString endLine;
startLine.clear();
if (!UTF8())
{
start = "\033(0";
end = "\033(B";
for (int i = 0; i < currentWidth; i++)
{
startLine += "q";
}
midLine = endLine = startLine;
if (GetLeftBorder())
{
startLine[0] = 'l';
}
if (GetRightBorder())
{
startLine[startLine.size() - 1] = 'k';
}
if (GetLeftBorder())
{
midLine[0] = 't';
}
if (GetRightBorder())
{
midLine[midLine.size() - 1] = 'u';
}
if (GetLeftBorder())
{
endLine[0] = 'm';
}
if (GetRightBorder())
{
endLine[endLine.size() - 1] = 'j';
}
bar = 'x';
}
else
{
AuString slash = "\xe2\x94\x80";
for (int i = GetLeftBorder(); i < currentWidth - int(GetRightBorder()); i++)
{
startLine += slash;
}
midLine = endLine = startLine;
if (GetLeftBorder())
{
startLine = "\xe2\x94\x8c" + startLine;
}
if (GetRightBorder())
{
startLine += "\xe2\x94\x90";
}
if (GetLeftBorder())
{
midLine = "\xe2\x94\x9c" + midLine;
}
if (GetRightBorder())
{
midLine += "\xe2\x94\xa4";
}
if (GetLeftBorder())
{
endLine = "\xe2\x94\x94" + endLine;
}
if (GetRightBorder())
{
endLine += "\xe2\x94\x98";
}
bar = "\xe2\x94\x82";
}
int height = currentHeight;
int widthM = currentWidth - 1;
// Begin drawing
WriteBuffered({}, start);
// Box: top
if (GetTopBorder())
{
WriteBuffered({}, Stringify(startLine, this->headerTitle, true, true, true));
}
// Box: sides
for (int i = GetTopBorder(); i < height - GetBottomBorder(); i++)
{
WriteBuffered({0, i}, bar);
WriteBuffered({widthM, i}, bar);
}
// Box: Bottom
if (GetBottomBorder())
{
WriteBuffered({0, height - 1}, endLine);
}
// Above hint splitter line
if (GetLogBoxHintBorder())
{
int l = this->GetHintLines();
// GetLogBoxHintBorder
WriteBuffered({0, this->currentHeight - (this->GetBottomBorder() + this->GetTextInputLines() + this->topInputPadding + this->GetLogBoxHintBorder() + (l ? (this->topHintPadding) : 0))}, midLine);
}
// Below subhead splitter line
if (this->GetBannerFootBorder())
{
int l = this->GetBannerLines();
if (l)
{
WriteBuffered({0, this->GetTopBorder() + this->GetBannerLines()}, Stringify(midLine, this->logTitle, true, true, true));
}
}
// End drawing mode
WriteBuffered({}, end);
}
const AuString &TTYConsole::Stringify(const AuString &referenceLine, const AlignedString &string, bool spacing, bool brackets, bool extraPadding)
{
if (string.str.empty())
{
return referenceLine;
}
this->tempMemory = referenceLine;
int lineWidth = this->currentWidth;
int stride = 1;
if (!referenceLine.empty())
{
if (UTF8())
{
stride = 3;
}
}
// HACK: if non-title, remove borders
// Before i'd drop the first & last char if line == width, but ofc this doesnt work with UTF8, and it'd pretty dumb to rely on an estimated char length
int L {}, R {};
if (!extraPadding)
{
lineWidth -= GetLeftBorder() * stride;
lineWidth -= GetRightBorder() * stride;
}
else
{
// Border offsets, if accounting for them.
L = GetLeftBorder();
R = GetRightBorder();
}
if (lineWidth < 0)
{
this->tempMemory.clear();
return this->tempMemory;
}
if (referenceLine.empty())
{
this->tempMemory = AuString(lineWidth, ' ');
}
int length = GuessWidth(string.str) + (brackets ? 2 : 0) + (spacing ? 2 : 0);
if (length > lineWidth)
{
return referenceLine;
}
int start {};
int padding2 = extraPadding ? 2 : 0;
// You're an idiot. you dont need a comment to work out what this does
switch (string.align)
{
case ETTYAlign::eLeft:
start = padding2 + L;
break;
case ETTYAlign::eRight:
start = lineWidth - (R + padding2 + length);
break;
case ETTYAlign::eCenter:
start = lineWidth / 2 - (length / 2);
break;
}
if (start + length + GetRightBorder() > this->currentWidth)
{
return referenceLine;
}
// In UTF8 mode, we fill the buffer of characters of a constant stride of 3
start *= stride;
if (start >= tempMemory.size())
{
return referenceLine;
}
// Brackets
AuString left;
AuString right;
if (brackets)
{
if (UTF8())
{
right = "\xe2\x94\x9c";
left = "\xe2\x94\xa4";
}
else
{
left = "u";
right = "t";
}
}
// Overhead to enter DEC drawing mode around the brackets on non-utf8 terminals
int DECOverhead = 0;
int DECOverheadA = 0;
int DECOverheadB = 0;
if (!UTF8())
{
DECOverheadA = DECOverheadB = 3;
DECOverhead = DECOverheadA + DECOverheadB;
}
// kanker
AuUInt toWrite = (brackets * stride) + DECOverheadA + spacing + string.str.size() + spacing + DECOverheadB + (brackets * stride);
AuUInt toSlice = stride * ((spacing * 2) + (brackets * 2) + string.str.size());
// brrr
if (toWrite <= toSlice)
{
// Fast path, pog. We dont need to allocate.
AuUInt strideTwo = brackets * stride;
if (toWrite < toSlice)
{
AuUInt second = start + strideTwo + DECOverheadA + spacing + string.str.size() + spacing + DECOverheadB + right.size();
AuUInt two = start + (length * strideTwo);
AuUInt count = this->tempMemory.size() - two;
AuMemmove(this->tempMemory.data() + second,
this->tempMemory.data() + two, this->tempMemory.size() - two);
this->tempMemory.resize(second + count);
}
if (brackets)
{
AuMemcpy(this->tempMemory.data() + start, left.data(), left.size());
}
if (spacing)
{
this->tempMemory.data()[start + strideTwo + DECOverheadA] = ' ';
}
if (DECOverheadA)
{
AuMemcpy(this->tempMemory.data() + strideTwo + DECOverheadA + spacing, "\033(B", 3);
}
AuMemcpy(this->tempMemory.data() + start + strideTwo + DECOverheadA + spacing, string.str.data(), string.str.size());
if (spacing)
{
this->tempMemory.data()[start + strideTwo + DECOverheadA + spacing + string.str.size() + DECOverheadB] = ' ';
}
if (DECOverheadB)
{
AuMemcpy(this->tempMemory.data() + start + strideTwo + DECOverheadA + spacing + string.str.size() + spacing, "\033(0", 3);
}
if (brackets)
{
AuMemcpy(this->tempMemory.data() + start + strideTwo + DECOverheadA + spacing + string.str.size() + spacing + DECOverheadB, right.data(), right.size());
}
}
else
{
// Slow allocation path
auto cpy = this->tempMemory; // alloc
AuString &ret = this->tempMemory;
auto begin = cpy.empty() ? "" : cpy.substr(0, start); // alloc
auto end = cpy.empty() ? "" : cpy.substr(start + (length * stride)); // alloc
ret = AuMove(begin);
ret.reserve(this->currentWidth * stride);
// potential allocs:
if (brackets)
{
ret += left;
}
if (DECOverheadA)
{
ret += "\033(B";
}
if (spacing)
{
ret += ' ';
}
ret += string.str;
if (spacing)
{
ret += ' ';
}
if (DECOverheadB)
{
ret += "\033(0";
}
if (brackets)
{
ret += right;
}
ret += AuMove(end);
return ret;
}
return this->tempMemory;
}
void TTYConsole::RedrawBanner()
{
if (this->header.str.size())
{
WriteLine(this->GetTopBorder() +
this->topHeaderPadding,
Stringify("", this->header, false, false, false));
}
if (this->subheader.str.size())
{
WriteLine(this->GetTopBorder() +
(this->header.str.size() ? 1 + this->topHeaderPadding : 0) +
(this->midHeaderPadding),
Stringify("", this->subheader, false, false, false));
}
}
void TTYConsole::RedrawLogBox()
{
auto indexBeforePadding = (this->GetBannerFootBorder() ? 1 + this->topLogPadding : 0) + this->topLogPaddingExtra;
auto startIndex = this->GetTopBorder() + this->GetBannerLines() + indexBeforePadding;
//auto startIndex2 = this->topLogPaddingExtra + indexBeforePadding;
int drawPos = startIndex;
auto maxLines = GetLogBoxLines();
for (int i = startIndex + maxLines; i < this->currentHeight; i++)
{
this->BlankLine(i);
}
auto startingLineBufferIndex = 0;
if (iScrollPos == -1)
{
if (this->screenBuffer.size() > maxLines)
{
startingLineBufferIndex = this->screenBuffer.size() - maxLines;
}
else
{
startingLineBufferIndex = 0;
}
}
else
{
startingLineBufferIndex = iScrollPos;
}
for (int i = 0; i < maxLines; i++)
{
auto strIdx = i + startingLineBufferIndex;
if (strIdx >= this->screenBuffer.size())
{
break;
}
auto &[color, message] = this->screenBuffer[strIdx];
WriteBufferedEx({ GetLeftBorder() + this->leftLogPadding, i + drawPos }, color, message);
//WriteBuffered({GetLeftBorder() + this->leftLogPadding, i + startIndex}, this->screenBuffer[strIdx].second);
}
}
void TTYConsole::BlankLogBox()
{
}
void TTYConsole::RedrawInput(bool clear)
{
int height = this->currentHeight - (1 + this->GetBottomBorder());
if (clear)
{
BlankLine(height);
}
WriteBuffered({this->GetLeftBorder() + this->leftPadding, height}, ">");
if (clear && NoncanonicalMode())
{
this->inputField.WriteBuffered(this, { this->GetLeftBorder() + this->leftPadding + 1, height });
}
}
void TTYConsole::RedrawHintLine()
{
}
int TTYConsole::GetHintLines()
{
return this->hintStrings.size();
}
bool TTYConsole::GetLogBoxHintBorder()
{
return true;
}
bool TTYConsole::GetBottomBorder()
{
return true;
}
ETTYAlign TTYConsole::GetTitleAlignment()
{
return this->headerTitle.align;
}
ETTYAlign TTYConsole::SetTitleAlignment(ETTYAlign newValue)
{
return AuExchange(this->headerTitle.align, newValue);
}
ETTYAlign TTYConsole::GetLogBoxTitleAlignment()
{
return this->logTitle.align;
}
ETTYAlign TTYConsole::SetLogBoxTitleAlignment(ETTYAlign newValue)
{
return AuExchange(this->logTitle.align, newValue);
}
ETTYAlign TTYConsole::GetHeaderAlignment()
{
return this->header.align;
}
ETTYAlign TTYConsole::GetSubheaderAlignment()
{
return this->subheader.align;
}
AuString TTYConsole::GetHeaderBorderTitle()
{
return this->headerTitle.str;
}
AuString TTYConsole::GetLogBoxBorderTitle()
{
return this->logTitle.str;
}
AuString TTYConsole::GetHeader()
{
return this->header.str;
}
AuString TTYConsole::GetSubHeader()
{
return this->subheader.str;
}
ETTYAlign TTYConsole::SetHeaderAlignment(ETTYAlign newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->header.align, newValue);
}
ETTYAlign TTYConsole::SetSubheaderAlignment(ETTYAlign newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->subheader.align, newValue);
}
AuString TTYConsole::SetHeaderBorderTitle(const AuString &newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->headerTitle.str, newValue);
}
AuString TTYConsole::SetLogBoxBorderTitle(const AuString &newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->logTitle.str, newValue);
}
AuString TTYConsole::SetHeader(const AuString &newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->header.str, newValue);
}
AuString TTYConsole::SetSubHeader(const AuString &newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->subheader.str, newValue);
}
bool TTYConsole::SetTopBorder(bool newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->bTopBorder, newValue);
}
bool TTYConsole::SetLeftBorder(bool newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->bLeftBorder, newValue);
}
bool TTYConsole::SetRightBorder(bool newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->bRightBorder, newValue);
}
int TTYConsole::GetBannerLines()
{
int ret = !this->header.str.empty() + !this->subheader.str.empty();
if (!ret)
{
return 0;
}
return ret + this->midHeaderPadding + (this->header.str.size() ? this->topHeaderPadding : 0) + (this->subheader.str.size() ? this->bottomSubHeaderPadding : 0);
}
int TTYConsole::GetLogBoxLines()
{
int hintLines = this->GetHintLines();
int bannerLines = this->GetBannerLines();
//
return this->currentHeight - (this->GetTopBorder() +
//////////////////
bannerLines +
//////////////////
(bannerLines ? 1 /* splitter */ + this->topLogPadding : 0) +
this->topLogPaddingExtra +
GetLogBoxHintBorder() +
//////////////////////////////
1 +
(bool(hintLines) ? (hintLines + this->topHintPadding) : 0) +
this->topInputPadding +
//////////////////////////////
this->GetTextInputLines() +
//////////////////////////////
this->GetBottomBorder());
}
int TTYConsole::GetTextInputLines()
{
return 1;
}
bool TTYConsole::GetBannerFootBorder()
{
return this->header.str.size() || this->subheader.str.size();
}
bool TTYConsole::GetTopBorder()
{
return this->bTopBorder;
}
bool TTYConsole::GetRightBorder()
{
return this->bRightBorder;
}
bool TTYConsole::GetLeftBorder()
{
return this->bLeftBorder;
}
bool TTYConsole::NoncanonicalMode()
{
return ConsoleStd::IsStdOutTTY();
}
bool TTYConsole::PermitDoubleBuffering()
{
// We can't double buffer and not share the input line between two framebuffers
#if defined(AURORA_IS_MODERNNT_DERIVED)
return NoncanonicalMode();
#endif
return true;
}
AuPair<AuUInt32, AuUInt32> TTYConsole::GetLogBoxStart()
{
return {this->GetLeftBorder(), this->GetTopBorder() + this->GetBannerLines() + this->GetBannerFootBorder()};
}
AuPair<AuUInt32, AuUInt32> TTYConsole::GetHintLine()
{
int hintLines = this->GetHintLines();
return {this->GetLeftBorder(), this->currentHeight - (1 + hintLines + bool(hintLines) + this->GetBottomBorder() + this->GetTextInputLines())};
}
AuPair<AuUInt32, AuUInt32> TTYConsole::GetInputCursor()
{
if (!this->NoncanonicalMode())
{
return {this->GetLeftBorder() + this->leftPadding + 1 + this->leftInputPadding, this->currentHeight - (1 + this->GetBottomBorder())};
}
return {this->GetLeftBorder() + this->leftPadding + 1 + this->leftInputPadding + (this->inputField.noncanonicalCursorPos == -1 ? 0 : this->inputField.noncanonicalCursorPos) /*:(*/, this->currentHeight - (1 + this->GetBottomBorder())}; // { i do not like this, ...}
}
AuPair<AuUInt32, AuUInt32> TTYConsole::GetInitialInputLine()
{
return {};
}
void TTYConsole::NoncanonicalSetCursor()
{
TTYSetPos(this->GetInputCursor());
}
void TTYConsole::SetHintStrings(const AuList<AuPair<AuString /*autocompletion*/, AuList<AuString/* secondary hint*/>>> &hints)
{
this->hintStrings = AuMove(hints);
}
bool TTYConsole::CheckRedraw()
{
return {};
}
void TTYConsole::SetInitialCursorPos()
{
}
void TTYConsole::PostRedraw(bool first)
{
if (first)
{
SetInitialCursorPos();
//AuConsole::TTYSetPos()
}
else if (NoncanonicalMode())
{
}
}
AuUInt8 TTYConsole::SetPaddingLeftOfLog(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->leftLogPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingRightOfLog(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->rightLogPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingLeftOfInput(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->leftInputPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingTopOfInput(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->topInputPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingTopOfHint(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->topHintPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingTopOfHeader(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->topHeaderPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingMidOfHeader(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->midHeaderPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingBottomOfSubheader(AuUInt8 newValue)
{
this->bTriggerRedraw = true;
return AuExchange(this->bottomSubHeaderPadding, newValue);
}
AuUInt8 TTYConsole::GetPaddingLeftOfLog()
{
return this->leftLogPadding;
}
AuUInt8 TTYConsole::GetPaddingRightOfLog()
{
return this->rightLogPadding;
}
AuUInt8 TTYConsole::GetPaddingLeftOfInput()
{
return this->leftInputPadding;
}
AuUInt8 TTYConsole::GetPaddingTopOfInput()
{
return this->topInputPadding;
}
AuUInt8 TTYConsole::GetPaddingTopOfHint()
{
return this->topHintPadding;
}
AuUInt8 TTYConsole::GetPaddingTopOfHeader()
{
return this->topHeaderPadding;
}
AuUInt8 TTYConsole::GetPaddingMidOfHeader()
{
return this->midHeaderPadding;
}
AuUInt8 TTYConsole::GetPaddingBottomOfSubheader()
{
return this->bottomSubHeaderPadding;
}
AuUInt8 TTYConsole::SetPaddingHeadOfLog(AuUInt8 newValue)
{
return AuExchange(this->topLogPadding, newValue);
}
AuUInt8 TTYConsole::SetPaddingTopOfLog(AuUInt8 newValue)
{
return AuExchange(this->topLogPaddingExtra, newValue);
}
AuUInt8 TTYConsole::GetPaddingHeadOfLog()
{
return this->topLogPadding;
}
AuUInt8 TTYConsole::GetPaddingTopOfLog()
{
return this->topLogPaddingExtra;
}
static void MainTTY()
{
while (AuIsThreadRunning())
{
AuThreading::Sleep(1000 / 20);
gTTYConsole.Pump();
}
}
void Init()
{
if (!gRuntimeConfig.console.enableConsole)
{
return;
}
gTTYConsole.Init();
if (gMultiThreadTTY && !gConsoleTTYThread)
{
gConsoleTTYThread = AuThreads::ThreadUnique(AuThreads::ThreadInfo(
AuMakeShared<AuThreads::IThreadVectorsFunctional>(AuThreads::IThreadVectorsFunctional::OnEntry_t(std::bind(MainTTY)),
AuThreads::IThreadVectorsFunctional::OnExit_t {}),
"ConsoleTTY pumper (win32 is slow as shit ok?)"
));
if (!gConsoleTTYThread)
{
gMultiThreadTTY = false;
return;
}
gConsoleTTYThread->SetThrottle(AuThreads::EThreadThrottle::eEfficient);
gConsoleTTYThread->SetPriority(AuThreads::EThreadPriority::ePrioHigh);
gConsoleTTYThread->Run();
}
}
void Exit()
{
gTTYConsole.Deinit();
}
void WriteTTYOut(const AuConsole::ConsoleMessage &msg)
{
gTTYConsole.BufferMessage(msg);
}
void WriteTTYOut(const AuConsole::ConsoleMessage &msg, const AuString &input)
{
gTTYConsole.BufferMessage(msg, input);
}
void Pump()
{
// :(
if (!gMultiThreadTTY)
{
gTTYConsole.Pump();
}
}
void PumpForce()
{
// no more force deinit for.now:
gConsoleTTYThread.reset();
gTTYConsole.Pump();
}
AUKN_SYM AuSPtr<ITTYConsole> GetTTYConsole()
{
return AuUnsafeRaiiToShared<ITTYConsole>(&gTTYConsole);
}
void OnEnter()
{
if (gTTYConsoleEnabled)
{
gTTYConsole.OnEnter();
}
}
#else
void Init()
{
}
void Pump()
{
}
void PumpForce()
{
}
void Exit()
{
}
void WriteTTYOut(const AuConsole::ConsoleMessage &msg, const AuString &input)
{
}
AUKN_SYM AuSPtr<ITTYConsole> GetTTYConsole()
{
return {};
}
void OnEnter()
{
}
#endif
}