Compiler Explorer

Source code

#include "app.h"
#include "ui_app.h"

#include <QScrollBar>

/*!
 * \brief Constructor
 * \param parent Qt parent: default = nullptr
 */
App::App(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::App)
{
    ui->setupUi(this);

// ===== CONFIG ROTORTEST LIBRARY ===== //

// Define the library directory paths:
    QString dir_parts, dir_materials, dir_excitations;

#ifdef QT_DEBUG
        #ifdef __APPLE__
            dir_parts = "../../../../../rotortest/library/parts";
            dir_materials = "../../../../../rotortest/library/materials";
            dir_excitations = "../../../../../rotortest/library/excitations";
        #else
            dir_parts = "../../rotortest/library/parts";
            dir_materials = "../../rotortest/library/materials";
            dir_excitations = "../../rotortest/library/excitations";
        #endif
    #else
        // RELEASE MODE:
        dir_parts = "./library/parts";
        dir_materials = "./library/materials";
        dir_excitations = "./library/excitations";
    #endif

// Join string paths in a list:
 std::list<QString> library_dirs;
 library_dirs.push_back(dir_parts);
 library_dirs.push_back(dir_materials);
 library_dirs.push_back(dir_excitations);

// Load all RTT libraries:
    loadLibraries(library_dirs);

// ===== CONFIG DEFAULT UI PROPERTIES ===== //
    // TOP MENUS:
    // Menu File:
    ui->actionSave->setDisabled(true);
    ui->actionSave_As->setDisabled(true);

// Menu File
    ui->actionClose_Project->setDisabled(true);
    ui->menuImport->setDisabled(true);
    ui->menuExport->setDisabled(true);

// Menu Material:
    ui->menuMaterial->setDisabled(true);

// Menu Geometry:
    ui->menuGeometry->setDisabled(true);

// Set console to read-only mode:
    ui->console_txt->setReadOnly(true);
    ui->console_txt->setCenterOnScroll(true);
    // =======================

// ===== PLUGIN LOADER ===== //
    QDir pluginsDir = QDir::currentPath();

#if defined(Q_OS_WIN)
    if (pluginsDir.dirName().toLower() == "debug" || pluginsDir.dirName().toLower() == "release")
        pluginsDir.cdUp();
#elif defined(Q_OS_MAC)
    if (pluginsDir.dirName() == "MacOS") {
        pluginsDir.cdUp();
        pluginsDir.cdUp();
        pluginsDir.cdUp();

#if defined (QT_DEBUG)
 pluginsDir.cdUp();
#endif
 }
#endif
 //pluginsDir.cd("plugins");
 pluginsDir.cdUp();
 pluginsDir.cdUp();
 pluginsDir.cd("build-lobular-bearing-plugin-Desktop_Qt_5_15_0_GCC_64bit-Debug");
 qInfo() << "Plugins Dir Path: " << pluginsDir.path();

QStringList plugins_path = getPluginsList(pluginsDir.path());
 // qInfo() << "Plugins List: " << plugins_path;

// Get plugins data and pointer:
    loadPlugins(plugins_path);
}

/*!
 * \brief Desconstructor
 */
App::~App()
{
    // Is there any opened project?
    if (!_workingFilePath.empty()) {
        auto question = new QMessageBox(QMessageBox::Question,
                                        QObject::tr("Save Project"),
                                        QObject::tr("Do you want to save your project changes?"),
                                        QMessageBox::Save | QMessageBox::Discard);

question->setDefaultButton(QMessageBox::Save);

// Run the user selected operation:
        if (question->exec() == QMessageBox::Save) {
            on_actionSave_triggered();
        }
    }

delete ui;
}

/*!
 * \brief Get all files from a given directory (recursive)
 * \param dirPath The dirctory/folder path
 * \return A file paths list
 */
