ArmarXGuiApp.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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/>.
*
* @package    ArmarX::Component::ArmarXGui
* @author     David Ruscheweyh (david.ruscheweyh at student.kit dot edu)
* @author     Kai Welke (welke at kit dot edu)
* @copyright  2011 Humanoids Group, HIS, KITh
* @license    http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "ArmarXGuiApp.h"
 
#include <iostream>
#include <optional>
 
#include <QHostInfo>
#include <QListWidget>
#include <QMessageBox>
#include <QTextCodec>
#include <QTime>
 
#include <SimoxUtility/algorithm/string.h>
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/util/StringHelpers.h>
#include <ArmarXCore/util/CPPUtility/trace.h>
 
namespace armarx
{
    int ArmarXGuiApp::globalargc = 0;
 
    ArmarXGuiAppPropertyDefinitions::ArmarXGuiAppPropertyDefinitions(std::string prefix) :
        ApplicationPropertyDefinitions(prefix)
    {
        defineOptionalProperty<std::string>(
            "LoadPlugins", "", "List of paths to GuiPlugin-Libs (semi-colon seperated)");
        defineOptionalProperty<std::string>(
            "GuiConfigFile", "", "Path to config file, that should be loaded on startup");
        defineOptionalProperty<bool>("DisablePreloading",
                                     false,
                                     "Disables the preloading of widgets. Can be helpful if some "
                                     "preloaded widget crashes the gui.");
    }
 
    ArmarXGuiApp::ArmarXGuiApp(int& argc, char** argv) :
        qApplication(nullptr), argc(argc), argv(argv)
    {
        qApplication = new ArmarXQApplication(argc, argv);
 
        // Set text encoding to UTF-8 (otherwise, umlauts display wrongly in, e.g., the log viewer)
        QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
    }
 
    ArmarXGuiApp::~ArmarXGuiApp()
    {
        //    std::cout << "FINISH" << std::endl;
    }
 
    void
    ArmarXGuiApp::setup(const ManagedIceObjectRegistryInterfacePtr& registry,
                        Ice::PropertiesPtr properties)
    {
        this->registry = registry;
    }
 
    int
    ArmarXGuiApp::run(int argc, char* argv[])
    {
        if (!ArmarXManager::CheckIceConnection(communicator(), false))
        {
            if (QMessageBox::question(nullptr,
                                      "ArmarX is not running",
                                      "ArmarX is not running - do you want me to start it now?",
                                      QMessageBox::No,
                                      QMessageBox::Yes) == QMessageBox::Yes)
            {
                int result = startArmarX();
                if (result != 0)
                {
                    return result;
                }
            }
            else
            {
                return 1;
            }
        }
        setName(makeName());
        return armarx::Application::run(argc, argv);
    }
 
    int
    ArmarXGuiApp::exec(const ArmarXManagerPtr& armarXManager)
    {
        // init SoDB and Qt, SoQt::init also creates an application object
        SoDB::init();
        SoQt::init(argc, argv, "ArmarXGuiApp*1123");
 
        // enable Coin3D extension: transparent settings without color
        (void)coin_setenv("COIN_SEPARATE_DIFFUSE_TRANSPARENCY_OVERRIDE", "1", TRUE);
 
        {
            const std::vector<std::string> packageNames = getArmarXPackageNames();
            QString configToLoad;
            if (getProperty<std::string>("GuiConfigFile").isSet())
            {
                configToLoad =
                    QString::fromStdString(getProperty<std::string>("GuiConfigFile").getValue());
            }
 
            // create top-level widget
            mainWindow = new ArmarXMainWindow(registry,
                                              packageNames,
                                              configToLoad,
                                              getProperty<bool>("DisablePreloading").getValue());
            connect(mainWindow, SIGNAL(closeRequest()), this, SLOT(closeRequest_sent()));
        }
        {
            // parse properties
            std::string plugins = getProperty<std::string>("LoadPlugins").getValue();
            std::vector<std::string> pluginList = Split(plugins, ",");
            for (auto iter = pluginList.begin(); iter != pluginList.end(); ++iter)
            {
                if (!iter->empty())
                {
                    ARMARX_VERBOSE << "Loading plugin: " << iter->c_str() << std::endl;
                    mainWindow->loadPlugin(iter->c_str());
                }
            }
        }
        std::cout << "Started ArmarXGui App" << std::endl;
 
        armarxManagerTask = new RunningTask<ArmarXGuiApp>(
            this, &ArmarXGuiApp::runArmarXManager, "ArmarXManagerWaitThread");
        armarxManagerTask->start();
 
        mainWindow->show();
        mainWindow->appendFileToWindowTitle();
 
        ARMARX_INFO << "Now showing main window";
        int result = qApplication->exec();
 
        // exit SoQt and Qt
        interruptCallback(0); // signal to the application it should terminate the ice connection
 
        armarXManager->waitForShutdown();
 
        // Shutdown.
        qApplication->quit();
        delete mainWindow;
 
        SoQt::done();
        delete qApplication;
        qApplication = 0;
 
        return result;
    }
 
    void
    ArmarXGuiApp::closeRequest_sent()
    {
    }
 
