vtkSMProperty.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMProperty_h
#define vtkSMProperty_h
 
#include "vtkParaViewDeprecation.h"         // for deprecation
#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkSMDomainIterator.h"            // needed for vtkSMDomainIterator
#include "vtkSMMessageMinimal.h"            // needed for vtkSMMessage
#include "vtkSMObject.h"
#include "vtkSmartPointer.h" // needed for vtkSmartPointer
#include "vtkWeakPointer.h"  // needed for vtkWeakPointer
 
class vtkClientServerStream;
class vtkPVXMLElement;
class vtkSMDocumentation;
class vtkSMDomain;
class vtkSMDomainIterator;
class vtkSMInformationHelper;
class vtkSMPropertyLink;
class vtkSMProxy;
class vtkSMProxyLocator;
 
struct vtkSMPropertyInternals;
 
class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMProperty : public vtkSMObject
{
public:
  static vtkSMProperty* New();
  vtkTypeMacro(vtkSMProperty, vtkSMObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetStringMacro(Command);
  vtkGetStringMacro(Command);
 
 
  vtkSetMacro(ImmediateUpdate, int);
  vtkGetMacro(ImmediateUpdate, int);
 
  int IsInDomains();
 
  int IsInDomains(vtkSMDomain** domain);
 
  void UnRegister(vtkObjectBase* obj) override;
 
  vtkSMDomainIterator* NewDomainIterator();
 
  vtkSMDomain* GetDomain(const char* name);
 
  vtkSMDomain* FindDomain(const char* classname);
 
  template <class DomainType>
  inline DomainType* FindDomain();
 
  unsigned int GetNumberOfDomains();
 
 
  vtkGetMacro(InformationOnly, int);
 
 
  vtkGetMacro(IgnoreSynchronization, int);
 
 
  vtkGetObjectMacro(InformationProperty, vtkSMProperty);
 
  void AddDomain(const char* name, vtkSMDomain* dom);
 
  virtual void AddLinkedProperty(vtkSMProperty* targetProperty);
 
  virtual void RemoveLinkedProperty(vtkSMProperty* targetProperty);
 
  virtual void RemoveFromSourceLink();
 
 
  vtkSetMacro(Animateable, int);
  vtkGetMacro(Animateable, int);
 
 
  vtkSetMacro(IsInternal, int);
  vtkGetMacro(IsInternal, int);
 
 
  vtkSetMacro(NoCustomDefault, int);
 
 
  vtkGetMacro(NoCustomDefault, int);
 
 
  vtkSetStringMacro(PanelVisibility);
 
 
  vtkGetStringMacro(PanelVisibility);
 
 
  vtkSetStringMacro(PanelVisibilityDefaultForRepresentation);
 
 
  vtkGetStringMacro(PanelVisibilityDefaultForRepresentation);
 
 
  vtkSetStringMacro(PanelWidget);
 
 
  vtkGetStringMacro(PanelWidget);
 
 
  vtkSetStringMacro(DisableSubTrace);
 
 
  vtkGetStringMacro(DisableSubTrace);
 
  virtual void Copy(vtkSMProperty* src);
 
 
  vtkGetObjectMacro(Documentation, vtkSMDocumentation);
 
  void ResetToDefault();
 
  virtual void ResetToXMLDefaults() {}
 
  virtual bool ResetToDomainDefaults(bool use_unchecked_values = false);
 
 
  vtkGetStringMacro(XMLLabel);
 
 
  vtkGetStringMacro(XMLName);
 
 
  vtkGetMacro(Repeatable, int);
 
 
  vtkGetObjectMacro(Hints, vtkPVXMLElement);
  void SetHints(vtkPVXMLElement* hints);
 
 
  void Modified() override
  {
    if (this->BlockModifiedEvents)
    {
      this->PendingModifiedEvents = true;
    }
    else
    {
      this->Superclass::Modified();
      this->PendingModifiedEvents = false;
    }
  }
 
  vtkSMProxy* GetParent();
 
  // Flag used to ignore property when building Proxy state for Undo/Redo state.
  // The default value is false.
  virtual bool IsStateIgnored() { return this->StateIgnored; }
 
  virtual bool IsValueDefault() { return false; }
 
  bool HasDomainsWithRequiredProperties();
 
  virtual void ClearUncheckedElements() {}
 
  PARAVIEW_DEPRECATED_IN_5_12_0(
    "Use vtkSMObject::CreatePrettyLabel(const std::string& name) instead.")
  static const char* CreateNewPrettyLabel(const char* name);
 
protected:
  vtkSMProperty();
  ~vtkSMProperty() override;
 
  friend class vtkSMSessionProxyManager;
  friend class vtkSMProxy;
  friend class vtkSMSubPropertyIterator;
  friend class vtkSMDomainIterator;
  friend class vtkSMSourceProxy;
  friend class vtkSMDomain;
  friend class vtkSMPropertyModificationUndoElement;
 
  virtual void WriteTo(vtkSMMessage* msg);
 
  virtual void ReadFrom(const vtkSMMessage*, int vtkNotUsed(message_offset), vtkSMProxyLocator*){};
 
  virtual int ReadXMLAttributes(vtkSMProxy* parent, vtkPVXMLElement* element);
 
  virtual void UpdateAllInputs(){};
 
 
  vtkSetStringMacro(XMLName);
 
  vtkSMProperty* NewProperty(const char* name);
 
  void AddDependent(vtkSMDomain* dom);
 
  void RemoveAllDependents();
 
  void UpdateDomains();
 
  virtual void SaveState(
    vtkPVXMLElement* parent, const char* property_name, const char* uid, int saveDomains = 1);
  virtual void SaveStateValues(vtkPVXMLElement* propertyElement);
 
  virtual void SaveDomainState(vtkPVXMLElement* propertyElement, const char* uid);
 
  virtual int LoadState(vtkPVXMLElement* element, vtkSMProxyLocator* loader);
 
  vtkPVXMLElement* Hints;
 
  char* Command;
 
  vtkSMPropertyInternals* PInternals;
 
  int ImmediateUpdate;
  int Animateable;
  int IsInternal;
  int NoCustomDefault;
 
  char* XMLName;
  char* XMLLabel;
  vtkSetStringMacro(XMLLabel);
 
  char* PanelVisibility;
  char* PanelVisibilityDefaultForRepresentation;
  char* PanelWidget;
  char* DisableSubTrace;
 
  vtkSMDomainIterator* DomainIterator;
 
  vtkSetMacro(InformationOnly, int);
  int InformationOnly;
 
  vtkSetMacro(IgnoreSynchronization, int);
  int IgnoreSynchronization;
 
  vtkSMInformationHelper* InformationHelper;
 
  void SetInformationProperty(vtkSMProperty* ip);
  vtkSMProperty* InformationProperty;
 
  vtkSMDocumentation* Documentation;
  void SetDocumentation(vtkSMDocumentation*);
 
  int Repeatable;
 
 
  bool SetBlockModifiedEvents(bool block)
  {
    bool prev = this->BlockModifiedEvents;
    this->BlockModifiedEvents = block;
    return prev;
  }
 
 
  vtkGetMacro(PendingModifiedEvents, bool);
 
  // Proxy is not reference-counted to avoid reference loops.
  void SetParent(vtkSMProxy* proxy);
 
  vtkWeakPointer<vtkSMProxy> Proxy;
 
  // Flag used to ignore property when building Proxy state for Undo/Redo state.
  // The default value is false.
  bool StateIgnored;
  vtkSetMacro(StateIgnored, bool);
  vtkBooleanMacro(StateIgnored, bool);
 
  // Links for properties that "subscribe" to changes to this property.
  vtkSMPropertyLink* Links;
 
private:
  vtkSMProperty(const vtkSMProperty&) = delete;
  void operator=(const vtkSMProperty&) = delete;
 
  // Callback to fire vtkCommand::DomainModifiedEvent every time any of the
  // domains change.
  void InvokeDomainModifiedEvent();
 
  bool PendingModifiedEvents;
  bool BlockModifiedEvents;
};
 
#define vtkSMPropertyTemplateMacroCase(typeSMProperty, type, prop, call)                           \
  if (typeSMProperty* SM_PROPERTY = typeSMProperty::SafeDownCast(prop))                            \
  {                                                                                                \
    (void)SM_PROPERTY;                                                                             \
    typedef type SM_TT;                                                                            \
    call;                                                                                          \
  }
/* clang-format off */
#define vtkSMVectorPropertyTemplateMacro(prop, call)                                               \
  vtkSMPropertyTemplateMacroCase(vtkSMDoubleVectorProperty, double, prop, call)                    \
  vtkSMPropertyTemplateMacroCase(vtkSMIntVectorProperty, int, prop, call)                          \
  vtkSMPropertyTemplateMacroCase(vtkSMIdTypeVectorProperty, vtkIdType, prop, call)                 \
  vtkSMPropertyTemplateMacroCase(vtkSMStringVectorProperty, std::string, prop, call)
/* clang-format on */
 
template <class DomainType>
DomainType* vtkSMProperty::FindDomain()
{
  auto iter = vtkSmartPointer<vtkSMDomainIterator>::Take(this->NewDomainIterator());
  for (iter->Begin(); !iter->IsAtEnd(); iter->Next())
  {
    if (DomainType* domain = DomainType::SafeDownCast(iter->GetDomain()))
    {
      return domain;
    }
  }
  return nullptr;
}
#endif