widgets.hpp

Go to the documentation of this file.

#ifndef WIDGET_HPP
#define WIDGET_HPP

#include <QGridLayout>
#include <QGroupBox>
#include <QLabel>
#include <QLineEdit>
#include <QMainWindow>
#include <QMdiSubWindow>
#include <QPushButton>
#include <QValidator>
#include <limits>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>

#include "dlplugin.hpp"
#include "event.hpp"
#include "io.hpp"
#include "rt.hpp"

// These metatype declarations are needed by qt to store
// the types in QVariant, which is very convenient and reduces
// unnecessary repetiotion in panel construction
Q_DECLARE_METATYPE(IO::Block*)
Q_DECLARE_METATYPE(IO::flags_t)
Q_DECLARE_METATYPE(IO::endpoint)
Q_DECLARE_METATYPE(RT::block_connection_t)
Q_DECLARE_METATYPE(RT::State::state_t)


namespace Widgets
{

namespace Variable
{

typedef size_t Id;
constexpr Id INVALID_ID = static_cast<Id>(std::numeric_limits<size_t>::max());

enum variable_t : size_t
{
 INT_PARAMETER = 0,
 DOUBLE_PARAMETER,
 UINT_PARAMETER,
 STATE,
 COMMENT,
 UNKNOWN
};

std::string state2string(RT::State::state_t state);

std::string vartype2string(variable_t type);

struct Info
{
 size_t id = 0;
 std::string name;
 std::string description;
 Widgets::Variable::variable_t vartype = Widgets::Variable::UNKNOWN;
 std::variant<int64_t, double, uint64_t, std::string, RT::State::state_t>
 value;
};

} // namespace Variable

class DefaultGUILineEdit : public QLineEdit
{
 Q_OBJECT

public:
 explicit DefaultGUILineEdit(QWidget* parent);

 void blacken();
 QPalette palette;

public slots:
 void redden();
}; // class DefaultGUILineEdi

// Forward declare plugin class for the component and panel private pointers
class Plugin;
class Panel;

struct FactoryMethods
{
 std::unique_ptr<Widgets::Plugin> (*createPlugin)(Event::Manager*) = nullptr;

 std::unique_ptr<Widgets::Component> (*createComponent)(Widgets::Plugin*) =
 nullptr;

 Widgets::Panel* (*createPanel)(QMainWindow*, Event::Manager*) = nullptr;
};

class Component : public RT::Thread
{
public:
 Component(Widgets::Plugin* hplugin,
 const std::string& mod_name,
 const std::vector<IO::channel_t>& channels,
 const std::vector<Widgets::Variable::Info>& variables);

 template<typename T>
 T getValue(const size_t& var_id)
 {
 return std::get<T>(this->parameters.at(var_id).value);
 }

 template<typename T>
 void setValue(const size_t& var_id, T value)
 {
 this->parameters.at(var_id).value = value;
 }

 std::string getDescription(const size_t& var_id);

 std::string getValueString(const size_t& var_id);

 RT::State::state_t getState() const { return this->component_state; }

 void setState(RT::State::state_t state) { this->component_state = state; }

 std::vector<Widgets::Variable::Info> getParametersInfo()
 {
 return this->parameters;
 }

 Widgets::Plugin* getHostPlugin() { return this->hostPlugin; }

private:
 std::vector<Widgets::Variable::Info> parameters;
 Widgets::Plugin* hostPlugin;
 RT::State::state_t component_state = RT::State::INIT;
};

class Panel : public QWidget
{
 Q_OBJECT
public:
 Panel(const std::string& mod_name,
 QMainWindow* mw,
 Event::Manager* ev_manager);

 QMdiSubWindow* getMdiWindow() { return this->m_subwindow; }

 virtual void createGUI(const std::vector<Widgets::Variable::Info>& vars,
 const std::vector<Widgets::Variable::Id>& skip_ids);

 void setHostPlugin(Widgets::Plugin* hplugin) { this->hostPlugin = hplugin; }

signals:

 void signal_state_change(RT::State::state_t state);

public slots:

 void resizeMe();

 virtual void exit();

 virtual void refresh();

 virtual void modify();

 virtual void pause(bool p);

 virtual void update_state(RT::State::state_t flag);

protected:
 QString getParameter(const QString& var_name);

 void setParameter(const QString& var_name, double value);

