tui.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 <Font.h>
#include <Terminal.h>
#include <Xterm.h>
#include <signal.h>
#include <stdint.h>
#include <string.h>
#include <tui.h>
#include <unistd.h>
 
#include <pedigree/log.h>
#include <sys/select.h>
 
struct TuiLocal {
  Terminal* pTerminal = nullptr;
 
  size_t nWidth = 0;
  size_t nHeight = 0;
 
  bool bKeyPressed = false;
  bool bRunning = false;
 
  cairo_t* pCairo = nullptr;
  cairo_surface_t* pSurface = nullptr;
 
  Font* pNormalFont = nullptr;
  Font* pBoldFont = nullptr;
};
 
Tui::Tui(TuiRedrawer* pRedrawer)
    : m_LocalData(nullptr), m_pWidget(nullptr), m_pRedrawer(pRedrawer) {
  m_LocalData = new TuiLocal;
}
 
Tui::Tui(Widget* widget) : Tui(static_cast<TuiRedrawer*>(nullptr)) {
  m_pWidget = widget;
}
 
Tui::~Tui() {
  delete m_LocalData->pTerminal;
  delete m_LocalData->pBoldFont;
  delete m_LocalData->pNormalFont;
 
  cairo_surface_destroy(m_LocalData->pSurface);
  cairo_destroy(m_LocalData->pCairo);
 
  delete m_LocalData;
}
 
bool Tui::initialise(size_t width, size_t height) {
  m_LocalData->nWidth = width;
  m_LocalData->nHeight = height;
 
  if (!m_LocalData->pCairo) {
    pedigree_log(LOG_ALERT, "TUI: cairo instance is not yet valid!");
    return false;
  }
 
  cairo_set_line_cap(m_LocalData->pCairo, CAIRO_LINE_CAP_SQUARE);
  cairo_set_line_join(m_LocalData->pCairo, CAIRO_LINE_JOIN_MITER);
  cairo_set_antialias(m_LocalData->pCairo, CAIRO_ANTIALIAS_NONE);
  cairo_set_line_width(m_LocalData->pCairo, 1.0);
 
  cairo_set_operator(m_LocalData->pCairo, CAIRO_OPERATOR_SOURCE);
  cairo_set_source_rgba(m_LocalData->pCairo, 0, 0, 0, 1.0);
  cairo_paint(m_LocalData->pCairo);
 
  if (!m_LocalData->pNormalFont) {
    m_LocalData->pNormalFont = new Font(m_LocalData->pCairo, 14, "DejaVu Sans Mono 10", true, 0);
    if (!m_LocalData->pNormalFont) {
      pedigree_log(LOG_EMERG, "Error: Normal font not loaded!");
      return false;
    }
  }
 
  if (!m_LocalData->pBoldFont) {
    m_LocalData->pBoldFont = new Font(m_LocalData->pCairo, 14, "DejaVu Sans Mono Bold 10", true, 0);
    if (!m_LocalData->pBoldFont) {
      pedigree_log(LOG_EMERG, "Error: Bold font not loaded!");
      return false;
    }
  }
 
  if (m_LocalData->pTerminal) {
    delete m_LocalData->pTerminal;
  }
 
  char newTermName[256];
  sprintf(newTermName, "Console%d", getpid());
 
  DirtyRectangle rect;
 
  m_LocalData->pTerminal = new Terminal(newTermName, m_LocalData->nWidth, m_LocalData->nHeight, 0,
                                        0, 0, m_LocalData->pCairo, m_pWidget, this,
                                        m_LocalData->pNormalFont, m_LocalData->pBoldFont);
  m_LocalData->pTerminal->setCairo(m_LocalData->pCairo, m_LocalData->pSurface);
  if (!m_LocalData->pTerminal->initialise()) {
    delete m_LocalData->pTerminal;
    m_LocalData->pTerminal = nullptr;
  } else {
    m_LocalData->pTerminal->setActive(true, rect);
    m_LocalData->pTerminal->redrawAll(rect);
  }
 
  rect.point(0, 0);
  rect.point(m_LocalData->nWidth, m_LocalData->nHeight);
 
  if (!m_LocalData->pTerminal) {
    pedigree_log(LOG_ALERT, "TUI: couldn't start up a terminal - failing gracefully...");
    m_LocalData->pBoldFont->render("There are no pseudo-terminals available.", 5, 5, 0xFFFFFF,
                                   0x000000, false);
    m_LocalData->pBoldFont->render("Press any key to close this window.", 5,
                                   m_LocalData->pBoldFont->getHeight() + 5, 0xFFFFFF, 0x000000,
                                   false);
 
    redraw(rect);
 
    m_LocalData->bKeyPressed = false;
    while (!m_LocalData->bKeyPressed) {
      if (m_pWidget) {
        Widget::checkForEvents(false);
      } else {
        // yield??
      }
    }
 
    return false;
  }
 
  redraw(rect);
 
  return true;
}
 
void Tui::setCursorStyle(bool filled) {
  if (m_LocalData->pTerminal) {
    DirtyRectangle dirty;
    m_LocalData->pTerminal->setCursorStyle(filled);
    m_LocalData->pTerminal->showCursor(dirty);
    redraw(dirty);
  }
}
 
