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