iconprogressbar.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
 
// Corresponding header include
#include <fifechan/widgets/iconprogressbar.hpp>
 
// Standard library includes
#include <cassert>
#include <string>
 
// Project headers (subdirs before local)
#include "fifechan/exception.hpp"
#include "fifechan/graphics.hpp"
#include "fifechan/image.hpp"
 
namespace fcn
{
    IconProgressBar::IconProgressBar() : mImage(nullptr)
    {
    }
 
    IconProgressBar::IconProgressBar(Image* image, int maxIcons) : mImage(image), mMaxIcons(maxIcons)
    {
        adjustSizeImpl();
    }
 
    IconProgressBar::IconProgressBar(std::string const & filename, int maxIcons) :
        mImage(Image::load(filename)), mInternalImage(true), mMaxIcons(maxIcons)
    {
        adjustSizeImpl();
    }
 
    IconProgressBar::~IconProgressBar()
    {
        if (mInternalImage) {
            delete mImage;
        }
    }
 
    void IconProgressBar::draw(Graphics* graphics)
    {
        assert("graphics must not be null" && graphics != nullptr);
        bool const active = isFocused();
 
        if (isOpaque()) {
            // Fill the background around the content
            if (active &&
                ((getSelectionMode() & Widget::SelectionMode::Background) == Widget::SelectionMode::Background)) {
                graphics->setColor(getSelectionColor());
            } else {
                graphics->setColor(getBackgroundColor());
            }
            graphics->fillRectangle(
                getBorderSize(),
                getBorderSize(),
                getWidth() - (2 * getBorderSize()),
                getHeight() - (2 * getBorderSize()));
        }
        // draw border or frame
        if (getBorderSize() > 0) {
            if (active && (getSelectionMode() & Widget::SelectionMode::Border) == Widget::SelectionMode::Border) {
                drawSelectionFrame(graphics);
            } else {
                drawBorder(graphics);
            }
        }
        if (mImage == nullptr) {
            return;
        }
        // draw "icons"
        int x = getBorderSize() + getPaddingLeft();
        int y = getBorderSize() + getPaddingTop();
        if (mOrientation == Orientation::Horizontal) {
            for (int i = 0; i < mIconCounter; i++) {
                graphics->drawImage(mImage, x, y);
                x += mImage->getWidth();
            }
        } else {
            for (int i = 0; i < mIconCounter; i++) {
                graphics->drawImage(mImage, x, y);
                y += mImage->getHeight();
            }
        }
    }
 
    void IconProgressBar::setOpaque(bool opaque)
    {
        mOpaque = opaque;
    }
 
    bool IconProgressBar::isOpaque() const
    {
        return mOpaque;
    }
 
    void IconProgressBar::setImage(Image* image)
    {
        if (mInternalImage) {
            delete mImage;
        }
 
        mInternalImage = false;
        mImage         = image;
 
        adjustSizeImpl();
    }
 
    Image const * IconProgressBar::getImage() const
    {
        return mImage;
    }
 
    void IconProgressBar::setMaxIcons(int maxIcons)
    {
        assert("max icons must be non-negative" && maxIcons >= 0);
        mMaxIcons = maxIcons;
        adjustSizeImpl();
    }
 
    int IconProgressBar::getMaxIcons() const
    {
        return mMaxIcons;
    }
 
    void IconProgressBar::setOrientation(Orientation orientation)
    {
        if (mOrientation != orientation) {
            if (orientation != Orientation::Horizontal && orientation != Orientation::Vertical) {
                throwException("Unknown orientation type in IconProgressBar object");
                return;
            }
            mOrientation = orientation;
            adjustSizeImpl();
        }
    }
 
    IconProgressBar::Orientation IconProgressBar::getOrientation() const
    {
        return mOrientation;
    }
 
    void IconProgressBar::advance()
    {
        assert("max icons must be non-negative" && mMaxIcons >= 0);
        mIconCounter = (mIconCounter + 1) % (mMaxIcons + 1);
    }
 
    void IconProgressBar::reset()
    {
        mIconCounter = 0;
    }
 
    void IconProgressBar::setIconCount(int icons)
    {
        mIconCounter = icons % (mMaxIcons + 1);
    }
 
    int IconProgressBar::getIconCount() const
    {
        return mIconCounter;
    }
 
    void IconProgressBar::resizeToContent(bool recursion)
    {
        static_cast<void>(recursion);
        adjustSizeImpl();
    }
 
    void IconProgressBar::adjustSize()
    {
        adjustSizeImpl();
    }
 
    void IconProgressBar::adjustSizeImpl()
    {
        int w = 0;
        int h = 0;
        if (mImage != nullptr) {
            w = mImage->getWidth();
            h = mImage->getHeight();
            if (mOrientation == Orientation::Horizontal) {
                w *= mMaxIcons;
            } else {
                h *= mMaxIcons;
            }
        }
        w += (2 * getBorderSize()) + getPaddingLeft() + getPaddingRight();
        h += (2 * getBorderSize()) + getPaddingTop() + getPaddingBottom();
        setSize(w, h);
    }
}; // namespace fcn