std::list<QString> App::getFilesPath(const QString dirPath)
{
 // Get the current folder path:
 QDir dir = QDir::currentPath();

// Move to the library folder path:
    dir.cd(dirPath);

// Sorting folders and files by name:
    dir.setSorting(QDir::SortFlag::DirsFirst | QDir::SortFlag::Name);

// Output paths list:
 std::list<QString> paths;

// For all files in the folder:
    QDirIterator it(dir.absolutePath(), QDir::AllEntries | QDir::NoDotAndDotDot,  QDirIterator::Subdirectories | QDirIterator::FollowSymlinks);
    while (it.hasNext()) {
        // Go to the next file:
        it.next();

// Check the file extension:
        if(it.fileInfo().isFile() && it.fileInfo().completeSuffix() == "json") {
            // Add path to the output list:
            paths.push_back(it.filePath());
        }
    }

return paths;
}

/*!
 * \brief Load all library files stored in a path list
 * \param paths A file paths list
 */
void App::loadLibraryFiles(const std::list<QString> paths)
{
 foreach(QString p, paths) {
 sendStatusMsg(tr("Loaded library: %1").arg(p));

// Load the JSON file
        std::ifstream i(p.toStdString());
        JSON data;
        i >> data;

// Get the file type:
 std::string fileType;
 if (data.contains("file_type")) {
 fileType = data["file_type"].get<std::string>();
 }

// Error checking:
        if (fileType.empty()) {
            QMessageBox::warning(nullptr,
                                 QObject::tr("Load Library Files"),
                                 QObject::tr("This file doesn't have the file type field"),
                                 QMessageBox::Ok);
            continue;
        }

// Store the file data in the internal JSON library:
        if (fileType == "part") {
            _library["part"].push_back(data);
        } else if (fileType == "material") {
            _library["material"].push_back(data);
        } else if (fileType == "excitation") {
            _library["excitation"].push_back(data);
        } else {
            QMessageBox::warning(nullptr,
                                 QObject::tr("Load Library Files"),
                                 QObject::tr("The file type '%1' is not supported").arg(QString::fromStdString(fileType)),
                                 QMessageBox::Ok);
            continue;
        }
    }
}

/*!
 * \brief Load all RotorTest libraries
 * \param paths Directory/folders list where are located this files
 */
void App::loadLibraries(const std::list<QString> paths)
{
 // Init empty library arrays:
 _library["part"] = JSON::array();
 _library["material"] = JSON::array();
 _library["excitation"] = JSON::array();

// For each 'path' stored in 'paths':
 for (auto path : paths) {
 // Get all file paths:
 std::list<QString> filesPath = getFilesPath(path);
 // Load these files:
 loadLibraryFiles(filesPath);
 }
}

