Console.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include "../Geometry/Size.h"
#include "../Geometry/Point.h"
#include "../Graphics/Color.h"
#include <assert.h>
 
namespace Gorgon { namespace Utils {
    
    class ConsoleBackend;
    
    class Console {
        Console StdOutConsole();
    public:
        Console() = default;
 
        Console(ConsoleBackend &backend) : backend(&backend), refcount(new int{1}) {
        }
 
        Console(const Console &other) : backend(other.backend), refcount(other.refcount) {
            (*refcount)++;
        }
 
        Console &operator =(const Console &other);
 
        ~Console();
 
        enum ColorSupportLevel {
            None = 0,
 
            Safelist,
 
            RGB
        };
 
        enum Color {
            Default,
            Black,
            White,
            Red,
            Cyan,
            Blue,
            Yellow,
            Magenta,
            Green
        };
        
        ColorSupportLevel ColorSupport() const;
        
        bool IsColorSupported() const {
            return ColorSupport() != None;
        }
        
        bool IsReady() const {
            return backend != nullptr;
        }
 
        explicit operator bool() const { return IsReady(); }
        
        bool IsStylesSupported() const;
 
        void SetColor(Color color);
 
        void SetColor(Graphics::RGBA color);
 
        void SetBackground(Color color);
 
        void SetBackground(Graphics::RGBA color);
 
        void Reset();
        
        void SetBold(bool bold=true);
        
        void SetUnderline(bool underline=true);
        
        void SetItalic(bool italic=true);
        
        void SetNegative(bool negative=true);
 
        Geometry::Size GetSize() const;
 
        int GetWidth() const;
 
        int GetHeight() const;
        
        void GotoXY(Geometry::Point location);
        
        inline void GotoXY(int x, int y) { GotoXY({x,y}); }
        
        void ClearScreen();
        
        void HideCaret();
        
        void ShowCaret();
 
        std::ostream &OutStream() const;
        
    private:
        ConsoleBackend *backend = nullptr;
        int *refcount = nullptr;
    };
    
    class ConsoleBackend {
    public:        
        virtual ~ConsoleBackend() { }
        
        virtual Console::ColorSupportLevel ColorSupport() const = 0;
        
        virtual bool IsStylesSupported() const = 0;
        
        virtual void SetColor(Console::Color color) = 0;
        
        virtual void SetColor(Graphics::RGBA color) = 0;
        
        virtual void SetBackground(Console::Color color) = 0;
        
        virtual void SetBackground(Graphics::RGBA color) = 0;
        
        virtual void Reset() = 0;
        
        virtual void SetBold(bool value) = 0;
        
        virtual void SetUnderline(bool value) = 0;
        
        virtual void SetItalic(bool value) = 0;
        
        virtual void SetNegative(bool value) = 0;
        
        virtual Geometry::Size GetSize() const = 0;
        
        virtual void GotoXY(Geometry::Point location) = 0;
        
        virtual void ClearScreen() = 0;
        
        virtual void HideCaret() = 0;
        
        virtual void ShowCaret() = 0;
 
        virtual std::ostream &OutStream() const = 0;
    };
    
    class StdOutBackend : public ConsoleBackend {
    public:        
        virtual Console::ColorSupportLevel ColorSupport() const override;
        
        virtual bool IsStylesSupported() const override;
        
        virtual void SetColor(Console::Color color) override;
        
        virtual void SetColor(Graphics::RGBA color) override;
        
        virtual void SetBackground(Console::Color color) override;
        
        virtual void SetBackground(Graphics::RGBA color) override;
        
        virtual void Reset() override;
        
        virtual void SetBold(bool value) override;
        
        virtual void SetUnderline(bool value) override;
        
        virtual void SetItalic(bool value) override;
        
        virtual void SetNegative(bool value) override;
        
        virtual Geometry::Size GetSize() const override;
        
        virtual void GotoXY(Geometry::Point location) override;
        
        virtual void ClearScreen() override;
        
        virtual void HideCaret() override;
        
        virtual void ShowCaret() override;
 
        virtual std::ostream &OutStream() const override { return std::cout; }
    };
 
    inline Console StdConsole() {
        static Console stdconsole = {*new StdOutBackend};
 
        return stdconsole;
    }
 
 
#define __mychk assert(refcount) 
 
 
    inline Console &Console::operator=(const Console &other) {
        if(&other == this) return *this;
        
        if(refcount) {
            if(--(*refcount) <= 0) {
                delete backend;
                delete refcount;
            }
        }
 
        backend = other.backend;
        refcount = other.refcount;
        if(refcount)
            (*refcount)++;
 
        return *this;
    }
 
    inline Console::~Console() {
        if(!refcount) return;
 
        if(--(*refcount) <= 0) {
            delete backend;
            delete refcount;
        }
    }
 
    inline Console::ColorSupportLevel Console::ColorSupport() const {
        __mychk; return backend->ColorSupport();
    }
 
    inline bool Console::IsStylesSupported() const {
        __mychk; return backend->IsStylesSupported();
    }
 
    inline void Console::SetColor(Color color) {
        __mychk; backend->SetColor(color);
    }
 
    inline void Console::SetColor(Graphics::RGBA color) {
        __mychk; backend->SetColor(color);
    }
 
    inline void Console::SetBackground(Color color) {
        __mychk; backend->SetBackground(color);
    }
 
    inline void Console::SetBackground(Graphics::RGBA color) {
        __mychk; backend->SetBackground(color);
    }
 
    inline void Console::Reset() {
        __mychk; backend->Reset();
    }
 
    inline void Console::SetBold(bool bold) {
        __mychk; backend->SetBold(bold);
    }
 
    inline void Console::SetUnderline(bool underline) {
        __mychk; backend->SetUnderline(underline);
    }
 
    inline void Console::SetItalic(bool italic) {
        __mychk; backend->SetUnderline(italic);
    }
 
    inline void Console::SetNegative(bool negative) {
        __mychk; backend->SetNegative(negative);
    }
 
    inline Geometry::Size Console::GetSize() const {
        __mychk; return backend->GetSize();
    }
 
    inline int Console::GetWidth() const {
        __mychk; return GetSize().Width;
    }
 
    inline int Console::GetHeight() const {
        __mychk; return GetSize().Height;
    }
 
    inline void Console::GotoXY(Geometry::Point location) {
        __mychk; backend->GotoXY(location);
    }
 
    inline void Console::ClearScreen() {
        __mychk; backend->ClearScreen();
    }
 
    inline void Console::HideCaret() {
        __mychk; backend->HideCaret();
    }
 
    inline void Console::ShowCaret() {
        __mychk; backend->ShowCaret();
    }
 
 
    inline std::ostream &Console::OutStream() const {
        __mychk; return backend->OutStream();
    }
 
#undef __mychk
 
} }