vtkSMProxyManager.h

Go to the documentation of this file.

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

#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkSMObject.h"
#include "vtkSmartPointer.h" // Needed for the singleton

#include <string> // needed for std::string

class vtkPVXMLElement;
class vtkSMPluginManager;
class vtkSMProxy;
class vtkSMProxyLocator;
class vtkSMProxySelectionModel;
class vtkSMReaderFactory;
class vtkSMSession;
class vtkSMSessionProxyManager;
class vtkSMStateLoader;
class vtkSMUndoStackBuilder;
class vtkSMWriterFactory;

class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMProxyManager : public vtkSMObject
{
public:
  vtkTypeMacro(vtkSMProxyManager, vtkSMObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkSMProxyManager* GetProxyManager();

  static void Finalize();

  static bool IsInitialized();

  static int GetVersionMajor();

  static int GetVersionMinor();

  static int GetVersionPatch();

  static const char* GetParaViewSourceVersion();

  vtkSMSession* GetActiveSession();


  void SetActiveSession(vtkSMSession* session);
  void SetActiveSession(vtkIdType sessionId);

  vtkSMSessionProxyManager* GetActiveSessionProxyManager();

  vtkSMSessionProxyManager* GetSessionProxyManager(vtkSMSession* session);


  vtkSMProxy* NewProxy(
    const char* groupName, const char* proxyName, const char* subProxyName = nullptr);
  void RegisterProxy(const char* groupname, const char* name, vtkSMProxy* proxy);
  vtkSMProxy* GetProxy(const char* groupname, const char* name);
  void UnRegisterProxy(const char* groupname, const char* name, vtkSMProxy*);
  const char* GetProxyName(const char* groupname, unsigned int idx);
  const char* GetProxyName(const char* groupname, vtkSMProxy* proxy);

  vtkSetMacro(BlockProxyDefinitionUpdates, bool);
  vtkGetMacro(BlockProxyDefinitionUpdates, bool);
  vtkBooleanMacro(BlockProxyDefinitionUpdates, bool);
  void UpdateProxyDefinitions();


  void SetUndoStackBuilder(vtkSMUndoStackBuilder* builder);
  vtkGetObjectMacro(UndoStackBuilder, vtkSMUndoStackBuilder);


  vtkGetObjectMacro(PluginManager, vtkSMPluginManager);


  vtkGetObjectMacro(ReaderFactory, vtkSMReaderFactory);


  vtkGetObjectMacro(WriterFactory, vtkSMWriterFactory);

  enum eventId
  {
    ActiveSessionChanged = 9753
  };

  struct RegisteredProxyInformation
  {
    vtkSMProxy* Proxy;
    const char* GroupName;
    const char* ProxyName;
    // Set when the register/unregister event if fired for registration of
    // a compound proxy definition.
    unsigned int Type;

    enum
    {
      PROXY = 0x1,
      COMPOUND_PROXY_DEFINITION = 0x2,
      LINK = 0x3,
    };
  };

  struct ModifiedPropertyInformation
  {
    vtkSMProxy* Proxy;
    const char* PropertyName;
  };

  struct LoadStateInformation
  {
    vtkPVXMLElement* RootElement;
    vtkSMProxyLocator* ProxyLocator;
  };

  struct StateChangedInformation
  {
    vtkSMProxy* Proxy;
    vtkPVXMLElement* StateChangeElement;
  };

  std::string GetUniqueProxyName(
    const char* groupname, const char* prefix, bool alwaysAppend = true);

protected:
  vtkSMProxyManager();
  ~vtkSMProxyManager() override;
#ifndef __WRAP__
  static vtkSMProxyManager* New();
#endif

  friend class vtkSMSessionProxyManager;

  void ConnectionsUpdated(vtkObject*, unsigned long, void*);

  vtkSMUndoStackBuilder* UndoStackBuilder;
  vtkSMPluginManager* PluginManager;
  vtkSMReaderFactory* ReaderFactory;
  vtkSMWriterFactory* WriterFactory;

  bool BlockProxyDefinitionUpdates;

private:
  class vtkPXMInternal;
  vtkPXMInternal* PXMStorage;

  static vtkSmartPointer<vtkSMProxyManager> Singleton;

  vtkSMProxyManager(const vtkSMProxyManager&) = delete;
  void operator=(const vtkSMProxyManager&) = delete;
};

#endif