abstractDockWidget.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2016, Institut fuer Technische Optik (ITO),
    Universitaet Stuttgart, Germany

    This file is part of itom.
  
    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.

    itom 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 Library
    General Public Licence for more details.

    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */

#ifndef ABSTRACTDOCKWIDGET_H
#define ABSTRACTDOCKWIDGET_H

#include "../global.h"
#include "../common/sharedStructures.h"

#include <qmainwindow.h>
#include <qdockwidget.h>
#include <qmenubar.h>
#include <qevent.h>
#include <qmap.h>
#include <qtoolbar.h>
#include <qdebug.h>
#include <qstring.h>
#include <qaction.h>
#include <qshortcut.h>
#include <qrect.h>
#include <qwidget.h>


namespace ito
{
    class AbstractDockWidget : public QDockWidget
    {
        Q_OBJECT
        
        //these properties are taken from QWidget in order to redirect them either to the QDockWidget or to the main window (depending on dock status)
        Q_PROPERTY(bool visible READ isVisible WRITE setVisible DESIGNABLE false)
        Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)

        Q_PROPERTY(QRect geometry READ geometry WRITE setGeometry)
        Q_PROPERTY(QRect frameGeometry READ frameGeometry)
        Q_PROPERTY(QRect normalGeometry READ normalGeometry)
        Q_PROPERTY(int x READ x)
        Q_PROPERTY(int y READ y)
        Q_PROPERTY(QPoint pos READ pos WRITE move DESIGNABLE false STORED false)
        Q_PROPERTY(QSize frameSize READ frameSize)
        Q_PROPERTY(QSize size READ size WRITE resize DESIGNABLE false STORED false)
        Q_PROPERTY(int width READ width)
        Q_PROPERTY(int height READ height)
        Q_PROPERTY(QRect rect READ rect)
        Q_PROPERTY(QRect childrenRect READ childrenRect)
        Q_PROPERTY(QRegion childrenRegion READ childrenRegion)
        Q_PROPERTY(QString windowTitle READ windowTitle WRITE setWindowTitle)

        public:

            enum tFloatingStyle { floatingNone, floatingStandard, floatingWindow }; 
            enum tMovingStyle { movingDisabled, movingEnabled };    
            enum tTopLevelStyle { topLevelOverall, topLevelParentOnly, topLevelNothing };

            struct Toolbar
            {
                Toolbar() : section(0), key(""), tb(NULL) {}
                Qt::ToolBarArea area;
                int section;
                QString key;
                QToolBar *tb;
            };

            AbstractDockWidget(bool docked, bool isDockAvailable, tFloatingStyle floatingStyle, tMovingStyle movingStyle, const QString &title = QString(), const QString &objName = QString(), QWidget *parent = 0);
            virtual ~AbstractDockWidget();

            inline bool docked() const { return m_docked; }    
            RetVal setAdvancedWindowTitle( QString newCompleteTitle = QString(), bool appendToBasicTitle = true );

            RetVal setTopLevel( tTopLevelStyle topLevel );

            void setParent ( QWidget * parent ) { m_overallParent = parent; QDockWidget::setParent(parent); }

            QWidget *getActiveInstance() 
            { 
                if(!m_docked && m_floatingStyle == floatingWindow)
                {
                    return m_pWindow;
                }
                return this;
            }

            //these methods are mainly redirected to QDockWidget or QMainWindow (depending on dock status)
            #define QWIDGETPROPGETTER(gettername) if(m_docked && m_dockAvailable) { return QDockWidget::gettername(); } else { return m_pWindow->gettername(); }

            #define QWIDGETPROPSETTER(settername,...) \
            if (m_docked) \
            { \
                QDockWidget::settername(__VA_ARGS__);  \
            } \
            else \
            { \
                if (m_floatingStyle == floatingWindow) \
                { \
                    m_pWindow->settername(__VA_ARGS__); \
                    QDockWidget::settername(__VA_ARGS__); \
                } \
                else \
                { \
                    QDockWidget::settername(__VA_ARGS__); \
                } \
            }

