SheetModelEntryFactory.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UI_GUI_SHEETMODELENTRYFACTORY_HPP_
#define IV_SRC_UI_GUI_SHEETMODELENTRYFACTORY_HPP_
 
#include "core/concepts.hpp"
#include "third_party/magic_enum/magic_enum.hpp"
#include "ui/gui/CCheckButton.hpp"
#include "ui/gui/CComboBox.hpp"
#include "ui/gui/CEditNum.hpp"
#include "ui/gui/CLayoutHorizontal.hpp"
#include "ui/gui/sheets/AbstractSheetModel.hpp"
#include "ui/panels/CPanelsTools.hpp"
#include "units/model/Unit.hpp"
 
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
namespace iv::gui::factory
{
 
class SheetModelEntryFactory
{
public:
    template<iv::concepts::IntegerType T>
    static iv::gui::sheets::CellDefinition
    createEntryNumberIntegerCellDefinition(const std::string &nameField, T &valueRef, unsigned short numMaxChar)
    {
        iv::gui::sheets::CellDefinition cellDefinition {};
 
        if (CEditNum *editNum = CEditNum::createInteger<T>(nameField, valueRef, numMaxChar))
        {
            prvSetEntryChangeListener(editNum);
 
            cellDefinition.m_component = editNum;
 
            editNum->setShouldDisplayPopOverIfError(true);
            editNum->setDefineSize(CEditNum::kDefaultSizeString);
        }
 
        return cellDefinition;
    }
 
    template<iv::concepts::IntegerType T>
    static iv::gui::sheets::CellDefinition createEntryOptionalNumberIntegerCellDefinition(const std::string &nameField,
                                                                                          std::optional<T> &valueRef,
                                                                                          unsigned short numMaxChar)
    {
        iv::gui::sheets::CellDefinition cellDefinition {};
 
        auto sharedValue = std::make_shared<T>(valueRef.value_or(0));
        if (CEditNum *editNum = CEditNum::createInteger<T>(nameField, *sharedValue, numMaxChar))
        {
            prvSetEntryChangeListener(editNum);
 
            auto checkButton = new CCheckButton(valueRef.has_value());
 
            CPanelCheckWithEdit::linkCheckWithComponent(checkButton, editNum);
 
            auto layout = new CLayoutHorizontal();
            layout->addStart(checkButton, false, false, 0);
            layout->addEnd(editNum, true, true, 0);
 
            layout->emplaceListenerAccept(
                    [checkButton, sharedValue, &valueRef]()
                    {
                        if (checkButton->getValue())
                        {
                            valueRef = *sharedValue;
                        }
                        else
                        {
                            valueRef = std::nullopt;
                        }
                    });
 
            cellDefinition.m_component = layout;
 
            editNum->setShouldDisplayPopOverIfError(true);
            editNum->setDefineSize(CEditNum::kDefaultSizeString);
        }
 
        return cellDefinition;
    }
 
    static iv::gui::sheets::CellDefinition createEntryOptionalStringCellDefinition(std::optional<std::string> &valueRef)
    {
        iv::gui::sheets::CellDefinition cellDefinition {};
 
        auto sharedValue = std::make_shared<std::string>(valueRef.value_or(""));
        if (CEdit *edit = new CEdit(sharedValue.get()))
        {
            prvSetEntryChangeListener(edit);
 
            auto checkButton = new CCheckButton(valueRef.has_value());
 
            CPanelCheckWithEdit::linkCheckWithComponent(checkButton, edit);
 
            auto layout = new CLayoutHorizontal();
            layout->addStart(checkButton, false, false, 0);
            layout->addEnd(edit, true, true, 0);
 
            layout->emplaceListenerAccept(
                    [checkButton, sharedValue, &valueRef]()
                    {
                        if (checkButton->getValue())
                        {
                            valueRef = *sharedValue;
                        }
                        else
                        {
                            valueRef = std::nullopt;
                        }
                    });
 
            cellDefinition.m_component = layout;
 
            edit->setShouldDisplayPopOverIfError(true);
            edit->setDefineSize(CEditNum::kDefaultSizeString);
        }
 
        return cellDefinition;
    }
 
    template<iv::concepts::IntegerType T>
    static iv::gui::sheets::CellDefinition
    createEntryNumberIntegerCellDefinitionWithInterval(const std::string &nameField, T &valueRef, T minValue,
                                                       T maxValue, unsigned short numMaxChar)
    {
        iv::gui::sheets::CellDefinition cellDefinition {};
 
        if (CEditNum *editNum =
                    CEditNum::createIntegerWithInterval(nameField, valueRef, minValue, maxValue, numMaxChar))
        {
            prvSetEntryChangeListener(editNum);
 
            cellDefinition.m_component = editNum;
 
            editNum->setShouldDisplayPopOverIfError(true);
            editNum->setDefineSize(CEdit::kDefaultSizeString);
        }
 
        return cellDefinition;
    }
 
