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)
  {
    ASSERT(index_from_newest >= 0);
    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();
      }
    }
  }
 
  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 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;
  }
 
  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);
  }