ui.h

Go to the documentation of this file.

#ifndef __UI_H
#define __UI_H

/* Copyright (C) 2018 - James Terman
 *
 * milo is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * milo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <iostream>
#include <unordered_map>
#include <string>
#include <memory>
#include "util.h"
#include "milo.h"

namespace UI {
    // Forward class declerations
    class Graphics;
    class MiloApp;
    class MiloWindow;
    class MiloPanel;

    using MiloWindowPtr = SmartPtr<MiloWindow>;        
    using MiloWindowVector = SmartVector<MiloWindow>;  
    using MiloWindowIter = MiloWindowVector::iterator; 
    using MiloPanelPtr = SmartPtr<MiloPanel>;          
    using MiloPanelVector = SmartVector<MiloPanel>;    
    using MiloPanelIter = MiloPanelVector::iterator;   

    using menu_handler = void (*)(void);

    namespace Keys {
        enum Key_Values {
            NONE, CTRL_A, CTRL_B, CTRL_C, CTRL_D, CTRL_E, CTRL_F, CTRL_G, CTRL_H,
            TAB, ENTER, CTRL_K, CTRL_L, CTRL_M, CTRL_N, CTRL_O, CTRL_P, CTRL_Q,
            CTRL_R, CTRL_S, CTRL_T, CTRL_U, CTRL_V, CTRL_W, CTRL_X, CTRL_Y, CTRL_Z, ESC,
            SPACE = 32, BANG, DBL_QUOTE, HASH, DOLLAR, PERCENT, AMP, QUOTE, L_PAR, R_PAR,
            STAR, PLUS, COMMA, MINUS, DOT, DIVIDE, K0, K1, K2, K3, K4, K5, K6, K7, K8, K9,
            COLON, SEMI, LESS, EQUAL, GREATER, QUESTION, AT, A, B, C, D, E, F, G, H, I, J, K,
            L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L_BRACKET, B_SLASH, R_BRACKET,
            POWER, U_SCORE, ACCENT, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r,
            s, t, u, v, w, x, y, z, L_BRACE, PIPE, R_BRACE, TILDE,
            F1 = 0x80, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
            INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, UP, DOWN, LEFT, RIGHT, BSPACE
        };
    }

    using Keyboard = Keys::Key_Values;
    
    enum Mouse {
        NO_MOUSE, POSITION, PRESSED, RELEASED, CLICKED, DOUBLE
    };

    enum Modifiers {
        NO_MOD, ALT, SHIFT, ALT_SHIFT, CTRL, CRL_ALT, CTRL_SHIFT, CTRL_ALT_SHIFT
    };

    class MouseEvent
    {
    public:
        MouseEvent(enum Mouse t, int b, enum Modifiers md = NO_MOD, int mouse_x = -1, int mouse_y = -1) :
            m_type{t}, m_button{b}, m_mod{md}, m_x{mouse_x}, m_y{mouse_y} {}

        void setCoords(int mouse_x, int mouse_y) { m_x = mouse_x; m_y = mouse_y; }

        enum Mouse getMouse() const { return m_type; }         
        int getButton() const { return m_button; }             
        enum Modifiers getModifiers() const { return m_mod; }  

        void getCoords(int& mouse_x, int& mouse_y) const { mouse_x = m_x; mouse_y = m_y; }

        bool noMod() const { return (m_mod == 0) ? true : false; }

        bool shiftMod() const { return (m_mod && Modifiers::SHIFT != 0) ? true : false; }

        bool altMod() const { return (m_mod && Modifiers::ALT != 0) ? true : false; }
        
        operator bool() const { return m_type !=NO_MOUSE; }

        std::size_t hash() const
        {
            return hash_calculate<int>({(int) m_type, m_button, (int) m_mod});
        }       

        bool equals(const MouseEvent& e) const
        {
            return e.m_type   == m_type &&
                   e.m_button == m_button &&
                   e.m_mod    == m_mod;
        }

        MouseEvent& operator=(const MouseEvent& e)
        {
            m_type   = e.m_type;
            m_button = e.m_button;
            m_mod    = e.m_mod;
            m_x      = e.m_x;
            m_y      = e.m_y;
            return *this;
        }
        
        std::string toString() const;
        
    private:
        enum Mouse m_type;     
        int m_button;          
        enum Modifiers m_mod;  
        int m_x;               
        int m_y;               
    };

    inline bool operator==(const MouseEvent& m1, const MouseEvent& m2)
    {
        return m1.equals(m2);
    }
    
    class KeyEvent
    {
    public:
        KeyEvent(Keyboard key, enum Modifiers md = NO_MOD) : m_key{key}, m_mod{md} {}
        
        KeyEvent(char key, enum Modifiers md = NO_MOD) : KeyEvent((Keyboard) key, md) {}

        KeyEvent(const std::string& key);

        constexpr KeyEvent(const KeyEvent& e) : m_key(e.m_key), m_mod(e.m_mod) {}
        
        Keyboard getKey() const { return m_key; }              
        enum Modifiers getModifiers() const { return m_mod; }  

        bool noMod() const { return (m_mod == 0) ? true : false; }

        bool shiftMod() const { return (m_mod && Modifiers::SHIFT != 0) ? true : false; }

        bool altMod() const { return (m_mod && Modifiers::ALT != 0) ? true : false; }
        
        operator bool() const { return m_key != Keys::NONE; }

        std::size_t hash() const
        {
            return hash_calculate<int>({(int) m_key, (int) m_mod});
        }

        bool equals(const KeyEvent e) const
        {
            return e.m_key == m_key &&
                   e.m_mod == m_mod;
        }

        KeyEvent& operator=(const KeyEvent& e)
        {
            m_key = e.m_key;
            m_mod = e.m_mod;
            return *this;
        }
        
        std::string toString() const;
    
    private:
        Keyboard m_key;       
        enum Modifiers m_mod; 
    };

    inline bool operator==(const KeyEvent& k1, const KeyEvent& k2)
    {
        return k1.equals(k2);
    }

    class Graphics  {
    public:
        Graphics() {}
        
        virtual ~Graphics() {}
        
        enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
        
        enum Attributes { NONE=0, BOLD=1, ITALIC=2, BOLD_ITALIC=3 };
        
        virtual void differential(int x0, int y0, char variable)=0;
        
        virtual void parenthesis(int x_size, int y_size, int x0, int y0)=0;
        
        virtual void horiz_line(int x_size, int x0, int y0)=0;
        
        virtual void at(int x0, int y0, int c, Attributes chrAttr, Color color = BLACK)=0;
        
        virtual void at(int x0, int y0, const std::string& s, Attributes chrAttr, Color color = BLACK)=0;

        virtual void clear_screen()=0;
        
        virtual void out()=0;
        
        virtual int getTextHeight()=0;
        
        virtual int getTextLength(const std::string& s)=0;
        
        virtual int getCharLength(char c)=0;
        
        virtual int getParenthesisWidth(int height = 1)=0;
        
        virtual int getDivideLineHeight()=0;
        
        virtual int getDifferentialHeight(char c)=0;
        
        virtual int getDifferentialWidth(char c)=0;
        
        virtual int getDifferentialBase(char c)=0;
        
        virtual void set(int x, int y, int x0 = 0, int y0 = 0) { 
            m_xSize = x; m_ySize = y; m_xOrig = x0, m_yOrig = y0;
        }
        
        virtual void setSelect(int x, int y, int x0, int y0) { m_select.set(x, y, x0, y0); }

        void set(const Box& box) { 
            set(box.width(), box.height(), box.x0(), box.y0());
        }
        
        void setSelect(const Box& box) { 
            setSelect(box.width(), box.height(), box.x0(), box.y0());
        }
        
        void parenthesis(const Box& box) {
            parenthesis(box.width(), box.height(), box.x0(), box.y0());
        }
        
        void relativeOrig(int& x, int& y) { x -= m_xOrig; y -= m_yOrig; }

    protected:
        int m_xSize;   
        int m_ySize;   
        int m_xOrig;   
        int m_yOrig;   
        Box m_select;  
    };

    template <class T> MiloPanelPtr createPanel(const std::string& init)
    {
        return MiloPanelPtr(new T(init));
    }

    using panel_factory = MiloPanelPtr (*)(const std::string&);
    
    class MiloPanel
    {
    public:
        MiloPanel() {}

        ~MiloPanel() {}

        virtual void doKey(const UI::KeyEvent& key) = 0;

        virtual void doMouse(const UI::MouseEvent& mouse) = 0;

        virtual bool doMenu(const std::string& menuFunctionName) = 0;
        
        virtual void doDraw() = 0;
        
        virtual void pushUndo()=0;
        
        virtual void popUndo()=0;

        virtual void saveState(std::ostream& fs) = 0;

        virtual void loadState(std::istream& is) = 0;

        void saveState(const std::string& filename) {
            std::fstream out(filename,  std::fstream::out | std::fstream::trunc);
            saveState(out);
        }

        void loadState(const std::string& filename) {
            std::ifstream ifs(filename);
            loadState(ifs);
        }

        virtual bool blink() = 0;

        virtual void getCursorOrig(int& x, int& y) = 0;

        static MiloPanelPtr makePanel(const std::string& name, const std::string& init);
        
    protected:
        static std::unordered_map<std::string, panel_factory> panel_map; 
    };

    class MiloWindow
    {
    public:

        MiloWindow(MiloPanelPtr panel) :
            m_panels({panel}), m_current_panel(m_panels.begin()) {}

        MiloWindow();

        virtual ~MiloWindow() {}

        MiloPanel& getPanel() { return *(m_current_panel->get()); }

        void addPanel(MiloPanelPtr panel) {
            m_current_panel = AddAfter(m_panels, m_current_panel, panel);
        }

        void deletePanel(MiloPanelIter it) {
            m_current_panel = m_panels.erase(it);
        }

        void deletePanel() {
            m_current_panel = m_panels.erase(m_current_panel);
        }

        virtual void makeTopWindow()=0;

    protected:
        MiloPanelVector m_panels;      
        MiloPanelIter m_current_panel; 
    };

    class MiloApp
    {
    public:
        virtual void redraw_screen()=0;

        virtual Graphics& getGraphics()=0;

        void doMenu(const std::string& menuFunctionName);
    
        static bool isRunning();

        MiloWindow& getWindow() { return *(m_current_window->get()); }

        void addWindow(MiloWindowPtr win) {
            m_current_window = AddAfter(m_windows, m_current_window, win);
        }

        void closeWindow() {
            m_current_window = m_windows.erase(m_current_window);
        }

        void closeWindow(MiloWindowIter it) {
            m_current_window = m_windows.erase(it);
        }

        static MiloApp& getGlobal() { return m_current; }

    protected:

        MiloApp() {}

        MiloApp(MiloWindowPtr win) :
            m_windows({win}), m_current_window(m_windows.begin()) {}

        ~MiloApp() {}
        
        MiloWindowVector m_windows;        
        MiloWindowIter   m_current_window; 

        static MiloApp& m_current; 

    private:
        
        static std::unordered_map<std::string, menu_handler> menu_map;
    };

    class MenuXML
    {
    public:
        virtual void define_menu(const StringMap& attributes)=0;

        virtual void define_menu_end(const std::string& name)=0;

        virtual void define_menu_item(const StringMap& attributes)=0;

        virtual void define_menu_line()=0;

        void parse_menu(XML::Parser& in);
    };
}

namespace std
{
    template<> struct hash<UI::KeyEvent>
    {
        size_t operator()(UI::KeyEvent const& key) const
        {
            return key.hash();
        }
    };

    template<> struct hash<UI::MouseEvent>
    {
        size_t operator()(UI::MouseEvent const& key) const
        {
            return key.hash();
        }
    };
}

#endif // __UI_H