    template<iv::concepts::FloatingPointType T>
    static iv::gui::sheets::CellDefinition createEntryNumberDecimalCellDefinition(const std::string &nameField,
                                                                                  T &valueRef, uint16_t numMaxChar,
                                                                                  uint16_t numMaxDecimals)
    {
        iv::gui::sheets::CellDefinition cellDefinition {};
 
        if (CEditNum *editNum = CEditNum::createFloatingPoint<T>(nameField, valueRef, numMaxDecimals, numMaxChar))
        {
            prvSetEntryChangeListener(editNum);
 
            cellDefinition.m_component = editNum;
 
            editNum->setShouldDisplayPopOverIfError(true);
            editNum->setDefineSize(CEdit::kDefaultSizeString);
        }
 
        return cellDefinition;
    }
 
    template<iv::concepts::FloatingPointType T>
    static iv::gui::sheets::CellDefinition
    createEntryNumberDecimalCellDefinitionWithInterval(const std::string &nameField, T &valueRef, T minValue,
                                                       T maxValue, uint16_t numMaxChar, uint16_t numMaxDecimals)
    {
        iv::gui::sheets::CellDefinition cellDefinition {};
 
        if (CEditNum *editNum = CEditNum::createFloatingPointWithInterval<T>(nameField, valueRef, minValue, maxValue,
                                                                             numMaxDecimals, numMaxChar))
        {
            prvSetEntryChangeListener(editNum);
 
            cellDefinition.m_component = editNum;
 
            editNum->setShouldDisplayPopOverIfError(true);
            editNum->setDefineSize(CEdit::kDefaultSizeString);
        }
 
        return cellDefinition;
    }
 
    template<iv::concepts::EnumType T>
    static iv::gui::sheets::CellDefinition createComboBoxEnumCellDefinition(T &option)
    {
        auto options = magic_enum::enum_values<T>();
        return createComboBoxEnumCellDefinitionLimitedOptions(option, std::set(std::begin(options), std::end(options)));
    }
 
    template<iv::concepts::EnumType T>
    static iv::gui::sheets::CellDefinition createComboBoxEnumCellDefinitionLimitedOptions(T &option,
                                                                                          std::set<T> options)
    {
        iv::gui::sheets::CellDefinition cellDefinition {};
        CComboBoxEnum<T> *comboBoxEnum {};
 
        comboBoxEnum = new CComboBoxEnum<T>(&option);
        IV_ASSERT_NULL_POINTER(comboBoxEnum);
 
        for (T comboBoxValue: options)
        {
            comboBoxEnum->addOption(comboBoxValue, magic_enum::enum_name(comboBoxValue));
        }
 
        comboBoxEnum->setOption(static_cast<uint32_t>(option));
 
        comboBoxEnum->emplaceListenerChange(
                [](CDialog *, AbstractComponentGUI *comboBox)
                {
                    if (auto tComboBoxEnum = dynamic_cast<CComboBoxEnum<T> *>(comboBox))
                    {
                        tComboBoxEnum->setTooltip(
                                magic_enum::enum_name(static_cast<T>(tComboBoxEnum->getIdOptionSelection())));
                    }
                });
 
        cellDefinition.m_component = comboBoxEnum;
 
        return cellDefinition;
    }
 
    static iv::gui::sheets::CellDefinition createComboBoxCellDefinition(uint32_t &option,
                                                                        std::map<uint32_t, std::string> options);
 
    static iv::gui::sheets::CellDefinition createCheckButtonCellDefinition(bool &activated,
                                                                           const std::string &text = "");
    static iv::gui::sheets::CellDefinition createButtonCellDefinition(std::string_view text, IListenerClick *listener);
 
    static iv::gui::sheets::CellDefinition createEntryCellDefinition(std::string &value);
    static iv::gui::sheets::CellDefinition createEntryCellDefinition(std::string &value,
                                                                     IListenerIsAccept *listenerIsAccept);
    static iv::gui::sheets::CellDefinition
    createEntryCellDefinitionForTag(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                    const std::weak_ptr<iv::units::Unit> &unit);
    static iv::gui::sheets::CellDefinition createButtonSelectChannelCellDefinition(
            iv::types::channelId &channelIdOut,
            const std::optional<std::function<bool(std::shared_ptr<iv::channels::AbstractChannel>)>> &filterCallback =
                    std::nullopt,
            const std::function<void(const std::weak_ptr<iv::channels::AbstractChannel> &)> &selectionCallback =
                    [](const auto &) {});
 
    static iv::gui::sheets::CellDefinition createEntryCellDefinitionStatic(std::string_view value = "");
 
private:
    static void prvSetEntryChangeListener(AbstractComponentGUI *entryComponent);
};
 
}// namespace iv::gui::factory
 
#endif//IV_SRC_UI_GUI_SHEETMODELENTRYFACTORY_HPP_