Xterm.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 XTERM_H
#define XTERM_H

#include "environment.h"
#include "tui.h"

#include <string>

#include "pedigree/native/graphics/Graphics.h"

#include <cairo/cairo.h>

#define XTERM_MAX_PARAMS 16

// We must always support at least 132 columns. Normally, the margins would be
// set to whatever the screen supports, but for DECCOLM support we will need to
// be able to expand to 132 columns and only render the visible portion.
#define XTERM_WIDE 132
#define XTERM_STANDARD 80
#define XTERM_MIN_WIDTH 132

// #define XTERM_DEBUG
// #define XTERM_DEBUG_EXTRA

class Xterm
{
  public:
    Xterm(
        PedigreeGraphics::Framebuffer *pFramebuffer, size_t nWidth,
        size_t nHeight, size_t offsetLeft, size_t offsetTop, class Terminal *pT,
        class Widget *pWidget, Tui *pTui, class Font *pNormalFont,
        class Font *pBoldFont);
    ~Xterm();

    void write(uint32_t utf32, DirtyRectangle &rect);

    void renderAll(DirtyRectangle &rect);

    size_t getRows() const
    {
        return m_pWindows[0]->m_Height;
    }
    size_t getCols() const
    {
        return m_pWindows[0]->m_Width;
    }
    size_t getStride() const
    {
        return m_pWindows[0]->m_Stride;
    }

    void showCursor(DirtyRectangle &rect)
    {
        m_pWindows[m_ActiveBuffer]->showCursor(rect);
    }
    void hideCursor(DirtyRectangle &rect)
    {
        m_pWindows[m_ActiveBuffer]->hideCursor(rect);
    }

    size_t getModes() const
    {
        return m_Modes;
    }

    void resize(size_t w, size_t h, PedigreeGraphics::Framebuffer *pFb)
    {
        m_pWindows[(m_ActiveBuffer + 1) % 2]->resize(w, h, false);
        m_pWindows[m_ActiveBuffer]->resize(w, h, true);
    }

    void setCursorStyle(bool bFilled)
    {
        m_pWindows[m_ActiveBuffer]->setCursorStyle(bFilled);
    }

    void processKey(uint64_t key);

    void setCairo(cairo_t *pCairo, cairo_surface_t *pSurface)
    {
        m_pCairo = pCairo;
        m_pCairoSurface = pSurface;
    }

    void setFonts(Font *pNormalFont, Font *pBoldFont)
    {
        m_pNormalFont = pNormalFont;
        m_pBoldFont = pBoldFont;
    }

  private:
    class Window
    {
        friend class Xterm;

      private:
        class TermChar
        {
          public:
            bool operator==(const TermChar &other) const
            {
                return (
                    flags == other.flags && fore == other.fore &&
                    back == other.back && utf32 == other.utf32);
            }
            bool operator!=(const TermChar &other) const
            {
                return !(
                    flags == other.flags && fore == other.fore &&
                    back == other.back && utf32 == other.utf32);
            }
            uint8_t flags;
            uint8_t fore, back;
            uint32_t utf32;
        };

      public:
        Window(
            size_t nRows, size_t nCols, PedigreeGraphics::Framebuffer *pFb,
            size_t nMaxScrollback, size_t offsetLeft, size_t offsetTop,
            size_t fbWidth, Xterm *parent);
        ~Window();

        void showCursor(DirtyRectangle &rect);
        void hideCursor(DirtyRectangle &rect);

        void resize(size_t nRows, size_t nCols, bool bActive);

        void setScrollRegion(int start, int end);
        void setForeColour(uint8_t fgColour);
        void setBackColour(uint8_t bgColour);
        void setFlags(uint8_t flags);
        uint8_t getFlags();

        void setMargins(size_t left, size_t right);

        void setChar(uint32_t utf32, size_t x, size_t y);
        TermChar getChar(size_t x = ~0UL, size_t y = ~0UL);

        void fillChar(uint32_t utf32, DirtyRectangle &rect);
        void addChar(uint32_t utf32, DirtyRectangle &rect);

        void setCursorRelOrigin(size_t x, size_t y, DirtyRectangle &rect);
        void setCursor(size_t x, size_t y, DirtyRectangle &rect);
        void setCursorX(size_t x, DirtyRectangle &rect);
        void setCursorY(size_t y, DirtyRectangle &rect);
        ssize_t getCursorX() const;
        ssize_t getCursorY() const;
        ssize_t getCursorXRelOrigin() const;
        ssize_t getCursorYRelOrigin() const;
        void setCursorStyle(bool bFilled)
        {
            m_bCursorFilled = bFilled;
        }

        void cursorToOrigin();

        void cursorLeft(DirtyRectangle &rect);
        void cursorLeftNum(size_t n, DirtyRectangle &rect);
        void cursorLeftToMargin(DirtyRectangle &rect);
        void cursorDown(size_t n, DirtyRectangle &);
        void cursorUp(size_t n, DirtyRectangle &);

        void backspace(DirtyRectangle &rect);

        void cursorUpWithinMargin(size_t n, DirtyRectangle &);
        void cursorLeftWithinMargin(size_t n, DirtyRectangle &);
        void cursorRightWithinMargin(size_t n, DirtyRectangle &);
        void cursorDownWithinMargin(size_t n, DirtyRectangle &);

