vtkSMProperty.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ParaView
  Module:    vtkSMProperty.h

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#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() {}

  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();

  void CreateAndSetPrettyLabel(const char* name);

  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, vtkStdString, 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