TextIO.h

/*
 * 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.
 */
 
#ifndef TEXTIO_H
#define TEXTIO_H
 
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/InputManager.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OwnedThread.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/processor/MemoryRegion.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Buffer.h"
#include "pedigree/kernel/utilities/String.h"
 
#include <vterm.h>
 
#include "modules/system/vfs/File.h"
 
class Filesystem;
class Vga;
 
#define MAX_TEXTIO_PARAMS 16
#define TEXTIO_BUFFER_SIZE 1024
 
// Blink periods in milliseconds.
// We show text for 2x as long as the text is hidden.
#define BLINK_ON_PERIOD 1000
#define BLINK_OFF_PERIOD (BLINK_ON_PERIOD / 2)
 
class EXPORTED_PUBLIC TextIO : public File {
 private:
  static const int COLOUR_BRIGHT_ADDEND = 8;
 
  enum VgaColour {
    Black = 0,
    Blue = 1,
    Green = 2,
    Cyan = 3,
    Red = 4,
    Magenta = 5,
    Orange = 6,
    LightGrey = 7,
    DarkGrey = 8,
    LightBlue = 9,
    LightGreen = 10,
    LightCyan = 11,
    LightRed = 12,
    LightMagenta = 13,
    Yellow = 14,
    White = 15
  };
 
  VgaColour adjustColour(int colour, bool up) {
    if (up) {
      return static_cast<VgaColour>(colour + COLOUR_BRIGHT_ADDEND);
    } else {
      return static_cast<VgaColour>(colour - COLOUR_BRIGHT_ADDEND);
    }
  }
 
  enum TerminalModes {
    LineFeedNewLine = 0x1,
    CursorKey = 0x2,
    AnsiVt52 = 0x4,
    Column = 0x8,
    Scrolling = 0x10,
    Screen = 0x20,
    Origin = 0x40,
    AutoWrap = 0x80,
    AutoRepeat = 0x100,
    Interlace = 0x200,
 
    Inverse = 0x100000,
 
    Bright = 0x200000,
 
    Blink = 0x400000,
 
    // Character sets.
    CharacterSetG0 = 0x1000000,
    CharacterSetG1 = 0x2000000,
  };
 
 public:
  enum InputMode {
    Standard,  // use built-in system keymap translation
    Raw,       // write scancodes directly
  };
 
  TextIO(String str, size_t inode, Filesystem* pParentFS, File* pParent);
  virtual ~TextIO();
 
  bool initialise(bool bClear = true);
 
  void writeStr(const char* s, size_t len);
 
  virtual uint64_t readBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                bool bCanBlock = true);
  virtual uint64_t writeBytewise(uint64_t location, uint64_t size, uintptr_t buffer,
                                 bool bCanBlock = true);
  virtual int select(bool bWriting = false, int timeout = 0);
 
  virtual bool isSeekable() const {
    return false;
  }
 
  virtual void flipThread();
 
  static void inputCallback(InputManager::InputNotification& in);
  void handleInput(InputManager::InputNotification& in);
 
  void markPrimary();
 
  void unmarkPrimary();
 
  bool isPrimary() const;
 
  void setMode(InputMode mode);
 
  InputMode getMode() const;
 
 private:
  static const ssize_t BACKBUFFER_COLS_WIDE = 132;
  static const ssize_t BACKBUFFER_COLS_NORMAL = 80;
  static const ssize_t BACKBUFFER_ROWS = 25;
 
  static const ssize_t BACKBUFFER_STRIDE = BACKBUFFER_COLS_WIDE;
 
  virtual bool isBytewise() const {
    return true;
  }
 
  void setColour(VgaColour* which, size_t param, bool bBright = false);
 
  void doBackspace();
  void doLinefeed();
  void doCarriageReturn();
  void doHorizontalTab();
 
  void checkScroll();
  void checkWrap();
 
  void eraseSOS();
  void eraseEOS();
  void eraseEOL();
  void eraseSOL();
  void eraseLine();
 
  void eraseScreen(uint8_t character);
 
  void goHome(ssize_t xmove = 0, ssize_t ymove = 0);
 
  void clearBackbuffer();
 
  void flip(bool timer = false, bool hideState = false);
 
  void initialiseVterm();
  void destroyVterm();
  void syncVtermRect(VTermRect rect);
  void syncVtermCell(VTermPos pos);
  void markVtermRect(VTermRect rect);
  void markVtermCell(VTermPos pos);
  void storeVtermScrollback(const VTermScreenCell* cells, int cols);
  int popVtermScrollback(VTermScreenCell* cells, int cols);
  VgaColour vtermColour(VTermColor colour, bool foreground) const;
 
  static void vtermOutput(const char* bytes, size_t length, void* user);
  static int vtermDamage(VTermRect rect, void* user);
  static int vtermMoveRect(VTermRect dest, VTermRect src, void* user);
  static int vtermMoveCursor(VTermPos pos, VTermPos oldPos, int visible, void* user);
  static int vtermSetTermProp(VTermProp prop, VTermValue* value, void* user);
  static int vtermBell(void* user);
  static int vtermResize(int rows, int cols, void* user);
  static int vtermScrollbackPush(int cols, const VTermScreenCell* cells, void* user);
  static int vtermScrollbackPop(int cols, VTermScreenCell* cells, void* user);
  static int vtermScrollbackClear(void* user);
 
  uint8_t translate(uint32_t codepoint);
 
  typedef struct {
    uint8_t character;
    VgaColour fore;
    VgaColour back;
    size_t flags;
 
    bool hidden;
  } VgaCell;
 
  void copyVtermCell(const VTermScreenCell& source, VgaCell& destination);
 
  static const size_t VTERM_SCROLLBACK_LINES = 64;
 
  Atomic<bool> m_bInitialised;
  bool m_bControlSeq;
  bool m_bBracket;
  bool m_bParenthesis;
  bool m_bParams;
  bool m_bQuestionMark;
  ssize_t m_CursorX, m_CursorY;
  ssize_t m_SavedCursorX, m_SavedCursorY;
  ssize_t m_ScrollStart, m_ScrollEnd;
  ssize_t m_LeftMargin, m_RightMargin;
  size_t m_CurrentParam;
  size_t m_Params[MAX_TEXTIO_PARAMS];
  int m_CurrentModes;
 
  VgaColour m_Fore, m_Back;
 
  MemoryRegion m_Backbuffer;
 
  uint16_t* m_pFramebuffer;
  VgaCell* m_pBackbuffer;
  Vga* m_pVga;
 
  VTerm* m_pVterm;
  VTermScreen* m_pVtermScreen;
  VTermState* m_pVtermState;
  uint8_t m_VtermDirty[BACKBUFFER_STRIDE * BACKBUFFER_ROWS];
  VgaCell m_VtermScrollback[VTERM_SCROLLBACK_LINES][BACKBUFFER_STRIDE];
  size_t m_VtermScrollbackLines;
 
  char m_TabStops[BACKBUFFER_STRIDE];
 
  Buffer<char> m_OutBuffer;
 
  uint8_t m_G0, m_G1;
 
  uint64_t m_NextInterval;
 
  bool m_bUtf8;
 
  uint32_t m_nCharacter;
 
  size_t m_nUtf8Handled;
 
  bool m_bActive;
 
  Mutex m_Lock;
 
  Semaphore m_FlipWake;
  OwnedThread m_FlipThread;
 
  bool m_bOwnsConsole;
 
  InputMode m_InputMode;
};
 
#endif