            #define QWIDGETPROPSETTERSPECIAL(settername,...) \
            if (m_docked) \
            { \
                QDockWidget::settername(__VA_ARGS__);  \
            } \
            else \
            { \
                if (m_floatingStyle == floatingWindow) \
                { \
                    m_pWindow->settername(__VA_ARGS__); \
                } \
                else \
                { \
                    QDockWidget::settername(__VA_ARGS__); \
                } \
            }

            QRect frameGeometry() const;
            const QRect &geometry() const;
            QRect normalGeometry() const;

            int x() const;
            int y() const;
            QPoint pos() const;
            QSize frameSize() const;
            QSize size() const;
            int width() const;
            int height() const;
            QRect rect() const;
            QRect childrenRect() const;
            QRegion childrenRegion() const;

            void move(int x, int y);
            void move(const QPoint &);
            void resize(int w, int h);
            void resize(const QSize &);
            void setGeometry(int x, int y, int w, int h);
            void setGeometry(const QRect &);

            QString windowTitle();
            void setWindowTitle(const QString &title);

            bool isEnabled() const;
            bool isVisible() const;

            void saveState(const QString &iniName) const;
            void restoreState(const QString &iniName);

            void synchronizeTopLevelState();

            virtual QSize sizeHint() const;
            virtual QSize minimumSizeHint() const;

        public Q_SLOTS:
            void setEnabled(bool);
            virtual void setVisible(bool visible);
   
        protected:

            class ShortcutAction : public QObject
            {
            public:
                ShortcutAction(const QString &text, AbstractDockWidget *parent) : QObject(parent), m_action(NULL), m_shortcut(NULL)
                {
                    m_action = new QAction(text, parent);
                    QString toolTipText = text;
                    toolTipText.replace("&", "");
                    m_action->setToolTip(toolTipText);
                }

                ShortcutAction(const QIcon &icon, const QString &text, AbstractDockWidget *parent) : QObject(parent), m_action(NULL), m_shortcut(NULL)
                {
                    m_action = new QAction(icon, text, parent);
                    QString toolTipText = text;
                    toolTipText.replace("&", "");
                    m_action->setToolTip(toolTipText);
                }

                ShortcutAction(const QIcon &icon, const QString &text, AbstractDockWidget *parent, const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut) : QObject(parent), m_action(NULL), m_shortcut(NULL)
                {
                    QString text2 = text;
                    QString text3 = text;
                    text3.replace("&", "");

                    //some key sequences do not exist as default on all operating systems
                    if (key.isEmpty() == false)
                    {
                        text2 += "\t" + key.toString(QKeySequence::NativeText);
                        text3 += " (" + key.toString(QKeySequence::NativeText) + ")";

                        m_shortcut = new QShortcut(key, parent->getCanvas());
                        m_shortcut->setContext(context);
                    }

                    m_action = new QAction(icon, text2, parent);
                    m_action->setToolTip(text3);
                }

                ~ShortcutAction()
                {
                    //do not delete action and shortcut here, since it will be deleted by common parent.
                }

                void connectTrigger(const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)
                {
                    if(m_action)
                    {
                        QObject::connect(m_action, SIGNAL(triggered()), receiver, method, type);
                    }
                    if(m_shortcut)
                    {
                        QObject::connect(m_shortcut, SIGNAL(activated()), receiver, method, type);
                    }
                }

                void setEnabled(bool actionEnabled, bool shortcutEnabled)
                {
                    if(m_action) 
                    {
                        m_action->setEnabled(actionEnabled);
                        if(m_shortcut) m_shortcut->setEnabled(shortcutEnabled);
                    }
                }

                void setEnabled(bool enabled)
                {
                    setEnabled(enabled,enabled);
                }

                void setVisible(bool actionVisible, bool shortcutEnabled)
                {
                    if(m_action) 
                    {
                        m_action->setVisible(actionVisible);
                        if(m_shortcut) m_shortcut->setEnabled(shortcutEnabled);
                    }
                }

                void setVisible(bool visible)
                {
                    setVisible(visible,visible);
                }

                QAction* action() { return m_action; }

