MakeGuiElement.h

Go to the documentation of this file.

#pragma once
 
#include <SimoxUtility/meta/type_traits/is_any_of.h>
#include <SimoxUtility/meta/type_traits/is_std_array.h>
 
#include "../../WidgetBuilder.h"
#include "../Common.h"
 
namespace armarx::meta::cfg
{
    template <class CL, class MT, MT CL::*ptr>
    struct gui_definition_create_element_details : element_details<CL, MT, ptr>
    {
        using element = element_details<CL, MT, ptr>;
 
        static void
        SetMin(auto& builder, [[maybe_unused]] MT defaultValue)
        {
            if constexpr (is_not_undefined_t(element::min))
            {
                builder.min(element::min);
            }
            else
            {
                builder.min(std::min(MT{0}, defaultValue));
            }
        }
 
        static void
        SetMax(auto& builder, [[maybe_unused]] MT defaultValue)
        {
            if constexpr (is_not_undefined_t(element::max))
            {
                builder.max(element::max);
            }
            else
            {
                builder.max(std::max(MT{100}, defaultValue));
            }
        }
 
        static void
        SetDescription(auto& builder)
        {
            if constexpr (is_not_undefined_t(element::description))
            {
                builder.toolTip(element::description);
            }
        }
 
        static void
        SetSteps(auto& builder)
        {
            if constexpr (is_not_undefined_t(element::steps))
            {
                builder.steps(element::steps);
            }
        }
 
        static void
        SetDecimals(auto& builder)
        {
            if constexpr (is_not_undefined_t(element::decimals))
            {
                builder.decimals(element::decimals);
            }
        }
 
        static std::string
        GetLabel(const std::string& name)
        {
            if constexpr (is_not_undefined_t(element::label))
            {
                return element::label;
            }
            return name;
        }
 
        static auto
        MakeLabel(const std::string& name)
        {
            auto b = RemoteGui::makeTextLabel(GetLabel(name));
            SetDescription(b);
            return b;
        }
    };
} // namespace armarx::meta::cfg
 
//element def (variant types except int)
namespace armarx::meta::cfg
{
    template <class CL, class MT, MT CL::*ptr, class = void>
    struct gui_definition_create_element : std::false_type
    {
    };
 
#define create_specalization_for_type(type)                                                        \
    template <class CL, type CL::*ptr>                                                             \
    struct gui_definition_create_element<CL, type, ptr, void> : std::true_type                     \
    {                                                                                              \
        using element = gui_definition_create_element_details<CL, type, ptr>;                      \
        static std::vector<RemoteGui::WidgetPtr>                                                   \
        create(type val, const std::string& prefix, const std::string& name);                      \
    };                                                                                             \
    template <class CL, type CL::*ptr>                                                             \
    std::vector<RemoteGui::WidgetPtr> gui_definition_create_element<CL, type, ptr>::create(        \
        type val, const std::string& prefix, const std::string& name)
 
    create_specalization_for_type(float)
    {
        ARMARX_TRACE;
        using widget_t = typename element::widget_t;
        static constexpr bool is_spinbox =
            simox::meta::is_any_of_v<widget_t, RemoteGui::FloatSpinBox, undefined_t>;
        static constexpr bool is_slider = std::is_same_v<RemoteGui::FloatSlider, widget_t>;
 
        static_assert(is_spinbox || is_slider, "the given type for element_widget can't be used");
 
        auto w = [&]
        {
            if constexpr (is_slider)
            {
                return RemoteGui::makeFloatSlider(ConcatID(prefix, name)).value(val);
            }
            else
            {
                return RemoteGui::makeFloatSpinBox(ConcatID(prefix, name)).value(val);
            }
        }();
        element::SetMin(w, 0);
        element::SetMax(w, 100);
        element::SetDescription(w);
        element::SetSteps(w);
        if constexpr (is_spinbox)
        {
            element::SetDecimals(w);
        }
        else
        {
            static_assert(!is_not_undefined_t(element::decimals),
                          "element_decimals can't be set for a slider");
        }
 
        return {element::MakeLabel(name), w};
    }
 
    create_specalization_for_type(bool)
    {
        ARMARX_TRACE;
        using widget_t = typename element::widget_t;
        static constexpr bool is_checkbox =
            simox::meta::is_any_of_v<widget_t, RemoteGui::CheckBox, undefined_t>;
        static constexpr bool is_toggleButton = std::is_same_v<RemoteGui::ToggleButton, widget_t>;
 
        static_assert(is_checkbox || is_toggleButton,
                      "the given type for element_widget can't be used");
 
        auto w = [&]
        {
            if constexpr (is_checkbox)
            {
                return RemoteGui::makeCheckBox(ConcatID(prefix, name)).value(val);
            }
            else
            {
                return RemoteGui::makeToggleButton(ConcatID(prefix, name)).value(val);
            }
        }();
        w.label(element::GetLabel(name));
 
        static_assert(!is_not_undefined_t(element::min),
                      "element_min can't be set for bool widgets");
        static_assert(!is_not_undefined_t(element::max),
                      "element_max can't be set for bool widgets");
 
        element::SetDescription(w);
 
        static_assert(!is_not_undefined_t(element::decimals),
                      "element_decimals can't be set for bool widgets");
        static_assert(!is_not_undefined_t(element::steps),
                      "element_steps can't be set for bool widgets");
        return {w};
    }
 
