pqApplicationCore.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-FileCopyrightText: Copyright (c) Sandia Corporation
// SPDX-License-Identifier: BSD-3-Clause
#ifndef pqApplicationCore_h
#define pqApplicationCore_h

#include "pqCoreModule.h"
#include "vtkSmartPointer.h" // for vtkSmartPointer
#include <QObject>
#include <QPointer>
#include <QStringList>
#include <QTranslator>
#include <exception> // for std::exception

class pqInterfaceTracker;
class pqLinksModel;
class pqMainWindowEventManager;
class pqObjectBuilder;
class pqPipelineSource;
class pqPluginManager;
class pqProgressManager;
class pqRecentlyUsedResourcesList;
class pqServer;
class pqServerConfigurationCollection;
class pqServerManagerModel;
class pqServerManagerObserver;
class pqServerResource;
class pqSettings;
class pqTestUtility;
class pqUndoStack;
class QApplication;
class QHelpEngine;
class vtkPVXMLElement;
class vtkSMProxyLocator;
class vtkSMStateLoader;
class vtkCLIOptions;

class PQCORE_EXPORT pqApplicationCoreExitCode : public std::exception
{
  int Code = 0;

public:
  pqApplicationCoreExitCode(int ecode)
    : Code(ecode)
  {
  }
  int code() const { return this->Code; }
};

class PQCORE_EXPORT pqApplicationCore : public QObject
{
  Q_OBJECT
  typedef QObject Superclass;

public:
  // Get the global instance for the pqApplicationCore.
  static pqApplicationCore* instance();

  pqApplicationCore(int& argc, char** argv, vtkCLIOptions* options = nullptr,
    bool addStandardArgs = true, QObject* parent = nullptr);

  pqObjectBuilder* getObjectBuilder() const { return this->ObjectBuilder; }

  void setUndoStack(pqUndoStack* stack);
  pqUndoStack* getUndoStack() const { return this->UndoStack; }

  void registerManager(const QString& function, QObject* manager);

  //. \sa registerManager
  QObject* manager(const QString& function);

  void unRegisterManager(const QString& function);

  QHelpEngine* helpEngine();

  void registerDocumentation(const QString& filename);

  pqServerManagerObserver* getServerManagerObserver() { return this->ServerManagerObserver; }

  pqServerManagerModel* getServerManagerModel() const { return this->ServerManagerModel; }

  pqInterfaceTracker* interfaceTracker() const { return this->InterfaceTracker; }

  pqLinksModel* getLinksModel() const { return this->LinksModel; }

  pqMainWindowEventManager* getMainWindowEventManager() const
  {
    return this->MainWindowEventManager;
  }

  pqPluginManager* getPluginManager() const { return this->PluginManager; }

  pqProgressManager* getProgressManager() const { return this->ProgressManager; }

  virtual pqTestUtility* testUtility();

  pqRecentlyUsedResourcesList& recentlyUsedResources();

  pqServerConfigurationCollection& serverConfigurations();

  pqSettings* settings();

  void clearSettings();

  enum class StateFileFormat : unsigned int
  {
    PVSM = 0,
    Python = 1
  };

  static QString stateFileFormatToExtension(pqApplicationCore::StateFileFormat format);

  QString getDefaultSaveStateFileFormatQString(bool pythonAvailable, bool loading);

  void useVersionedSettings(bool use);

  vtkPVXMLElement* saveState();

  bool saveState(const QString& filename, vtkTypeUInt32 location = 0x10 /*vtkPVSession::CLIENT*/);

  void loadState(vtkPVXMLElement* root, pqServer* server, vtkSMStateLoader* loader = nullptr);

  void loadState(const char* filename, pqServer* server, vtkSMStateLoader* loader = nullptr);

  void loadStateFromString(
    const char* xmlcontents, pqServer* server, vtkSMStateLoader* loader = nullptr);

  void clearViewsForLoadingState(pqServer* server);

  void loadStateIncremental(
    vtkPVXMLElement* root, pqServer* server, vtkSMStateLoader* loader = nullptr);
  void loadStateIncremental(
    const QString& filename, pqServer* server, vtkSMStateLoader* loader = nullptr);

  void setLoadingState(bool value) { this->LoadingState = value; };

  bool isLoadingState() { return this->LoadingState; };

  pqServer* getActiveServer() const;

  QString getTranslationsPathFromInterfaceLanguage(QString prefix, QString locale);

  QTranslator* getQtTranslations(QString prefix, QString locale);

  QString getInterfaceLanguage();

  ~pqApplicationCore() override;

  void _paraview_client_environment_complete();

public Q_SLOTS: // NOLINT(readability-redundant-access-specifiers)

  void prepareForQuit();

  void quit();


  void loadConfiguration(const QString& filename);
  void loadConfigurationXML(const char* xmldata);

  void updateAvailableReadersAndWriters();

  void render();

Q_SIGNALS:
  void aboutToWriteState(QString filename);

  void aboutToReadState(QString filename);

  void aboutToLoadState(vtkPVXMLElement* root);

  void stateLoaded(vtkPVXMLElement* root, vtkSMProxyLocator* locator);

  void stateSaved(vtkPVXMLElement* root);

  void undoStackChanged(pqUndoStack*);

  void loadXML(vtkPVXMLElement*);

  void forceFilterMenuRefresh();

  void updateMasterEnableState(bool);

  void clientEnvironmentDone();

protected Q_SLOTS:
  void onStateLoaded(vtkPVXMLElement* root, vtkSMProxyLocator* locator);
  void onStateSaved(vtkPVXMLElement* root);
  void onHelpEngineWarning(const QString&);

private Q_SLOTS:
  void generalSettingsChanged();

protected:
  bool LoadingState;

  pqLinksModel* LinksModel;
  pqObjectBuilder* ObjectBuilder;
  pqInterfaceTracker* InterfaceTracker;
  pqMainWindowEventManager* MainWindowEventManager;
  pqPluginManager* PluginManager;
  pqProgressManager* ProgressManager;
  pqServerManagerModel* ServerManagerModel;
  pqServerManagerObserver* ServerManagerObserver;
  pqUndoStack* UndoStack;
  pqRecentlyUsedResourcesList* RecentlyUsedResourcesList;
  pqServerConfigurationCollection* ServerConfigurations;
  pqSettings* Settings;
  QHelpEngine* HelpEngine;
  QPointer<pqTestUtility> TestUtility;

private:
  Q_DISABLE_COPY(pqApplicationCore)

  class pqInternals;
  pqInternals* Internal;
  static pqApplicationCore* Instance;
  void constructor();

  QString getSettingFileBaseName();

  bool VersionedSettings = false;
};

#endif