            private:
                QAction *m_action;
                QShortcut *m_shortcut;
                
            };


            bool eventFilter(QObject *obj, QEvent *event)
            {
                if (event->type() == QEvent::Close)
                {
                    closeEvent((QCloseEvent*)event);
                    if(testAttribute(Qt::WA_DeleteOnClose) && event->isAccepted() ) //if window should be closed and dockwidget is assigned with WA_DeleteOnClose, delete this dockwidget first.
                    {
                       deleteLater();
                    }
                    
                    return true;
                }
                else
                {
                    return QObject::eventFilter(obj,event);
                }
            };

            void init();

            virtual void closeEvent(QCloseEvent *event);

            virtual void createActions() = 0;
            virtual void createMenus() = 0;
            virtual void createToolBars() = 0;
            virtual void createStatusBar() = 0;
            virtual void updateActions() {}
            virtual void updatePythonActions() = 0;
        
            Qt::WindowFlags modifyFlags(const Qt::WindowFlags &flags, const Qt::WindowFlags &setFlags, const Qt::WindowFlags &unsetFlags);

            virtual void windowStateChanged( bool /*windowNotToolbox*/ ) {}

            void setContentWidget(QWidget *widget);
            inline QWidget* getContentWidget() const { return m_pWindow->centralWidget(); }   
            inline QMainWindow* getCanvas() { return m_pWindow; }

            inline bool pythonBusy() const { return m_pythonBusy; }                    
            inline bool pythonDebugMode() const { return m_pythonDebugMode; }          
            inline bool pythonInWaitingMode() const { return m_pythonInWaitingMode; }  
            //RetVal addAndRegisterToolBar(QToolBar* tb, QString key);
            //RetVal unregisterToolBar(QString key);
            QToolBar* getToolBar(QString key) const;
            inline QMenuBar* getMenuBar() const { return (m_pWindow == NULL) ?  NULL : m_pWindow->menuBar(); }

            RetVal addToolBar(QToolBar *tb, const QString &key, Qt::ToolBarArea area = Qt::TopToolBarArea, int section = 1);
            RetVal removeToolBar(const QString &key);

            QAction *m_actStayOnTop;
            QAction *m_actStayOnTopOfApp;

        private:

            void contextMenuEvent(QContextMenuEvent *e)
            {
                e->accept();
                qDebug() << "context menu of abstractDockWidget clicked. [placeholder for (un)docking feature.] pos: " << e->pos();
            }

            QMainWindow *m_pWindow;

            bool m_docked;                      
            bool m_dockAvailable;               
            tFloatingStyle m_floatingStyle;     
            tMovingStyle m_movingStyle;         
            QString m_basicTitle;               
            QString m_completeTitle;            
            QMap<QString,QToolBar*> m_toolBars; 
            QList<Toolbar> m_toolbars;

            bool m_pythonBusy;                  
            bool m_pythonDebugMode;             
            bool m_pythonInWaitingMode;         
            QToolBar* m_dockToolbar;
            QAction* m_actDock;
            QAction* m_actUndock;

            QWidget* m_overallParent;           
            tTopLevelStyle m_recentTopLevelStyle;

            QSize m_oldMinSize;
            QSize m_oldMaxSize;
            QRect m_lastUndockedSize;
            QByteArray m_pendingGeometryState; //if the window has a loaded geometry state from the settings file, but has been hidden at startup, the geometry is saved here and applied once the window becomes visible. Then, this variable is cleared.

        public slots:
            virtual void dockedToMainWindow(AbstractDockWidget * /*widget*/){}
            virtual void removedFromMainWindow(AbstractDockWidget * /*widget*/){}
            virtual void pythonStateChanged(tPythonTransitions pyTransition);

            void raiseAndActivate();  
            void setDockSize(int newWidth, int newHeight);

            void dockWidget();
            void undockWidget(bool show_it = true);

        private slots:
            void mnuStayOnTop(bool checked);
            void mnuStayOnTopOfApp(bool checked);

            void returnToOldMinMaxSizes();
    };

} //end namespace ito

#endif