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