pqObjectBuilder.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 pqObjectBuilder_h
#define pqObjectBuilder_h

#include "pqCoreModule.h"
#include "vtkNetworkAccessManager.h" // needed for vtkNetworkAccessManager::ConnectionResult.

#include <QMap>
#include <QObject>
#include <QVariant>

class pqAnimationCue;
class pqDataRepresentation;
class pqOutputPort;
class pqPipelineSource;
class pqProxy;
class pqRepresentation;
class pqScalarBarRepresentation;
class pqScalarsToColors;
class pqServer;
class pqServerResource;
class pqView;
class vtkSMProxy;

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

public:
  pqObjectBuilder(QObject* parent = nullptr);
  ~pqObjectBuilder() override;


  pqServer* createServer(const pqServerResource& resource, int connectionTimeout = 60)
  {
    vtkNetworkAccessManager::ConnectionResult result;
    return this->createServer(resource, connectionTimeout, result);
  }
  pqServer* createServer(const pqServerResource& resource, int connectionTimeout,
    vtkNetworkAccessManager::ConnectionResult& result);

  void removeServer(pqServer* server);

  pqServer* resetServer(pqServer* server);

  virtual pqPipelineSource* createSource(
    const QString& sm_group, const QString& sm_name, pqServer* server);

  virtual pqPipelineSource* createFilter(const QString& group, const QString& name,
    QMap<QString, QList<pqOutputPort*>> namedInputs, pqServer* server);

  virtual pqPipelineSource* createFilter(
    const QString& group, const QString& name, pqPipelineSource* input, int output_port = 0);

  virtual pqPipelineSource* createReader(
    const QString& sm_group, const QString& sm_name, const QStringList& files, pqServer* server);

  virtual pqView* createView(const QString& type, pqServer* server);

  virtual void destroy(pqView* view);

  virtual void addToLayout(pqView* view, pqProxy* layout = nullptr);

  virtual pqDataRepresentation* createDataRepresentation(
    pqOutputPort* source, pqView* view, const QString& representationType = "");

  virtual vtkSMProxy* createProxy(
    const QString& sm_group, const QString& sm_name, pqServer* server, const QString& reg_group);

  virtual void destroy(pqRepresentation* repr);

  // \li removing all displays belonging to the source,
  // \li breaking any input connections.
  // \li unregistering the source.
  // Note that the source must have no consumers, otherwise,
  // one cannot delete the source.
  virtual void destroy(pqPipelineSource* source);

  virtual void destroy(pqAnimationCue* cue);

  virtual void destroy(pqProxy* proxy);

  virtual void destroySources(pqServer* server = nullptr);

  virtual void destroyLookupTables(pqServer* server = nullptr);

  virtual void destroyPipelineProxies(pqServer* server = nullptr);

  virtual void destroyAllProxies(pqServer* server);

  static QString getFileNamePropertyName(vtkSMProxy*);

  bool waitingForConnection() const
  {
    return this->ForceWaitingForConnection ? true : this->WaitingForConnection;
  }

  bool forceWaitingForConnection(bool force);

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

Q_SIGNALS:

  void finishedAddingServer(pqServer* server);

  void sourceCreated(pqPipelineSource*);

  void filterCreated(pqPipelineSource*);

  void readerCreated(pqPipelineSource*, const QString& filename);
  void readerCreated(pqPipelineSource*, const QStringList& filename);

  void aboutToCreateView(pqServer* server);

  void viewCreated(pqView*);

  void dataRepresentationCreated(pqDataRepresentation*);

  void proxyCreated(pqProxy*);

  void proxyCreated(vtkSMProxy*);

  void destroying(pqView* view);

  void destroying(pqRepresentation* display);

  void destroying(pqPipelineSource* source);

  void destroying(pqProxy* proxy);

protected:
  virtual void destroyProxyInternal(pqProxy* proxy);

private:
  Q_DISABLE_COPY(pqObjectBuilder)

  bool ForceWaitingForConnection;
  bool WaitingForConnection;
};

#endif