void App::on_actionNew_Project_triggered()
{
    // Open the file dialog UI:
    QString fileName = QFileDialog::getSaveFileName(this,
            tr("New Project"),
            QDir::homePath(),
            tr("json (*.json)"));

// Error checking:
    if (fileName.isEmpty()) { return; }

// Check fileName extension:
    if (!fileName.endsWith(".json")) {
        fileName.append(".json");
    }

// Set the working file path:
    _workingFilePath = fileName.toStdString();

// Open file to write:
    std::ofstream file(_workingFilePath);

// Error checking:
    if(!file.is_open()) {
        QMessageBox::warning(this, tr("Unable to write file"), tr("Unable to open the file to save"));
        return;
    }

// ===== STACK WIDGETS ===== //
    // Allocate a Stack Widgets forms:
    _formLibrary = new Form_Library(_library);
    _formMaterialFluid = new Form_Material_Fluid(_project["material"]);
    _formMaterialElastic = new Form_Material_Elastic(_project["material"]);
    _formPart = new Form_Part(_project["part"]);
    _formExcitation = new Form_Excitation(_project["excitation"]);
    _formJob = new Form_Job(_project["job"]);
    _formAssembly = new Form_Assembly(_project["assembly"]);

// ===== INSERT STACKED WIDGETS PAGES ===== //
    ui->stackedWidget->insertWidget(PART_PAGE, _formPart);
    ui->stackedWidget->insertWidget(MATERIAL_FLUID_PAGE, _formMaterialFluid);
    ui->stackedWidget->insertWidget(EXCITATION_PAGE, _formExcitation);
    ui->stackedWidget->insertWidget(JOB_PAGE, _formJob);
    ui->stackedWidget->insertWidget(ASSEMBLY_PAGE, _formAssembly);
    ui->stackedWidget->insertWidget(LIBRARY_PAGE, _formLibrary);
    ui->stackedWidget->insertWidget(MATERIAL_ELASTIC_PAGE, _formMaterialElastic);

connect(_formLibrary, SIGNAL(closeForm(void)), this, SLOT(closeForm(void)));
    connect(_formMaterialFluid, SIGNAL(closeForm(void)), this, SLOT(closeForm(void)));
    connect(_formMaterialElastic, SIGNAL(closeForm(void)), this, SLOT(closeForm(void)));

connect(_formAssembly, &Form_Assembly::sendMsg, this, &App::receivedMsg);
    connect(_formExcitation, &Form_Excitation::sendMsg, this, &App::receivedMsg);
    connect(_formJob, &Form_Job::sendMsg, this, &App::receivedMsg);
    connect(_formLibrary, &Form_Library::sendMsg, this, &App::receivedMsg);
    connect(_formMaterialElastic, &Form_Material_Elastic::sendMsg, this, &App::receivedMsg);
    connect(_formMaterialFluid, &Form_Material_Fluid::sendMsg, this, &App::receivedMsg);
    connect(_formPart, &Form_Part::sendMsg, this, &App::receivedMsg);

updateMaterialTopMenu();
    updateGeometryTopMenu();

// Init project fields:
    _project["metadata"] = JSON::object();
    _project["assembly"]["sheft"] = JSON::array();
    _project["assembly"]["bearing"] = JSON::array();
    _project["part"] = JSON::array();
    _project["material"] = JSON::array();
    _project["excitation"] = JSON::array();
    _project["job"] = JSON::array();
    _project["plugin"] = JSON::array();

// Write JSON data to file:
 file << std::setw(4) << _project << std::endl;

// Enable menus:
    ui->actionSave->setEnabled(true);
    ui->actionSave_As->setEnabled(true);
    ui->menuImport->setEnabled(true);
    ui->menuExport->setEnabled(true);

// ===== ENABLE TOP MENUS ===== //
    ui->actionClose_Project->setEnabled(true);
    ui->menuMaterial->setEnabled(true);
    ui->menuGeometry->setEnabled(true);

showStatusBarMessage(tr("Created in: %1").arg(QString::fromStdString(_workingFilePath)));

setWindowTitle("Rotortest - " + fileName);
}

void App::on_actionOpenProject_triggered()
{
    // Open the file dialog UI:
    QString fileName = QFileDialog::getOpenFileName(this,
            tr("Open Project"),
            QDir::homePath(),
            tr("json (*.json)"));

// Error checking:
    if (fileName.isEmpty()) { return; }

// Set the working file path:
    _workingFilePath = fileName.toStdString();

// Open file to read:
    std::ifstream file(_workingFilePath);

// Error checking:
    if(!file.is_open()) {
        QMessageBox::warning(this, tr("Unable to open file"),
                             tr("Unable to open this project file"));

return;
    }

// Load file to a JSON object:
    _project.clear();
    file >> _project;

validadeProjectFile();

updateMaterialTopMenu();
    updateGeometryTopMenu();

// Enable menus:
    ui->actionSave->setEnabled(true);
    ui->actionSave_As->setEnabled(true);
    ui->menuImport->setEnabled(true);
    ui->menuExport->setEnabled(true);

// ===== ENABLE TOP MENUS ===== //
    ui->actionClose_Project->setEnabled(true);
    ui->menuMaterial->setEnabled(true);
    ui->menuGeometry->setEnabled(true);

showStatusBarMessage(tr("Loaded File: %1").arg(fileName));

setWindowTitle("Rotortest - " + fileName);
}

void App::on_actionClose_Project_triggered()
{
    auto question = new QMessageBox(QMessageBox::Question,
                                    QObject::tr("Save Material"),
                                    QObject::tr("Do you want to save this project?"),
                                    QMessageBox::Save|QMessageBox::Discard);

question->setDefaultButton(QMessageBox::Save);

// Run the user selected operation:
    if (question->exec() == QMessageBox::Save) {
        on_actionSave_triggered();
    }

// Clear the project in memory:
    _project.clear();

// ===== CLEAR TOP MENUS ===== //
    ui->menuFluid->clear();
    ui->menuElastic->clear();

// ===== CONFIG DEFAULT UI PROPERTIES ===== //
    // TOP MENUS:
    // Menu File:
    ui->actionSave->setDisabled(true);
    ui->actionSave_As->setDisabled(true);
    ui->menuImport->setDisabled(true);
    ui->menuExport->setDisabled(true);
    ui->actionClose_Project->setDisabled(true);

// Menu Material:
    ui->menuMaterial->setDisabled(true);

// Return to the blank page:
    ui->stackedWidget->setCurrentIndex(CLEAN_PAGE);

showStatusBarMessage(tr("Closed project: %1").arg(QString::fromStdString(_workingFilePath)));
}

