GridLayoutConfig.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 GRIDLAYOUTCONFIG_HPP
#define GRIDLAYOUTCONFIG_HPP

#include <duds/general/BitFlags.hpp>
#include <duds/ui/graphics/BppImage.hpp>

namespace duds { namespace ui { namespace graphics {

struct GridSizeStep;

typedef std::vector<GridSizeStep>  GridSizeSteps;

struct GridLayoutConfig {
    GridSizeSteps sizes;
    typedef duds::general::BitFlags<struct GridLayoutConfigFlags>  Flags;
    static constexpr Flags PanelHidden          = Flags::Bit(0);
    static constexpr Flags PanelShown           = Flags::Zero();
    static constexpr Flags PanelWidthExpand     = Flags::Bit(1);
    static constexpr Flags PanelHeightExpand    = Flags::Bit(2);
    static constexpr Flags PanelExpand = PanelWidthExpand | PanelHeightExpand;
    static constexpr Flags PanelJustifyLeft     = Flags::Zero();
    static constexpr Flags PanelJustifyRight    = Flags::Bit(3);
    static constexpr Flags PanelJustifyUp       = Flags::Zero();
    static constexpr Flags PanelJustifyDown     = Flags::Bit(4);
    static constexpr Flags PanelCenterHoriz     = Flags::Bit(5);
    static constexpr Flags PanelCenterVert      = Flags::Bit(6);
    static constexpr Flags PanelCenter = PanelCenterHoriz | PanelCenterVert;
    static constexpr Flags PanelPositionHorizMask =
        PanelJustifyRight | PanelCenterHoriz;
    static constexpr Flags PanelPositionVertMask =
        PanelJustifyDown | PanelCenterVert;
    static constexpr Flags PanelPositionMask =
        PanelPositionHorizMask | PanelPositionVertMask;
    Flags flags = Flags::Zero();
    GridLayoutConfig() = default;
    GridLayoutConfig(const GridSizeSteps &gss, Flags flg) :
    sizes(gss), flags(flg) { }
    GridLayoutConfig(GridSizeSteps &&gss, Flags flg) :
    sizes(std::move(gss)), flags(flg) { }
    GridLayoutConfig(const GridSizeSteps &gss) : sizes(gss) { }
    GridLayoutConfig(GridSizeSteps &&gss) : sizes(std::move(gss)) { }
    GridLayoutConfig(const GridSizeStep &step);
    GridLayoutConfig(GridSizeStep &&step);
    void justifyLeft() {
        flags &= ~PanelPositionHorizMask;
    }
    void justifyRight() {
        flags.setMasked(PanelJustifyRight, PanelPositionHorizMask);
    }
    void centerHoriz() {
        flags.setMasked(PanelCenterHoriz, PanelPositionHorizMask);
    }
    void justifyUp() {
        flags &= ~PanelPositionVertMask;
    }
    void justifyDown() {
        flags.setMasked(PanelJustifyDown, PanelPositionVertMask);
    }
    void centerVert() {
        flags.setMasked(PanelCenterVert, PanelPositionVertMask);
    }
    void center() {
        flags.setMasked(PanelCenter, PanelPositionMask);
    }
    void hide() {
        flags |= PanelHidden;
    }
    void show() {
        flags &= ~PanelHidden;
    }
};

struct GridLocation {
    std::uint16_t c;
    std::uint16_t r;
    GridLocation() = default;
    template <
        typename Int0,
        typename Int1,
        std::enable_if_t<std::is_integral<Int0>::value, bool> = true,
        std::enable_if_t<std::is_integral<Int1>::value, bool> = true
    >
    constexpr GridLocation(Int0 col, Int1 row) :
    c((std::int16_t)col), r((std::int16_t)row) { }
    constexpr bool operator == (const GridLocation &gl) const {
        return (gl.r == r) && (gl.c == c);
    }
    constexpr bool operator != (const GridLocation &gl) const {
        return (gl.r != r) || (gl.c != c);
    }
};

struct GridSizeStep {
    ImageDimensions minDim;
    GridLocation loc;
    GridLayoutConfig::Flags flags;
    GridSizeStep() = default;
    constexpr GridSizeStep(
        const ImageDimensions &id,
        const GridLocation &gl,
        const GridLayoutConfig::Flags flg
    ) : minDim(id), loc(gl), flags(flg) { }
    constexpr GridSizeStep(
        const ImageDimensions &id,
        const GridLocation &gl
    ) : minDim(id), loc(gl), flags(GridLayoutConfig::Flags::Zero()) { }
    void justifyLeft() {
        flags &= ~GridLayoutConfig::PanelPositionHorizMask;
    }
    void justifyRight() {
        flags.setMasked(
            GridLayoutConfig::PanelJustifyRight,
            GridLayoutConfig::PanelPositionHorizMask
        );
    }
    void centerHoriz() {
        flags.setMasked(
            GridLayoutConfig::PanelCenterHoriz,
            GridLayoutConfig::PanelPositionHorizMask
        );
    }
    void justifyUp() {
        flags &= ~GridLayoutConfig::PanelPositionVertMask;
    }
    void justifyDown() {
        flags.setMasked(
            GridLayoutConfig::PanelJustifyDown,
            GridLayoutConfig::PanelPositionVertMask
        );
    }
    void centerVert() {
        flags.setMasked(
            GridLayoutConfig::PanelCenterVert,
            GridLayoutConfig::PanelPositionVertMask
        );
    }
    void center() {
        flags.setMasked(
            GridLayoutConfig::PanelCenter,
            GridLayoutConfig::PanelPositionMask
        );
    }
    void hide() {
        flags |= GridLayoutConfig::PanelHidden;
    }
    void show() {
        flags &= ~GridLayoutConfig::PanelHidden;
    }
};

} } }

#endif        //  #ifndef GRIDLAYOUTCONFIG_HPP