void Tui::recreateSurfaces(void* fb) {
  if (!(m_LocalData->nWidth && m_LocalData->nHeight)) {
    // don't yet know the size of the framebuffer
    return;
  }
 
  if (m_LocalData->pSurface) {
    cairo_surface_destroy(m_LocalData->pSurface);
    cairo_destroy(m_LocalData->pCairo);
  }
 
  // Wipe out the framebuffer before we do much with it.
  int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, m_LocalData->nWidth);
  memset(fb, 0, m_LocalData->nHeight * stride);
 
  m_LocalData->pSurface = cairo_image_surface_create_for_data(
      (uint8_t*)fb, CAIRO_FORMAT_ARGB32, m_LocalData->nWidth, m_LocalData->nHeight, stride);
  m_LocalData->pCairo = cairo_create(m_LocalData->pSurface);
 
  if (m_LocalData->pTerminal) {
    m_LocalData->pTerminal->setCairo(m_LocalData->pCairo, m_LocalData->pSurface);
  }
 
  if (m_LocalData->pNormalFont) {
    m_LocalData->pNormalFont->updateCairo(m_LocalData->pCairo);
  }
 
  if (m_LocalData->pBoldFont) {
    m_LocalData->pBoldFont->updateCairo(m_LocalData->pCairo);
  }
}
 
void Tui::resize(size_t newWidth, size_t newHeight) {
  m_LocalData->nWidth = newWidth;
  m_LocalData->nHeight = newHeight;
 
  if (!(m_LocalData->pTerminal && m_LocalData->pCairo)) {
    // Nothing more to do for us.
    return;
  }
 
  // Wipe out the framebuffer, start over.
  cairo_set_operator(m_LocalData->pCairo, CAIRO_OPERATOR_SOURCE);
  cairo_set_source_rgba(m_LocalData->pCairo, 0, 0, 0, 0.8);
  cairo_rectangle(m_LocalData->pCairo, 0, 0, m_LocalData->nWidth, m_LocalData->nHeight);
  cairo_fill(m_LocalData->pCairo);
 
  if (m_LocalData->pTerminal) {
    m_LocalData->pTerminal->renewBuffer(newWidth, newHeight);
 
    DirtyRectangle rect;
    m_LocalData->pTerminal->redrawAll(rect);
    m_LocalData->pTerminal->showCursor(rect);
    redraw(rect);
 
    kill(m_LocalData->pTerminal->getPid(), SIGWINCH);
  }
}
 
void Tui::run() {
  size_t maxBuffSz = 32768;
  char buffer[32768];
 
  m_LocalData->bRunning = true;
  while (m_LocalData->bRunning) {
    int n = 0;
 
    fd_set fds;
    FD_ZERO(&fds);
 
    if (m_pWidget) {
      n = std::max(m_pWidget->getSocket(), n);
      FD_SET(m_pWidget->getSocket(), &fds);
    }
 
    if (m_LocalData->pTerminal) {
      if (!m_LocalData->pTerminal->isAlive()) {
        m_LocalData->bRunning = false;
      } else {
        int fd = m_LocalData->pTerminal->getSelectFd();
        FD_SET(fd, &fds);
        n = std::max(fd, n);
      }
    }
 
    if (!m_LocalData->bRunning) {
      continue;
    }
 
    int nReady = select(n + 1, &fds, NULL, NULL, 0);
    if (nReady <= 0) {
      continue;
    }
 
    // Check for widget events.
    if (m_pWidget) {
      if (FD_ISSET(m_pWidget->getSocket(), &fds)) {
        // Dispatch callbacks.
        Widget::checkForEvents(true);
 
        // Don't do redraw processing if this was the only descriptor
        // that was found readable.
        if (nReady == 1) {
          continue;
        }
      }
    }
 
    bool bShouldRedraw = false;
 
    DirtyRectangle dirtyRect;
    if (m_LocalData->pTerminal) {
      int fd = m_LocalData->pTerminal->getSelectFd();
      if (FD_ISSET(fd, &fds)) {
        // Something to read.
        ssize_t len = read(fd, buffer, maxBuffSz);
        if (len > 0) {
          m_LocalData->pTerminal->write(buffer, static_cast<size_t>(len), dirtyRect);
          bShouldRedraw = true;
        }
      }
    }
 
    if (bShouldRedraw) {
      redraw(dirtyRect);
    }
  }
 
  pedigree_log(LOG_INFO, "TUI shutting down cleanly.");
}
 
void Tui::stop() {
  m_LocalData->bRunning = false;
}
 
void Tui::keyInput(uint64_t key) {
  if (!m_LocalData->pTerminal)
    return;
 
  // CTRL + key -> unprintable characters
  if ((key & Keyboard::Ctrl) && !(key & Keyboard::Special)) {
    key &= 0x1F;
  }
 
  m_LocalData->pTerminal->processKey(key);
}
 
void Tui::redraw(DirtyRectangle& rect) {
  if (rect.getX() == ~0UL && rect.getY() == ~0UL && rect.getX2() == 0 && rect.getY2() == 0) {
    return;
  }
 
  PedigreeGraphics::Rect rt(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
  if (m_LocalData->pSurface) {
    cairo_surface_flush(m_LocalData->pSurface);
  }
 
  if (m_pWidget) {
    m_pWidget->redraw(rt);
  } else if (m_pRedrawer) {
    m_pRedrawer->redraw(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
  }
}