        void cursorDownAndLeftToMargin(DirtyRectangle &rect);
        void cursorDownAndLeft(DirtyRectangle &rect);
        void cursorTab(DirtyRectangle &rect);
        void cursorTabBack(DirtyRectangle &rect);

        void renderAll(DirtyRectangle &rect, Window *pPrevious);
        void render(
            DirtyRectangle &rect, size_t flags = 0, size_t x = ~0UL,
            size_t y = ~0UL);
        void renderArea(
            DirtyRectangle &rect, size_t x = ~0UL, size_t y = ~0UL,
            size_t w = ~0UL, size_t h = ~0UL);

        void scrollRegionUp(size_t n, DirtyRectangle &rect);
        void scrollRegionDown(size_t n, DirtyRectangle &rect);

        void scrollUp(size_t n, DirtyRectangle &rect);
        void scrollDown(size_t n, DirtyRectangle &rect);

        void eraseEOL(DirtyRectangle &rect);
        void eraseSOL(DirtyRectangle &rect);
        void eraseLine(DirtyRectangle &rect);
        void eraseChars(size_t n, DirtyRectangle &rect);
        void eraseUp(DirtyRectangle &rect);
        void eraseDown(DirtyRectangle &rect);
        void eraseScreen(DirtyRectangle &rect);

        void deleteCharacters(size_t n, DirtyRectangle &rect);
        void insertCharacters(size_t n, DirtyRectangle &rect);

        void insertLines(size_t n, DirtyRectangle &rect);
        void deleteLines(size_t n, DirtyRectangle &rect);

        void setTabStop();
        void clearTabStop();
        void clearAllTabStops();

        void checkWrap(DirtyRectangle &rect);

        void checkScroll(DirtyRectangle &rect);

        /* Inverts the display, if the character has the default colours. */
        void invert(DirtyRectangle &rect);

        void setLineRenderMode(bool b)
        {
            m_bLineRender = b;
        }

        bool getLineRenderMode()
        {
            return m_bLineRender;
        }

        void lineRender(uint32_t utf32, DirtyRectangle &rect);

      private:
        Window(const Window &);
        Window &operator=(const Window &);

        TermChar *m_pBuffer;
        size_t m_BufferLength;

        PedigreeGraphics::Framebuffer *m_pFramebuffer;

        size_t m_FbWidth;
        size_t m_Width, m_Height, m_Stride;

        size_t m_OffsetLeft, m_OffsetTop;

        size_t m_nMaxScrollback;
        ssize_t m_CursorX, m_CursorY;

        ssize_t m_ScrollStart, m_ScrollEnd;
        ssize_t m_LeftMargin, m_RightMargin;

        TermChar *m_pInsert;
        TermChar *m_pView;

        uint8_t m_Fg, m_Bg;
        uint8_t m_Flags;

        bool m_bCursorFilled;

        bool m_bLineRender;

        Xterm *m_pParentXterm;
    };

    Xterm(const Xterm &);
    Xterm &operator=(const Xterm &);

    size_t m_ActiveBuffer;

    Window *m_pWindows[2];

    typedef struct
    {
        int params[XTERM_MAX_PARAMS];
        int cur_param;
        bool has_param;
    } XtermCmd;
    XtermCmd m_Cmd;

    typedef struct
    {
        std::string params[XTERM_MAX_PARAMS];
        int cur_param;
        bool has_param;
    } XtermOsControl;
    XtermOsControl m_OsCtl;

    bool m_bChangingState;

    bool m_bContainedBracket;
    bool m_bContainedParen;
    bool m_bIsOsControl;

    enum TerminalModes
    {
        LineFeedNewLine = 0x1,
        CursorKey = 0x2,
        AnsiVt52 = 0x4,  // ANSI vs VT52 mode toggle.
        Column = 0x8,
        Scrolling = 0x10,
        Screen = 0x20,
        Origin = 0x40,
        AutoWrap = 0x80,
        AutoRepeat = 0x100,
        Interlace = 0x200,
        AppKeypad = 0x400,
        Margin = 0x800,
        Insert = 0x1000,
    };

    enum TerminalFlags
    {
        Question = 0x1,

        LeftAngle = 0x2,

        RightAngle = 0x4,

        LeftSquare = 0x8,

        RightSquare = 0x10,

        LeftRound = 0x20,

        RightRound = 0x40,

        Dollar = 0x80,

        Apostrophe = 0x100,

        Quote = 0x200,

        Space = 0x400,

        Bang = 0x800,

        Escape = 0x1000,

        Percent = 0x2000,

        Asterisk = 0x4000,

        Plus = 0x8000,

        Minus = 0x10000,

        Period = 0x20000,

        Slash = 0x40000,

        Hash = 0x80000,

        Backslash = 0x100000,

        Underscore = 0x200000,

        Vt52SetCursorWaitY = 0x400000,

        Vt52SetCursorWaitX = 0x800000,
    };

    bool setFlagsForUtf32(uint32_t utf32);

    size_t m_Flags;

    size_t m_Modes;

    char *m_TabStops;

    uint32_t m_SavedX, m_SavedY;

    class Terminal *m_pT;

    bool m_bFbMode;

    class Widget *m_pWidget;

    Tui *m_pTui;

    cairo_t *m_pCairo;
    cairo_surface_t *m_pCairoSurface;

    Font *m_pNormalFont;
    Font *m_pBoldFont;
};

#endif