ArmarXWidgetController.h

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::Gui
* @author     Mirko Waechter ( mirko.waechter at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include <IceUtil/Shared.h>
 
#include <QSettings>
#include <QPointer>
#include <QWidget>
 
#include <memory>
#include <mutex>
 
 
class SoNode;
class QDialog;
class QMainWindow;
 
namespace armarx
{
    class ArmarXWidgetController;
    class TipDialog;
    using ArmarXWidgetControllerPtr = IceUtil::Handle<ArmarXWidgetController>;
    class ArmarXWidgetController :
        public QObject,
        virtual public Logging,
        virtual public IceUtil::Shared
    {
        Q_OBJECT
    public:
        explicit ArmarXWidgetController();
        ~ArmarXWidgetController() override;
 
        virtual QPointer<QWidget> getWidget();
 
        virtual QPointer<QDialog> getConfigDialog(QWidget* parent = 0);
 
        virtual void configured() {}
 
        virtual QPointer<QWidget> getCustomTitlebarWidget(QWidget* parent = 0);
 
        virtual QString getWidgetName() const = 0;
 
        virtual QIcon getWidgetIcon() const;
 
        static QIcon GetWidgetIcon();
 
        virtual QIcon getWidgetCategoryIcon() const;
        static QIcon GetWidgetCategoryIcon();
 
        virtual void loadSettings(QSettings* settings) = 0;
 
        virtual void saveSettings(QSettings* settings) = 0;
 
        virtual SoNode* getScene()
        {
            return 0;
        }
        virtual QPointer<QDialog> getSceneConfigDialog(QWidget* parent = nullptr);
 
 
        virtual bool onClose()
        {
            return true;
        }
 
        virtual void postDocking()
        {
 
        }
 
        bool setInstanceName(QString instanceName);
        QString getInstanceName();
        virtual void setMainWindow(QMainWindow* mainWindow);
        virtual QMainWindow* getMainWindow();
 
        QPointer<TipDialog> getTipDialog() const;
        void setTipDialog(QPointer<TipDialog> tipDialog);
 
        // This is all total madness. Why do we put mutexes and locks into shared pointers?
        using RecursiveMutex = std::recursive_mutex;
        using RecursiveMutexPtr = std::shared_ptr<RecursiveMutex>;
        using RecursiveMutexLock = std::unique_lock<RecursiveMutex>;
        using RecursiveMutexLockPtr = std::shared_ptr<RecursiveMutexLock>;
        virtual void setMutex3D(RecursiveMutexPtr const& mutex3D);
 
        template <typename Class>
        static ArmarXWidgetControllerPtr createInstance()
        {
            ArmarXWidgetControllerPtr ptr = new Class();
            return ptr;
        }
 
        static int showMessageBox(const QString& msg);
 
        void enableMainWidgetAsync(bool enable);
 
 
        virtual void onLockWidget();
        virtual void onUnlockWidget();
    signals:
        void configAccepted(ArmarXWidgetControllerPtr widget);
        void configRejected(ArmarXWidgetControllerPtr widget);
    public slots:
        void configAccepted();
        void configRejected();
        void enableMainWidget(bool enable);
 
    private:
        QString __instanceName;
        QPointer<QWidget> __widget;
        QMainWindow* __appMainWindow;
        QPointer<TipDialog> tipDialog;
    protected:
        std::shared_ptr<std::recursive_mutex> mutex3D;
    };
}
 
namespace std
{
 
    ARMARXCORE_IMPORT_EXPORT ostream& operator<< (ostream& stream, const QString& string);
 
    ARMARXCORE_IMPORT_EXPORT ostream& operator<<(ostream& stream, const QPointF& point);
 
    ARMARXCORE_IMPORT_EXPORT ostream& operator<<(ostream& stream, const QRectF& rect);
 
    ARMARXCORE_IMPORT_EXPORT ostream& operator<<(ostream& stream, const QSizeF& rect);
 
}