terminal.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/size2d.h>
#include <promeki/platform.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
// Terminal owns an internal AnsiStream layered over a File that adopts the
// output fd (with BufferedIODevice write buffering enabled) and routes ALL
// escape-sequence emission through it, so there is a single ordered, buffered
// write path to the terminal.  Both are held by UniquePtr behind forward
// declarations: the AnsiStream one breaks a terminal.h <-> ansistream.h
// include cycle (ansistream.h depends on Terminal::ColorSupport), and
// forward-declaring File keeps file.h out of this header.
class AnsiStream;
class File;
 
class Terminal {
        public:
 
                enum ColorSupport {
                        NoColor,     
                        Grayscale16, 
                        Grayscale256, 
                        GrayscaleTrue, 
                        Basic,         
                        Color256,      
                        TrueColor      
                };
 
                Terminal();
 
                Terminal(int inputFd, int outputFd);
 
                ~Terminal();
 
                Terminal(const Terminal &) = delete;
                Terminal &operator=(const Terminal &) = delete;
 
                int inputFd() const { return _inputFd; }
 
                int outputFd() const { return _outputFd; }
 
                Error enableRawMode();
 
                Error disableRawMode();
 
                bool isRawMode() const { return _rawMode; }
 
                Result<int> readInput(char *buf, int maxLen);
 
                Error windowSize(int &cols, int &rows) const;
 
                Size2Di32 size() const;
 
                Error enableMouseTracking();
 
                Error disableMouseTracking();
 
                bool isMouseTrackingEnabled() const { return _mouseTracking; }
 
                Error enableBracketedPaste();
 
                Error disableBracketedPaste();
 
                Error enableFocusReporting();
 
                Error disableFocusReporting();
 
                bool isFocusReportingEnabled() const { return _focusReporting; }
 
                Error enableAlternateScreen();
 
                Error disableAlternateScreen();
 
                static ColorSupport colorSupport();
 
                Result<int> writeOutput(const char *data, int len);
 
                AnsiStream &ansiStream();
 
                void emergencyRestore();
 
                class RawModeGuard {
                        public:
                                explicit RawModeGuard(Terminal &t) : _t(t) { _t.enableRawMode(); }
                                ~RawModeGuard() { _t.disableRawMode(); }
                                RawModeGuard(const RawModeGuard &) = delete;
                                RawModeGuard &operator=(const RawModeGuard &) = delete;
 
                        private:
                                Terminal &_t;
                };
 
                class AlternateScreenGuard {
                        public:
                                explicit AlternateScreenGuard(Terminal &t) : _t(t) { _t.enableAlternateScreen(); }
                                ~AlternateScreenGuard() { _t.disableAlternateScreen(); }
                                AlternateScreenGuard(const AlternateScreenGuard &) = delete;
                                AlternateScreenGuard &operator=(const AlternateScreenGuard &) = delete;
 
                        private:
                                Terminal &_t;
                };
 
                class MouseTrackingGuard {
                        public:
                                explicit MouseTrackingGuard(Terminal &t) : _t(t) { _t.enableMouseTracking(); }
                                ~MouseTrackingGuard() { _t.disableMouseTracking(); }
                                MouseTrackingGuard(const MouseTrackingGuard &) = delete;
                                MouseTrackingGuard &operator=(const MouseTrackingGuard &) = delete;
 
                        private:
                                Terminal &_t;
                };
 
                class BracketedPasteGuard {
                        public:
                                explicit BracketedPasteGuard(Terminal &t) : _t(t) { _t.enableBracketedPaste(); }
                                ~BracketedPasteGuard() { _t.disableBracketedPaste(); }
                                BracketedPasteGuard(const BracketedPasteGuard &) = delete;
                                BracketedPasteGuard &operator=(const BracketedPasteGuard &) = delete;
 
                        private:
                                Terminal &_t;
                };
 
                class FocusReportingGuard {
                        public:
                                explicit FocusReportingGuard(Terminal &t) : _t(t) { _t.enableFocusReporting(); }
                                ~FocusReportingGuard() { _t.disableFocusReporting(); }
                                FocusReportingGuard(const FocusReportingGuard &) = delete;
                                FocusReportingGuard &operator=(const FocusReportingGuard &) = delete;
 
                        private:
                                Terminal &_t;
                };
 
        private:
                void init();
 
                int            _inputFd;
                int            _outputFd;
                bool           _rawMode = false;
                bool           _mouseTracking = false;
                bool           _bracketedPaste = false;
                bool           _alternateScreen = false;
                bool           _focusReporting = false;
 
                // Single ordered write path: a File adopting the output fd and
                // the AnsiStream layered over it.  Created in init().  Held by
                // UniquePtr behind forward declarations to keep this header
                // free of the file.h / ansistream.h includes (see top of file).
                UniquePtr<File>       _outDevice;
                UniquePtr<AnsiStream> _ansi;
 
                // Opaque storage for platform-specific terminal state.
                // On POSIX this holds a struct termios.
                void *_origState = nullptr;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE