flowcontainer.cpp

// SPDX-License-Identifier: LGPL-2.1-or-later OR BSD-3-Clause
// SPDX-FileCopyrightText: 2004 - 2008 Olof Naessén and Per Larsson
// SPDX-FileCopyrightText: 2013 - 2026 Fifengine contributors
 
#include "fifechan/widgets/flowcontainer.hpp"
 
#include <algorithm>
#include <list>
#include <vector>
 
#include "fifechan/exception.hpp"
 
namespace fcn
{
 
    FlowContainer::FlowContainer()
    {
        setOpaque(true);
    }
 
    FlowContainer::~FlowContainer() = default;
 
    void FlowContainer::setAlignment(FlowContainer::Alignment alignment)
    {
        mAlignment = alignment;
    }
 
    FlowContainer::Alignment FlowContainer::getAlignment() const
    {
        return mAlignment;
    }
 
    void FlowContainer::adjustContent()
    {
        // diff means border, padding, ...
        int const diffW = std::abs(getDimension().width - getChildrenArea().width);
        int const diffH = std::abs(getDimension().height - getChildrenArea().height);
 
        int const containerW = getChildrenArea().width;
        int const containerH = getChildrenArea().height;
 
        // calculates max layout size per column or row
        std::vector<int> layoutMax;
        int tmpSize       = 0;
        int x             = 0;
        int y             = 0;
        int visibleChilds = 0;
        std::list<Widget*>::const_iterator currChild(mChildren.begin());
        std::list<Widget*>::const_iterator endChildren(mChildren.end());
        for (; currChild != endChildren; ++currChild) {
            Widget* child = *currChild;
            if (!child->isVisible()) {
                continue;
            }
            ++visibleChilds;
            Rectangle const & rec = child->getDimension();
            if (mLayout == LayoutPolicy::Vertical) {
                // new column
                // negative bottom margin have no effect here
                if (y + child->getMarginTop() + rec.height +
                        (child->getMarginBottom() > 0 ? child->getMarginBottom() : 0) >
                    containerH) {
                    y = 0;
                    layoutMax.push_back(tmpSize);
                    tmpSize = 0;
                }
                y += rec.height + child->getMarginTop() + child->getMarginBottom() + getVerticalSpacing();
                tmpSize = std::max(
                    tmpSize,
                    rec.width + child->getMarginLeft() + (child->getMarginRight() > 0 ? child->getMarginRight() : 0));
            } else {
                // new row
                // negative right margin have no effect here
                if (x + rec.width + child->getMarginLeft() +
                        (child->getMarginRight() > 0 ? child->getMarginRight() : 0) >
                    containerW) {
                    x = 0;
                    layoutMax.push_back(tmpSize);
                    tmpSize = 0;
                }
                x += rec.width + child->getMarginLeft() + child->getMarginRight() + getHorizontalSpacing();
                tmpSize = std::max(
                    tmpSize,
                    rec.height + child->getMarginTop() + (child->getMarginBottom() > 0 ? child->getMarginBottom() : 0));
            }
        }
        if (tmpSize != 0) {
            layoutMax.push_back(tmpSize);
        }
 
        // places all widgets
        x                   = 0;
        y                   = 0;
        int totalW          = 0;
        int totalH          = 0;
        unsigned int layout = 0;
        if (mLayout == LayoutPolicy::Vertical && visibleChilds > 0) {
            currChild   = mChildren.begin();
            endChildren = mChildren.end();
            for (; currChild != endChildren; ++currChild) {
                if (!(*currChild)->isVisible()) {
                    continue;
                }
                int columnW       = layoutMax[layout];
                int const layoutW = (*currChild)->getWidth() + (*currChild)->getMarginLeft() +
                                    ((*currChild)->getMarginRight() > 0 ? (*currChild)->getMarginRight() : 0);
                Rectangle dim(
                    (*currChild)->getMarginLeft(), (*currChild)->getMarginTop(), layoutW, (*currChild)->getHeight());
 
                // new column
                // negative bottom margin have no effect here
                if (y + (*currChild)->getMarginTop() + dim.height +
                        ((*currChild)->getMarginBottom() > 0 ? (*currChild)->getMarginBottom() : 0) >
                    containerH) {
                    x += columnW + getHorizontalSpacing();
                    y = 0;
                    ++layout;
                    columnW = layoutMax[layout];
                }
                dim.y += y;
 
                switch (getAlignment()) {
                case Alignment::Left:
                    dim.x += x;
                    break;
                case Alignment::Center:
                    dim.x += x + (columnW - layoutW) / 2;
                    break;
                case Alignment::Right:
                    dim.x += x + (columnW - layoutW);
                    break;
                default:
                    throwException("Unknown alignment.");
                }
 
                (*currChild)->setDimension(dim);
                y += (*currChild)->getHeight() + (*currChild)->getMarginTop() + (*currChild)->getMarginBottom() +
                     getVerticalSpacing();
                totalW = std::max(totalW, dim.x + dim.width);
                totalH = std::max(totalH, y);
            }
            // remove last spacing
            totalH -= getVerticalSpacing();
            // always expand height but width only if horizontal expand is enabled
            totalH = std::max(totalH, containerH);
            if (isHorizontalExpand()) {
                totalW = std::max(totalW, containerW);
            }
        } else if (mLayout == LayoutPolicy::Horizontal && visibleChilds > 0) {
            currChild   = mChildren.begin();
            endChildren = mChildren.end();
            for (; currChild != endChildren; ++currChild) {
                if (!(*currChild)->isVisible()) {
                    continue;
                }
                int rowH          = layoutMax[layout];
                int const layoutH = (*currChild)->getHeight() + (*currChild)->getMarginTop() +
                                    ((*currChild)->getMarginBottom() > 0 ? (*currChild)->getMarginBottom() : 0);
                Rectangle dim(
                    (*currChild)->getMarginLeft(), (*currChild)->getMarginTop(), (*currChild)->getWidth(), layoutH);
 
                // new row
                // negative right margin have no effect here
                if (x + (*currChild)->getMarginLeft() + dim.width +
                        ((*currChild)->getMarginRight() > 0 ? (*currChild)->getMarginRight() : 0) >
                    containerW) {
                    x = 0;
                    y += rowH + getVerticalSpacing();
                    ++layout;
                    rowH = layoutMax[layout];
                }
                dim.x += x;
 
                switch (getAlignment()) {
                case Alignment::Top:
                    dim.y += y;
                    break;
                case Alignment::Center:
                    dim.y += y + (rowH - layoutH) / 2;
                    break;
                case Alignment::Bottom:
                    dim.y += y + (rowH - layoutH);
                    break;
                default:
                    throwException("Unknown alignment.");
                }
 
                (*currChild)->setDimension(dim);
                x += (*currChild)->getWidth() + (*currChild)->getMarginLeft() + (*currChild)->getMarginRight() +
                     getHorizontalSpacing();
                totalW = std::max(totalW, x);
                totalH = std::max(totalH, dim.y + dim.height);
            }
            // remove last spacing
            totalW -= getHorizontalSpacing();
            // always expand width but height only if vertical expand is enabled
            totalW = std::max(totalW, containerW);
            if (isVerticalExpand()) {
                totalH = std::max(totalH, containerH);
            }
        }
 
        // resize container
        totalW += diffW;
        totalH += diffH;
        setSize(totalW, totalH);
    }
 
