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();
 
  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* _valuePtr;
 
  bool  _internalValue;
 
  void _initialize(const std::string& name="", bool* valuePtr=nullptr);
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT IntField : public Field
{
  ML_CLASS_HEADER(IntField)
 
public:
 
  IntField();
 
  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:
 
  MLintPtr _valuePtr;
 
  MLint    _internalValue;
 
  void _initialize(const std::string& name="", MLintPtr valuePtr=nullptr);
 
  MLint _minValue;
  MLint _maxValue;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
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;
 
  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, int* valuePtr=nullptr);
 
  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* _valuePtr;
 
  int  _internalValue;
 
  bool _linearEntries;
 
  std::vector<EnumEntry> _entries;
 
protected:
  EnumField() {};
};
 
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.push_back(EnumField::EnumEntry(stringValue, static_cast<int>(value)));
  }
 
  void add(const std::string& stringValue, EnumType value) {
    _entries.push_back(EnumField::EnumEntry(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();
 
  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;
 
  void _initialize(const std::string& name="", float* valuePtr=nullptr);
 
 
  float* _valuePtr;
 
  float  _internalValue;
 
  float _minValue;
  float _maxValue;
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ProgressField : public FloatField
{
  ML_CLASS_HEADER(ProgressField)
 
public:
 
  ProgressField();
 
  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;
 
  void _initialize();
 
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT DoubleField : public Field
{
  ML_CLASS_HEADER(DoubleField)
 
 
public:
 
  DoubleField();
 
  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* _valuePtr;
 
  double  _internalValue;
 
  void _initialize(const std::string& name="", double* valuePtr=nullptr);
 
  double _minValue;
  double _maxValue;
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT StringField : public Field
{
  ML_CLASS_HEADER(StringField)
 
 
public:
 
  StringField();
 
  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;
 
  void _initialize(const std::string& name="");
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT NotifyField : public Field
{
  ML_CLASS_HEADER(NotifyField)
 
public:
 
  NotifyField();
 
  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* _valuePtr;
 
  void _initialize();
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
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* _valuePtr;
 
  void _initialize();
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT BaseField : public Field
{
  ML_CLASS_HEADER(BaseField)
 
public:
 
  BaseField();
 
  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);
 
  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;
 
  void _initialize(const std::string& name="");
 
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
 
template<class T>
class TypedBaseField : public BaseField
{
public:
  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:
  void addAllowedType() {}
  void setBaseValueAndAddAllowedType() {}
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SoNodeField : public Field
{
  ML_CLASS_HEADER(SoNodeField)
 
public:
 
  SoNodeField();
 
  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*  _internalValue;
 
  void _initialize(const std::string& name="");
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT PointerField : public Field
{
  ML_CLASS_HEADER(PointerField)
 
public:
 
  PointerField();
 
  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* _valuePtr;
 
  void _initialize(const std::string& name="");
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector2Field : public Field
{
  ML_CLASS_HEADER(Vector2Field)
 
public:
 
  Vector2Field();
 
  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* _valuePtr;
 
  Vector2  _internalValue;
 
  void _initialize(const std::string& name="", Vector2* valuePtr=nullptr);
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector3Field : public Field
{
  ML_CLASS_HEADER(Vector3Field)
 
public:
 
  Vector3Field();
 
  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* _valuePtr;
 
  Vector3  _internalValue;
 
  void _initialize(const std::string& name="", Vector3* valuePtr=nullptr);
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector4Field : public Field
{
  ML_CLASS_HEADER(Vector4Field)
 
public:
 
  Vector4Field();
 
  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* _valuePtr;
 
  Vector4  _internalValue;
 
  void _initialize(const std::string& name="", Vector4* valuePtr=nullptr);
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector5Field : public Field
{
  ML_CLASS_HEADER(Vector5Field)
 
 
public:
 
  Vector5Field();
 
  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;
 
  void _initialize(const std::string& name="");
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector6Field : public Field
{
  ML_CLASS_HEADER(Vector6Field)
 
 
public:
 
  Vector6Field();
 
  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* _valuePtr;
 
  Vector6  _internalValue;
 
  void _initialize(const std::string& name="", Vector6* valuePtr=nullptr);
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector10Field : public Field
{
  ML_CLASS_HEADER(Vector10Field)
 
 
public:
 
  Vector10Field();
 
  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;
 
  void _initialize(const std::string& name="");
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ColorField : public Vector3Field
{
  ML_CLASS_HEADER(ColorField)
 
public:
 
  ColorField();
 
  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:
  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:
  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();
 
  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* _valuePtr;
 
  Matrix4  _internalValue;
 
  void _initialize(const std::string& name="", Matrix4* valuePtr=nullptr);
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix4Field : public MatrixField
{
  ML_CLASS_HEADER(Matrix4Field)
 
public:
  Matrix4Field(const std::string& name="");
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix5Field : public Field
{
  ML_CLASS_HEADER(Matrix5Field)
 
public:
  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:
  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();
 
  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* _valuePtr;
  MLDataType  _internalValue;
 
  void _initialize(const std::string& name="", MLDataType* valuePtr=nullptr);
};
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ImageVectorField : public Field
{
  ML_CLASS_HEADER(ImageVectorField)
 
public:
 
  ImageVectorField();
 
  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* _valuePtr;
 
  ImageVector  _internalValue;
 
  void _initialize(const std::string& name="", ImageVector* valuePtr=nullptr);
};
 
 
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SubImageBoxField : public Field
{
  ML_CLASS_HEADER(SubImageBoxField)
 
public:
 
  SubImageBoxField();
 
  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* _valuePtr;
  SubImageBox  _internalValue;
 
  void _initialize(const std::string& name="", SubImageBox* valuePtr=nullptr);
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SubImageBoxdField : public Field
{
  ML_CLASS_HEADER(SubImageBoxdField)
 
public:
 
  SubImageBoxdField();
 
  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* _valuePtr;
 
  SubImageBoxd  _internalValue;
 
  void _initialize(const std::string& name="", SubImageBoxd* valuePtr=nullptr);
};
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT UniversalTypeField : public Field
{
  ML_CLASS_HEADER(UniversalTypeField)
 
public:
  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); }
 
  MLTypeData* getValue() const { return getUniversalTypeValue(); }
 
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:
  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:
  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 //of __mlFields_H