    create_specalization_for_type(std::string)
    {
        ARMARX_TRACE;
        return {
            RemoteGui::makeTextLabel(name),
            RemoteGui::makeLineEdit(ConcatID(prefix, name)).value(val) ///TODO
        };
    }
 
    create_specalization_for_type(Eigen::Matrix4f)
    {
        ARMARX_TRACE;
        return {
            RemoteGui::makeTextLabel(name),
            RemoteGui::makePosRPYSpinBoxes(ConcatID(prefix, name)).value(val) ///TODO
        };
    }
 
    create_specalization_for_type(Eigen::Vector3f)
    {
        ARMARX_TRACE;
        using widget_t = typename element::widget_t;
        static constexpr bool is_spinbox =
            simox::meta::is_any_of_v<widget_t, RemoteGui::FloatSpinBox, undefined_t>;
        auto w = RemoteGui::makeVector3fSpinBoxes(ConcatID(prefix, name)).value(val);
        if constexpr (is_not_undefined_t(element::min))
        {
            element::SetMin(w, Eigen::Vector3f(-100, -100, -100));
        }
        else
        {
        }
        if constexpr (is_not_undefined_t(element::max))
        {
            element::SetMax(w, Eigen::Vector3f(100, 100, 100));
        }
        else
        {
        }
        element::SetSteps(w);
        if constexpr (is_spinbox)
        {
            element::SetDecimals(w);
        }
        else
        {
            static_assert(!is_not_undefined_t(element::decimals),
                          "element_decimals can't be set for a slider");
        }
        return {
            RemoteGui::makeTextLabel(name), w ///TODO
 
        };
    }
 
#undef create_specalization_for_type
} // namespace armarx::meta::cfg
 
//element def (integral types except bool)
namespace armarx::meta::cfg
{
    template <class CL, class MT, MT CL::*ptr>
    struct gui_definition_create_element<
        CL,
        MT,
        ptr,
        std::enable_if_t<std::is_integral_v<MT> && !std::is_same_v<MT, bool>>> : std::true_type
    {
        using element = gui_definition_create_element_details<CL, MT, ptr>;
 
        static std::vector<RemoteGui::WidgetPtr>
        create(MT val, const std::string& prefix, const std::string& name)
        {
            ARMARX_TRACE;
            using widget_t = typename element::widget_t;
            static constexpr bool is_spinbox =
                simox::meta::is_any_of_v<widget_t, RemoteGui::IntSpinBox, undefined_t>;
            static constexpr bool is_slider = std::is_same_v<RemoteGui::IntSlider, widget_t>;
 
            static_assert(is_spinbox || is_slider,
                          "the given type for element_widget can't be used");
 
            auto w = [&]
            {
                if constexpr (is_slider)
                {
                    return RemoteGui::makeIntSlider(ConcatID(prefix, name)).value(val);
                }
                else
                {
                    return RemoteGui::makeIntSpinBox(ConcatID(prefix, name)).value(val);
                }
            }();
 
            element::SetMin(w, 0);
            element::SetMax(w, 100);
 
            element::SetDescription(w);
 
            static_assert(!is_not_undefined_t(element::decimals),
                          "element_decimals can't be set for int spin boxes or sliders");
            static_assert(!is_not_undefined_t(element::steps),
                          "element_steps can't be set for int spin boxes or sliders");
 
            return {element::MakeLabel(name), w};
        }
    };
} // namespace armarx::meta::cfg
 
#include <SimoxUtility/meta/enum/adapt_enum.h>
 
//element def (enum types)
namespace armarx::meta::cfg
{
    template <class CL, class MT, MT CL::*ptr>
    struct gui_definition_create_element<CL,
                                         MT,
                                         ptr,
                                         std::enable_if_t<simox::meta::is_enum_adapted_v<MT>>> :
        std::true_type
    {
        using element = gui_definition_create_element_details<CL, MT, ptr>;
 
        static std::vector<RemoteGui::WidgetPtr>
        create(MT val, const std::string& prefix, const std::string& name)
        {
            ARMARX_TRACE;
            static_assert(simox::meta::is_any_of_v<typename element::widget_t,
                                                   RemoteGui::ComboBox,
                                                   undefined_t>,
                          "the given type for element_widget can't be used");
            static_assert(is_undefined_t(element::min));
            static_assert(is_undefined_t(element::max));
            static_assert(is_undefined_t(element::decimals));
            static_assert(is_undefined_t(element::steps));
            static_assert(is_undefined_t(element::label));
 
            auto builder = RemoteGui::makeComboBox(ConcatID(prefix, name));
 
            const auto& names = simox::meta::enum_names<MT>;
 
            builder.addOptions(names.template names<std::vector>());
            builder.value(names.to_name(val));
            element::SetDescription(builder);
 
            return {element::MakeLabel(name), builder};
        }
    };
} // namespace armarx::meta::cfg