display.hpp

 
static size_t HistoryLineSize(const HistoryLine& line)
{
  size_t size = 0;
  while (size < MAX_LINE_SIZE && line[size] != '\0')
  {
    size++;
  }
  return size;
}
 
const HistoryLine& HistoryFromNewest(int index_from_newest)
{
  DEV_ASSERT(index_from_newest >= 0);
  DEV_ASSERT(index_from_newest < static_cast<int>(history_.Size()));
  return history_[-index_from_newest - 1];
}
 
void LineFeed()
{
  if (MODE == Mode::CRLF)
  {
    write_stream_ << ConstRawData("\r\n");
  }
  else if (MODE == Mode::LF)
  {
    write_stream_ << ConstRawData('\n');
  }
  else if (MODE == Mode::CR)
  {
    write_stream_ << ConstRawData('\r');
  }
}
 
void UpdateDisplayPosition()
{
  write_stream_ << ConstRawData(KEY_SAVE) << ConstRawData(CLEAR_BEHIND)
                << ConstRawData(&input_line_[input_line_.Size() + offset_], -offset_)
                << ConstRawData(KEY_LOAD);
}
 
bool CanDisplayChar() { return input_line_.EmptySize() > 1; }
 
bool CanDeleteChar() { return input_line_.Size() + offset_ > 0; }
 
void AddCharToInputLine(char data)
{
  if (offset_ == 0)
  {
    input_line_.Push(data);
  }
  else
  {
    input_line_.Insert(data, input_line_.Size() + offset_);
  }
  input_line_[input_line_.Size()] = '\0';
}
 
void DisplayChar(char data)
{
  bool use_history = false;
 
  if (history_index_ >= 0)
  {
    CopyHistoryToInputLine();
    use_history = true;
  }
 
  if (CanDisplayChar())
  {
    AddCharToInputLine(data);
    if (use_history)
    {
      ShowHistory();
    }
    else
    {
      write_stream_ << ConstRawData(input_line_[input_line_.Size() - 1 + offset_]);
    }
    if (offset_ != 0)
    {
      UpdateDisplayPosition();
    }
  }
  else
  {
    line_truncated_ = true;
  }
}
 
void RemoveCharFromInputLine()
{
  if (offset_ == 0)
  {
    input_line_.Pop();
  }
  else
  {
    input_line_.Delete(input_line_.Size() + offset_ - 1);
  }
  input_line_[input_line_.Size()] = '\0';
}
 
void DeleteChar()
{
  bool use_history = false;
 
  if (history_index_ >= 0)
  {
    CopyHistoryToInputLine();
    use_history = true;
  }
 
  if (CanDeleteChar())
  {
    RemoveCharFromInputLine();
    if (use_history)
    {
      ShowHistory();
    }
    else
    {
      write_stream_ << ConstRawData(DELETE_CHAR);
    }
 
    if (offset_ != 0)
    {
      UpdateDisplayPosition();
    }
  }
}
 
void ShowHeader()
{
  write_stream_ << ConstRawData(ramfs_.root_.GetName(), strlen(ramfs_.root_.GetName()));
  if (current_dir_ == &ramfs_.root_)
  {
    write_stream_ << ConstRawData(":/");
  }
  else
  {
    write_stream_ << ConstRawData(":") << ConstRawData(current_dir_->GetName());
  }
 
  write_stream_ << ConstRawData("$ ");
}
 
void ShowTruncatedLineNotice()
{
  char digits[20];
  size_t pos = sizeof(digits);
  size_t value = MAX_LINE_SIZE;
  do
  {
    digits[--pos] = static_cast<char>('0' + value % 10);
    value /= 10;
  } while (value != 0);
 
  write_stream_ << ConstRawData("Line truncated to ")
                << ConstRawData(&digits[pos], sizeof(digits) - pos)
                << ConstRawData(" characters (MAX_LINE_SIZE).");
  LineFeed();
}
 
void ClearLine() { write_stream_ << ConstRawData(CLEAR_LINE); }
 
void Clear() { write_stream_ << ConstRawData(CLEAR_ALL); }
 
void ShowHistory()
{
  ClearLine();
  ShowHeader();
  offset_ = 0;
  if (history_index_ >= 0)
  {
    const auto& line = HistoryFromNewest(history_index_);
    write_stream_ << ConstRawData(line.data(), HistoryLineSize(line));
  }
  else
  {
    write_stream_ << ConstRawData(&input_line_[0], input_line_.Size());
  }
}
 
void CopyHistoryToInputLine()
{
  input_line_.Reset();
  const auto& line = HistoryFromNewest(history_index_);
  for (size_t i = 0; i < HistoryLineSize(line); i++)
  {
    input_line_.Push(line[i]);
  }
  input_line_[input_line_.Size()] = '\0';
  history_index_ = -1;
  offset_ = 0;
  line_truncated_ = false;
}
 
void AddHistory()
{
  HistoryLine line{};
  const size_t line_size =
      LibXR::min(static_cast<size_t>(input_line_.Size()), MAX_LINE_SIZE);
  input_line_.Push('\0');
  if (line_size > 0)
  {
    std::memcpy(line.data(), &input_line_[0], line_size);
  }
  line[line_size] = '\0';
 
  if (history_.EmptySize() == 0)
  {
    history_.Pop();
  }
  history_.Push(line);
}