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 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
class vtkDataIOManagerLogic;
class vtkSlicerApplicationLogic;
class vtkMRMLApplicationLogic;
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 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(bool isRelease READ isRelease 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(int majorVersion READ majorVersion CONSTANT)
  Q_PROPERTY(int minorVersion READ minorVersion CONSTANT)
  Q_PROPERTY(QString platform READ platform CONSTANT)
  Q_PROPERTY(QString arch READ arch CONSTANT)
  Q_PROPERTY(QString os READ os CONSTANT)
public:

  typedef QApplication Superclass;
  qSlicerCoreApplication(int &argc, char **argv);
  virtual ~qSlicerCoreApplication();

  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;

  Q_INVOKABLE QProcessEnvironment environment() const;

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

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

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

  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;

  Q_INVOKABLE vtkMRMLScene* mrmlScene() const;

  Q_INVOKABLE vtkSlicerApplicationLogic* applicationLogic() 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 launcherExecutableFilePath()const;

  QString launcherSettingsFilePath()const;

  QString launcherRevisionSpecificUserSettingsFilePath()const;

  QString slicerDefaultSettingsFilePath()const;

  QString slicerUserSettingsFilePath()const;

  QString slicerRevisionUserSettingsFilePath()const;

  QString defaultExtensionsInstallPath() const;

  QString extensionsInstallPath() const;

  void setExtensionsInstallPath(const QString& path);

  QString intDir()const;

  bool isInstalled()const;

  QString releaseType()const;

  bool isRelease()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

  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;

  virtual QString copyrights()const;

  virtual QString acknowledgment()const;

  virtual QString libraries()const;

  QString repositoryUrl()const;

  QString repositoryBranch()const;

  QString repositoryRevision()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;

  Q_INVOKABLE void setDICOMDatabase(ctkDICOMDatabase* dicomDatabase);
#endif

  static void loadTranslations(const QString& dir);

  static void loadLanguage();

  static bool loadCaCertificates(const QString& slicerHome);

  Q_INVOKABLE int registerResource(const QByteArray& data);

public slots:

  static void restart();

  bool unregisterResource(int handle);

protected:
  virtual void handlePreApplicationCommandLineArguments();

  virtual void setMRMLScene(vtkMRMLScene * scene);

protected slots:

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

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

  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 invokeEventRequested(unsigned int delay, void* caller,
                            unsigned long event, void* callData);

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)

#endif