qSlicerCoreApplication.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware Inc.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  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.
 
  This file was originally developed by Jean-Christophe Fillion-Robin, Kitware Inc.
  and was partially funded by NIH grant 3P41RR013218-12S1
 
==============================================================================*/
 
#ifndef __qSlicerCoreApplication_h
#define __qSlicerCoreApplication_h
 
// Qt includes
#include <QApplication>
#include <QMetaType>
#include <QProcessEnvironment>
#include <QStringList>
#include <QVariant>
 
// CTK includes
#include <ctkVTKObject.h>
 
// SlicerCore includes
#include "vtkSlicerConfigure.h" // For Slicer_USE_PYTHONQT
#include "qSlicerBaseQTCoreExport.h"
 
#ifdef Slicer_BUILD_DICOM_SUPPORT
class ctkDICOMDatabase;
#endif
class ctkErrorLogAbstractModel;
class QSettings;
class qSlicerCoreIOManager;
class qSlicerCoreCommandOptions;
class qSlicerCoreApplicationPrivate;
class qSlicerModuleManager;
#ifdef Slicer_USE_PYTHONQT
class qSlicerCorePythonManager;
class ctkPythonConsole;
#endif
#ifdef Slicer_BUILD_EXTENSIONMANAGER_SUPPORT
class qSlicerExtensionsManagerModel;
#endif
#ifdef Slicer_BUILD_APPLICATIONUPDATE_SUPPORT
class qSlicerApplicationUpdateManager;
#endif
class vtkDataIOManagerLogic;
class vtkSlicerApplicationLogic;
class vtkMRMLAbstractLogic;
class vtkMRMLApplicationLogic;
class vtkMRMLMessageCollection;
class vtkMRMLRemoteIOLogic;
class vtkMRMLScene;
 
class Q_SLICER_BASE_QTCORE_EXPORT qSlicerCoreApplication : public QApplication
{
  Q_OBJECT
  QVTK_OBJECT
  Q_ENUMS(ReturnCode)
 
  
  Q_PROPERTY(QString slicerHome READ slicerHome CONSTANT)
  Q_PROPERTY(QString defaultScenePath READ defaultScenePath WRITE setDefaultScenePath)
  Q_PROPERTY(QString slicerSharePath READ slicerSharePath CONSTANT)
  Q_PROPERTY(QString temporaryPath READ temporaryPath WRITE setTemporaryPath)
  Q_PROPERTY(QString cachePath READ cachePath WRITE setCachePath)
  Q_PROPERTY(QString startupWorkingPath READ startupWorkingPath CONSTANT)
  Q_PROPERTY(QString launcherExecutableFilePath READ launcherExecutableFilePath CONSTANT)
  Q_PROPERTY(QString launcherSettingsFilePath READ launcherSettingsFilePath CONSTANT)
  Q_PROPERTY(QString slicerDefaultSettingsFilePath READ slicerDefaultSettingsFilePath CONSTANT)
  Q_PROPERTY(QString slicerUserSettingsFilePath READ slicerUserSettingsFilePath CONSTANT)
  Q_PROPERTY(QString slicerRevisionUserSettingsFilePath READ slicerRevisionUserSettingsFilePath CONSTANT)
  Q_PROPERTY(QString extensionsInstallPath READ extensionsInstallPath WRITE setExtensionsInstallPath)
  Q_PROPERTY(QString intDir READ intDir CONSTANT)
  Q_PROPERTY(bool isInstalled READ isInstalled CONSTANT)
  Q_PROPERTY(QString releaseType READ releaseType CONSTANT)
  Q_PROPERTY(QString repositoryUrl READ repositoryUrl CONSTANT)
  Q_PROPERTY(QString repositoryBranch READ repositoryBranch CONSTANT)
  Q_PROPERTY(QString repositoryRevision READ repositoryRevision CONSTANT)
  Q_PROPERTY(QString revision READ revision CONSTANT)
  Q_PROPERTY(int majorVersion READ majorVersion CONSTANT)
  Q_PROPERTY(int minorVersion READ minorVersion CONSTANT)
  Q_PROPERTY(QLocale applicationLocale READ applicationLocale CONSTANT)
  Q_PROPERTY(QString applicationLocaleName READ applicationLocaleName CONSTANT)
  Q_PROPERTY(QString documentationBaseUrl READ documentationBaseUrl)
  Q_PROPERTY(QString documentationVersion READ documentationVersion CONSTANT)
  Q_PROPERTY(QString documentationLanguage READ documentationLanguage CONSTANT)
  Q_PROPERTY(QString platform READ platform CONSTANT)
  Q_PROPERTY(QString arch READ arch CONSTANT)
  Q_PROPERTY(QString os READ os CONSTANT)
  Q_PROPERTY(bool isCustomMainApplication READ isCustomMainApplication CONSTANT)
  Q_PROPERTY(QString mainApplicationName READ mainApplicationName CONSTANT)
  Q_PROPERTY(QString mainApplicationDisplayName READ mainApplicationDisplayName CONSTANT)
  Q_PROPERTY(QString mainApplicationRepositoryUrl READ mainApplicationRepositoryUrl CONSTANT)
  Q_PROPERTY(QString mainApplicationRepositoryRevision READ mainApplicationRepositoryRevision CONSTANT)
  Q_PROPERTY(QString mainApplicationRevision READ mainApplicationRevision CONSTANT)
  Q_PROPERTY(int mainApplicationMajorVersion READ mainApplicationMajorVersion CONSTANT)
  Q_PROPERTY(int mainApplicationMinorVersion READ mainApplicationMinorVersion CONSTANT)
  Q_PROPERTY(int mainApplicationPatchVersion READ mainApplicationPatchVersion CONSTANT)
  Q_PROPERTY(bool isUsageLoggingSupported READ isUsageLoggingSupported CONSTANT)
 
public:
  typedef QApplication Superclass;
  qSlicerCoreApplication(int& argc, char** argv);
  ~qSlicerCoreApplication() override;

