MenuItem.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2019  Jeff Jackowski
 */
#ifndef MENUITEM_HPP
#define MENUITEM_HPP

#include <duds/general/BitFlags.hpp>
#include <boost/noncopyable.hpp>
#include <memory>
#include <string>

namespace duds { namespace ui { namespace menu {

class Menu;
class MenuView;
class MenuAccess;

class MenuItem : public std::enable_shared_from_this<MenuItem>, boost::noncopyable {
public:
    typedef duds::general::BitFlags<struct MenuItemFlags>  Flags;
    static constexpr Flags Disabled = Flags::Bit(0);
    static constexpr Flags Invisible = Flags::Bit(1);
    static constexpr Flags HasValue = Flags::Bit(2);
    static constexpr Flags Toggle = Flags::Bit(3);
    static constexpr Flags ToggledOn = Flags::Bit(4);
private:
    std::string lbl;
    std::string descr;
    std::string val;
    Menu *parent = nullptr;
    Flags flgs;
    friend Menu;
protected:
    struct MenuItemToken { };
public:
    MenuItem(
        MenuItemToken,
        const std::string &label,
        Flags flags = Flags::Zero()
    ) : lbl(label), flgs(flags) { }
    MenuItem(
        MenuItemToken,
        const std::string &label,
        const std::string &description,
        Flags flags = Flags::Zero()
    ) : lbl(label), descr(description), flgs(flags) { }
    MenuItem(
        MenuItemToken,
        const std::string &label,
        const std::string &description,
        const std::string &value,
        Flags flags = Flags::Zero()
    ) : lbl(label), descr(description), val(value), flgs(flags | HasValue) { }
    MenuItem(MenuItemToken, const MenuItem &mi) :
    lbl(mi.lbl), descr(mi.descr), val(mi.val), flgs(mi.flgs) { }
    const std::string &label() const {
        return lbl;
    }
    void label(const std::string &l);
    const std::string &description() const {
        return descr;
    }
    void description(const std::string &d);
    const std::string &value() const {
        return val;
    }
    void value(const std::string &v);
    void changeEnabledState(bool state);
    void disable() {
        changeEnabledState(false);
    }
    void enable() {
        changeEnabledState(true);
    }
    void changeVisibility(bool vis);
    void hide() {
        changeVisibility(false);
    }
    void show() {
        changeVisibility(true);
    }
    bool toggle();
    void changeToggle(bool state);
    void clearToggle() {
        changeToggle(false);
    }
    void setToggle() {
        changeToggle(true);
    }
    Menu *menu() const {
        return parent;
    }
    Flags flags() const {
        return flgs;
    }
    bool isDisabled() const {
        return flgs & Disabled;
    }
    bool isEnabled() const {
        return !(flgs & Disabled);
    }
    bool isInvisible() const {
        return flgs & Invisible;
    }
    bool isVisible() const {
        return !(flgs & Invisible);
    }
    bool hasValue() const {
        return flgs & HasValue;
    }
    bool isToggle() const {
        return flgs & Toggle;
    }
    bool isToggledOn() const {
        return flgs & ToggledOn;
    }
    bool isSelectable() const {
        return !(flgs & (Disabled | Invisible));
    }
    void remove();
    virtual void select(MenuView &invokingView, const MenuAccess &access);
    virtual void deselect(MenuView &invokingView, const MenuAccess &access);
    virtual void chose(MenuView &invokingView, const MenuAccess &access) = 0;
};

typedef std::shared_ptr<MenuItem>  MenuItemSptr;

typedef std::weak_ptr<MenuItem>  MenuItemWptr;

} } }

#endif        //  #ifndef MENUITEM_HPP