vtkSMSessionProxyManager.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMSessionProxyManager_h
#define vtkSMSessionProxyManager_h
 
#include "vtkRemotingServerManagerModule.h" // needed for exports
#include "vtkSMMessageMinimal.h"            // needed for vtkSMMessage.
#include "vtkSMSessionObject.h"
#include "vtkSmartPointer.h" // needed for vtkSmartPointer
 
#include <set>    // needed for std::set
#include <string> // needed for std::string
 
class vtkCollection;
class vtkEventForwarderCommand;
class vtkPVXMLElement;
class vtkSMCompoundSourceProxy;
class vtkSMDocumentation;
class vtkSMLink;
class vtkSMProperty;
class vtkSMProxy;
class vtkSMProxyDefinitionManager;
class vtkSMProxyIterator;
class vtkSMProxyLocator;
class vtkSMProxyManagerObserver;
class vtkSMProxyManagerProxySet;
class vtkSMSession;
class vtkSMStateLoader;
class vtkStringList;
class vtkSMPipelineState;
class vtkSMStateLocator;
class vtkSMProxySelectionModel;
 
struct vtkSMSessionProxyManagerInternals;
struct vtkClientServerID;
 
class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMSessionProxyManager : public vtkSMSessionObject
{
public:
 
  static vtkSMSessionProxyManager* New(vtkSMSession* session);
  vtkTypeMacro(vtkSMSessionProxyManager, vtkSMSessionObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkTypeUInt32 GetReservedGlobalID();
 
  vtkSMProxy* NewProxy(
    const char* groupName, const char* proxyName, const char* subProxyName = nullptr);
 
  vtkSMDocumentation* GetProxyDocumentation(const char* groupName, const char* proxyName);
 
  vtkSMDocumentation* GetPropertyDocumentation(
    const char* groupName, const char* proxyName, const char* propertyName);
 
  void RegisterProxy(const char* groupname, const char* name, vtkSMProxy* proxy);
 
  std::string RegisterProxy(const char* groupname, vtkSMProxy* proxy);
 
 
  vtkSMProxy* GetProxy(const char* groupname, const char* name);
  vtkSMProxy* GetProxy(const char* name);
 
  void GetProxies(const char* groupname, const char* name, vtkCollection* collection);
  void GetProxies(const char* groupname, vtkCollection* collection)
  {
    this->GetProxies(groupname, nullptr, collection);
  }
 
  vtkSMProxy* GetPrototypeProxy(const char* groupname, const char* name);
 
  unsigned int GetNumberOfProxies(const char* groupname);
 
  const char* GetProxyName(const char* groupname, unsigned int idx);
 
  const char* GetProxyName(const char* groupname, vtkSMProxy* proxy);
 
  void GetProxyNames(const char* groupname, vtkSMProxy* proxy, vtkStringList* names);
 
  std::string GetUniqueProxyName(
    const char* groupname, const char* prefix, bool alwaysAppend = true);
 
  const char* IsProxyInGroup(vtkSMProxy* proxy, const char* groupname);
 
 
  void UnRegisterProxy(const char* groupname, const char* name, vtkSMProxy*);
  void UnRegisterProxy(const char* name);
 
  void UnRegisterProxy(vtkSMProxy* proxy);
 
  void UnRegisterProxies();
 
 
  void UpdateRegisteredProxies(const char* groupname, int modified_only = 1);
  void UpdateRegisteredProxies(int modified_only = 1);
 
 
  void UpdateRegisteredProxiesInOrder(int modified_only = 1);
  void UpdateProxyInOrder(vtkSMProxy* proxy);
 
  int GetNumberOfLinks();
 
  const char* GetLinkName(int index);
 
  void RegisterLink(const char* linkname, vtkSMLink* link);
 
  void UnRegisterLink(const char* linkname);
 
  vtkSMLink* GetRegisteredLink(const char* linkname);
 
  const char* GetRegisteredLinkName(vtkSMLink* link);
 
  void UnRegisterAllLinks();
 
  void RegisterCustomProxyDefinition(const char* group, const char* name, vtkPVXMLElement* top);
 
  void UnRegisterCustomProxyDefinition(const char* group, const char* name);
 
  void UnRegisterCustomProxyDefinitions();
 
  vtkPVXMLElement* GetProxyDefinition(const char* group, const char* name);
 
 
  void LoadCustomProxyDefinitions(const char* filename);
  void LoadCustomProxyDefinitions(vtkPVXMLElement* root);
 
  void SaveCustomProxyDefinitions(vtkPVXMLElement* root);
 
 
  void LoadXMLState(const char* filename, vtkSMStateLoader* loader = nullptr,
    vtkTypeUInt32 location = 0x10 /*vtkPVSession::CLIENT*/);
  void LoadXMLState(
    vtkPVXMLElement* rootElement, vtkSMStateLoader* loader = nullptr, bool keepOriginalIds = false);
 
  vtkGetMacro(InLoadXMLState, bool);
 
  bool SaveString(const char* string, const char* filename, vtkTypeUInt32 location);
 
  std::string LoadString(const char* filename, vtkTypeUInt32 location);
 
  bool SaveXMLState(const char* filename, vtkTypeUInt32 location = 0x10 /*vtkPVSession::CLIENT*/);
 
  vtkPVXMLElement* SaveXMLState();
 
 
  vtkSmartPointer<vtkPVXMLElement> GetXMLState() { return this->GetXMLState({}); }
  vtkSmartPointer<vtkPVXMLElement> GetXMLState(
    const std::set<vtkSMProxy*>& restrictionSet, bool forceRestriction = false);
 
  void SaveRegisteredLinks(vtkPVXMLElement* root);
 
  void InstantiateGroupPrototypes(const char* groupName);
 
  void InstantiatePrototypes();
 
  void ClearPrototypes();
 
  bool HasDefinition(const char* groupName, const char* proxyName);
 
  int AreProxiesModified();
 
 
  vtkPVXMLElement* GetProxyHints(const char* xmlgroup, const char* xmlname);
  vtkPVXMLElement* GetPropertyHints(
    const char* groupName, const char* proxyName, const char* propertyName);
 
 
  vtkGetMacro(UpdateInputProxies, int);
 
  bool LoadConfigurationXML(const char* xmlcontents);
 
 
  vtkGetObjectMacro(ProxyDefinitionManager, vtkSMProxyDefinitionManager);
 
  vtkSMProxySelectionModel* GetSelectionModel(const char* name);
 
  vtkIdType GetNumberOfSelectionModel();
 
  vtkSMProxySelectionModel* GetSelectionModelAt(int idx);
 
 
  void RegisterSelectionModel(const char* name, vtkSMProxySelectionModel*);
  void UnRegisterSelectionModel(const char* name);
 
  void UpdateFromRemote();
 
 
  bool IsStateUpdateNotificationEnabled();
  void DisableStateUpdateNotification();
  void EnableStateUpdateNotification();
  void TriggerStateUpdate();
 
  virtual const vtkSMMessage* GetFullState();
 
  virtual void LoadState(const vtkSMMessage* msg, vtkSMProxyLocator* locator);
 
  vtkSMProxy* FindProxy(const char* reggroup, const char* xmlgroup, const char* xmltype);
 
protected:
  vtkSMSessionProxyManager(vtkSMSession*);
  ~vtkSMSessionProxyManager() override;
 
  friend class vtkSMProxy;
  friend class vtkPVProxyDefinitionIterator;
  friend class vtkSMProxyIterator;
  friend class vtkSMProxyManagerObserver;
 
  vtkSMProxy* NewProxy(vtkPVXMLElement* element, const char* groupname, const char* proxyname,
    const char* subProxyName = nullptr);
 
  vtkPVXMLElement* GetProxyElement(
    const char* groupName, const char* proxyName, const char* subProxyName = nullptr);
 
  virtual void ExecuteEvent(vtkObject* obj, unsigned long event, void* data);
 
  void RemovePrototype(const char* groupname, const char* proxyname);
 
 
  void MarkProxyAsModified(vtkSMProxy*);
  void UnMarkProxyAsModified(vtkSMProxy*);
 
  void CollectReferredProxies(vtkSMProxyManagerProxySet& setOfProxies, vtkSMProxy* proxy);
 
  int UpdateInputProxies;
  vtkSMProxyDefinitionManager* ProxyDefinitionManager;
  vtkEventForwarderCommand* Forwarder;
  vtkSMPipelineState* PipelineState;
  bool StateUpdateNotification;
 
private:
  vtkSMSessionProxyManagerInternals* Internals;
  vtkSMProxyManagerObserver* Observer;
  bool InLoadXMLState;
 
#ifndef __WRAP__
  static vtkSMSessionProxyManager* New() { return nullptr; }
#endif
 
  vtkSMSessionProxyManager(const vtkSMSessionProxyManager&) = delete;
  void operator=(const vtkSMSessionProxyManager&) = delete;
};
 
#endif
 
// VTK-HeaderTest-Exclude: vtkSMSessionProxyManager.h