  static qSlicerCoreApplication* application();

  enum ApplicationAttribute
  {
    AA_DisablePython = 1000,
    AA_EnableTesting
  };

  static void setAttribute(qSlicerCoreApplication::ApplicationAttribute attribute, bool on = true);

  static bool testAttribute(qSlicerCoreApplication::ApplicationAttribute attribute);

  Q_INVOKABLE QProcessEnvironment startupEnvironment() const;

  QString startupWorkingPath() const;

  Q_INVOKABLE QProcessEnvironment environment() const;

  Q_INVOKABLE void setEnvironmentVariable(const QString& key, const QString& value);

  Q_INVOKABLE bool isEnvironmentVariableValueSet(const QString& key, const QString& value);

  Q_INVOKABLE void prependEnvironmentVariable(const QString& key, const QString& value, QChar separator = ';');

  Q_INVOKABLE void appendEnvironmentVariable(const QString& key, const QString& value, QChar separator = ';');

  void parseArguments(bool& exitWhenDone);
 
  enum ReturnCode
  {
    ExitNotRequested = -1,
    ExitSuccess = EXIT_SUCCESS,
    ExitFailure = EXIT_FAILURE
  };

  int returnCode() const;

  static int exec();

  Q_INVOKABLE vtkMRMLScene* mrmlScene() const;

  Q_INVOKABLE vtkSlicerApplicationLogic* applicationLogic() const;
 
  // Convenience method for getting a module logic from the application logic.
  Q_INVOKABLE vtkMRMLAbstractLogic* moduleLogic(const QString& moduleName) const;

  QString slicerHome() const;

  QString defaultScenePath() const;

  void setDefaultScenePath(const QString& path);

  QString slicerSharePath() const;

  bool isEmbeddedModule(const QString& moduleFileName) const;

  QString defaultTemporaryPath() const;

  QString temporaryPath() const;

  void setTemporaryPath(const QString& path);

  QString defaultCachePath() const;

  QString cachePath() const;

