milxQtMain.h

/*=========================================================================
  The Software is copyright (c) Commonwealth Scientific and Industrial Research Organisation (CSIRO)
  ABN 41 687 119 230.
  All rights reserved.

  Licensed under the CSIRO BSD 3-Clause License
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License in the file LICENSE.md or at

  https://stash.csiro.au/projects/SMILI/repos/smili/browse/license.txt

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
=========================================================================*/
#ifndef MILXQTMAIN_H
#define MILXQTMAIN_H
//Qt
#include <QPointer>
#include <QMainWindow>
#include <QTabWidget>
#include <QWorkspace>
#include <QList>
#include <QWebView>
//VTK
#include <vtkEventQtSlotConnect.h>
//Displays
#include "milxQtImage.h"
#include "milxQtModel.h"
#include "milxQtUnifiedWindow.h"
#include "milxQtPluginInterface.h"





class MILXQT_EXPORT milxQtMain : public QMainWindow
{
    Q_OBJECT

public:
    milxQtMain(QWidget *theParent = 0);
    virtual ~milxQtMain();

    QString activeName();
    QString activeNamePrefix();

    //Options
    inline void preferWhiteBackground(const bool whiteBack)
    {   whiteBackground = whiteBack;    }
    inline bool isWhiteBackgroundPreferred()
    {   return whiteBackground;   }
    inline void preferHumanGlyph(const bool human)
    {   humanGlyph = human;   }
    inline bool isHumanGlyphPreferred()
    {   return humanGlyph;   }
    inline void preferSubWindowSize(const int winSize)
    {   subWindowSize = winSize;   }
    inline int hasPreferredSubWindowSize()
    {   return subWindowSize;   }
    inline void preferMaximumProcessors(const int procs)
    {   maxProcessors = procs;   }
    inline int hasMaximumProcessors()
    {   return maxProcessors;   }
    inline void preferScreenshotMagnifyFactor(const int factor)
    {   magnifyFactor = factor;   }
    inline int hasScreenshotMagnifyFactor()
    {   return magnifyFactor;   }
    inline void preferTimestamps(const bool timestamps)
    {   timestamping = timestamps;   }
    inline bool isTimestampsPreferred()
    {   return timestamping;   }
    inline void preferImageInterpolation(const bool interp)
    {   interpolationImages = interp;   }
    inline bool isImageInterpolationPreferred()
    {   return interpolationImages;   }
    inline void preferOrientation(const bool orient)
    {   orientationImages = orient;   }
    inline bool isOrientationPreferred()
    {   return orientationImages;   }
    inline void preferModelInterpolation(const bool interp)
    {   interpolationModels = interp;   }
    inline bool isModelInterpolationPreferred()
    {   return interpolationModels;   }
    inline void preferScalarBar(const bool bar)
    {   scalarBarModels = bar;   }
    inline bool isScalarBarPreferred()
    {   return scalarBarModels;   }

public slots:
    bool isRender(QWidget *win);
    bool isActiveRender();
    milxQtRenderWindow* activeRender();
    bool isImage(QWidget *win);
    bool isActiveImage();
    milxQtImage* activeImage();
    bool isModel(QWidget *win);
    bool isActiveModel();
    milxQtModel* activeModel();
    bool isPlot(QWidget *win);
    bool isActivePlot();
    milxQtModel* activePlot();
    bool isUnifiedWindow(QWidget *win);
    bool isActiveUnifiedWindow();
    milxQtUnifiedWindow* activeUnifiedWindow();
    bool isActiveWebView();
    QWebView* activeWebView();
    void setActiveWindow(QWidget *currentWindow);

    void newTab();
    bool open();
    void openCollection();
    void openSeries();
    void openRecentFile();
    void loadFiles(const QStringList &filenames);
    bool loadFile(const QString &filename);
    void setCurrentFile(const QString &fileName);
    void updateRecentFileActions();
    QActionGroup* updateWindowMenu();
    QActionGroup* updateWindowListMenu(bool applyMapper = true);
    QActionGroup* updateImportFromMenu(bool applyMapper = false);
    void updateWindowsWithValue(int value);
    void updateWindowsWithAutoLevel();
    void updateWindowsWithRefresh();
    void updateWindowsWithCursors();
    void updateWindowsWithView(int value);
    void updateWindowsWithViewType(int value);
    void updateWindowsWithViewOrientation(int value);
    QActionGroup* windowActionList(QMenu *menuForList, bool groupTogether = true, bool applyMapper = false);

    void save(QString filename = "");
    void saveScreen(QString filename = "");

