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();
 
  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();
};
 
#endif