  void setCachePath(const QString& path);

  QString launcherExecutableFilePath() const;

  QString launcherSettingsFilePath() const;

  QString launcherRevisionSpecificUserSettingsFilePath() const;

  QString slicerDefaultSettingsFilePath() const;

  QString slicerUserSettingsFilePath() const;

  QString slicerRevisionUserSettingsFilePath() const;

  static QString applicationNameFromExecutablePath(const QString& executablePath);

  static QString applicationHomeDirectoryFromExecutablePath(const QString& executablePath, QString* intDir = nullptr);

  static QString revisionUserSettingsDirectory(const QString& slicerHome, const QString& applicationName);

  QString defaultExtensionsInstallPath() const;

  QString extensionsInstallPath() const;

  void setExtensionsInstallPath(const QString& path);

  QString intDir() const;

  bool isInstalled() const;

  QString releaseType() const;

  Q_INVOKABLE void addModuleAssociatedNodeType(const QString& nodeClassName, const QString& moduleName);

  Q_INVOKABLE void removeModuleAssociatedNodeType(const QString& nodeClassName, const QString& moduleName);

  Q_INVOKABLE QStringList modulesAssociatedWithNodeType(const QString& nodeClassName) const;

  Q_INVOKABLE QStringList allModuleAssociatedNodeTypes() const;
 
#ifdef Slicer_USE_PYTHONQT
  qSlicerCorePythonManager* corePythonManager() const;

  void setCorePythonManager(qSlicerCorePythonManager* pythonManager);

  ctkPythonConsole* pythonConsole() const;

  void setPythonConsole(ctkPythonConsole* pythonConsole);
 
#endif
 
#ifdef Slicer_BUILD_EXTENSIONMANAGER_SUPPORT
  Q_INVOKABLE qSlicerExtensionsManagerModel* extensionsManagerModel() const;

  void setExtensionsManagerModel(qSlicerExtensionsManagerModel* model);
#endif
 
#ifdef Slicer_BUILD_APPLICATIONUPDATE_SUPPORT
  Q_INVOKABLE qSlicerApplicationUpdateManager* applicationUpdateManager() const;

  void setapplicationUpdateManager(qSlicerApplicationUpdateManager* model);
#endif

  Q_INVOKABLE ctkErrorLogAbstractModel* errorLogModel() const;

  Q_INVOKABLE qSlicerModuleManager* moduleManager() const;

  Q_INVOKABLE qSlicerCoreIOManager* coreIOManager() const;

  void setCoreIOManager(qSlicerCoreIOManager* ioManager);

  qSlicerCoreCommandOptions* coreCommandOptions() const;

  void setCoreCommandOptions(qSlicerCoreCommandOptions* options);

  Q_INVOKABLE QSettings* defaultSettings() const;

  Q_INVOKABLE QSettings* userSettings() const;

  Q_INVOKABLE QSettings* settings() const;

  Q_INVOKABLE QSettings* revisionUserSettings() const;

  bool isCustomMainApplication() const;

  QString mainApplicationName() const;

  QString mainApplicationDisplayName() const;

  QString mainApplicationRepositoryUrl() const;

  QString mainApplicationRepositoryRevision() const;

  QString mainApplicationRevision() const;

  int mainApplicationMajorVersion() const;

  int mainApplicationMinorVersion() const;

  int mainApplicationPatchVersion() const;

  QString documentationBaseUrl() const;

  QString documentationVersion() const;

  QString documentationLanguage() const;

  QLocale applicationLocale() const;

  QString applicationLocaleName() const;

  Q_INVOKABLE QString moduleDocumentationUrl(const QString& moduleName) const;

  virtual QString copyrights() const;

  virtual QString acknowledgment() const;

  virtual QString libraries() const;

  QString repositoryUrl() const;

  QString repositoryBranch() const;

  QString repositoryRevision() const;

  QString revision() const;

  int majorVersion() const;

  int minorVersion() const;

  QString platform() const;

  QString arch() const;

