panel.h

Go to the documentation of this file.

#ifndef __PANEL_H
#define __PANEL_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 "ui.h"

namespace UI {

    class EqnPanel : public MiloPanel
    {
    public:
        using key_handler = bool (*)(EqnPanel&, const KeyEvent&);
        
        using mouse_handler = bool (*)(EqnPanel&, const MouseEvent&);
        
        using menu_handler = bool (*)(EqnPanel&);

        EqnPanel() : MiloPanel(),  m_eqn(new Equation("#")) {}

        EqnPanel(std::istream& is) : MiloPanel(), m_eqn(new Equation(is)) {}

        EqnPanel(const std::string& eq) : MiloPanel(), m_eqn(new Equation(eq)) {}

        ~EqnPanel() {} 

        
        void doKey(const KeyEvent& key);
    
        void doMouse(const MouseEvent& mouse);

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

        void saveState(std::ostream& fs);
        
        void loadState(std::istream& is);
        
        bool blink();
        
        void getCursorOrig(int& x, int& y);

        Equation& getEqn() { return *m_eqn; }

        Equation& newEqn(std::string eq) {
            m_eqn.reset(new Equation(eq));
            return *m_eqn;
        }

        Equation& newEqn(std::istream& is) {
            m_eqn.reset(new Equation(is));
            return *m_eqn;
        }

        void set_refresh(bool refresh) { m_fRefresh = refresh; }

        static const std::string name; 
    private:
        EqnPtr      m_eqn;              
        EqnUndoList m_eqns;             
        bool m_fRefresh = true;         
        Node* m_start_select = nullptr; 
        int m_start_mouse_x = -1;       
        int m_start_mouse_y = -1;       
        static bool init;               

        static bool do_init();

        static bool emit_key(EqnPanel& panel, const KeyEvent& key);

        static const std::unordered_map<MouseEvent, mouse_handler> mouse_event_map;
        
        static const std::unordered_map<KeyEvent, key_handler> key_event_map;
        
        static const std::unordered_map<std::string, menu_handler> menu_map;

        bool do_alphaNumber(const KeyEvent& event);

        bool do_backspace(const KeyEvent& event);

        bool do_left(const KeyEvent& event);

        bool do_right(const KeyEvent& event);

        bool do_shift_left(const KeyEvent& event);

        bool do_shift_right(const KeyEvent& event);
        
        bool do_up(const KeyEvent& event);

        bool do_down(const KeyEvent& event);

        bool do_shift_up(const KeyEvent& event);

        bool do_shift_down(const KeyEvent& event);

        bool do_enter(const KeyEvent& event);

        bool do_tab(const KeyEvent& event);

        bool do_plus_minus(const KeyEvent& event);

        bool do_divide(const KeyEvent& event);

        bool do_power(const KeyEvent& event);

        bool do_left_parenthesis(const KeyEvent& event);

        bool do_space(const KeyEvent& event);       

        bool do_mouse_pressed(const MouseEvent& mouse);

        bool do_mouse_released(const MouseEvent& mouse);

        bool do_mouse_clicked(const MouseEvent& mouse);
        
        bool do_mouse_double(const MouseEvent& mouse);
        
        bool do_mouse_position(const MouseEvent& mouse);
    };
    
}

#endif // __PANEL_H