mlFields.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_FIELDS_H
#define ML_FIELDS_H

 
// ML-includes
#include "mlInitSystemML.h"
#include "mlField.h"
#include "mlRuntimeSubClass.h"
 
#include "mlPlane.h"
#include "mlRotation.h"
#include "mlSubImageBoxd.h"
#include "mlRefCountedBase.h"
 
#include <type_traits>

// Inventor Nodes
class SoNode;

 
 
ML_START_NAMESPACE
 
class Module;
class OutputConnector;
class InputConnector;
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
MLEXPORT void MLInitFields();
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT BoolField : public Field
{
  ML_CLASS_HEADER(BoolField)
 
public:

  BoolField() = default;

  explicit BoolField(const std::string& name);

  void setStringValue(const std::string& value) override;

  void setBoolValue(bool boolValue);

  void updateBoolValue(bool boolValue);

  void toggleValue();

  std::string getStringValue() const override;

  bool getBoolValue() const;

  bool isOn() const;

  void setValue(bool boolValue) { setBoolValue(boolValue); }

  void updateValue(bool boolValue) { updateBoolValue(boolValue); }

  bool getValue() const { return getBoolValue(); }
 
protected:

  void setValueFromField(const Field& field) override;
 
private:

  bool _value{};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT IntField : public Field
{
  ML_CLASS_HEADER(IntField)
 
public:

  IntField() = default;

  explicit IntField(const std::string& name);

  void setStringValue(const std::string& value) override;

  void setIntValue(MLint intValue);

  void updateIntValue(MLint intValue);

  std::string getStringValue() const override;

  MLint getIntValue() const;

  void setValue(MLint intValue) { setIntValue(intValue); }

  void updateValue(MLint intValue) { updateIntValue(intValue); }

  MLint getValue() const { return getIntValue(); }
 
protected:

  void setValueFromField(const Field& field) override;
 
private:

  MLint _value{};
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT EnumField : public Field
{
  ML_ABSTRACT_CLASS_HEADER(EnumField)
 
public:
  EnumField(const std::string& name, const std::string enumerationItemNames[], size_t numEnumerationItems);

  EnumField(const std::string& name, const char* const* enumerationItemNames, size_t numEnumerationItems);

  EnumField(const std::string& name, const std::vector<std::string> &enumerationItemNames);

   ~EnumField() override = default;

  void setStringValue(const std::string& value) override;

  void setStringValueDefaulted(const std::string& value);

  void setEnumValue(int enumValue);

  void updateEnumValue(int enumValue);

  std::string getStringValue() const override;

  int getEnumValue() const;

  struct EnumEntry {
    EnumEntry():value(-1) {}
    EnumEntry(const std::string& sv, int v) : stringValue(sv), value(v) { }

    std::string stringValue;
    int         value;
  };

  const EnumEntry& getEnumEntryAtIndex(size_t index) const;

  size_t getNumEnumerationItems() const;

  void setValue(int enumValue) { setEnumValue(enumValue); }

  void updateValue(int enumValue) { updateEnumValue(enumValue); }

  int getValue() const { return getEnumValue(); }
 
protected:

  void _initialize(const std::string& name="", size_t numEnums=0);

  void _setEnumerationNames(const std::string enumNames[]);
  void _setEnumerationNames(const char* const* enumNames);
  void _setEnumerationNames(const std::vector<std::string> &enumNames);
  void _setEnumerationNames(const std::vector<EnumField::EnumEntry>& enumValues, int initialValue);

  int _value{};

  bool _linearEntries{};

  std::vector<EnumEntry> _entries;
 
protected:
  EnumField() = default;
};

template <typename EnumType>
class EnumValues
{
public:
  struct Entry {
    Entry():stringValue(nullptr), value(-1) {}
    Entry(const char* sv, EnumType v) : stringValue(sv), value(v) { }

    const char* stringValue;
    EnumType    value;
  };
 
public:
  void add(const char* stringValue, EnumType value) {
    _entries.emplace_back(stringValue, static_cast<int>(value));
  }

  void add(const std::string& stringValue, EnumType value) {
    _entries.emplace_back(stringValue, static_cast<int>(value));
  }

  void add(const Entry& value) {
    _entries.push_back(EnumField::EnumEntry(value.stringValue, static_cast<int>(value.value)));
  }

  EnumValues& operator<<(const Entry& value) {
    add(value);
    return *this;
  }

  const std::vector<EnumField::EnumEntry>& getEntries() const { return _entries; }
 
protected:
  std::vector<EnumField::EnumEntry> _entries;
};

#define ML_ENUM_VALUE(enumValue) internal::createEnumEntry(#enumValue, enumValue)

#define ML_EXTERNAL_ENUM_VALUE(enumClass, enumValue) internal::createEnumEntry(#enumValue, enumClass::enumValue)
 
namespace internal {
  template <typename EnumType>
  inline typename EnumValues<EnumType>::Entry createEnumEntry(const char* value, EnumType enumValue) {
    return typename EnumValues<EnumType>::Entry(value, enumValue);
  }
}
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
template <typename EnumType>
class TypedEnumField : public EnumField
{
public:
  static_assert(sizeof(std::underlying_type<EnumType>) <= sizeof(int), "The underlying type cannot be bigger than int!");

  TypedEnumField(const std::string& name, const EnumValues<EnumType>& enumValues, EnumType initialValue) : EnumField()
  {
    const std::vector<EnumField::EnumEntry>& entries = enumValues.getEntries();
    _initialize(name, entries.size());
    _setEnumerationNames(entries, static_cast<int>(initialValue));
  }

  EnumType getEnumValue() const { return static_cast<EnumType>(EnumField::getEnumValue()); }
  void setEnumValue(EnumType enumValue) { EnumField::setEnumValue(static_cast<int>(enumValue)); }
  void updateEnumValue(EnumType enumValue) { EnumField::updateEnumValue(static_cast<int>(enumValue)); }
  EnumType getValue() const { return getEnumValue(); }
  void setValue(EnumType enumValue) { setEnumValue(enumValue); }
  void updateValue(EnumType enumValue) { updateEnumValue(enumValue); }
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT FloatField : public Field
{
  ML_CLASS_HEADER(FloatField)
 
public:

  FloatField() = default;

  explicit FloatField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setFloatValue(float floatValue);

  void updateFloatValue(float floatValue);

  std::string getStringValue() const override;

  float getFloatValue() const;

  void setValue(float floatValue) { setFloatValue(floatValue); }

  void updateValue(float floatValue) { updateFloatValue(floatValue); }

  float getValue() const { return getFloatValue(); }

  static void setValueCallback(void* field, double value);
 
protected:
  void setValueFromField(const Field& field) override;

  float _value{};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ProgressField : public FloatField
{
  ML_CLASS_HEADER(ProgressField)
 
public:

  ProgressField();

  explicit ProgressField(const std::string& name);

  void setFloatValue(float floatValue);

  void setProgressValue(float floatValue);

  inline float getProgressValue() { return getFloatValue(); }

  void setUpdateDifference(float epsilonValue);

  void setValue(float floatValue) { setFloatValue(floatValue); }
 
private:
  float _difference{0.02f};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT DoubleField : public Field
{
  ML_CLASS_HEADER(DoubleField)
 
 
public:

  DoubleField() = default;

  explicit DoubleField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setDoubleValue(double doubleValue);

  void updateDoubleValue(double doubleValue);

  std::string getStringValue() const override;

  double getDoubleValue() const;

  void setValue(double doubleValue) { setDoubleValue(doubleValue); }

  void updateValue(double doubleValue) { updateDoubleValue(doubleValue); }

  double getValue() const { return getDoubleValue(); }

  static void setValueCallback(void* field, double value);
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  double _value{};
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT StringField : public Field
{
  ML_CLASS_HEADER(StringField)
 
public:

  StringField() = default;

  explicit StringField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void updateStringValue(const std::string& stringValue);

  std::string getStringValue() const override;

  void setValue(const std::string& stringValue) { setStringValue(stringValue); }

  void updateValue(const std::string& stringValue) { updateStringValue(stringValue); }

  std::string getValue() const { return getStringValue(); }
 
private:
  std::string _value;
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT NotifyField : public Field
{
  ML_CLASS_HEADER(NotifyField)
 
public:

  NotifyField();

  explicit NotifyField(const std::string& name);

  void setStringValue(const std::string& /*value*/) override;

  std::string getStringValue() const override;

  void notify();
 
};

typedef NotifyField TriggerField;
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT OutputConnectorField : public Field
{
  ML_CLASS_HEADER(OutputConnectorField)
 
public:

  OutputConnectorField();

  OutputConnectorField(const std::string& name, Module* module, MLint outputImageIndex);

  ~OutputConnectorField() override;

  void setStringValue(const std::string& /*value*/) override;

  void touch(FieldSensor::Strength strength=FieldSensor::CHANGED) override;

  std::string getStringValue() const override;

  OutputConnector& getOutputConnectorValue() const;

  MLint isValidValue() override;
 
private:

  OutputConnector* _value{};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT InputConnectorField : public Field
{
  ML_CLASS_HEADER(InputConnectorField)
 
public:

  InputConnectorField();

  InputConnectorField(const std::string& name, Module* module, MLint inputImageIndex);

  ~InputConnectorField() override;

  void setStringValue(const std::string& /*value*/) override;

   std::string getStringValue() const override;

  InputConnector& getInputConnectorValue() const;

  MLint isValidValue() override;
 
private:
  InputConnector* _value{};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT BaseField : public Field
{
  ML_CLASS_HEADER(BaseField)
 
public:

  BaseField() = default;

  explicit BaseField(const std::string& name);

  ~BaseField() override;

  void setStringValue(const std::string& stringValue) override;

  void setBaseValue(Base* basePointerValue);

  void setBaseValue(const RefCountedBasePtr& value);

  std::string getStringValue() const override;

  Base* getBaseValue() const;

  virtual void touchSourceFields();

  void addAllowedType(const RuntimeType* allowedType);

  template <typename T>
  void addAllowedType() { addAllowedType(T::getClassTypeId()); }

  template <typename T>
  void setBaseValueAndAddAllowedType(T* value) { addAllowedType(value->getClassTypeId()); setBaseValue(value); }

  template <typename T>
  void setBaseValueAndAddAllowedType(const ::boost::intrusive_ptr<T>& value) { setBaseValueAndAddAllowedType(value.get()); }

  std::vector<const RuntimeType*> getAllowedTypes() const { return _allowedTypes; }

  bool hasUnallowedType() const { return _unallowedType; }

  void setValue(Base* basePointerValue) { setBaseValue(basePointerValue); }

  void setValue(const RefCountedBasePtr& value) { setBaseValue(value); }

  Base* getValue() const { return getBaseValue(); }

  template <class Type>
  Type getTypedValue() const { return mlbase_cast<Type>(getValue()); }

  template <class Type>
  Type getTypedBaseValue() const { return mlbase_cast<Type>(getValue()); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Base* _value{};

  std::vector<const RuntimeType*> _allowedTypes;

  bool _unallowedType{};
  bool _isRefCountedBase{};
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
 
template<class T>
class TypedBaseField : public BaseField
{
public:
  explicit TypedBaseField(const std::string& name) : BaseField(name) { BaseField::addAllowedType<T>(); }

  void setValue(T* basePointerValue) { setBaseValue(basePointerValue); }

  void setValue(const ::boost::intrusive_ptr<T>& value) { setValue(value.get()); }

  T* getValue() const { return getTypedValue<T*>(); }
 
private:
  using BaseField::addAllowedType;
  using BaseField::setBaseValueAndAddAllowedType;
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SoNodeField : public Field
{
  ML_CLASS_HEADER(SoNodeField)
 
public:

  SoNodeField() = default;

  explicit SoNodeField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setSoNodeValue(SoNode* soNodeValue);

  std::string getStringValue() const override;

  SoNode* getSoNodeValue() const;

  void setValue(SoNode* soNodeValue) { setSoNodeValue(soNodeValue); }

  SoNode* getValue() const { return getSoNodeValue(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  SoNode* _value{};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT PointerField : public Field
{
  ML_CLASS_HEADER(PointerField)
 
public:

  PointerField() = default;

  explicit PointerField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setPointerValue(void* voidPointerValue);

  std::string getStringValue() const override;

  void* getPointerValue() const;

  void setValue(void* voidPointerValue) { setPointerValue(voidPointerValue); }

  void* getValue() const { return getPointerValue(); }
 
private:
  void* _value{};
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector2Field : public Field
{
  ML_CLASS_HEADER(Vector2Field)
 
public:

  Vector2Field() = default;

  explicit Vector2Field(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setVector2Value(const Vector2& vectorValue);

  void updateVector2Value(const Vector2& vectorValue);

  inline void setVectorValue(const Vector2& vectorValue) { setVector2Value(vectorValue); }

  std::string getStringValue() const override;

  const Vector2& getVector2Value() const;

  inline const Vector2& getVectorValue() const { return getVector2Value(); }

  void setValue(const Vector2& vectorValue) { setVector2Value(vectorValue); }

  void updateValue(const Vector2& vectorValue) { updateVector2Value(vectorValue); }

  const Vector2& getValue() const { return getVector2Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Vector2 _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector3Field : public Field
{
  ML_CLASS_HEADER(Vector3Field)
 
public:

  Vector3Field() = default;

  explicit Vector3Field(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setVector3Value(const Vector3& vectorValue);

  void updateVector3Value(const Vector3& vectorValue);

  inline void setVectorValue(const Vector3& vectorValue) { setVector3Value(vectorValue); }

  std::string getStringValue() const override;

  const Vector3& getVector3Value() const;

  inline const Vector3& getVectorValue() const { return getVector3Value(); }

  void setValue(const Vector3& vectorValue) { setVector3Value(vectorValue); }

  void updateValue(const Vector3& vectorValue) { updateVector3Value(vectorValue); }

  const Vector3& getValue() const { return getVector3Value(); }
 
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Vector3 _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector4Field : public Field
{
  ML_CLASS_HEADER(Vector4Field)
 
public:

  Vector4Field() = default;

  explicit Vector4Field(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setVector4Value(const Vector4& vectorValue);

  void updateVector4Value(const Vector4& vectorValue);

  inline void setVectorValue(const Vector4& vectorValue) { setVector4Value(vectorValue); }

  std::string getStringValue() const override;

  const Vector4& getVector4Value() const;

  inline const Vector4& getVectorValue() const { return getVector4Value(); }

  void setValue(const Vector4& vectorValue) { setVector4Value(vectorValue); }

  void updateValue(const Vector4& vectorValue) { updateVector4Value(vectorValue); }

  const Vector4& getValue() const { return getVector4Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Vector4 _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector5Field : public Field
{
  ML_CLASS_HEADER(Vector5Field)
 
 
public:

  Vector5Field() = default;

  explicit Vector5Field(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setVector5Value(const Vector5& vectorValue);

  void updateVector5Value(const Vector5& vectorValue);

  inline void setVectorValue(const Vector5& vectorValue) { setVector5Value(vectorValue); }

  std::string getStringValue() const override;

  const Vector5& getVector5Value() const;

  inline const Vector5& getVectorValue() const { return getVector5Value(); }

  void setValue(const Vector5& vectorValue) { setVector5Value(vectorValue); }

  void updateValue(const Vector5& vectorValue) { updateVector5Value(vectorValue); }

  const Vector5& getValue() const { return getVector5Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Vector5 _value;
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector6Field : public Field
{
  ML_CLASS_HEADER(Vector6Field)
 
 
public:

  Vector6Field() = default;

  explicit Vector6Field(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setVector6Value(const Vector6& vectorValue);

  void updateVector6Value(const Vector6& vectorValue);

  inline void setVectorValue(const Vector6& vectorValue) { setVector6Value(vectorValue); }

  std::string getStringValue() const override;

  const Vector6& getVector6Value() const;

  inline const Vector6& getVectorValue() const { return getVector6Value(); }

  void setValue(const Vector6& vectorValue) { setVector6Value(vectorValue); }

  void updateValue(const Vector6& vectorValue) { updateVector6Value(vectorValue); }

  const Vector6& getValue() const { return getVector6Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Vector6 _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector10Field : public Field
{
  ML_CLASS_HEADER(Vector10Field)
 
 
public:

  Vector10Field() = default;

  explicit Vector10Field(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setVector10Value(const Vector10& vectorValue);

  void updateVector10Value(const Vector10& vectorValue);

  inline void setVectorValue(const Vector10& vectorValue) { setVector10Value(vectorValue); }
 

  std::string getStringValue() const override;

  const Vector10& getVector10Value() const;

  inline const Vector10& getVectorValue() const { return getVector10Value(); }

  void setValue(const Vector10& vectorValue) { setVector10Value(vectorValue); }

  void updateValue(const Vector10& vectorValue) { updateVector10Value(vectorValue); }

  const Vector10& getValue() const { return getVector10Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Vector10 _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ColorField : public Vector3Field
{
  ML_CLASS_HEADER(ColorField)
 
public:

  ColorField();

  explicit ColorField(const std::string& name);

  void setColorValue(float r, float g, float b);

  void updateColorValue(float r, float g, float b);

  void getColorValue(float& r, float& g, float& b) const;

  const Vector3& getColorValue() const { return getVectorValue(); }

  void setPackedColorValue(MLuint32 rgba);

  MLuint32 getPackedColorValue() const;
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix2Field : public Field
{
  ML_CLASS_HEADER(Matrix2Field)
 
public:
  explicit Matrix2Field(const std::string& name="");

  void setStringValue(const std::string& stringValue) override;

  void setMatrixValue(const Matrix2& matrixValue);

  void setMatrix2Value(const Matrix2& matrixValue);

  void updateMatrix2Value(const Matrix2& matrixValue);

  std::string getStringValue() const override;

  const Matrix2& getMatrixValue() const;

  const Matrix2& getMatrix2Value() const;

  void setValue(const Matrix2& matrixValue) { setMatrix2Value(matrixValue); }

  void updateValue(const Matrix2& matrixValue) { updateMatrix2Value(matrixValue); }

  const Matrix2& getValue() const { return getMatrix2Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Matrix2 _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix3Field : public Field
{
  ML_CLASS_HEADER(Matrix3Field)
 
public:
  explicit Matrix3Field(const std::string& name="");

  void setStringValue(const std::string& stringValue) override;

  void setMatrixValue(const Matrix3& matrixValue);

  void setMatrix3Value(const Matrix3& matrixValue);

  void updateMatrix3Value(const Matrix3& matrixValue);

  std::string getStringValue() const override;

  const Matrix3& getMatrixValue() const;

  const Matrix3& getMatrix3Value() const;

  void setValue(const Matrix3& matrixValue) { setMatrix3Value(matrixValue); }

  void updateValue(const Matrix3& matrixValue) { updateMatrix3Value(matrixValue); }

  const Matrix3& getValue() const { return getMatrix3Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Matrix3 _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT MatrixField : public Field
{
  ML_CLASS_HEADER(MatrixField)
 
public:

  MatrixField() = default;

  explicit MatrixField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setMatrixValue(const Matrix4& matrixValue);

  void setMatrix4Value(const Matrix4& matrixValue);

  void updateMatrix4Value(const Matrix4& matrixValue);

  std::string getStringValue() const override;

  const Matrix4& getMatrixValue() const;

  const Matrix4& getMatrix4Value() const;

  void setValue(const Matrix4& matrixValue) { setMatrix4Value(matrixValue); }

  void updateValue(const Matrix4& matrixValue) { updateMatrix4Value(matrixValue); }

  const Matrix4& getValue() const { return getMatrix4Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Matrix4 _value{Matrix4::getIdentity()};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix4Field : public MatrixField
{
  ML_CLASS_HEADER(Matrix4Field)
 
public:
  explicit Matrix4Field(const std::string& name="");
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix5Field : public Field
{
  ML_CLASS_HEADER(Matrix5Field)
 
public:
  explicit Matrix5Field(const std::string& name="");

  void setStringValue(const std::string& stringValue) override;

  void setMatrixValue(const Matrix5& matrixValue);

  void setMatrix5Value(const Matrix5& matrixValue);

  void updateMatrix5Value(const Matrix5& matrixValue);

  std::string getStringValue() const override;

  const Matrix5& getMatrixValue() const;

  const Matrix5& getMatrix5Value() const;

  void setValue(const Matrix5& matrixValue) { setMatrix5Value(matrixValue); }

  void updateValue(const Matrix5& matrixValue) { updateMatrix5Value(matrixValue); }

  const Matrix5& getValue() const { return getMatrix5Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Matrix5 _value;
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix6Field : public Field
{
  ML_CLASS_HEADER(Matrix6Field)
 
public:
  explicit Matrix6Field(const std::string& name="");

  void setStringValue(const std::string& stringValue) override;

  void setMatrixValue(const Matrix6& matrixValue);

  void setMatrix6Value(const Matrix6& matrixValue);

  void updateMatrix6Value(const Matrix6& matrixValue);

  std::string getStringValue() const override;

  const Matrix6& getMatrixValue() const;

  const Matrix6& getMatrix6Value() const;

  void setValue(const Matrix6& matrixValue) { setMatrix6Value(matrixValue); }

  void updateValue(const Matrix6& matrixValue) { updateMatrix6Value(matrixValue); }

  const Matrix6& getValue() const { return getMatrix6Value(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  Matrix6 _value;
};
 
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT MLDataTypeField : public Field
{
  ML_CLASS_HEADER(MLDataTypeField)
 
public:

  MLDataTypeField() = default;

  explicit MLDataTypeField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setMLDataTypeValue(MLDataType dataType);

  std::string getStringValue() const override;

  MLDataType getMLDataTypeValue() const;

  void setValue(MLDataType dataType) { setMLDataTypeValue(dataType); }

  MLDataType getValue() const { return getMLDataTypeValue(); }
 
private:
  MLDataType _value{MLuint8Type};
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ImageVectorField : public Field
{
  ML_CLASS_HEADER(ImageVectorField)
 
public:

  ImageVectorField() = default;

  explicit ImageVectorField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setImageVectorValue(const ImageVector& imageVectorValue);

  void updateImageVectorValue(const ImageVector& imageVectorValue);

  std::string getStringValue() const override;

  const ImageVector& getImageVectorValue() const;

  void setValue(const ImageVector& imageVectorValue) { setImageVectorValue(imageVectorValue); }

  void updateValue(const ImageVector& imageVectorValue) { updateImageVectorValue(imageVectorValue); }

  const ImageVector& getValue() const { return getImageVectorValue(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  ImageVector _value;
};
 
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SubImageBoxField : public Field
{
  ML_CLASS_HEADER(SubImageBoxField)
 
public:

  SubImageBoxField() = default;

  explicit SubImageBoxField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setSubImageBoxValue(const SubImageBox& subImageBoxValue);

  void updateSubImageBoxValue(const SubImageBox& subImageBoxValue);

  std::string getStringValue() const override;

  const SubImageBox& getSubImageBoxValue() const;

  void setValue(const SubImageBox& subImageBoxValue) { setSubImageBoxValue(subImageBoxValue); }

  void updateValue(const SubImageBox& subImageBoxValue) { updateSubImageBoxValue(subImageBoxValue); }

  const SubImageBox& getValue() const { return getSubImageBoxValue(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  SubImageBox _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SubImageBoxdField : public Field
{
  ML_CLASS_HEADER(SubImageBoxdField)
 
public:

  SubImageBoxdField() = default;

  explicit SubImageBoxdField(const std::string& name);

  void setStringValue(const std::string& stringValue) override;

  void setSubImageBoxdValue(const SubImageBoxd& subImageBoxfValue);

  void updateSubImageBoxdValue(const SubImageBoxd& subImageBoxfValue);

  std::string getStringValue() const override;

  const SubImageBoxd& getSubImageBoxdValue() const;

  void setValue(const SubImageBoxd& subImageBoxValue) { setSubImageBoxdValue(subImageBoxValue); }

  void updateValue(const SubImageBoxd& subImageBoxValue) { updateSubImageBoxdValue(subImageBoxValue); }

  const SubImageBoxd& getValue() const { return getSubImageBoxdValue(); }
 
protected:
  void setValueFromField(const Field& field) override;
 
private:
  SubImageBoxd _value;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT UniversalTypeField : public Field
{
  ML_CLASS_HEADER(UniversalTypeField)
 
public:
  explicit UniversalTypeField(const std::string& name="", MLDataType dt=-1);

  ~UniversalTypeField() override;

  MLint isValidValue() override;

  void setStringValue(const std::string& stringValue) override;

  std::string getStringValue() const override;

  virtual void setDataType(MLDataType dataType);

  virtual MLDataType getDataType() const;

  virtual void setUniversalTypeValue(const MLTypeData* dataType);

  virtual MLTypeData* getUniversalTypeValue() const;

  virtual const MLTypeData* getShortLivedUniversalTypeValue() const;

  virtual MLldouble getValueCastToLDouble() const;

  void setValue(const MLTypeData* typeData) { setUniversalTypeValue(typeData); };

  const MLTypeData* getValue() const { return getShortLivedUniversalTypeValue(); };
 
protected:
  virtual void _updateIsValidAndTypeDataFromOrigString();

  virtual void _updateIsValidAndStrValueFromTypeData();

  void _updateFieldFromOrigString();
 
private:
  std::string _origString;

  std::string _strValue;

  MLDataType _dataType{};

  MLint _isValid{};

  MLTypeData* _typeData{};
};
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLEXPORT RotationField : public Vector4Field {

  ML_CLASS_HEADER(RotationField)
 
public:
  explicit RotationField(const std::string &name=""): Vector4Field(name) {}

  void setRotationValue(const Vector3& vec, double angle);

  void setRotationValue(const Rotation& rot);

  void getRotationValue(Vector3& vec, double& angle) const;

  Rotation getRotationValue() const;
};
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLEXPORT PlaneField : public Vector4Field {

  ML_CLASS_HEADER(PlaneField)
 
public:
  explicit PlaneField(const std::string &name=""): Vector4Field(name) {}

  void setPlaneValue(double f0, double f1, double f2, double f3);

  void setPlaneValue(const Plane& p);

  void getPlaneValue(double &f0, double &f1, double &f2, double &f3) const;

  void getPlaneValue(Plane &plane) const;

  Plane getPlaneValue() const;
};
 
 
ML_END_NAMESPACE
 
 
#endif // ML_FIELDS_H