void App::validadeProjectFile(void)
{
    // Verify the basic fiels

// validade all elastic and fluid materials
}

void App::on_actionSave_triggered()
{

if (_workingFilePath.empty()) {
        on_actionSave_As_triggered();
        return;
    }

// Open file to write:
    std::ofstream file(_workingFilePath);

// Error checking:
    if(!file.is_open()) {
        QMessageBox::warning(this, tr("Unable to write file"), tr("Unable to open the file to save"));
        return;
    }

// Write JSON data to file:
 file << std::setw(4) << _project << std::endl;

showStatusBarMessage(tr("Saved in: %1").arg(QString::fromStdString(_workingFilePath)));
}

void App::on_actionSave_As_triggered()
{
    // Open the file dialog UI:
    QString fileName = QFileDialog::getSaveFileName(this,
            tr("Save Project"),
            QDir::homePath(),
            tr("json (*.json)"));

// Error checking:
    if (fileName.isEmpty()) { return; }

// Check fileName extension:
    if (!fileName.endsWith(".json")) {
        fileName.append(".json");
    }

// Set the Working file path:
    _workingFilePath = fileName.toStdString();

// Open file to write:
    std::ofstream file(_workingFilePath);

// Error checking:
    if(!file.is_open()) {
        QMessageBox::warning(this, tr("Unable to write file"), tr("Unable to open the file to save"));
        return;
    }

// Write JSON data to file:
 file << std::setw(4) << _project << std::endl;

showStatusBarMessage(tr("Saved in: %1").arg(QString::fromStdString(_workingFilePath)));
}

void App::on_actionExit_triggered()
{
    this->close();
}

void App::on_actionPlugins_triggered()
{

}

void App::on_actionAbout_triggered()
{

}

void App::on_actionClear_console_text_triggered()
{
    ui->console_txt->clear();
}

void App::on_actionImport_From_Library_triggered()
{
    // Change the current stackWidget page:
    ui->stackedWidget->setCurrentIndex(LIBRARY_PAGE);
    // Form layout ajust:
    ui->stackedWidget->setContentsMargins(50, 5, 50, 5);
}

void App::on_actionImport_From_File_triggered()
{
    // Open the file dialog UI:
    QString fileName = QFileDialog::getOpenFileName(this,
                        tr("Open Image"),
                        QDir::homePath(),
                        tr("JSON (*.json)"));

// Error checking:
    if (fileName.isEmpty()) { return; }

// Open file:
    std::ifstream file(fileName.toStdString());

// Error checking:
    if(!file.is_open()) {
        QMessageBox::warning(this, tr("Unable to open file"),
                             tr("Unable to import this file"));

return;
    }

// Read file data:
    JSON j;
    file >> j;

// Get file type:
 std::string fileType = j["file_type"].get<std::string>();

// Append file data to project:
    if (fileType == "part") {
        _project["part"].push_back(j);
    } else if (fileType == "material") {
        _project["material"].push_back(j);
    } else if (fileType == "excitation") {
        _project["excitation"].push_back(j);
    } else {
        QMessageBox::warning(this, tr("Unable to import this file"),
                             tr("Unkown the file type: '%1'").arg(QString::fromStdString(fileType)));
        return;
    }
}

void App::on_actionExport_Part_triggered()
{

}

void App::on_actionExport_Material_triggered()
{

}

void App::on_actionExport_Excitation_triggered()
{

}

/*!
 * \brief Get material JSON data from the loaded materials list
 * \param manufacturer Desired material manufacturer
 * \param name Desired material name
 * \return If material was found return the material JSON data. If not,
 * return a empty JSON object
 */