    void FlowContainer::setLayout(Container::LayoutPolicy policy)
    {
        if (policy == LayoutPolicy::Circular) {
            throwException("Circular layout is not implemented for the FlowContainer.");
        } else {
            Container::setLayout(policy);
        }
    }
 
    void FlowContainer::resizeToContent(bool recursion)
    {
        if (recursion) {
            std::list<Widget*>::const_iterator currChild(mChildren.begin());
            std::list<Widget*>::const_iterator const endChildren(mChildren.end());
            for (; currChild != endChildren; ++currChild) {
                if (!(*currChild)->isVisible()) {
                    continue;
                }
                (*currChild)->resizeToContent(recursion);
            }
        }
 
        if (mLayout != Container::LayoutPolicy::Absolute) {
            if (getParent() != nullptr) {
                setSize(getMinSize().getWidth(), getMinSize().getHeight());
            }
        }
    }
 
    void FlowContainer::expandContent(bool recursion)
    {
        if (mLayout != Container::LayoutPolicy::Absolute) {
            adjustContent();
        }
        // not really needed
        if (recursion) {
            std::list<Widget*>::const_iterator currChild(mChildren.begin());
            std::list<Widget*>::const_iterator const endChildren(mChildren.end());
            for (; currChild != endChildren; ++currChild) {
                if (!(*currChild)->isVisible()) {
                    continue;
                }
                (*currChild)->expandContent(recursion);
            }
        }
    }
 
} // namespace fcn