LocalIO.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "pedigree/kernel/debugger/LocalIO.h"
#include "pedigree/kernel/machine/Keyboard.h"
#include "pedigree/kernel/machine/Vga.h"
 
LocalIO::LocalIO(Vga* pVga, Keyboard* pKeyboard)
    : m_nWidth(80),
      m_nHeight(25),
      m_UpperCliLimit(0),
      m_LowerCliLimit(0),
      m_CursorX(0),
      m_CursorY(0),
      m_pVga(pVga),
      m_pKeyboard(pKeyboard) {
  initialise();
}
 
LocalIO::~LocalIO() {}
 
void LocalIO::initialise() {
  m_nWidth = 80;
  m_nHeight = 25;
  m_UpperCliLimit = 0;
  m_LowerCliLimit = 0;
  m_CursorX = 0;
  m_CursorY = 0;
  // Clear the framebuffer.
  for (size_t i = 0; i < MAX_CONSOLE_WIDTH * MAX_CONSOLE_HEIGHT; i++) {
    uint8_t attributeByte = (DebuggerIO::Black << 4) | (DebuggerIO::White & 0x0F);
    uint16_t blank = ' ' | (attributeByte << 8);
    m_pFramebuffer[i] = blank;
  }
  m_pCommand[0] = '\0';
 
  // Copy the current screen contents into our old frame buffer.
  m_pVga->peekBuffer(reinterpret_cast<uint8_t*>(m_pOldFramebuffer),
                     MAX_CONSOLE_WIDTH * MAX_CONSOLE_HEIGHT * 2);
  // Set a nice big text mode.
  m_pVga->setLargestTextMode();
 
  // Set our width and height variables.
  m_nWidth = m_pVga->getNumCols();
  m_nHeight = m_pVga->getNumRows();
}
 
void LocalIO::destroy() {
  // Copy our old frame buffer to the screen.
  m_pVga->pokeBuffer(reinterpret_cast<uint8_t*>(m_pOldFramebuffer),
                     MAX_CONSOLE_WIDTH * MAX_CONSOLE_HEIGHT * 2);
}
 
void LocalIO::setCliUpperLimit(size_t nlines) {
  // Do a quick sanity check.
  if (nlines < m_nHeight)
    m_UpperCliLimit = nlines;
 
  // If the cursor is now in an invalid area, move it back.
  if (m_CursorY < m_UpperCliLimit)
    m_CursorY = m_UpperCliLimit;
}
 
void LocalIO::setCliLowerLimit(size_t nlines) {
  // Do a quick sanity check.
  if (nlines < m_nHeight)
    m_LowerCliLimit = nlines;
 
  // If the cursor is now in an invalid area, move it back.
  if (m_CursorY >= m_nHeight - m_LowerCliLimit)
    m_CursorY = m_LowerCliLimit;
}
 
void LocalIO::enableCli() {
  // Clear the framebuffer.
  for (size_t i = 0; i < m_nWidth * m_nHeight; i++) {
    uint8_t attributeByte = (DebuggerIO::Black << 4) | (DebuggerIO::White & 0x0F);
    uint16_t blank = ' ' | (attributeByte << 8);
    m_pFramebuffer[i] = blank;
  }
  m_pCommand[0] = '\0';
 
  // Reposition the cursor.
  m_CursorX = 0;
  m_CursorY = m_UpperCliLimit;
 
  // We've enabled the CLI, so let's make sure the screen is ready.
  forceRefresh();
}
 
void LocalIO::disableCli() {
  // Clear the framebuffer.
  for (size_t i = 0; i < m_nWidth * m_nHeight; i++) {
    uint8_t attributeByte = (DebuggerIO::Black << 4) | (DebuggerIO::White & 0x0F);
    uint16_t blank = ' ' | (attributeByte << 8);
    m_pFramebuffer[i] = blank;
  }
 
  // Reposition the cursor.
  m_CursorX = 0;
  m_CursorY = m_UpperCliLimit;
 
  forceRefresh();
}
 
char LocalIO::getCharNonBlock() {
  return m_pKeyboard->getCharNonBlock();
}
 
char LocalIO::getChar() {
  return m_pKeyboard->getChar();
}
 
void LocalIO::drawHorizontalLine(char c, size_t row, size_t colStart, size_t colEnd,
                                 DebuggerIO::Colour foreColour, DebuggerIO::Colour backColour) {
  // colEnd must be bigger than colStart.
  if (colStart > colEnd) {
    size_t tmp = colStart;
    colStart = colEnd;
    colEnd = tmp;
  }
 
  if (colEnd >= m_nWidth)
    colEnd = m_nWidth - 1;
  if (static_cast<int32_t>(colStart) < 0)
    colStart = 0;
  if (row >= m_nHeight)
    row = m_nHeight - 1;
  if (static_cast<int32_t>(row) < 0)
    row = 0;
 
  uint8_t attributeByte = (backColour << 4) | (foreColour & 0x0F);
  for (size_t i = colStart; i <= colEnd; i++) {
    m_pFramebuffer[row * m_nWidth + i] = c | (attributeByte << 8);
  }
 
  if (m_bRefreshesEnabled)
    forceRefresh();
}
 
