vtkSMProxy.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMProxy_h
#define vtkSMProxy_h
 
#include "vtkClientServerID.h"              // needed for vtkClientServerID
#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkSMRemoteObject.h"
 
struct vtkSMProxyInternals;
 
class vtkClientServerStream;
class vtkPVInformation;
class vtkSMLoadStateContext;
class vtkPVXMLElement;
class vtkSMDocumentation;
class vtkSMProperty;
class vtkSMPropertyGroup;
class vtkSMPropertyIterator;
class vtkSMProxyLocator;
class vtkSMProxyManager;
class vtkSMSessionProxyManager;
class vtkSMProxyObserver;
 
class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMProxy : public vtkSMRemoteObject
{
public:
  static vtkSMProxy* New();
  vtkTypeMacro(vtkSMProxy, vtkSMRemoteObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  // Description:
  // Set or override a key/value pair as annotation to that proxy.
  // If the value is nullptr, this method is equivalent to RemoveAnnotation(key)
  void SetAnnotation(const char* key, const char* value);
 
  const char* GetAnnotation(const char* key);
 
  void RemoveAnnotation(const char* key);
 
  void RemoveAllAnnotations();
 
  bool HasAnnotation(const char* key);
 
  int GetNumberOfAnnotations();
 
  const char* GetAnnotationKeyAt(int index);
 
  void SetLocation(vtkTypeUInt32) override;
 
  virtual vtkSMProperty* GetProperty(const char* name)
  {
    return this->GetProperty(name, /*self-only*/ 0);
  }
 
  virtual vtkSMProperty* GetProperty(const char* name, int selfOnly);
 
  const char* GetPropertyName(vtkSMProperty* prop);
 
  virtual void UpdateVTKObjects();
 
  virtual void RecreateVTKObjects();
 
 
  bool UpdateProperty(const char* name) { return this->UpdateProperty(name, 0); }
  bool UpdateProperty(const char* name, int force);
 
  void InvokeCommand(const char* name) { this->UpdateProperty(name, 1); }
 
 
  vtkGetStringMacro(VTKClassName);
 
 
  vtkSetStringMacro(VTKClassName);
 
  virtual vtkSMPropertyIterator* NewPropertyIterator();
 
  unsigned int GetNumberOfConsumers();
 
  vtkSMProxy* GetConsumerProxy(unsigned int idx);
 
  vtkSMProperty* GetConsumerProperty(unsigned int idx);
 
  unsigned int GetNumberOfProducers();
 
  vtkSMProxy* GetProducerProxy(unsigned int idx);
 
  vtkSMProperty* GetProducerProperty(unsigned int idx);
 
 
  vtkGetStringMacro(XMLName);
 
 
  vtkGetStringMacro(XMLGroup);
 
 
  vtkGetStringMacro(XMLLabel);
 
  virtual void UpdatePropertyInformation();
 
  virtual void UpdatePropertyInformation(vtkSMProperty* prop);
 
  virtual void MarkAllPropertiesAsModified();
 
  virtual void ResetPropertiesToXMLDefaults();
 
  virtual void ResetPropertiesToDomainDefaults();
 
  enum ResetPropertiesMode
  {
    DEFAULT = 0,
    ONLY_XML = 1,
    ONLY_DOMAIN = 2
  };
 
  virtual void ResetPropertiesToDefault(ResetPropertiesMode mode = DEFAULT);
 
  enum
  {
    COPY_PROXY_PROPERTY_VALUES_BY_REFERENCE = 0,
 
    COPY_PROXY_PROPERTY_VALUES_BY_CLONING // < No longer supported!!!
  };
 
 
  void Copy(vtkSMProxy* src);
  void Copy(vtkSMProxy* src, const char* exceptionClass);
  virtual void Copy(vtkSMProxy* src, const char* exceptionClass, int proxyPropertyCopyFlag);
 
  virtual void MarkModified(vtkSMProxy* modifiedProxy);
 
 
  vtkGetObjectMacro(Documentation, vtkSMDocumentation);
 
 
  vtkGetObjectMacro(Hints, vtkPVXMLElement);
 
 
  vtkGetMacro(ObjectsCreated, int);
 
  void InitializeAndCopyFromProxy(vtkSMProxy* source);
 
  virtual void MarkDirty(vtkSMProxy* modifiedProxy);
 
  vtkObjectBase* GetClientSideObject();
 
 
  bool GatherInformation(vtkPVInformation* information);
  bool GatherInformation(vtkPVInformation* information, vtkTypeUInt32 location);
 
  virtual vtkPVXMLElement* SaveXMLState(vtkPVXMLElement* root);
  virtual vtkPVXMLElement* SaveXMLState(vtkPVXMLElement* root, vtkSMPropertyIterator* iter);
 
  virtual int LoadXMLState(vtkPVXMLElement* element, vtkSMProxyLocator* locator);
 
 
  void PrototypeOn() override;
  void PrototypeOff() override;
  void SetPrototype(bool undo) override;
 
  void UpdateSelfAndAllInputs();
 
  bool GetIsSubProxy();
 
  vtkSMProxy* GetParentProxy();
 
  vtkSMProxy* GetTrueParentProxy();
 
  void EnableLocalPushOnly() override;
 
  void DisableLocalPushOnly() override;
 
  const vtkSMMessage* GetFullState() override;
 
  void LoadState(const vtkSMMessage* msg, vtkSMProxyLocator* locator) override;
 
  vtkSMPropertyGroup* GetPropertyGroup(size_t index) const;
 
  size_t GetNumberOfPropertyGroups() const;
 
 
  void SetLogName(const char* name);
  vtkGetStringMacro(LogName);
 
  const char* GetLogNameOrDefault();
 
  bool GetPropertiesModified() { return this->PropertiesModified; }
 
protected:
  vtkSMProxy();
  ~vtkSMProxy() override;
 
  void ExecuteStream(
    const vtkClientServerStream& msg, bool ignore_errors = false, vtkTypeUInt32 location = 0);
 
  // Any method changing the annotations will trigger this method that will
  // update the local full state as well as sending the annotation state part
  // to the session.
  virtual void UpdateAndPushAnnotationState();
 
 
  virtual const vtkClientServerStream& GetLastResult();
  virtual const vtkClientServerStream& GetLastResult(vtkTypeUInt32 location);
 
  virtual void AddProperty(const char* name, vtkSMProperty* prop);
 
  virtual void MarkConsumersAsDirty(vtkSMProxy* modifiedProxy);
 
  virtual void MarkDirtyFromProducer(
    vtkSMProxy* modifiedProxy, vtkSMProxy* producer, vtkSMProperty* property);
 
  void MarkInputsAsDirty();
 
 
  friend class vtkSMCameraLink;
  friend class vtkSMCompoundProxy;
  friend class vtkSMCompoundSourceProxy;
  friend class vtkSMDeserializerProtobuf;
  friend class vtkSMInputProperty;
  friend class vtkSMMultiServerSourceProxy;
  friend class vtkSMNamedPropertyIterator;
  friend class vtkSMOrderedPropertyIterator;
  friend class vtkSMPreselectionPipeline;
  friend class vtkSMProperty;
  friend class vtkSMPropertyIterator;
  friend class vtkSMProxyObserver;
  friend class vtkSMProxyProperty;
  friend class vtkSMProxyRegisterUndoElement;
  friend class vtkSMProxyUnRegisterUndoElement;
  friend class vtkSMSessionProxyManager;
  friend class vtkSMSourceProxy;
  friend class vtkSMStateLoader;
  friend class vtkSMStateLocator;
  friend class vtkSMUndoRedoStateLoader;
  friend class vtkSMViewProxy;
 
 
  vtkSetStringMacro(XMLName);
 
 
  vtkSetStringMacro(XMLGroup);
 
 
  vtkSetStringMacro(XMLLabel);
 
 
  vtkSetStringMacro(XMLSubProxyName);
 
  virtual void CreateVTKObjects();
 
  void RemoveAllObservers();
 
  virtual void SetPropertyModifiedFlag(const char* name, int flag);
 
  void AddSubProxy(const char* name, vtkSMProxy* proxy, int overrideOK = 0);
 
  void RemoveSubProxy(const char* name);
 
  vtkSMProxy* GetSubProxy(const char* name);
 
  vtkSMProxy* GetSubProxy(unsigned int index);
 
  const char* GetSubProxyName(unsigned int index);
 
  const char* GetSubProxyName(vtkSMProxy*);
 
  unsigned int GetNumberOfSubProxies();
 
  virtual void AddConsumer(vtkSMProperty* property, vtkSMProxy* proxy);
 
  virtual void RemoveConsumer(vtkSMProperty* property, vtkSMProxy* proxy);
 
  virtual void RemoveAllConsumers();
 
  void AddProducer(vtkSMProperty* property, vtkSMProxy* proxy);
 
  void RemoveProducer(vtkSMProperty* property, vtkSMProxy* proxy);
 
  virtual void PostUpdateData(bool using_cache);
 
  void PostUpdateDataSelfOnly(bool using_cache);
 
  bool WarnIfDeprecated();
 
  virtual void UpdatePipelineInformation();
 
  // When an algorithm proxy is marked modified, NeedsUpdate is
  // set to true. In PostUpdateData(), NeedsUpdate is set to false.
  // This is used to keep track of data information validity.
  bool NeedsUpdate;
 
 
  vtkSMProperty* NewProperty(const char* name);
  vtkSMProperty* NewProperty(const char* name, vtkPVXMLElement* propElement);
 
  void LinkProperty(vtkSMProperty* inputProperty, vtkSMProperty* outputProperty);
 
  vtkSMPropertyGroup* NewPropertyGroup(vtkPVXMLElement* propElement);
 
  void AppendPropertyGroup(vtkSMPropertyGroup* group);
 
 
  virtual int ReadXMLAttributes(vtkSMSessionProxyManager* pm, vtkPVXMLElement* element);
  void SetupExposedProperties(const char* subproxy_name, vtkPVXMLElement* element);
  void SetupSharedProperties(vtkSMProxy* subproxy, vtkPVXMLElement* element);
 
  void ExposeSubProxyProperty(const char* subproxy_name, const char* property_name,
    const char* exposed_name, int overrideOK = 0);
 
  virtual void ExecuteSubProxyEvent(vtkSMProxy* o, unsigned long event, void* data);
 
  virtual int CreateSubProxiesAndProperties(vtkSMSessionProxyManager* pm, vtkPVXMLElement* element);
 
  virtual void UpdatePropertyInformationInternal(vtkSMProperty* prop = nullptr);
 
  void RebuildStateForProperties();
 
  virtual void SetLogNameInternal(
    const char* name, bool propagate_to_subproxies, bool propagate_to_proxylistdomains);
 
 
  vtkSetStringMacro(SIClassName);
  vtkGetStringMacro(SIClassName);
  char* SIClassName;
 
  char* VTKClassName;
  char* XMLGroup;
  char* XMLName;
  char* XMLLabel;
  char* XMLSubProxyName;
  int ObjectsCreated;
  int DoNotUpdateImmediately;
  int DoNotModifyProperty;
 
  int InUpdateVTKObjects;
 
  bool PropertiesModified;
 
  bool ArePropertiesModified();
 
  void SetHints(vtkPVXMLElement* hints);
  void SetDeprecated(vtkPVXMLElement* deprecated);
 
  void SetXMLElement(vtkPVXMLElement* element);
  vtkPVXMLElement* XMLElement;
 
  vtkSMDocumentation* Documentation;
  vtkPVXMLElement* Hints;
  vtkPVXMLElement* Deprecated;
 
  // Cached version of State
  vtkSMMessage* State;
 
  // Flag used to break consumer loops.
  int InMarkModified;
 
  vtkWeakPointer<vtkSMProxy> ParentProxy;
 
  vtkSMProxyInternals* Internals;
  vtkSMProxyObserver* SubProxyObserver;
  vtkSMProxy(const vtkSMProxy&) = delete;
  void operator=(const vtkSMProxy&) = delete;
 
private:
  vtkSMProperty* SetupExposedProperty(vtkPVXMLElement* propertyElement, const char* subproxy_name);
 
  friend class vtkSMProxyInfo;
 
  char* LogName;
  std::string DefaultLogName;
};
 
class VTKREMOTINGSERVERMANAGER_EXPORT SIPROXY : public SIOBJECT
{
public:
  SIPROXY(vtkSMProxy* proxy)
    : SIOBJECT(proxy)
  {
  }
};
 
class VTKREMOTINGSERVERMANAGER_EXPORT VTKOBJECT
{
  vtkSMProxy* Reference;
  friend VTKREMOTINGSERVERMANAGER_EXPORT vtkClientServerStream& operator<<(
    vtkClientServerStream& stream, const VTKOBJECT& manipulator);
 
public:
  VTKOBJECT(vtkSMProxy* proxy)
    : Reference(proxy)
  {
  }
};
VTKREMOTINGSERVERMANAGER_EXPORT vtkClientServerStream& operator<<(
  vtkClientServerStream& stream, const VTKOBJECT& manipulator);
 
#endif