ParamsConfig.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include <QWidget>
#include "ChoiceListDialog.h"
#include "TextEditor.h"
 
#include "stdafx.h"
 
namespace Ui
{
    class ParamsConfig;
}
 
namespace DynExp
{
    class DynExpCore;
    class Object;
    class ObjectLinkBase;
 
    enum class TextUsageType { Standard, Path, Code };
}
 
struct ParamInfo
{
    ParamInfo(std::string Title, std::string Description)
        : Title(std::move(Title)), Description(std::move(Description)) {}
 
    ParamInfo(std::string_view Title, std::string_view Description)
        : Title(Title), Description(Description) {}
 
    const std::string Title;                                            
    const std::string Description;                                      
};
 
class ParamsConfigDialog : public QDialog
{
    Q_OBJECT
 
public:
    using NumberType = double;                                          
    using TextType = Util::TextType;                                    
    using TextRefType = Util::TextRefType;                              
    using TextListType = Util::TextListType;                            
    using TextListIndexType = Util::TextListIndexType;                  
 
    using IndexType = qulonglong;
 
private:
    using FunctionsToCallIfAcceptedType = std::function<void(void)>;
 
    struct Param
    {
        enum class ParamType { Number, SignedInteger, UnsignedInteger, Text, Path, Code, TextList, IndexedTextList, Index, IndexList };
        Param() = delete;
 
        Param(const ParamType Type, QWidget* const Widget, const std::any Destiny,
            IndexType DefaultIndex = 0, const bool AllowResetToDefault = true)
            : Type(Type), Widget(Widget), Destiny(Destiny),
            DefaultIndex(DefaultIndex), AllowResetToDefault(AllowResetToDefault) {}
 
        const ParamType Type;               
        QWidget* const Widget;              
        const std::any Destiny;             
        const IndexType DefaultIndex;       
        const bool AllowResetToDefault;     
    };
 
public:
    ParamsConfigDialog(QWidget* parent, const DynExp::DynExpCore& Core, std::string Title);
 
    ~ParamsConfigDialog();
 
    void AddParam(ParamInfo&& Info, const std::any Destiny, const NumberType Value,
        const NumberType MinValue, const NumberType MaxValue, const NumberType Precision, const NumberType Increment);
 
    void AddParam(ParamInfo&& Info, const std::any Destiny, const TextType Value, const DynExp::TextUsageType TextUsage);
 
    void AddParam(ParamInfo&& Info, const std::any Destiny, const TextRefType Value,
        const TextListType& TextList, const bool AllowResetToDefault);
 
    void AddParam(ParamInfo&& Info, const std::any Destiny, const TextListIndexType Value,
        const TextListIndexType DefaultValue, const TextListType& TextList);
 
    template <typename EnumType, std::enable_if_t<std::is_enum_v<EnumType>, int> = 0>
    void AddParam(ParamInfo&& Info, const std::any Destiny, const EnumType Value,
        const EnumType DefaultValue, const Util::TextValueListType<EnumType>& TextValueList);
 
    void AddParam(ParamInfo&& Info, const std::any Destiny, const DynExp::ItemIDType Value,
        bool IsOptional, std::string_view IconResourcePath, FunctionsToCallIfAcceptedType FunctionToCallIfAccepted,
        Util::TextValueListType<IndexType>&& ItemIDsWithLabels);
 
    void AddParam(ParamInfo&& Info, const std::any Destiny, const std::vector<DynExp::ItemIDType>& Values,
        bool IsOptional, std::string_view IconResourcePath, FunctionsToCallIfAcceptedType FunctionToCallIfAccepted,
        Util::TextValueListType<IndexType>&& ItemIDsWithLabels);
 
    size_t GetNumParams() const noexcept { return ParamList.size(); }
 
    bool IsResetRequired() const noexcept { return ResetRequired; }
 
    bool Display(DynExp::Object* Object = nullptr);
 
private:
    void InsertWidget(ParamInfo&& Info, Param&& ParamData);
 
    template <typename ParamT>
    void Assign(ParamT& Param, typename ParamT::UnderlyingType Value);
 
    template <typename ParamT>
    void Assign(ParamT& Param, const std::vector<typename ParamT::UnderlyingType::value_type>& Values);
 
    void HandleTextEditorDialogsOnClose();
 
    std::unique_ptr<Ui::ParamsConfig> ui;
 
    const DynExp::DynExpCore& Core;
 
    std::vector<Param> ParamList;
 
    std::vector<FunctionsToCallIfAcceptedType> FunctionsToCallIfAccepted;
 
    DynExp::Object* Object;
 
    bool ResetRequired; 
 
    std::vector<TextEditor*> TextEditorDialogs;
 
private slots:
    void OnOpenParam();                 
    void OnEditParam();                 
    void OnResetParam();                
    virtual void accept() override;     
    virtual void reject() override;     
};
 
template <typename EnumType, std::enable_if_t<std::is_enum_v<EnumType>, int>>
void ParamsConfigDialog::AddParam(ParamInfo&& Info, const std::any Destiny, const EnumType Value,
    const EnumType DefaultValue, const Util::TextValueListType<EnumType>& TextValueList)
{
    using IntegerType = std::underlying_type_t<EnumType>;
    constexpr Param::ParamType ParamType = std::is_signed_v<IntegerType> ? Param::ParamType::SignedInteger : Param::ParamType::UnsignedInteger;
 
    auto ComboBox = new QComboBox(this);
    int SelectedIndex = 0;
    int DefaultIndex = 0;
 
    for (const auto& TextValuePair : TextValueList)
    {
        if (Value == TextValuePair.second)
            SelectedIndex = ComboBox->count();
        if (DefaultValue == TextValuePair.second)
            DefaultIndex = ComboBox->count();
 
        ComboBox->addItem(QString::fromStdString(TextValuePair.first), QVariant(static_cast<IntegerType>(TextValuePair.second)));
    }
    ComboBox->setCurrentIndex(SelectedIndex);
 
    Param ParamData(ParamType, ComboBox, Destiny, DefaultIndex);
    InsertWidget(std::move(Info), std::move(ParamData));
}
 
template <typename ParamT>
void ParamsConfigDialog::Assign(ParamT& Param, typename ParamT::UnderlyingType Value)
{
    ResetRequired |= Param != Value && Param.GetNeedsResetToApplyChange();
    Param = std::move(Value);
}
 
template <typename ParamT>
void ParamsConfigDialog::Assign(ParamT& Param, const std::vector<typename ParamT::UnderlyingType::value_type>& Values)
{
    ResetRequired |= Param.GetNeedsResetToApplyChange();
    Param = std::move(Values);
}