JSON App::getMaterialByName(const std::string manufacturer, const std::string name) const
{
 // For each material array element:
 for (auto& el : _library["material"]) {
 // Get the element manufacturer and name:
 std::string elManu = el["manufacturer"].get<std::string>();
 std::string elName = el["name"].get<std::string>();

// Verify if the desired element was found:
        if (elManu == manufacturer && elName == name) {
            // Material found:
            return el;
        }
    }

// If material was not found, return a clean JSON object:
    return JSON::object();
}

/*!
 * \brief Close central Form and return to a blank page
 */
void App::closeForm()
{
    const int currentPage = ui->stackedWidget->currentIndex();

switch (currentPage) {
        case CLEAN_PAGE:
            // Nothing to do....
            break;

case PART_PAGE:
            // Update part ...
            break;

case MATERIAL_ELASTIC_PAGE:
            updateMaterialTopMenu();
            break;

case MATERIAL_FLUID_PAGE:
            updateMaterialTopMenu();
            break;

case EXCITATION_PAGE:
            // Update excitation...
            break;

case JOB_PAGE:
            // Update JOB...
            break;

case ASSEMBLY_PAGE:
            // Update Assembly...
            break;

case LIBRARY_PAGE:
            // Update Library...
            break;

default:
            sendErrorMsg(tr("Unknown current page!"));
            break;
    }

// Change the current stackWidget page:
    ui->stackedWidget->setCurrentIndex(CLEAN_PAGE);
    // Form layout ajust:
    ui->stackedWidget->setContentsMargins(1, 1, 1, 1);
}

void App::updateMaterialTopMenu(void)
{
    // ===== CLEAR ALL OLD ACTIONS ===== //
    ui->menuElastic->clear();
    ui->menuFluid->clear();

// ===== SET THE DEFAUT MENU ACTIONS ===== //
    QAction* newElastic = new QAction(tr("New Elastic Material"));
    connect(newElastic, &QAction::triggered, this, [=] {
        _formMaterialElastic->cleanAllFields();
        ui->stackedWidget->setCurrentIndex(MATERIAL_ELASTIC_PAGE);
    });

QAction* newFluid = new QAction(tr("New Fluid Material"));
    connect(newFluid, &QAction::triggered, this, [=] {
        _formMaterialFluid->cleanAllFields();
        ui->stackedWidget->setCurrentIndex(MATERIAL_FLUID_PAGE);
    });

// ===== ADD ACTIONS TO THE TOP MENUS ===== //
    ui->menuElastic->addAction(newElastic);
    ui->menuFluid->addAction(newFluid);

// ===== ADD THE PROJECT MATERIAL ACTIONS ===== //
    const auto& materialArray = _project["material"];
    const size_t materialSize = materialArray.size();

for (size_t m = 0; m < materialSize; m++) {

const std::string materialName = materialArray[m]["name"].get<std::string>();
 const std::string materialType = materialArray[m]["type"].get<std::string>();

QAction* action = new QAction(QString::fromStdString(materialName), this);
        action->setStatusTip(tr("Edit material"));

if (materialType == "elastic") {
            connect(action, &QAction::triggered, this, [=]{
                _formMaterialElastic->load(materialArray[m]);
                ui->stackedWidget->setCurrentIndex(MATERIAL_ELASTIC_PAGE);
            });
            ui->menuElastic->addAction(action);
        } else if (materialType == "fluid") {
            connect(action, &QAction::triggered, this, [=]{
                _formMaterialFluid->load(materialArray[m]);
                ui->stackedWidget->setCurrentIndex(MATERIAL_FLUID_PAGE);
            });
            ui->menuFluid->addAction(action);
        } else {
            sendErrorMsg(tr("Uknown material type: %1").arg(QString::fromStdString(materialType)));
        }
    }
}

