Vector3fWidgets.h

Go to the documentation of this file.

#pragma once
 
#include "Basic.h"
 
namespace armarx::RemoteGui::detail
{
    template <typename Derived>
    struct Vector3fMinMaxMixin : MinMaxMixin<Derived, Eigen::Vector3f>
    {
        using Base = MinMaxMixin<Derived, Eigen::Vector3f>;
 
        Derived&
        steps(const Eigen::Vector3i steps)
        {
            Derived& this_ = *static_cast<Derived*>(this);
            this_.widget().steps = toIceI(steps);
            return this_;
        }
 
        using Base::max;
        using Base::min;
 
        Derived&
        min(float v)
        {
            return Base::min({v, v, v});
        }
 
        Derived&
        min(std::array<float, 1> v)
        {
            return min(v.at(0));
        }
 
        Derived&
        max(float v)
        {
            return Base::max({v, v, v});
        }
 
        Derived&
        max(std::array<float, 1> v)
        {
            return max(v.at(0));
        }
 
        Derived&
        steps(int v)
        {
            return steps(v, v, v);
        }
 
        Derived&
        steps(std::array<int, 1> v)
        {
            return steps(v.at(0));
        }
 
        Derived&
        min(float x, float y, float z)
        {
            return Base::min(Eigen::Vector3f{x, y, z});
        }
 
        Derived&
        min(std::array<float, 3> v)
        {
            return min(v.at(0), v.at(1), v.at(2));
        }
 
        Derived&
        max(float x, float y, float z)
        {
            return Base::max(Eigen::Vector3f{x, y, z});
        }
 
        Derived&
        max(std::array<float, 3> v)
        {
            return max(v.at(0), v.at(1), v.at(2));
        }
 
        Derived&
        steps(int x, int y, int z)
        {
            return steps(Eigen::Vector3i{x, y, z});
        }
 
        Derived&
        steps(std::array<int, 3> v)
        {
            return steps(v.at(0), v.at(1), v.at(2));
        }
    };
 
    struct Vector3fSpinBoxesBuilder :
        public ValueMixin<Vector3fSpinBoxes, Eigen::Vector3f, Vector3fSpinBoxesBuilder>,
        public Vector3fMinMaxMixin<Vector3fSpinBoxesBuilder>,
        public ToolTipMixin<Vector3fSpinBoxesBuilder>
    {
        Vector3fSpinBoxesBuilder(std::string const& name, float limpos = 1000) : ValueMixin(name)
        {
            widget().steps = toIceI(Eigen::Vector3i::Ones() * static_cast<int>(2 * limpos + 1));
            widget().decimals = toIceI(Eigen::Vector3i::Ones());
            widget().min = toIceF(Eigen::Vector3f::Ones() * -limpos);
            widget().max = toIceF(Eigen::Vector3f::Ones() * +limpos);
            widget().defaultValue = makeValue(Eigen::Vector3f{Eigen::Vector3f::Zero()});
        }
 
        Vector3fSpinBoxesBuilder&
        decimals(const Eigen::Vector3i decimals)
        {
            widget().decimals = toIceI(decimals);
            return *this;
        }
 
        Vector3fSpinBoxesBuilder&
        decimals(int x, int y, int z)
        {
            return decimals(Eigen::Vector3i(x, y, z));
        }
 
        Vector3fSpinBoxesBuilder&
        decimals(int d)
        {
            return decimals(Eigen::Vector3i(d, d, d));
        }
 
        Vector3fSpinBoxesBuilder&
        decimals(std::array<int, 1> d)
        {
            return decimals(d.at(0));
        }
    };
} // namespace armarx::RemoteGui::detail
 
namespace armarx::RemoteGui
{
    inline detail::Vector3fSpinBoxesBuilder
    makeVector3fSpinBoxes(std::string const& name, float limpos = 1000)
    {
        return {name, limpos};
    }
} // namespace armarx::RemoteGui