pqServerManagerModel.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 pqServerManagerModel_h
#define pqServerManagerModel_h

#include "pqCoreModule.h"
#include "vtkType.h" // for vtkIdType.
#include <QList>
#include <QObject>

class pqExtractor;
class pqPipelineSource;
class pqProxy;
class pqRepresentation;
class pqServer;
class pqServerManagerModelItem;
class pqServerManagerObserver;
class pqServerResource;
class pqView;
class vtkPVXMLElement;
class vtkSession;
class vtkSMProxy;
class vtkSMProxyLocator;
class vtkSMSession;

class pqServerManagerModel;

template <class T>
inline QList<T> pqFindItems(const pqServerManagerModel* model);
template <class T>
inline QList<T> pqFindItems(const pqServerManagerModel* model, pqServer* server);
template <class T>
inline T pqFindItem(const pqServerManagerModel* model, const QString& name);
template <class T>
inline T pqFindItem(const pqServerManagerModel* model, vtkSMProxy* proxy);
template <class T>
inline T pqFindItem(const pqServerManagerModel* model, vtkTypeUInt32 id);
template <class T>
inline int pqGetNumberOfItems(const pqServerManagerModel* model);
template <class T>
inline T pqGetItemAtIndex(const pqServerManagerModel* model, int index);

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

public:
  pqServerManagerModel(pqServerManagerObserver* observer, QObject* parent = nullptr);
  ~pqServerManagerModel() override;

  pqServer* findServer(vtkIdType cid) const;

  pqServer* findServer(vtkSession*) const;
  pqServer* findServer(vtkSMSession*) const;

  pqServer* findServer(const pqServerResource& resource) const;

  pqServer* findServer(const QString& name) const;

  void beginRemoveServer(pqServer* server);
  void endRemoveServer();

  void setActiveResource(const pqServerResource& resource);

  template <class T>
  T findItem(vtkSMProxy* proxy) const
  {
    return ::pqFindItem<T>(this, proxy);
  }

  template <class T>
  T findItem(vtkTypeUInt32 id) const
  {
    return ::pqFindItem<T>(this, id);
  }

  template <class T>
  QList<T> findItems() const
  {
    return ::pqFindItems<T>(this);
  }

  template <class T>
  int getNumberOfItems() const
  {
    return ::pqGetNumberOfItems<T>(this);
  }

  template <class T>
  T getItemAtIndex(int index) const
  {
    return ::pqGetItemAtIndex<T>(this, index);
  }

  template <class T>
  QList<T> findItems(pqServer* server) const
  {
    return ::pqFindItems<T>(this, server);
  }

  template <class T>
  T findItem(const QString& name) const
  {
    return ::pqFindItem<T>(this, name);
  }

  static void findItemsHelper(const pqServerManagerModel* model, const QMetaObject& mo,
    QList<void*>* list, pqServer* server = nullptr);

  static pqServerManagerModelItem* findItemHelper(
    const pqServerManagerModel* model, const QMetaObject& mo, vtkSMProxy* proxy);

  static pqServerManagerModelItem* findItemHelper(
    const pqServerManagerModel* model, const QMetaObject& mo, vtkTypeUInt32 id);

  static pqServerManagerModelItem* findItemHelper(
    const pqServerManagerModel* model, const QMetaObject& mo, const QString& name);

