main_window.cpp

Go to the documentation of this file.

#include "gui/main_window.h"
 
#include <QDebug>
#include <QRandomGenerator>
 
static QColor
getRandomColor()
{
    QRandomGenerator* generator{ QRandomGenerator::global() };
    auto r = static_cast<float>(generator->generateDouble());
    auto g = static_cast<float>(generator->generateDouble());
    auto b = static_cast<float>(generator->generateDouble());
    return QColor::fromRgbF(r, g, b);
}
 
namespace Gui
{
    MainWindow::MainWindow(QWidget* parent)
        : QMainWindow(parent), m_MenuBar{ new MenuBar(this) },
          m_MainContent{ new MainContent(this) },
          m_Scenario{ std::make_shared<CompileScenario::Scenario>(
              "Untitled Scenario",
              Core::GeographicalCoordinate(59.66584230, 9.65059460), 2700) },
          m_ScenarioSettingsDialog{ new MapDialog(this) }
    {
        setObjectName("MainWindow");
        setWindowTitle("Hivemind");
        setWindowIcon(QIcon(":/icons/logo_transparent_512.png"));
        setMenuBar(m_MenuBar);
        setCentralWidget(m_MainContent);
        resize(1280, 720);
 
        ConnectSlotsAndSignals();
        CreateNewAgent();
    }
 
    MainWindow::~MainWindow() {}
 
    void
    MainWindow::ConnectSlotsAndSignals()
    {
        // Menu bar signals
        connect(m_MenuBar, SIGNAL(SaveScenario(const std::string&)), this,
                SLOT(SaveScenario(const std::string&)));
        connect(m_MenuBar, SIGNAL(LoadScenario(const std::string&)), this,
                SLOT(LoadScenario(const std::string&)));
 
        // Connect keyframe list and keyframe manager
        auto keyframeList{ findChild<KeyframeList*>("KeyframeList") };
        if (keyframeList) {
            connect(&KeyframeManagement::KeyframeManager::Instance(),
                    SIGNAL(KeyframeAdded()), keyframeList, SLOT(Update()));
            connect(this, SIGNAL(ScenarioLoaded()), keyframeList,
                    SLOT(Update()));
        }
 
        auto mapViewer{ findChild<MapViewer*>("MapViewer") };
        if (mapViewer) {
            // Connect map viewer and keyframe manager
            connect(&KeyframeManagement::KeyframeManager::Instance(),
                    SIGNAL(KeyframeAdded()), mapViewer, SLOT(update()));
 
            // Connect satellite image request and map loading
            connect(&MapManagement::MapManager::Instance(),
                    &MapManagement::MapManager::RequestImage, mapViewer,
                    &MapViewer::WaitForData);
            connect(&MapManagement::MapManager::Instance(),
                    &MapManagement::MapManager::GotImage, mapViewer,
                    &MapViewer::DataReceived);
 
            connect(
                this,
                SIGNAL(ScenarioCompiled(
                    std::pair<CompileScenario::Scenario::RouteMap::iterator,
                              CompileScenario::Scenario::RouteMap::iterator>)),
                mapViewer,
                SLOT(UpdateRoutes(
                    std::pair<CompileScenario::Scenario::RouteMap::iterator,
                              CompileScenario::Scenario::RouteMap::iterator>)));
 
            auto timeline{ findChild<Timeline*>("Timeline") };
            if (timeline) {
                connect(timeline, SIGNAL(timeStampSelected(float)), mapViewer,
                        SLOT(UpdateTimeStamp(float)));
            }
        }
 
        // Connect deletion of keyframes in GUI
        auto keyframeControls{ findChild<KeyframeControls*>(
            "KeyframeControls") };
        if (keyframeControls && keyframeList) {
            connect(keyframeControls, SIGNAL(DeleteSelectedKeyframes()),
                    keyframeList, SLOT(DeleteSelected()));
        }
 
        auto scenarioControls{ findChild<ScenarioControls*>(
            "ScenarioControls") };
        if (scenarioControls) {
            connect(scenarioControls, SIGNAL(OpenSettingsDialog()),
                    m_ScenarioSettingsDialog, SLOT(exec()));
            connect(m_ScenarioSettingsDialog,
                    SIGNAL(MapDataReady(float, float, float)), this,
                    SLOT(UpdateScenario(float, float, float)));
            connect(scenarioControls, SIGNAL(CompileScenario()), this,
                    SLOT(CompileScenario()));
        }
 
        auto agentControls{ findChild<AgentControls*>("AgentControls") };
        if (agentControls) {
            connect(this, SIGNAL(SyncAgentColor()), agentControls,
                    SLOT(SyncColor()));
            if (mapViewer) {
                connect(agentControls,
                        SIGNAL(AgentChanged(
                            std::pair<std::vector<Core::Agent>::iterator,
                                      std::vector<Core::Agent>::iterator>)),
                        mapViewer,
                        SLOT(UpdateAgents(
                            std::pair<std::vector<Core::Agent>::iterator,
                                      std::vector<Core::Agent>::iterator>)));
                connect(agentControls, SIGNAL(ActiveAgentChanged(int)),
                        mapViewer, SLOT(UpdateActiveAgent(int)));
            }
 
            connect(
                this,
                SIGNAL(AgentAdded(std::pair<std::vector<Core::Agent>::iterator,
                                            std::vector<Core::Agent>::iterator>)),
                agentControls,
                SLOT(UpdateAgents(std::pair<std::vector<Core::Agent>::iterator,
                                            std::vector<Core::Agent>::iterator>)));
 
            connect(agentControls, SIGNAL(AddAgent()), this,
                    SLOT(CreateNewAgent()));
        }
    }
 
    void
    MainWindow::SaveScenario(const std::string& filepath)
    {
        m_Scenario->save(filepath);
    }
 
    void
    MainWindow::LoadScenario(const std::string& filepath)
    {
        m_Scenario->load(filepath);
        emit AgentAdded(m_Scenario->GetAgents());
        emit ScenarioLoaded();
        update();
    }
 
    void
    MainWindow::UpdateScenario(float latitude, float longitude, float size)
    {
        Core::GeographicalCoordinate coord{ latitude, longitude };
        m_Scenario->SetOrigin(coord, static_cast<int>(size));
    }
 
    void
    MainWindow::CompileScenario()
    {
        m_Scenario->Compile();
        auto routes = m_Scenario->GetRoutes();
        emit ScenarioCompiled(m_Scenario->GetRoutes());
    }
 
    void
    MainWindow::CreateNewAgent()
    {
        int maxId{ -1 };
        auto agents = m_Scenario->GetAgents();
        for (auto iter{ agents.first }; iter != agents.second; ++iter) {
            maxId = std::max(maxId, iter->Id);
        }
        int id{ maxId == -1 ? 0 : maxId + 1 };
 
        std::string color = getRandomColor().name().toStdString();
        m_Scenario->AddAgent({ id, "Untitled agent", color });
        emit AgentAdded(m_Scenario->GetAgents());
        emit SyncAgentColor();
    }
 
} // namespace Gui