workspace.hpp

Go to the documentation of this file.

/*
 The Real-Time eXperiment Interface (RTXI)
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah,
 Will Cornell Medical College This program is free software: you can
 redistribute it and/or modify it under the terms of the GNU General Public
 License as published by the Free Software Foundation, either version 3 of the
 License, or (at your option) any later version. This program is distributed
 in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See the GNU General Public License for more details. You should have received
 a copy of the GNU General Public License along with this program. If not,
 see <http://www.gnu.org/licenses/>.
*/

#ifndef WORKSPACE_H
#define WORKSPACE_H

#include <utility>

#include "daq.hpp"
#include "dlplugin.hpp"
#include "event.hpp"
#include "widgets.hpp"

namespace Workspace
{

/*
 * Returns a set of functions for generating plugin, component, and panel
 * classes for a core RTXI widgets
 *
 */
std::optional<Widgets::FactoryMethods> get_core_plugin_factory(
 const std::string& plugin_name);

class Manager : public Event::Handler
{
public:
 Manager(const Manager&) = delete;
 Manager(Manager&&) = delete;
 Manager& operator=(const Manager&) = delete;
 Manager& operator=(Manager&&) = delete;
 explicit Manager(Event::Manager* ev_manager);
 ~Manager() override;

 Widgets::Plugin* loadPlugin(const std::string& library);

 void unloadPlugin(Widgets::Plugin* plugin);

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

 bool isRegistered(const Widgets::Plugin* plugin);

 std::vector<DAQ::Device*> getDevices(const std::string& driver);

 std::vector<DAQ::Device*> getAllDevices();

 void saveSettings(const QString& profile_name);

 void loadSettings(const QString& profile_name);

private:
 using driver_registry_entry = std::pair<std::string, DAQ::Driver*>;
 QString settings_prefix;
 void registerDriver(const std::string& driver_location);
 void unregisterDriver(const std::string& driver_location);

 [[nodiscard]] Widgets::Plugin* registerWidget(
 std::unique_ptr<Widgets::Plugin> widget);
 void unregisterWidget(Widgets::Plugin* plugin);

 void registerFactories(const std::string& widget_name,
 Widgets::FactoryMethods fact);
 void unregisterFactories(const std::string& widget_name);
 Widgets::Plugin* loadCorePlugin(const std::string& library);

 std::unordered_map<std::string, std::vector<std::unique_ptr<Widgets::Plugin>>>
 rtxi_widgets_registry;
 std::vector<driver_registry_entry> m_driver_registry;
 std::unordered_map<std::string, Widgets::FactoryMethods>
 rtxi_factories_registry;
 Event::Manager* event_manager;
 std::unique_ptr<DLL::Loader> m_plugin_loader;
 std::unique_ptr<DLL::Loader> m_driver_loader;

 std::mutex m_widgets_mut;
 std::mutex m_drivers_mut;
};

} // namespace Workspace

#endif // WORKSPACE_H