Q_SIGNALS:
  void preServerAdded(pqServer*);
  void serverAdded(pqServer*);

  void serverReady(pqServer*);

  void preServerRemoved(pqServer*);
  void serverRemoved(pqServer*);

  void aboutToRemoveServer(pqServer* server);

  void finishedRemovingServer();

  void preItemAdded(pqServerManagerModelItem*);
  void itemAdded(pqServerManagerModelItem*);

  void preItemRemoved(pqServerManagerModelItem*);
  void itemRemoved(pqServerManagerModelItem*);

  void preProxyAdded(pqProxy*);
  void proxyAdded(pqProxy*);

  void preProxyRemoved(pqProxy*);
  void proxyRemoved(pqProxy*);

  void preSourceAdded(pqPipelineSource* source);
  void sourceAdded(pqPipelineSource* source);

  void preSourceRemoved(pqPipelineSource*);
  void sourceRemoved(pqPipelineSource*);

  void preViewAdded(pqView* view);
  void viewAdded(pqView* view);

  void preViewRemoved(pqView*);
  void viewRemoved(pqView*);

  void preRepresentationAdded(pqRepresentation* rep);
  void representationAdded(pqRepresentation* rep);

  void preRepresentationRemoved(pqRepresentation*);
  void representationRemoved(pqRepresentation*);


  void preExtractorAdded(pqExtractor*);
  void extractorAdded(pqExtractor*);
  void preExtractorRemoved(pqExtractor*);
  void extractorRemoved(pqExtractor*);

  void nameChanged(pqServerManagerModelItem* item);

  void modifiedStateChanged(pqServerManagerModelItem* item);

  void connectionAdded(pqPipelineSource* source, pqPipelineSource* consumer, int srcOutputPort);
  void preConnectionAdded(pqPipelineSource* source, pqPipelineSource* consumer, int srcOutputPort);

  void connectionRemoved(pqPipelineSource* source, pqPipelineSource* consumer, int srcOutputPort);
  void preConnectionRemoved(
    pqPipelineSource* source, pqPipelineSource* consumer, int srcOutputPort);


  void connectionAdded(pqServerManagerModelItem* source, pqExtractor* consumer);
  void connectionRemoved(pqServerManagerModelItem* source, pqExtractor* consumer);

  void dataUpdated(pqPipelineSource*);

protected Q_SLOTS:
  virtual void onProxyRegistered(const QString& group, const QString& name, vtkSMProxy* proxy);

  virtual void onProxyUnRegistered(const QString& group, const QString& name, vtkSMProxy* proxy);

  virtual void onConnectionCreated(vtkIdType id);

  virtual void onConnectionClosed(vtkIdType id);

  virtual void onStateLoaded(vtkPVXMLElement*, vtkSMProxyLocator*);

private:
  Q_DISABLE_COPY(pqServerManagerModel)

  
  void updateSettingsFromQSettings(pqServer* server);

  class pqInternal;
  pqInternal* Internal;
};

//-----------------------------------------------------------------------------
template <class T>
inline QList<T> pqFindItems(const pqServerManagerModel* model)
{
  QList<T> list;
  pqServerManagerModel::findItemsHelper(
    model, ((T)0)->staticMetaObject, reinterpret_cast<QList<void*>*>(&list), nullptr);
  return list;
}

//-----------------------------------------------------------------------------
template <class T>
inline QList<T> pqFindItems(const pqServerManagerModel* model, pqServer* server)
{
  QList<T> list;
  pqServerManagerModel::findItemsHelper(
    model, ((T)0)->staticMetaObject, reinterpret_cast<QList<void*>*>(&list), server);
  return list;
}

//-----------------------------------------------------------------------------
template <class T>
inline T pqFindItem(const pqServerManagerModel* model, vtkSMProxy* proxy)
{
  return qobject_cast<T>(
    pqServerManagerModel::findItemHelper(model, ((T)0)->staticMetaObject, proxy));
}

//-----------------------------------------------------------------------------
template <class T>
inline T pqFindItem(const pqServerManagerModel* model, vtkTypeUInt32 id)
{
  return qobject_cast<T>(pqServerManagerModel::findItemHelper(model, ((T)0)->staticMetaObject, id));
}

//-----------------------------------------------------------------------------
template <class T>
inline T pqFindItem(const pqServerManagerModel* model, const QString& name)
{
  return qobject_cast<T>(
    pqServerManagerModel::findItemHelper(model, ((T)0)->staticMetaObject, name));
}

//-----------------------------------------------------------------------------
template <class T>
inline int pqGetNumberOfItems(const pqServerManagerModel* model)
{
  return pqFindItems<T>(model).size();
}

//-----------------------------------------------------------------------------
template <class T>
inline T pqGetItemAtIndex(const pqServerManagerModel* model, int index)
{
  QList<T> items = pqFindItems<T>(model);
  if (index < items.size())
  {
    return items[index];
  }

  return 0;
}

#endif