BppMenuRenderer.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) 2020  Jeff Jackowski
 */
#ifndef BPPMENURENDERER_HPP
#define BPPMENURENDERER_HPP

#include <duds/ui/menu/MenuOutputAccess.hpp>
#include <duds/ui/graphics/BppStringCache.hpp>
#include <duds/ui/graphics/BppPositionIndicator.hpp>

namespace duds { namespace ui { namespace menu { namespace renderers {

struct BppMenuRendererError : virtual std::exception, virtual boost::exception { };

struct BppMenuDestinationTooSmall : BppMenuRendererError { };

struct BppMenuDestinationMissing : BppMenuRendererError { };

struct BppMenuLacksStringCache : BppMenuRendererError { };

class BppMenuRenderer {
public:
    enum ScrollBarPlacement {
        ScrollRight,
        ScrollLeft,
        ScrollBottom,
        ScrollTop
    };
    typedef duds::general::BitFlags<struct BppMenuFlags>  Flags;
    static constexpr Flags ScrollBarMask           = Flags(3);
    static constexpr Flags ScrollBarNeverHides     = Flags::Bit(2);
    static constexpr Flags HorizontalList          = Flags::Bit(3);
    static constexpr Flags InvertSelected          = Flags::Bit(4);
    static constexpr Flags ValueRightJustified     = Flags::Bit(5);
    static constexpr Flags DoNotShowText           = Flags::Bit(6);
private:
    static constexpr Flags ScrollBarShown          = Flags::Bit(14);
    static constexpr Flags Calculated              = Flags::Bit(15);
    static constexpr Flags InternalMask            = Flags(0xFF00);
    std::unique_ptr<duds::ui::graphics::BppPositionIndicator> posInd;
    duds::ui::graphics::ConstBppImageSptr selIcon;
    duds::ui::graphics::ConstBppImageSptr disIcon;
    duds::ui::graphics::ConstBppImageSptr togOffIcon;
    duds::ui::graphics::ConstBppImageSptr togOnIcon;
    duds::ui::graphics::BppStringCacheSptr cache;
    duds::ui::graphics::ImageDimensions itemDim;
    duds::ui::graphics::ImageDimensions textDim;
    duds::ui::graphics::ImageDimensions destDim =
        duds::ui::graphics::ImageDimensions(0, 0);
    duds::ui::graphics::ImageDimensions iconDim =
        duds::ui::graphics::ImageDimensions(0, 0);
    Flags flgs;
    std::uint16_t selDisWidth = 0;
    std::uint16_t toggleWidth = 0;
    std::uint16_t valWidth = 0;
    std::uint16_t valMg = 0;
    std::uint16_t itemMg = 0;
    std::uint16_t iconTxMg = 0;
    std::uint16_t scrollMg = 0;
    std::uint16_t items = 0;
    std::uint16_t scrollWidth;
    std::uint16_t fracshow;
    void recalculateDimensions(duds::ui::graphics::ImageDimensions fitDim);
public:
    BppMenuRenderer(Flags cfg = Flags::Zero()) : flgs(cfg & ~InternalMask) { }
    BppMenuRenderer(
        const duds::ui::graphics::BppStringCacheSptr &cachePtr,
        Flags cfg = Flags::Zero()
    ) : cache(cachePtr), flgs(cfg & ~InternalMask) { }
    BppMenuRenderer(
        const duds::ui::graphics::BppStringCacheSptr &cachePtr,
        int vmItems,
        Flags cfg = Flags::Zero()
    ) : cache(cachePtr), items(vmItems), flgs(cfg & ~InternalMask) { }
    Flags flags() const {
        return flgs;
    }
    void flags(Flags cfg) {
        flgs = cfg & ~InternalMask;
    }
    const duds::ui::graphics::ConstBppImageSptr &selectedIcon() const {
        return selIcon;
    }
    void selectedIcon(const duds::ui::graphics::ConstBppImageSptr &img) {
        selIcon = img;
        flgs.clear(Calculated);
    }
    const duds::ui::graphics::ConstBppImageSptr &disabledIcon() const {
        return disIcon;
    }
    void disabledIcon(const duds::ui::graphics::ConstBppImageSptr &img) {
        disIcon = img;
        flgs.clear(Calculated);
    }
    const duds::ui::graphics::ConstBppImageSptr &toggledOffIcon() const {
        return togOffIcon;
    }
    void toggledOffIcon(const duds::ui::graphics::ConstBppImageSptr &img) {
        togOffIcon = img;
        flgs.clear(Calculated);
    }
    const duds::ui::graphics::ConstBppImageSptr &toggledOnIcon() const {
        return togOnIcon;
    }
    void toggledOnIcon(const duds::ui::graphics::ConstBppImageSptr &img) {
        togOnIcon = img;
        flgs.clear(Calculated);
    }
    const duds::ui::graphics::ImageDimensions &iconDimensions() const {
        return iconDim;
    }
    void iconDimensions(const duds::ui::graphics::ImageDimensions &dim);
    std::uint16_t iconTextMargin() const {
        return iconTxMg;
    }
    void iconTextMargin(std::uint16_t itm) {
        iconTxMg = itm;
        flgs.clear(Calculated);
    }
    const duds::ui::graphics::BppStringCacheSptr &stringCache() const {
        return cache;
    }
    void stringCache(const duds::ui::graphics::BppStringCacheSptr &sc) {
        cache = sc;
        flgs.clear(Calculated);
    }
    std::uint16_t maxVisible() const {
        return items;
    }
    void maxVisible(std::uint16_t i);
    std::uint16_t valueWidth() const {
        return valWidth;
    }
    void valueWidth(std::uint16_t w) {
        valWidth = w;
        flgs.clear(Calculated);
    }
    std::uint16_t valueMargin() const {
        return valMg;
    }
    void valueMargin(std::uint16_t m) {
        valMg = m;
        flgs.clear(Calculated);
    }
    std::uint16_t itemMargin() const {
        return itemMg;
    }
    void itemMargin(std::uint16_t im) {
        itemMg = im;
        flgs.clear(Calculated);
    }
    void addScrollBar(
        std::uint16_t width = 1,
        std::uint16_t margin = 1,
        std::uint16_t minsize = 4,
        ScrollBarPlacement place = ScrollRight
    );
    void removeScrollBar();
    bool hasScrollBar() const {
        return scrollWidth != 0;
    }
    void render(
        duds::ui::graphics::BppImageSptr &dest,
        duds::ui::menu::MenuOutputAccess &mova
    );
    void render(
        duds::ui::graphics::BppImageSptr &dest,
        duds::ui::menu::MenuOutput &mov
    ) {
        duds::ui::menu::MenuOutputAccess mova(mov, items);
        render(dest, mova);
    }
    duds::ui::graphics::BppImageSptr render(
        const duds::ui::graphics::ImageDimensions &dim,
        duds::ui::menu::MenuOutputAccess &mova
    ) {
        graphics::BppImageSptr img = graphics::BppImage::make(dim);
        render(img, mova);
        return img;
    }
    duds::ui::graphics::BppImageSptr render(
        const duds::ui::graphics::ImageDimensions &dim,
        duds::ui::menu::MenuOutput &mov
    ) {
        duds::ui::menu::MenuOutputAccess mova(mov, items);
        return render(dim, mova);
    }
};

} } } }

#endif        //  #ifndef BPPMENURENDERER_HPP