void App::updateGeometryTopMenu(void)
{
    // ===== CLEAR ALL OLD ACTIONS ===== //
    ui->menuGeometry->clear();

// ===== LOAD SHEFT PLUGINS ===== //
    QMenu* sheft = new QMenu(tr("Shafts"));

for (const auto& p : _pluginsMapMap["Shaft"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newSheft = new QAction(tr("New %1").arg(pluginName));
        connect(newSheft, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newSheft);
        sheft->addMenu(menu);
    }

// ===== LOAD BEARING PLUGINS ===== //
    QMenu* bearing = new QMenu(tr("Bearings"));

for (const auto& p : _pluginsMapMap["Bearing"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

// The new action
        QAction* newBearing = new QAction(tr("New %1").arg(pluginName));
        connect(newBearing, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newBearing);

// The project stored settings
        for (const auto& config : _project["plugin"]) {

const std::string& pluginType = config["type"].get<std::string>();

if (pluginType != pluginName.toStdString()) { continue; }

const std::string configName = config["name"].get<std::string>();
 QAction* storedBearing = new QAction(QString::fromStdString(configName));
 connect(storedBearing, &QAction::triggered, this, [=] {
 plugin->showUI(config);
 });

menu->addAction(storedBearing);
        }

bearing->addMenu(menu);
    }

// ===== LOAD FLOW SEAL PLUGINS ===== //
    QMenu* flowSeal = new QMenu(tr("Flow Seals"));

for (const auto& p : _pluginsMapMap["Flow Seal"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newFlowSeal = new QAction(tr("New %1").arg(pluginName));
        connect(newFlowSeal, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newFlowSeal);
        flowSeal->addMenu(menu);
    }

// ===== LOAD SQUEEZE FILM DAMPPER PLUGINS ===== //
    QMenu* squeeze = new QMenu(tr("Squeeze Film Damppers"));

for (const auto& p : _pluginsMapMap["Squeeze Film Dampper"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newSqueeze = new QAction(tr("New %1").arg(pluginName));
        connect(newSqueeze, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newSqueeze);
        squeeze->addMenu(menu);
    }

// ===== LOAD COUPLING PLUGINS ===== //
    QMenu* coupling = new QMenu(tr("Couplings"));

for (const auto& p : _pluginsMapMap["Coupling"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newCoupling = new QAction(tr("New %1").arg(pluginName));
        connect(newCoupling, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newCoupling);
        coupling->addMenu(menu);
    }

// ===== LOAD GEAR PLUGINS ===== //
    QMenu* gear = new QMenu(tr("Gears"));

for (const auto& p : _pluginsMapMap["Gear"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newGear = new QAction(tr("New %1").arg(pluginName));
        connect(newGear, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newGear);
        gear->addMenu(menu);
    }

// ===== LOAD FOUNDATION PLUGINS ===== //
    QMenu* foundation = new QMenu(tr("Foundations"));

for (const auto& p : _pluginsMapMap["Foundation"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newFoundation = new QAction(tr("New %1").arg(pluginName));
        connect(newFoundation, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newFoundation);
        foundation->addMenu(menu);
    }

// ===== LOAD FORCES PLUGINS ===== //
    QMenu* force = new QMenu(tr("Forces"));

for (const auto& p : _pluginsMapMap["Force"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newForce = new QAction(tr("New %1").arg(pluginName));
        connect(newForce, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newForce);
        force->addMenu(menu);
    }

// ===== LOAD SYSTEM PLUGINS ===== //
    QMenu* system = new QMenu(tr("Systems"));

for (const auto& p : _pluginsMapMap["System"]) {
        const auto& plugin = p.second;

const QString pluginName = plugin->getName();
        QMenu* menu = new QMenu(pluginName);

QAction* newSystem = new QAction(tr("New %1").arg(pluginName));
        connect(newSystem, &QAction::triggered, this, [=] {
            plugin->showUI(JSON());
        });

menu->addAction(newSystem);
        system->addMenu(menu);
    }

// ===== ADD SUB MENUS ===== //
    ui->menuGeometry->addMenu(sheft);
    ui->menuGeometry->addMenu(bearing);
    ui->menuGeometry->addMenu(flowSeal);
    ui->menuGeometry->addMenu(squeeze);
    ui->menuGeometry->addMenu(coupling);
    ui->menuGeometry->addMenu(gear);
    ui->menuGeometry->addMenu(foundation);
    ui->menuGeometry->addMenu(force);
    ui->menuGeometry->addMenu(system);
}

void App::showStatusBarMessage(const QString& msg, const int timeout)
{
    ui->statusbar->showMessage(msg, timeout);
}

void App::sendStatusMsg(const QString& msg)
{
    receivedMsg("App", MSG_TYPE::STATUS_MSG, msg);
}

void App::sendWarningMsg(const QString& msg)
{
    receivedMsg("App", MSG_TYPE::WARNING_MSG, msg);
}

void App::sendErrorMsg(const QString& msg)
{
   receivedMsg("App", MSG_TYPE::ERROR_MSG, msg);
}

void App::on_actionNew_Elastic_Material_triggered()
{
    // Change the current stackWidget page:
    ui->stackedWidget->setCurrentIndex(MATERIAL_ELASTIC_PAGE);
    _formMaterialElastic->cleanAllFields();
}

void App::on_actionNew_Fluid_Material_triggered()
{
    // Change the current stackWidget page:
    ui->stackedWidget->setCurrentIndex(MATERIAL_FLUID_PAGE);
    _formMaterialFluid->cleanAllFields();
}

void App::receivedMsg(const QString& sourceObject, const MSG_TYPE msgType, const QString& msg)
{
    QString html;
    QString msgTypeString;

switch (msgType) {
 case MSG_TYPE::STATUS_MSG:
 html = "";
 msgTypeString = "Status";
 break;

case MSG_TYPE::WARNING_MSG:
 html = "";
 msgTypeString = "Warning";
 break;

case MSG_TYPE::ERROR_MSG:
 html = "";
 msgTypeString = "Error";
 break;

default:
            QMessageBox::warning(this, tr("App Received Message"), tr("Unkown message type"));
            return;
        break;
    }

html.append("[" + sourceObject + "][" + msgTypeString + "]: " + msg + "");

ui->console_txt->appendHtml(html);
}

QStringList App::getPluginsList(QString path)
{
    QStringList filter;

#ifdef Q_OS_WIN
 filter << "*.dll";
#elif defined(Q_OS_LINUX)
 filter << "*.so";
#elif defined(Q_OS_MACOS)
 filter << "*.dylib";
#endif

QDir dir(path);
    QFileInfoList list = dir.entryInfoList(filter);

QStringList plugins;
    foreach (QFileInfo file, list) {
#ifdef Q_OS_MACOS
        // Check if this file is not a Mac symbolic link:
        if(!file.isSymLink()) {
#endif
            plugins.append(file.filePath());
#ifdef Q_OS_MACOS
        }
#endif
    }

return plugins;
}

void App::receivedPluginSettings(JSON settings)
{
 // std::cout << settings.dump(2) << std::endl;
 addToArray(_project["plugin"], settings);

updateGeometryTopMenu();
}

/*!
 * \brief Load plugins (dynamic libraries) to main application
 * \param plugins List of plugins absolute paths
 */
void App::loadPlugins(const QStringList pluginsList)
{
 foreach(QString file, pluginsList) {
 // qInfo() << "Loading: " << file;

QPluginLoader loader(file);

// Error checking:
        if (!loader.load()) {
            sendErrorMsg(tr("%1: ").arg(loader.errorString()));
            continue;
        }

// Get and display the plugin file name:
        const QStringList pathSplited = loader.fileName().split("/");
        const QString fileName = pathSplited.last();
        sendStatusMsg(tr("Loading plugin: %1").arg(fileName));

// Cast plugin interface:
 Plugin_API* plugin = qobject_cast<Plugin_API*>(loader.instance());

// Error chekcing: nullptr
        if (!plugin) {
            sendErrorMsg(tr("Wrong Plugin API! Could not cast: %1").arg(loader.fileName()));
            continue;
        }

// ===== CONNECT ALL SIGNALS /  SLOTS ===== //
        bool conn1 = connect(plugin, &Plugin_API::sendMsg, this, &App::receivedMsg);
        bool conn2 = connect(plugin, &Plugin_API::savePluginSettings, this, &App::receivedPluginSettings);

bool allConnections = conn1 & conn2;

if (!allConnections) {
            sendErrorMsg(tr("Unable to connect: %1").arg(plugin->getName()));
            continue;
        }

plugin->setProject(&_project);

// pluginInstance = plugin;

// sendStatusMsg(plugin->getName());

// Store the plugin in a map:
        _pluginsMapMap[plugin->getType()][plugin->getName()] = plugin;
    }
}