    void setTabName(QWidget *fromWindow);
    void setTabName(const QString newName);
    void closeTab(int index);
    inline void closeTabActiveWindow()
    {
        qobject_cast<QWorkspace *>(workspaces->currentWidget())->closeActiveWindow();
    }
    inline void closeTabAllWindows()
    {
        qobject_cast<QWorkspace *>(workspaces->currentWidget())->closeAllWindows();
    }
    inline void cascadeTab()
    {
        qobject_cast<QWorkspace *>(workspaces->currentWidget())->cascade();
    }
    inline void tileTab()
    {
        qobject_cast<QWorkspace *>(workspaces->currentWidget())->tile();
    }
    void tileTabVertically();
    void tileTabHorizontally();
    void helpContents();
    void preferences();
    void controls();
    void about();

    void working(int value);
    void done(int value);

    void display(milxQtRenderWindow* rnd);
    void predisplay(milxQtImage* img);
    void display(milxQtImage* img);
    void display(vtkImageData* img, QString nameOfImage);
    void display(milxQtModel* mdl);
    void display(vtkPolyData* newModel, QString nameOfModel);
    void display(milxQtUnifiedWindow* uni);
    void display(vtkPolyDataCollection *modelCollection, QStringList &filenames);

    void addRender(milxQtRenderWindow *rnd);
    void addImage(milxQtImage *img);
    void addModel(milxQtModel *mdl);
    void addUnifiedWindow(milxQtUnifiedWindow *uni);
    inline void addToUnifiedWindow(milxQtImage *img)
    {
        currentUnifiedWindow->addToWindow(img);
    }
    inline void addToUnifiedWindow(milxQtModel *mdl)
    {
        currentUnifiedWindow->addToWindow(mdl);
    }
    inline void showUnifiedWindow()
    {
        display(currentUnifiedWindow);
    }
    inline milxQtUnifiedWindow* getUnifiedWindow()
    {
        return currentUnifiedWindow;
    }
    void cleanUpOnClose(QWidget *win);

    //Window traversal
    inline QWidgetList getListOfWindows()
    {
        return qobject_cast<QWorkspace *>(workspaces->currentWidget())->windowList();
    }
    inline int getNumberOfWindows()
    {
        return qobject_cast<QWorkspace *>(workspaces->currentWidget())->windowList().size();
    }
    int getNumberOfImageWindows();
    int getNumberOfModelWindows();
    inline int getNumberOfTabs()
    {
        return workspaces->count();
    }
    inline void initialiseWindowTraversal()
    {
        windowIterator = 0;
    }
    milxQtWindow* currentWindow();
    milxQtWindow* nextWindow();
    milxQtRenderWindow* nextRenderWindow();
    milxQtModel* nextModel();
    milxQtImage* nextImage();

    //Image-Model Inter-Members
    void imageToSurface(vtkSmartPointer<vtkImageData> img, const float value = numeric_limits<float>::max());
    void imageToPolyData(vtkSmartPointer<vtkImageData> img);
    void imageToPseudoImage(vectorImageType::Pointer img);
    void imageToVectorField(vectorImageType::Pointer img, floatImageType::Pointer magImg, int subsampleFactor = 0, float scaling = 0.0);
    void imageToTensorField(vectorImageType::Pointer img, floatImageType::Pointer magImg, int subsampleFactor = 0, float scaling = 0.0);
    void imageToStreamLines(vectorImageType::Pointer img, floatImageType::Pointer magImg, size_t subsampleFactor = 0);
    void imageToVolume(vtkSmartPointer<vtkImageData> img, bool eightbit);
    void imageToPlot(vtkSmartPointer<vtkImageData> img, int displaceAxis = 2);
    void tableToPlot(vtkSmartPointer<vtkTable> tbl, QString title);
    void voxeliseSurface(vtkSmartPointer<vtkPolyData> surface);

    //Batch
    void imagesMix();
    void imagesBlend(QVector<float> opacities);
    void imagesAdd();
    void imagesAverage();
    void imagesSubtract();
    void imagesMultiply();
    void imagesConvolve();
    void imagesMergeLabels();

    void unify();
    inline void link()
    {   actionLinkWindows->setChecked(true);  }
    inline void unlink()
    {   actionLinkWindows->setChecked(false);  }
    void update();
    void writeSettings();
    void readSettings();

    bool loadPlugins();
    inline QList< QPointer<milxQtPluginInterface> > getPlugins()
    {   return plugins;   }

    //Print Members
    inline void printError(QString msg)
    {   console->printError(msg);   }
//    {   cerr << msg.toStdString() << endl;   }
    inline void printWarning(QString msg)
    {   console->printWarning(msg);   }
//    {   cerr << msg.toStdString() << endl;   }
    inline void printDebug(QString msg)
    {   console->printDebug(msg);   }
//    {   cerr << msg.toStdString() << endl;   }
    inline void printInfo(QString msg)
    {   console->printInfo(msg);   }
//    {   cerr << msg.toStdString() << endl;   }

protected slots:
    inline void redirectWindowActivated(QWidget *win)
    {
        emit windowActivated(win);
    }
    void transferViewToWindows(vtkObject *obj, unsigned long, void *client_data, void *, vtkCommand *command);
    void dataMenu();
    inline void updateQtEvents()
    {
        qApp->processEvents();
    }

signals:
    void windowActivated(QWidget * win);
    void displayed(milxQtRenderWindow*);
    void displayed(milxQtImage*);
    void displayed(milxQtModel*);
    void displayed(milxQtUnifiedWindow*);
    void updatedWindowListMenu(QActionGroup *);
    void updatedWindowListMenu(QMenu *);
    void updatedImportFromMenu(QActionGroup *);
    void updatedImportFromMenu(QMenu *);

protected:
    bool debugMode; 

