MakeGuiConfigStruct.h

Go to the documentation of this file.

#pragma once
 
#include "MakeGuiElement.h"
 
namespace armarx::meta::cfg
{
    template <class T, class = void>
    struct gui_definition_create : std::false_type
    {
    };
} // namespace armarx::meta::cfg
 
namespace armarx::meta::cfg::detail
{
    template <class VarName, class CL, class MT, MT CL::*ptr>
    std::vector<RemoteGui::WidgetPtr>
    DoCreateElement(
        const boost::hana::pair<VarName, boost::hana::struct_detail::member_ptr<MT CL::*, ptr>>&,
        const std::string& prefix,
        const CL& val)
    {
        ARMARX_TRACE;
        const auto varname = hana::to<char const*>(VarName{});
        const auto& var = val.*ptr;
        using def_create = gui_definition_create<MT>;
        using elem_create = gui_definition_create_element<CL, MT, ptr>;
        if constexpr (def_create::value)
        {
            return {def_create::create(var, prefix, varname)};
        }
        else if constexpr (elem_create::value)
        {
            return elem_create::create(var, prefix, varname);
        }
        else
        {
            static_assert(!std::is_same_v<MT, MT>, "this member type is not handeled!");
            return {};
        }
    }
} // namespace armarx::meta::cfg::detail
 
namespace armarx::meta::cfg
{
    template <class T>
    struct gui_definition_create<T, std::enable_if_t<meta::cfg::gui_definition_enabled_v<T>>> :
        std::true_type
    {
        template <class OverrideLayoutT = undefined_t>
        static auto
        create(const T& val, const std::string& prefix, const std::string& name)
        {
            using layout_t = first_not_undefined_t<OverrideLayoutT,
                                                   config_layout<T>,
                                                   RemoteGui::GroupBox // default value
                                                   >;
 
            ARMARX_TRACE;
            namespace hana = boost::hana;
            static constexpr auto accessors = hana::accessors<T>();
 
            auto [widget, addChildren] = [&]
            {
                static constexpr bool grpbox = std::is_same_v<layout_t, RemoteGui::GroupBox>;
                static constexpr bool sgrid = std::is_same_v<layout_t, RemoteGui::SimpleGridLayout>;
                static constexpr bool vbox = std::is_same_v<layout_t, RemoteGui::VBoxLayout>;
                static constexpr bool hbox = std::is_same_v<layout_t, RemoteGui::HBoxLayout>;
 
                if constexpr (grpbox || sgrid)
                {
                    RemoteGui::SimpleGridLayoutPtr l = new RemoteGui::SimpleGridLayout;
                    l->columns = 2;
                    auto add = [l](const auto& cs)
                    {
                        if (cs.size() == 1)
                        {
                            l->children.emplace_back(new RemoteGui::Widget);
                            l->children.emplace_back(cs.front());
                        }
                        else
                        {
                            l->children.insert(l->children.end(), cs.begin(), cs.end());
                        }
                    };
                    if constexpr (grpbox)
                    {
                        return std::make_pair(
                            RemoteGui::makeGroupBox(ConcatID(prefix, name)).label(name).addChild(l),
                            add);
                    }
                    else
                    {
                        return std::make_pair(l, add);
                    }
                }
                else if constexpr (vbox || hbox)
                {
                    RemoteGui::WidgetPtr l = new layout_t;
                    auto add = [l](const auto& cs)
                    { l->children.insert(l->children.end(), cs.begin(), cs.end()); };
                    return std::make_pair(l, add);
                }
                else
                {
                    static_assert(!std::is_same_v<T, T>,
                                  "the given type for config_layout can't be used");
                }
            }();
 
            hana::for_each(accessors,
                           [&, addChildren = std::ref(addChildren)](auto& e)
                           {
                               ARMARX_TRACE_LITE;
                               using elem_det = decltype(armarx::meta::cfg::to_element_detail(e));
                               if constexpr (!elem_det::no_remote_gui)
                               {
                                   addChildren(
                                       detail::DoCreateElement(e, ConcatID(prefix, name), val));
                               }
                               else
                               {
                                   // do nothing
                               }
                           });
 
            return widget;
        }
 
        static auto
        create(const T& val, const std::string& prefix, const std::string& name)
        {
            return create<>(val, prefix, name);
        }
    };
} // namespace armarx::meta::cfg