PlainWavePanel.hh

#ifndef VTESTBED_GUI_PLAINWAVEPANEL_HH
#define VTESTBED_GUI_PLAINWAVEPANEL_HH

#include <typeindex>
#include <vector>

#include <vtestbed/core/plain_wave_generator.hh>
#include <vtestbed/core/types.hh>
#include <vtestbed/core/units.hh>

namespace vtb {

    namespace gui {

        template <class T>
        class PlainWavePanel {

        public:
            using amplitude_type = vtb::core::Amplitude<T>;
            using length_type = vtb::core::Length<T>;
            using direction_type = vtb::core::Direction<T>;
            using wave_type = vtb::core::Wave_base<T,3>;
            using wavy_surface_generator = vtb::core::Wavy_surface_generator<T,3>;
            using wavy_surface_generator_ptr = std::unique_ptr<wavy_surface_generator>;
            using policy_type = vtb::core::Policy;
            using testbed_type = vtb::core::Testbed<T,3>;

        private:
            using constructor_type =
                wavy_surface_generator_ptr(*)(const PlainWavePanel<T>*,policy_type);

        private:
            amplitude_type _amplitude{T{1}};
            length_type _length{T{40}};
            direction_type _direction{T{}};
            std::vector<const char*> _names;
            std::vector<std::type_index> _types;
            std::vector<constructor_type> _constructors;
            int _selectedIndex = 1;
            bool _waves = true;

        public:
            PlainWavePanel();

            inline void set_waves(bool b) { this->_waves = b; }
            inline bool get_waves() { return this->_waves; }
            void type(std::type_index t);

            void init(const testbed_type& testbed);
            void draw();

            inline amplitude_type amplitude() const { return this->_amplitude; }
            inline length_type length() const { return this->_length; }
            inline direction_type direction() const { return this->_direction; }
            void wave(const wave_type& rhs);

            wavy_surface_generator_ptr generator(policy_type policy) const;

        private:

            template <class Wave>
            inline void add_wave(const char* name) {
                using namespace vtb::core;
                this->_names.emplace_back(name);
                this->_types.emplace_back(typeid(Plain_wave_generator<T,3,Wave>));
                auto ctr = [] (const PlainWavePanel* p, policy_type policy) {
                    return make_plain_wave_generator<T,3>(
                        Wave(p->amplitude(), p->length(), p->direction()), policy);
                };
                this->_constructors.emplace_back(ctr);
            }

        };

    }
}

#endif // vim:filetype=cpp