ControlPanel.hpp

#pragma once
#include <Core/Types.hpp>
#include <Core/Utils/Color.hpp>
#include <Gui/RaGui.hpp>
#include <Gui/Widgets/ConstrainedNumericSpinBox.hpp>
#include <Gui/Widgets/VectorEditor.hpp>
 
#include <QBoxLayout>
#include <QFrame>
#include <QVBoxLayout>
 
#include <functional>
#include <stack>
#include <string>
 
#include <QLabel>
 
namespace Ra {
namespace Gui {
namespace Widgets {
class RA_GUI_API ControlPanel : public QFrame
{
    Q_OBJECT
  public:
    explicit ControlPanel( const std::string& name, bool hline = true, QWidget* parent = nullptr );
    ControlPanel( const ControlPanel& )            = delete;
    ControlPanel& operator=( const ControlPanel& ) = delete;
    ControlPanel( ControlPanel&& )                 = delete;
    ControlPanel& operator=( ControlPanel&& )      = delete;
    ~ControlPanel() override                       = default;
 
    void addOption( const std::string& name,
                    std::function<void( bool )> callback,
                    bool set                   = false,
                    const std::string& tooltip = "" );
 
    void addLabel( const std::string& text );
 
    void addButton( const std::string& name,
                    std::function<void()> callback,
                    const std::string& tooltip = "" );
 
    void addColorInput( const std::string& name,
                        const std::function<void( const Ra::Core::Utils::Color& clr )>& callback,
                        Ra::Core::Utils::Color color = Ra::Core::Utils::Color::Black(),
                        bool withAlpha               = true,
                        const std::string& tooltip   = "" );
 
    template <typename T = Scalar>
    void addNumberInput( const std::string& name,
                         std::function<void( T )> callback,
                         T initial,
                         T min                      = std::numeric_limits<T>::lowest(),
                         T max                      = std::numeric_limits<T>::max(),
                         const std::string& tooltip = "",
                         int dec                    = 3 );
 
    template <typename T = Scalar>
    void addConstrainedNumberInput( const std::string& name,
                                    std::function<void( T )> callback,
                                    Scalar initial,
                                    std::function<bool( T )> predicate,
                                    const std::string& tooltip = "",
                                    int dec                    = 3 );
 
    void addSliderInput( const std::string& name,
                         std::function<void( int )> callback,
                         int initial                = 0,
                         int min                    = 0,
                         int max                    = 100,
                         const std::string& tooltip = "" );
 
    void addPowerSliderInput( const std::string& name,
                              std::function<void( double )> callback,
                              double initial             = 0,
                              double min                 = 0,
                              double max                 = 100,
                              const std::string& tooltip = "" );
 
    template <typename T = Scalar>
    void addVectorInput( const std::string& name,
                         std::function<void( const std::vector<T>& )> callback,
                         const std::vector<T>& initial,
                         const std::string& tooltip = "" );
 
    void addMatrixInput( const std::string& name,
                         std::function<void( const Ra::Core::MatrixN& )> callback,
                         const Ra::Core::MatrixN& initial,
                         int dec                    = 3,
                         const std::string& tooltip = "" );
 
    void addFileInput( const std::string& name,
                       std::function<void( std::string )> callback,
                       const std::string& rootDirectory,
                       const std::string& filters,
                       const std::string& tooltip = "" );
 
    void addFileOutput( const std::string& name,
                        std::function<void( std::string )> callback,
                        const std::string& rootDirectory,
                        const std::string& filters,
                        const std::string& tooltip = "" );
 
    void addComboBox( const std::string& name,
                      std::function<void( int )> callback,
                      int initial,
                      const std::vector<std::string>& items,
                      const std::string& tooltip = "" );
    void addComboBox( const std::string& name,
                      std::function<void( const QString& )> callback,
                      const std::string& initial,
                      const std::vector<std::string>& items,
                      const std::string& tooltip = "" );
 
    void addWidget( QWidget* newWidget );
 
    void addSeparator();
    void addStretch( int stretch );
 
    void newLayout() {
        m_contentLayout = new QGridLayout();
        m_contentLayout->setObjectName( "new layout" );
        m_mainLayout->addLayout( m_contentLayout );
    }
 
