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