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 "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() {}

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