    //Settings
    bool whiteBackground; 
    bool humanGlyph; 
    int subWindowSize; 
    int maxProcessors; 
    int magnifyFactor; 
    bool timestamping; 
    bool interpolationImages; 
    bool orientationImages; 
    bool interpolationModels; 
    bool scalarBarModels; 

    enum { MaxRecentFiles = 10 };
    //Menus (hierarchical deletion)
    QMenuBar* menuBar; 
    QMenu* menuFile; 
    QMenu* menuImages; 
    QMenu* menuData; 
    //QMenu* menuNew; //!< File menu
    QMenu* menuWindows; 
    QMenu* menuHelp; 

    size_t progressCallCount; 
    int windowIterator; 

    //File dialog attributes
    QString saveSupport; 
    QString openSupport; 

    //----File---- (hierarchical deletion)
    QAction* actionOpen; 
    QAction* actionOpenSeries; 
    QAction* actionOpenCollect; 
    QAction* actionSave; 
    QAction* actionSaveScreen; 
    QAction* actionCloseActive; 
    QAction* actionCloseAll; 
    QAction* actionsRecentFile[MaxRecentFiles]; 
    QAction* actionRecentFileSeparator; 
    QAction* actionExit; 
    //----New---- (hierarchical deletion)
    QAction* actionNewTab; 
    //----Images---- (hierarchical deletion)
    QAction* actionBlendImages; 
    QAction* actionAddImages; 
    QAction* actionAverageImages; 
    QAction* actionSubtractImages; 
    QAction* actionMultiplyImages; 
    QAction* actionConvolveImages; 
    QAction* actionMergeLabels; 
    //----Windows---- (hierarchical deletion)
    QAction* actionLinkWindows; 
    QAction* actionCascade; 
    QAction* actionTile; 
    QAction* actionTileVertically; 
    QAction* actionTileHorizontally; 
    QAction* actionConsole; 
    //----Help---- (hierarchical deletion)
    QAction* actionContents; 
    QAction* actionPreferences; 
    QAction* actionControls; 
    QAction* actionAbout; 

    //Common actions/menus
    QAction* actionCompare; 
    QMenu* menuWindowList; 
    QMenu* importFromMenu; 

    //Toolbars
    QToolBar* fileToolBar; 
//    QToolBar* editToolBar; //!< Some actions from edit menu, like copy, paste etc.
    QToolBar* windowToolBar; 
    QToolBar* defaultToolBar; 
    QToolBar* imageToolBar; 

    //Image toolbar actions
    QAction* actionImageText; 
    QSlider* imageLevelSlider; 
    QPushButton* imageLevelButton; 
    //QDial* imageLevelDial; //!< adjust window level of image display via a dial
    QPushButton* refreshButton; 
    QPushButton* cursorButton; 

    //Workspaces (hierarchical deletion)
    QTabWidget* workspaces; 
    QSignalMapper *windowMapper; 
    //Plugins (Smart Pointer deletion)
    QList< QPointer<milxQtPluginInterface> > plugins; 
    QList< QAction* > renderExtsActions; 
    QList< QAction* > modelExtsActions; 
    QList< QAction* > imageExtsActions; 
    QList< QAction* > dockActions; 
    //Bar (hierarchical deletion)
    QProgressBar *progressBar; 
    //Console
    QPointer<milxQtConsole> console; 

    //Default Comboboxes
    QComboBox *defaultViewBox; 
    QComboBox *defaultViewTypeBox; 
    QComboBox *defaultOrientationTypeBox; 

    QPointer<milxQtUnifiedWindow> currentUnifiedWindow; 
    QList< QPointer<milxQtModel> > modelWindows; 
    QList< QPointer<milxQtImage> > imageWindows; 

    vtkSmartPointer<vtkEventQtSlotConnect> Connector; 

    void linkProgressEventOf(vtkObject * obj);
    void commonChildProperties(QWidget *widget);
    void createMenu();
    void createComboBoxes();
    void createToolBars();
    void createConnections();
    void createProgressBar();
    void setupTooltips();
    void contextMenuEvent(QContextMenuEvent *event);
    inline QString strippedName(const QString &fullFileName)
    {
        return QFileInfo(fullFileName).fileName();
    }
    void dragEnterEvent(QDragEnterEvent *event);
    void dropEvent(QDropEvent *event);
    void closeEvent(QCloseEvent *event);

private:

};

#endif // MILXQTMAIN_H