void LocalIO::drawVerticalLine(char c, size_t col, size_t rowStart, size_t rowEnd,
                               DebuggerIO::Colour foreColour, DebuggerIO::Colour backColour) {
  // rowEnd must be bigger than rowStart.
  if (rowStart > rowEnd) {
    size_t tmp = rowStart;
    rowStart = rowEnd;
    rowEnd = tmp;
  }
 
  if (rowEnd >= m_nHeight)
    rowEnd = m_nHeight - 1;
  if (static_cast<int32_t>(rowStart) < 0)
    rowStart = 0;
  if (col >= m_nWidth)
    col = m_nWidth - 1;
  if (static_cast<int32_t>(col) < 0)
    col = 0;
 
  uint8_t attributeByte = (backColour << 4) | (foreColour & 0x0F);
  for (size_t i = rowStart; i <= rowEnd; i++) {
    m_pFramebuffer[i * m_nWidth + col] = c | (attributeByte << 8);
  }
 
  if (m_bRefreshesEnabled)
    forceRefresh();
}
 
void LocalIO::drawString(const char* str, size_t row, size_t col, DebuggerIO::Colour foreColour,
                         DebuggerIO::Colour backColour) {
  // Now then, this is a lesson in cheating. Listen up.
  // Firstly we save the current cursorX and cursorY positions.
  size_t savedX = m_CursorX;
  size_t savedY = m_CursorY;
 
  // Then, we change cursorX and Y to be row, col.
  m_CursorX = col;
  m_CursorY = row;
 
  bool bRefreshWasEnabled = false;
  if (m_bRefreshesEnabled) {
    bRefreshWasEnabled = true;
    m_bRefreshesEnabled = false;
  }
 
  // Then, we just call putChar to put the string out for us! :)
  while (*str)
    putChar(*str++, foreColour, backColour);
 
  if (bRefreshWasEnabled) {
    m_bRefreshesEnabled = true;
    forceRefresh();
  }
 
  // And restore the cursor.
  m_CursorX = savedX;
  m_CursorY = savedY;
 
  // Ensure the cursor is correct in hardware.
  moveCursor();
}
 
void LocalIO::enableRefreshes() {
  m_bRefreshesEnabled = true;
  forceRefresh();
}
 
void LocalIO::disableRefreshes() {
  m_bRefreshesEnabled = false;
}
 
void LocalIO::forceRefresh() {
  m_pVga->pokeBuffer(reinterpret_cast<uint8_t*>(m_pFramebuffer), m_nWidth * m_nHeight * 2);
  moveCursor();
}
 
void LocalIO::scroll() {
  // Get a space character with the default colour attributes.
  uint8_t attributeByte = (DebuggerIO::Black << 4) | (DebuggerIO::White & 0x0F);
  uint16_t blank = ' ' | (attributeByte << 8);
  if (m_CursorY >= m_nHeight - m_LowerCliLimit) {
    for (size_t i = m_UpperCliLimit * m_nWidth; i < (m_nHeight - m_LowerCliLimit - 1) * m_nWidth;
         i++)
      m_pFramebuffer[i] = m_pFramebuffer[i + m_nWidth];
 
    for (size_t i = (m_nHeight - m_LowerCliLimit - 1) * m_nWidth;
         i < (m_nHeight - m_LowerCliLimit) * m_nWidth; i++)
      m_pFramebuffer[i] = blank;
 
    m_CursorY = m_nHeight - m_LowerCliLimit - 1;
  }
}
 
void LocalIO::moveCursor() {
  m_pVga->moveCursor(m_CursorX, m_CursorY);
}
 
void LocalIO::putChar(char c, DebuggerIO::Colour foreColour, DebuggerIO::Colour backColour) {
  // Backspace?
  if (c == 0x08) {
    // Can we just move backwards? or do we have to go up?
    if (m_CursorX)
      m_CursorX--;
    else {
      m_CursorX = m_nWidth - 1;
      m_CursorY--;
    }
 
    // Erase the contents of the cell currently.
    uint8_t attributeByte = (backColour << 4) | (foreColour & 0x0F);
    m_pFramebuffer[m_CursorY * m_nWidth + m_CursorX] = ' ' | (attributeByte << 8);
  }
 
  // Tab?
  else if (c == 0x09 && (((m_CursorX + 8) & ~(8 - 1)) < m_nWidth))
    m_CursorX = (m_CursorX + 8) & ~(8 - 1);
 
  // Carriage return?
  else if (c == '\r')
    m_CursorX = 0;
 
  // Newline?
  else if (c == '\n') {
    m_CursorX = 0;
    m_CursorY++;
  }
 
  // Normal character?
  else if (c >= ' ') {
    uint8_t attributeByte = (backColour << 4) | (foreColour & 0x0F);
    m_pFramebuffer[m_CursorY * m_nWidth + m_CursorX] = c | (attributeByte << 8);
 
    // Increment the cursor.
    m_CursorX++;
  }
 
  // Do we need to wrap?
  if (m_CursorX >= m_nWidth) {
    m_CursorX = 0;
    m_CursorY++;
  }
}
 
void LocalIO::cls() {
  // Clear the framebuffer.
  for (size_t i = 0; i < m_nWidth * m_nHeight; i++) {
    unsigned char attributeByte = (DebuggerIO::Black << 4) | (DebuggerIO::White & 0x0F);
    unsigned short blank = ' ' | (attributeByte << 8);
    m_pFramebuffer[i] = blank;
  }
}