  QString os() const;
 
#ifdef Slicer_BUILD_DICOM_SUPPORT
  Q_INVOKABLE ctkDICOMDatabase* dicomDatabase() const;

  QSharedPointer<ctkDICOMDatabase> dicomDatabaseShared() const;
#endif

  Q_INVOKABLE static QStringList translationFolders();

  Q_INVOKABLE static void loadTranslations(const QString& dir);

  Q_INVOKABLE static void loadLanguage();

  Q_INVOKABLE static bool loadCaCertificates(const QString& slicerHome);

  Q_INVOKABLE static QString caCertificatesPath(const QString& slicerHome);
 
  Q_INVOKABLE int registerResource(const QByteArray& data);

  Q_INVOKABLE void showConsoleMessage(QString message, bool error = true) const;

  Q_INVOKABLE QString toSlicerHomeAbsolutePath(const QString& path) const;

  Q_INVOKABLE QString toSlicerHomeRelativePath(const QString& path) const;

  Q_INVOKABLE QStringList toSlicerHomeAbsolutePaths(const QStringList& path) const;

  Q_INVOKABLE QStringList toSlicerHomeRelativePaths(const QStringList& path) const;

  Q_INVOKABLE void logUsageEvent(const QString& component, const QString& event);

  bool isUsageLoggingSupported() const;

  Q_INVOKABLE void handleURIArguments(const QStringList& fileNames);

  bool isURIArgumentHandlingEnabled() const;
  void setURIArgumentHandlingEnabled(bool enabled);
 
public slots:

  static void restart();
 
  bool unregisterResource(int handle);

  virtual void setRenderPaused(bool pause) { Q_UNUSED(pause); };
  virtual void pauseRender() {};
  virtual void resumeRender() {};

  virtual bool loadFiles(const QStringList& filePaths, vtkMRMLMessageCollection* userMessages = nullptr);

  virtual void openUrl(const QString& url);
 
protected:
  virtual void handlePreApplicationCommandLineArguments();

  virtual void setMRMLScene(vtkMRMLScene* scene);
 
protected slots:

  virtual void handleCommandLineArguments();
 
  virtual void onSlicerApplicationLogicModified();
  virtual void onUserInformationModified();
  void onSlicerApplicationLogicRequest(vtkObject*, void*, unsigned long);
  void processAppLogicModified();
  void processAppLogicReadData();
  void processAppLogicWriteData();

  virtual void editNode(vtkObject*, void*, unsigned long) {};

  void terminate(int exitCode = qSlicerCoreApplication::ExitSuccess);

  virtual void onAboutToQuit();

  void requestInvokeEvent(vtkObject* caller, void* callData);

  void scheduleInvokeEvent(unsigned int delay, void* caller, unsigned long event, void* callData);

  void invokeEvent();
 
signals:
  void mrmlSceneChanged(vtkMRMLScene* mrmlScene);

  void urlReceived(QString url);

  void invokeEventRequested(unsigned int delay, void* caller, unsigned long event, void* callData);
 
  void usageEventLogged(const QString& component, const QString& event);
 
protected:
  qSlicerCoreApplication(qSlicerCoreApplicationPrivate* pimpl, int& argc, char** argv);
  QScopedPointer<qSlicerCoreApplicationPrivate> d_ptr;
 
private:
  Q_DECLARE_PRIVATE(qSlicerCoreApplication);
  Q_DISABLE_COPY(qSlicerCoreApplication);
};
 
Q_DECLARE_METATYPE(qSlicerCoreApplication::ReturnCode)
 

class Q_SLICER_BASE_QTCORE_EXPORT SlicerRenderBlocker
{
public:
  qSlicerCoreApplication* Application;
  SlicerRenderBlocker()
  {
    this->Application = qSlicerCoreApplication::application();
    if (this->Application)
    {
      this->Application->pauseRender();
    }
  };
  ~SlicerRenderBlocker()
  {
    if (this->Application)
    {
      this->Application->resumeRender();
    }
  }
};
 
#endif