sizer.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_SIZER_H
#define EGT_SIZER_H
 
#include <egt/detail/alignment.h>
#include <egt/detail/meta.h>
#include <egt/frame.h>
#include <memory>
#include <utility>
 
namespace egt
{
inline namespace v1
{
 
class EGT_API BoxSizer : public Frame
{
public:
 
    explicit BoxSizer(Orientation orient = Orientation::horizontal,
                      Justification justify = Justification::middle)
        : m_orient(orient),
          m_justify(justify)
    {
        name("BoxSizer" + std::to_string(m_widgetid));
    }
 
    explicit BoxSizer(Frame& parent,
                      Orientation orient = Orientation::horizontal,
                      Justification justify = Justification::middle)
        : BoxSizer(orient, justify)
    {
        parent.add(*this);
    }
 
    explicit BoxSizer(Serializer::Properties& props)
        : BoxSizer(props, false)
    {
    }
 
protected:
 
    explicit BoxSizer(Serializer::Properties& props, bool is_derived);
 
public:
 
    void layout() override;
 
    EGT_NODISCARD Justification justify() const { return m_justify; }
 
    void justify(Justification justify)
    {
        if (detail::change_if_diff<>(m_justify, justify))
            layout();
    }
 
    EGT_NODISCARD Orientation orient() const { return m_orient; }
 
    void orient(Orientation orient)
    {
        if (detail::change_if_diff<>(m_orient, orient))
            layout();
    }
 
    void serialize(Serializer& serializer) const override;
 
protected:
 
    EGT_NODISCARD Size super_rect() const
    {
        if (orient() == Orientation::flex)
        {
            Rect result = size();
            for (auto& child : children())
                result = Rect::merge(result, child->box());
 
            return result.size();
        }
 
        DefaultDim width = 0;
        DefaultDim height = 0;
 
        if (orient() == Orientation::horizontal)
        {
            for (auto& child : children())
            {
                if (!child->align().is_set(AlignFlag::expand_horizontal))
                {
                    width += child->box().width();
                    height = std::max(child->box().height(), height);
                }
            }
        }
        else
        {
            for (auto& child : children())
            {
                if (!child->align().is_set(AlignFlag::expand_vertical))
                {
                    width = std::max(child->box().width(), width);
                    height += child->box().height();
                }
            }
        }
        width += 2. * moat();
        height += 2. * moat();
 
        if (align().is_set(AlignFlag::expand_horizontal))
            if (width < box().width())
                width = box().width();
 
        if (align().is_set(AlignFlag::expand_vertical))
            if (height < box().height())
                height = box().height();
 
        return {width, height};
    }
 
    Orientation m_orient{Orientation::horizontal};
    Justification m_justify{Justification::start};
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
class EGT_API HorizontalBoxSizer : public BoxSizer
{
public:
 
    explicit HorizontalBoxSizer(Justification justify = Justification::middle)
        : BoxSizer(Orientation::horizontal, justify)
    {
        name("HorizontalBoxSizer" + std::to_string(m_widgetid));
    }
 
    explicit HorizontalBoxSizer(Serializer::Properties& props)
        : HorizontalBoxSizer(props, false)
    {
    }
 
protected:
 
    explicit HorizontalBoxSizer(Serializer::Properties& props, bool is_derived)
        : BoxSizer(props, true)
    {
        if (!is_derived)
            deserialize_leaf(props);
    }
 
public:
 
    explicit HorizontalBoxSizer(Frame& parent, Justification justify = Justification::middle)
        : BoxSizer(parent, Orientation::horizontal, justify)
    {}
};
 
class EGT_API VerticalBoxSizer : public BoxSizer
{
public:
 
    explicit VerticalBoxSizer(Justification justify = Justification::middle)
        : BoxSizer(Orientation::vertical, justify)
    {
        name("VerticalBoxSizer" + std::to_string(m_widgetid));
    }
 
    explicit VerticalBoxSizer(Serializer::Properties& props)
        : VerticalBoxSizer(props, false)
    {
    }
 
protected:
 
    explicit VerticalBoxSizer(Serializer::Properties& props, bool is_derived)
        : BoxSizer(props, true)
    {
        if (!is_derived)
            deserialize_leaf(props);
    }
 
public:
 
    explicit VerticalBoxSizer(Frame& parent, Justification justify = Justification::middle)
        : BoxSizer(parent, Orientation::vertical, justify)
    {}
};
 
class EGT_API FlexBoxSizer : public BoxSizer
{
public:
 
    explicit FlexBoxSizer(Justification justify = Justification::middle)
        : BoxSizer(Orientation::flex, justify)
    {
        name("FlexBoxSizer" + std::to_string(m_widgetid));
    }
 
    explicit FlexBoxSizer(Frame& parent, Justification justify = Justification::middle)
        : BoxSizer(parent, Orientation::flex, justify)
    {}
 
    explicit FlexBoxSizer(Serializer::Properties& props)
        : FlexBoxSizer(props, false)
    {
    }
 
protected:
 
    explicit FlexBoxSizer(Serializer::Properties& props, bool is_derived)
        : BoxSizer(props, true)
    {
        if (!is_derived)
            deserialize_leaf(props);
    }
};
 
}
}
 
#endif