vtkSMRangeDomainTemplate.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMRangeDomainTemplate_h
#define vtkSMRangeDomainTemplate_h
 
#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkSMDomain.h"
#include "vtkTuple.h" // needed for vtkTuple.
#include <vector>     // needed for std::vector
 
template <class T>
class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMRangeDomainTemplate : public vtkSMDomain
{
public:
  vtkTypeMacro(vtkSMRangeDomainTemplate, vtkSMDomain);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  int IsInDomain(vtkSMProperty* property) override;
 
  bool IsInDomain(unsigned int idx, T val);
 
  T GetMinimum(unsigned int idx, int& exists);
 
  T GetMaximum(unsigned int idx, int& exists);
 
  int GetResolution();
 
 
  bool GetMinimumExists(unsigned int idx);
  bool GetMaximumExists(unsigned int idx);
 
  bool GetResolutionExists();
 
  T GetMinimum(unsigned int idx)
  {
    int not_used;
    return this->GetMinimum(idx, not_used);
  }
  T GetMaximum(unsigned int idx)
  {
    int not_used;
    return this->GetMaximum(idx, not_used);
  }
 
  unsigned int GetNumberOfEntries();
 
  void Update(vtkSMProperty*) override;
 
  void SetAnimationValue(vtkSMProperty* property, int idx, double value) override;
 
  enum DefaultModes
  {
    MIN,
    MAX,
    MID
  };
 
  DefaultModes GetDefaultMode(unsigned int index = 0);
 
  int SetDefaultValues(vtkSMProperty*, bool use_unchecked_values) override;
 
protected:
  vtkSMRangeDomainTemplate();
  ~vtkSMRangeDomainTemplate() override;
 
  int ReadXMLAttributes(vtkSMProperty* prop, vtkPVXMLElement* element) override;
 
  struct vtkEntry
  {
    vtkTuple<T, 2> Value;
    vtkTuple<bool, 2> Valid;
    vtkEntry()
    {
      this->Value[0] = this->Value[1] = 0;
      this->Valid[0] = this->Valid[1] = false;
    }
    vtkEntry(T min, bool minValid, T max, bool maxValid)
    {
      this->Value[0] = min;
      this->Value[1] = max;
      this->Valid[0] = minValid;
      this->Valid[1] = maxValid;
    }
    vtkEntry(T min, T max)
    {
      this->Value[0] = min;
      this->Value[1] = max;
      this->Valid[0] = this->Valid[1] = true;
    }
 
    bool operator==(const vtkEntry& other) const
    {
      return this->Valid == other.Valid && this->Value == other.Value;
    }
  };
 
  // We keep Entries private so we can carefully manage firing the modified
  // events since subclasses can often forget the minutia.
  const std::vector<vtkEntry>& GetEntries() const { return this->Entries; }
  void SetEntries(const std::vector<vtkEntry>& new_value)
  {
    typedef typename std::vector<vtkEntry>::const_iterator cit;
    cit b = this->Entries.begin();
    cit e = this->Entries.end();
    if (this->Entries.size() != new_value.size() || !std::equal(b, e, new_value.begin()))
    {
      this->Entries = new_value;
      this->DomainModified();
    }
  }
  std::vector<DefaultModes> DefaultModeVector;
  DefaultModes DefaultDefaultMode;
 
  int Resolution;
 
private:
  vtkSMRangeDomainTemplate(const vtkSMRangeDomainTemplate&) = delete;
  void operator=(const vtkSMRangeDomainTemplate&) = delete;
 
  bool GetComputedDefaultValue(unsigned int index, T& value);
 
  std::vector<vtkEntry> Entries;
};
 
#if !defined(VTK_NO_EXPLICIT_TEMPLATE_INSTANTIATION)
#define VTK_SM_RANGE_DOMAIN_TEMPLATE_INSTANTIATE(T)                                                \
  template class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMRangeDomainTemplate<T>
#else
#include "vtkSMRangeDomainTemplate.txx" // needed for templates.
#define VTK_SM_RANGE_DOMAIN_TEMPLATE_INSTANTIATE(T)
#endif // !defined(VTK_NO_EXPLICIT_TEMPLATE_INSTANTIATION)
 
#endif // !defined(vtkSMRangeDomainTemplate_h)
 
// This portion must be OUTSIDE the include blockers.  Each
// vtkSMRangeDomainTemplate subclass uses this to give its instantiation
// of this template a DLL interface.
#if defined(VTK_SM_RANGE_DOMAIN_TEMPLATE_TYPE)
#if defined(VTK_BUILD_SHARED_LIBS) && defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4091) // warning C4091: 'extern ' :
                                // ignored on left of 'int' when no variable is declared
#pragma warning(disable : 4231) // Compiler-specific extension warning.
// Use an "extern explicit instantiation" to give the class a DLL
// interface.  This is a compiler-specific extension.
extern VTK_SM_RANGE_DOMAIN_TEMPLATE_INSTANTIATE(VTK_SM_RANGE_DOMAIN_TEMPLATE_TYPE);
#pragma warning(pop)
#endif
#undef VTK_SM_RANGE_DOMAIN_TEMPLATE_TYPE
#endif