    void
    ArmarXGuiApp::runArmarXManager()
    {
        getArmarXManager()->waitForShutdown();
 
        if (qApplication)
        {
            qApplication->quit();
        }
    }
 
    int
    ArmarXGuiApp::startArmarX()
    {
        CMakePackageFinder armarx_core("ArmarXCore");
        CMakePackageFinder armarx_memoryx("MemoryX");
 
        int res;
        if (armarx_core.packageFound())
        {
            res = system(
                std::string(armarx_core.getBinaryDir() + std::string("/armarx start")).c_str());
        }
        else
        {
            res = system("armarx start");
        }
        res = WEXITSTATUS(res);
        if (res == EXIT_SUCCESS)
        {
            ARMARX_INFO_S << "Started ArmarX successfully!";
            if (armarx_memoryx.packageFound())
            {
                if (armarx_core.packageFound())
                {
                    res = system(std::string(armarx_core.getBinaryDir() +
                                             std::string("/armarx memory start"))
                                     .c_str());
                }
                else
                {
                    res = system("armarx memory assureRunning");
                }
                res = WEXITSTATUS(res);
                if (res == EXIT_FAILURE)
                {
                    QMessageBox::warning(nullptr,
                                         "ArmarX Error",
                                         "Could not start MongoDB! See terminal output for more "
                                         "information. The GUI will now started anyway.");
                    return 0;
                }
            }
        }
        else
        {
            QMessageBox::critical(
                nullptr,
                "ArmarX Error",
                "Could not start ArmarX! See terminal output for more information.");
            return 1;
        }
        return 0;
    }
 
    static QString
    getUserName()
    {
        QString username = qgetenv("USER");
        if (username.isEmpty())
        {
            username = qgetenv("USERNAME");
        }
        return username;
    }
 
    static QString
    getUserNameAtHostName(const QString& delimiter, const QString& at)
    {
        const QString hostname = QHostInfo::localHostName();
        QString user = getUserName();
        if (user.isEmpty())
        {
            return hostname;
        }
        else
        {
            return user + delimiter + at + delimiter + hostname;
        }
    }
 
    std::string
    ArmarXGuiApp::makeName()
    {
        std::vector<std::string> items{"ArmarXGui"};
        items.push_back(getUserNameAtHostName("-", "at").toStdString());
        items.push_back(DateTime::Now().toDateTimeString());
 
        std::string name = simox::alg::join(items, "_");
 
        return name;
    }
 
    bool
    ArmarXQApplication::notify(QObject* obj, QEvent* ev)
    {
        try
        {
            return QApplication::notify(obj, ev);
        }
        catch (std::exception& e)
        {
            ARMARX_ERROR_S << "Exception caught:\n" << armarx::GetHandledExceptionString();
            emit exceptionCaught(QString::fromStdString(armarx::GetHandledExceptionString()));
            detail::Trace::ClearExceptionBacktrace();
        }
 
        return false;
    }
 
    void
    ArmarXQApplication::showException(QString exceptionReason)
    {
        QStringList infos = exceptionReason.split("Backtrace:");
        QListWidget* list = exceptionDialogHandler.listWidgetExceptions;
        auto item = new QListWidgetItem("[" + QTime::currentTime().toString() + "] " +
                                        infos.first().trimmed());
        item->setToolTip(exceptionReason);
        list->addItem(item);
        list->scrollToBottom();
 
        if (!exceptionDialogHandler.checkBoxDoNotShowAgain->isChecked())
        {
            exceptionDialog.show();
        }
        /*
        QStringList infos = exceptionReason.split("Backtrace:");
        QMessageBox box;
        box.setIcon(QMessageBox::Warning);
        box.setWindowTitle("An exception occured!");
        box.setText("An exception was caught!\n" + infos.first());
        if(infos.size() > 1)
            box.setDetailedText(infos.last());
        box.exec();
        */
    }
 
    ArmarXQApplication::ArmarXQApplication(int& argc, char** argv) : QApplication(argc, argv)
    {
        const auto guiWindowBaseName = QString{"ArmarX"} + " @ " + QHostInfo::localHostName();
        setApplicationName(guiWindowBaseName);
 
        {
            const char* envArmarxWorkspace = std::getenv("ARMARX_WORKSPACE_NAME");
            if (envArmarxWorkspace == nullptr)
            {
                envArmarxWorkspace = std::getenv("ARMARX_WORKSPACE");
            }
 
            QString applicationDisplayName;
            if (envArmarxWorkspace != nullptr)
            {
                applicationDisplayName += "[▽" + QString(envArmarxWorkspace) + "] ";
            }
            applicationDisplayName += getUserNameAtHostName(" ", "@");
            setApplicationDisplayName(applicationDisplayName);
        }
 
        connect(this,
                SIGNAL(exceptionCaught(QString)),
                this,
                SLOT(showException(QString)),
                Qt::QueuedConnection);
        exceptionDialogHandler.setupUi(&exceptionDialog);
        QListWidget* list = exceptionDialogHandler.listWidgetExceptions;
        connect(exceptionDialogHandler.pushButtonClearHistory,
                SIGNAL(clicked()),
                list,
                SLOT(clear()),
                Qt::QueuedConnection);
    }
 
    ArmarXQApplication::~ArmarXQApplication()
    {
    }
 
} // namespace armarx