menu.h

Go to the documentation of this file.

/* 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 <ncursesw/ncurses.h>
#include <locale.h>
#include <unordered_map>
#include <memory>
#include <utf8.h>
#include "ui.h"


class MenuBaseItem
{
public:
    MenuBaseItem(const StringMap& tags) :
        m_name(tags.at("name")),
        m_type(tags.at("type")),
        m_width(-1) {}
    virtual ~MenuBaseItem() {}

    const std::string& getName() { return m_name; }

    const std::string& getType() { return m_type; }

    int getWidth() { if (m_width == -1) m_width = calc_width(); return m_width; }   
    
    virtual void select()=0;
    
    virtual const std::string& getTitle()=0;

    virtual bool getActive()=0;

    virtual void draw(bool fHighlight, const int y0, const int x0, const int w) = 0;

protected:
    void draw_menu(bool fHighlight, const int y0, const int x0, const int w, const std::string& key = std::string());

private:
    virtual int calc_width()=0;

    const std::string m_name; 
    const std::string m_type; 
    int m_width;              
};

using MenuBasePtr = std::shared_ptr<MenuBaseItem>; 
class MenuBar;

class Menu : public MenuBaseItem
{
public:
    Menu(const StringMap& tags) :
        MenuBaseItem(tags),
        m_active(tags.at("active") == "true"),
        m_title(tags.at("title")),
        m_parent(nullptr) {}
    ~Menu() {}

    void drawInBar(int x, bool fHighlight = false);

    bool handleKey(int code);

    void select();

    const std::string& getTitle() { return m_title; }

    bool getActive() { return m_active; }

    int calc_width();

    void draw(bool fHighlight, const int y0, const int x0, const int w) {
        draw_menu(fHighlight, y0, x0, w);
    }

    void addItem(MenuBaseItem* m) { m_items.push_back(MenuBasePtr(m)); }

    Menu* getParent() { return m_parent; }

    void highlight_next(int step);

    void refresh_window();

    bool isCurrent();
    
    friend class MenuBar;
private:
    bool m_active;                             
    const std::string m_title;                 
    std::vector<MenuBasePtr> m_items;          
    Menu* m_parent;                            
    int m_xbar;                                
    int m_wbar;                                
    std::vector<MenuBasePtr>::iterator m_highlight; 
    int m_x0;     
    int m_y0;     
    int m_width;  
    int m_height; 

    static Menu* m_current;      
};

using MenuPtr = std::shared_ptr<Menu>; 

class MenuItem : public MenuBaseItem
{
public:
    MenuItem(const StringMap& tags) :
        MenuBaseItem(tags),
        m_active(tags.at("active") == "true"),
        m_title(tags.at("title")),
        m_action(tags.at("action")),
        m_key((tags.at("key") == "NONE") ? std::string() : tags.at("key")) {}
        
    ~MenuItem() {}

    void select() { UI::MiloApp::getGlobal().doMenu(m_action); }

    const std::string& getTitle() { return m_title; }

    bool getActive() { return m_active; }

    int calc_width();

    void draw(bool fHighlight, const int y0, const int x0, const int w) {
        draw_menu(fHighlight, y0, x0, w, m_key);
    }

private:
    bool m_active;              
    const std::string m_title;  
    const std::string m_action; 
    const std::string m_key;    
};

class MenuLine : public MenuBaseItem
{
public:
    MenuLine() : MenuBaseItem({ {"type", "line"}, {"name", "line"} }) {}
    ~MenuLine() {}

    void draw(bool fHighlight, const int y0, const int x0, const int w);

    void select() {}

    const std::string& getTitle() { return m_line_title; }

    bool getActive() { return false; }

    int calc_width() { return -1; }
private:
    static const std::string m_line_title;
};

class MenuBar : public UI::MenuXML
{
public:
    MenuBar(const std::string& xml);

    void add(Menu* menu);

    void draw();

    bool select(int mouse_x = 1);

    bool active() { return m_root != 0; }

    bool handleKey(int code);

    bool doMenuKey(const UI::KeyEvent& key);

    void define_menu(const StringMap& attributes);
    
    void define_menu_end(const std::string& name);
    
    void define_menu_item(const StringMap& attributes);
    
    void define_menu_line();
    
private:
    MenuPtr m_root;                
    int m_level;                   
    std::vector<MenuPtr> m_menus;  
    std::stack<Menu*> m_menu_heap; 

    std::unordered_map<UI::KeyEvent, std::string> key_menu_map;
};