utils.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UI_UTILS_HPP_
#define IV_SRC_UI_UTILS_HPP_
 
#include "alarms/enums.hpp"
#include "ui/representationsStructs.hpp"
 
#include <algorithm>
#include <cstdint>
 
namespace iv::ui::utils
{
 
inline iv::ui::eAnchorPoint justifyToAnchorPoint(uint8_t justify)
{
    switch (justify)
    {
        case 1:
            return iv::ui::eAnchorPoint::BottomLeft;
 
        case 2:
            return iv::ui::eAnchorPoint::BottomCenter;
 
        case 3:
            return iv::ui::eAnchorPoint::BottomRight;
 
        case 4:
            return iv::ui::eAnchorPoint::CenterLeft;
 
        case 0:
        case 5:
        default:
            return iv::ui::eAnchorPoint::Center;
 
        case 6:
            return iv::ui::eAnchorPoint::CenterRight;
 
        case 7:
            return iv::ui::eAnchorPoint::TopLeft;
 
        case 8:
            return iv::ui::eAnchorPoint::TopCenter;
 
        case 9:
            return iv::ui::eAnchorPoint::TopRight;
    }
}
 
inline iv::ui::AlarmStateRepresentation
getAlarmStateRepresentation(std::optional<iv::alarms::eAlarmState> alarmState,
                            std::optional<iv::alarms::eAlarmPriority> alarmPriority)
{
    iv::ui::AlarmStateRepresentation alarmStateRepresentation {.color = std::nullopt,
                                                               .isBlinking = false,
                                                               .blinkingColor = std::nullopt};
 
    if (not alarmState.has_value() or not alarmPriority.has_value())
    {
        return alarmStateRepresentation;
    }
 
    switch (alarmState.value())
    {
        case iv::alarms::eAlarmState::Acknowledged:
            alarmStateRepresentation.color = iv::alarms::getAlarmColor(
                    alarmState.value(), iv::alarms::eAlarmType::Normal, alarmPriority.value());
            break;
 
        case iv::alarms::eAlarmState::Active:
        case iv::alarms::eAlarmState::Unacknowledged:
            alarmStateRepresentation.isBlinking = true;
            alarmStateRepresentation.blinkingColor = iv::alarms::getAlarmColor(
                    alarmState.value(), iv::alarms::eAlarmType::Normal, alarmPriority.value());
            break;
 
        case iv::alarms::eAlarmState::Inactive:
        case iv::alarms::eAlarmState::Undefined:
            break;
    }
 
    return alarmStateRepresentation;
}
 
class PaginationIndex
{
public:
    PaginationIndex(uint64_t totalElements, uint64_t elementsPerPage, bool allPagesMustBeFilled = false)
        : m_currentIndex(0), m_totalElements(totalElements), m_elementsPerPage(elementsPerPage),
          m_allPagesMustBeFilled(allPagesMustBeFilled)
    {
    }
 
    [[nodiscard]] uint64_t getCurrentIndex() const
    {
        return m_currentIndex;
    }
    [[nodiscard]] uint64_t getElementsPerPage() const
    {
        return m_elementsPerPage;
    }
    [[nodiscard]] uint64_t getTotalElements() const
    {
        return m_totalElements;
    }
 
    void setTotalElements(uint64_t totalElements)
    {
        this->m_totalElements = totalElements;
    }
 
    void setElementsPerPage(uint64_t elementsPerPage)
    {
        this->m_elementsPerPage = elementsPerPage;
    }
 
    void setAllPagesMustBeFilled(bool allPagesMustBeFilled)
    {
        this->m_allPagesMustBeFilled = allPagesMustBeFilled;
    }
 
    void incrementIndex()
    {
        if (m_currentIndex < m_totalElements - 1)
        {
            m_currentIndex++;
 
            if (m_allPagesMustBeFilled)
            {
                m_currentIndex = std::min(m_currentIndex, m_totalElements - m_elementsPerPage);
            }
        }
    }
 
    void decrementIndex()
    {
        if (m_currentIndex > 0)
        {
            m_currentIndex--;
        }
    }
 
    void nextPage()
    {
        uint64_t nextPageIndex = m_currentIndex + m_elementsPerPage;
        if (m_allPagesMustBeFilled)
        {
            nextPageIndex = std::min(nextPageIndex, m_totalElements - m_elementsPerPage);
        }
 
        if (nextPageIndex < m_totalElements)
        {
            m_currentIndex = nextPageIndex;
        }
        else
        {
            m_currentIndex = m_totalElements - 1;
        }
    }
 
    void previousPage()
    {
        if (m_currentIndex >= m_elementsPerPage)
        {
            m_currentIndex -= m_elementsPerPage;
        }
        else
        {
            m_currentIndex = 0;
        }
    }
 
    void goToPage(uint64_t pageNumber)
    {
        uint64_t pageIndex = pageNumber * m_elementsPerPage;
 
        if (m_allPagesMustBeFilled)
        {
            pageIndex = std::min(pageIndex, m_totalElements - m_elementsPerPage);
        }
 
        if (pageIndex < m_totalElements)
        {
            m_currentIndex = pageIndex;
        }
        else
        {
            m_currentIndex = m_totalElements - 1;
        }
    }
 
    [[nodiscard]] uint64_t getCurrentPage() const
    {
        return m_currentIndex / m_elementsPerPage;
    }
 
    [[nodiscard]] uint64_t getTotalPages() const
    {
        return (m_totalElements + m_elementsPerPage - 1) / m_elementsPerPage;
    }
 
    void reset()
    {
        m_currentIndex = 0;
    }
 
private:
    uint64_t m_currentIndex;
    uint64_t m_totalElements;
    uint64_t m_elementsPerPage;
    bool m_allPagesMustBeFilled;
};
 
}// namespace iv::ui::utils
 
#endif//IV_SRC_UI_UTILS_HPP_