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 "modules/system/vfs/File.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/InputManager.h"
#include "pedigree/kernel/process/Mutex.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"

class Filesystem;
class Thread;
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 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);

    uint8_t translate(uint32_t codepoint);

    typedef struct
    {
        uint8_t character;
        VgaColour fore;
        VgaColour back;
        size_t flags;

        bool hidden;
    } VgaCell;

    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;

    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;

    Thread *m_pFlipThread;

    bool m_bOwnsConsole;

    InputMode m_InputMode;
};

#endif