 void setParameter(const QString& var_name, uint64_t value);

 void setParameter(const QString& var_name, int value);

 QString getComment(const QString& name);

 void setComment(const QString& var_name, const QString& comment);

 void closeEvent(QCloseEvent* event) override;

 std::string getName() { return this->m_name; }

 Widgets::Plugin* getHostPlugin() { return this->hostPlugin; }

 QMainWindow* getQMainWindowPtr() { return this->main_window; }

 Event::Manager* getRTXIEventManager() { return this->event_manager; }

private:
 QMainWindow* main_window = nullptr;
 std::string m_name;
 QMdiSubWindow* m_subwindow = nullptr;
 Widgets::Plugin* hostPlugin = nullptr;
 Event::Manager* event_manager = nullptr;

 // Default buttons
 QPushButton* pauseButton = nullptr;
 QPushButton* modifyButton = nullptr;
 QPushButton* unloadButton = nullptr;

 struct param_t
 {
 QLabel* label = nullptr;
 QString str_value;
 DefaultGUILineEdit* edit = nullptr;
 Widgets::Variable::variable_t type = Widgets::Variable::UNKNOWN;
 Widgets::Variable::Info info;
 };
 std::unordered_map<std::string, param_t> parameter;
 QPalette palette;
};

class Plugin : public Event::Handler
{
public:
 Plugin(Event::Manager* ev_manager, std::string mod_name);
 Plugin(const Plugin& plugin) = delete; // copy constructor
 Plugin& operator=(const Plugin& plugin) =
 delete; // copy assignment noperator
 Plugin(Plugin&&) = delete; // move constructor
 Plugin& operator=(Plugin&&) = delete; // move assignment operator
 ~Plugin() override;

 size_t getID();

 void attachComponent(std::unique_ptr<Widgets::Component> component);

 void attachPanel(Widgets::Panel* panel);

 int64_t getComponentIntParameter(const Variable::Id& parameter_id);

 uint64_t getComponentUIntParameter(const Variable::Id& parameter_id);

 double getComponentDoubleParameter(const Variable::Id& parameter_id);

 template<typename T>
 int setComponentParameter(const Variable::Id& parameter_id, T value)
 {
 const int result = 0;
 Widgets::Variable::variable_t param_type = Widgets::Variable::UNKNOWN;
 if (typeid(T) == typeid(int64_t)) {
 param_type = Widgets::Variable::INT_PARAMETER;
 } else if (typeid(T) == typeid(double)) {
 param_type = Widgets::Variable::DOUBLE_PARAMETER;
 } else if (typeid(T) == typeid(uint64_t)) {
 param_type = Widgets::Variable::UINT_PARAMETER;
 } else if (typeid(T) == typeid(std::string)) {
 param_type = Widgets::Variable::COMMENT;
 } else {
 ERROR_MSG(
 "Widgets::Plugin::setComponentParameter : Parameter type not "
 "supported");
 return -1;
 }
 Event::Object event(Event::Type::RT_WIDGET_PARAMETER_CHANGE_EVENT);
 event.setParam("paramID", std::any(parameter_id));
 event.setParam("paramType", std::any(param_type));
 event.setParam("paramValue", std::any(value));
 event.setParam("paramWidget", std::any(this->plugin_component.get()));
 this->event_manager->postEvent(&event);
 return result;
 }

 std::string getName() const { return this->name; }

 bool getActive();

 int setActive(bool state);

 void receiveEvent(Event::Object* event) override;

 std::string getLibrary() const { return this->library; }

 void setLibrary(const std::string& lib) { this->library = lib; }

 void registerComponent();

 void setComponentState(RT::State::state_t state);

 virtual std::vector<Widgets::Variable::Info> getComponentParametersInfo();

protected:
 Widgets::Component* getComponent();
 Event::Manager* getEventManager();
 QMainWindow* getQMainWindow();
 Widgets::Panel* getPanel();

private:
 // owned pointers
 std::unique_ptr<Widgets::Component> plugin_component;

 // not owned pointers (managed by external objects)
 Event::Manager* event_manager = nullptr;
 QMainWindow* main_window = nullptr; // Qt handles this lifetime
 Widgets::Panel* widget_panel = nullptr; // Qt handles this lifetime

 std::string library;
 std::string name;
};

} // namespace Widgets

#endif