  private:
    QVBoxLayout* m_mainLayout;
    QGridLayout* m_contentLayout;
};
 
template <typename T>
void ControlPanel::addConstrainedNumberInput( const std::string& name,
                                              std::function<void( T )> callback,
                                              Scalar initial,
                                              std::function<bool( T )> predicate,
                                              const std::string& tooltip,
                                              int dec ) {
    auto inputLabel = new QLabel( tr( name.c_str() ) );
 
    auto inputField = new ConstrainedNumericSpinBox<T>();
    inputField->setValue( initial );
    inputField->setMinimum( std::numeric_limits<T>::lowest() );
    inputField->setMaximum( std::numeric_limits<T>::max() );
    connect( inputField,
             qOverload<typename QtSpinBox::getType<T>::SignalType>(
                 &ConstrainedNumericSpinBox<T>::valueChanged ),
             std::move( callback ) );
    inputField->setPredicate( predicate );
 
    if constexpr ( std::is_floating_point_v<T> ) { inputField->setDecimals( dec ); }
 
    if ( !tooltip.empty() ) {
        auto tooltipString =
            QString( "<qt>%1</qt>" ).arg( QString( tooltip.c_str() ).toHtmlEscaped() );
        inputLabel->setToolTip( tooltipString );
        inputField->setToolTip( tooltipString );
    }
    auto index = m_contentLayout->rowCount();
    m_contentLayout->addWidget( inputLabel, index, 0 );
    m_contentLayout->addWidget( inputField, index, 1 );
}
 
template <typename T>
void ControlPanel::addNumberInput( const std::string& name,
                                   std::function<void( T )> callback,
                                   T initial,
                                   T min,
                                   T max,
                                   const std::string& tooltip,
                                   int dec ) {
 
    auto inputLabel = new QLabel( tr( name.c_str() ) );
 
    using WidgetType = typename QtSpinBox::getType<T>::Type;
    auto inputField  = new WidgetType();
    auto inputLayout = new QHBoxLayout();
    inputLayout->addStretch();
    inputLayout->addWidget( inputField );
    // to prevent overflow
    inputField->setRange(
        min,
        std::min( T( std::numeric_limits<typename QtSpinBox::getType<T>::SignalType>::max() ),
                  max ) );
    inputField->setValue( initial );
    connect( inputField,
             qOverload<typename QtSpinBox::getType<T>::SignalType>( &WidgetType::valueChanged ),
             std::move( callback ) );
    if constexpr ( std::is_floating_point_v<T> ) { inputField->setDecimals( dec ); }
 
    if ( !tooltip.empty() ) {
        auto tooltipString =
            QString( "<qt>%1</qt>" ).arg( QString( tooltip.c_str() ).toHtmlEscaped() );
        inputLabel->setToolTip( tooltipString );
        inputField->setToolTip( tooltipString );
    }
    auto index = m_contentLayout->rowCount();
    m_contentLayout->addWidget( inputLabel, index, 0 );
    m_contentLayout->addLayout( inputLayout, index, 1 );
}
 
template <typename T>
void ControlPanel::addVectorInput( const std::string& name,
                                   std::function<void( const std::vector<T>& )> callback,
                                   const std::vector<T>& initial,
                                   const std::string& tooltip ) {
 
    auto inputLabel = new QLabel( tr( name.c_str() ) );
    auto inputField = new VectorEditor<T>( initial );
 
    if ( !tooltip.empty() ) {
        auto tooltipString =
            QString( "<qt>%1</qt>" ).arg( QString( tooltip.c_str() ).toHtmlEscaped() );
        inputLabel->setToolTip( tooltipString );
        inputField->setToolTip( tooltipString );
    }
    connect( inputField,
             QOverload<const std::vector<T>&>::of( &VectorEditorSignals::valueChanged ),
             std::move( callback ) );
 
    auto index = m_contentLayout->rowCount();
    m_contentLayout->addWidget( inputLabel, index, 0 );
    m_contentLayout->addWidget( inputField, index, 1 );
}
 
} // namespace Widgets
} // namespace Gui
} // namespace Ra