MeVis/Foundation/Sources/ML/include/mlFields.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlFields_H
#define __mlFields_H

// ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlBasics_H
#include "mlBasics.h"
#endif
#ifndef __mlField_H
#include "mlField.h"
#endif
#ifndef __mlRuntimeSubClass_H
#include "mlRuntimeSubClass.h"
#endif

#include "mlPlane.h"
#include "mlRotation.h"
#include "mlSubImageBoxd.h"
#include "mlRefCountedBase.h"

// Inventor Nodes
class SoNode;



ML_START_NAMESPACE

#ifdef ML_DEPRECATED
#define ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER ML_DEPRECATED
#endif

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

  void setBoolValue(bool boolValue);

  void updateBoolValue(bool boolValue);

  void toggleValue();

  std::string getStringValue() const;

  bool getBoolValue() const;

  bool isOn() const;
  
protected:
  
  virtual void setValueFromField(const Field& field);

private:
  
  bool* _valuePtr;

  bool  _internalValue;

  void _initialize(const std::string& name="", bool* valuePtr=NULL);
  
#ifdef ML_DEPRECATED
  

  
public:
  
  inline ML_DEPRECATED void switch_Value() { toggleValue(); }
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  

  
public:

  BoolField(const std::string &name, bool *valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
 
  
};


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

public:

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

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

  void setIntValue(MLint intValue);

  void updateIntValue(MLint intValue);

  std::string getStringValue() const;

  MLint getIntValue() const;
  
protected:
  
  virtual void setValueFromField(const Field& field);

private:
  
  MLintPtr _valuePtr;
  
  MLint    _internalValue;

  void _initialize(const std::string& name="", MLintPtr valuePtr=NULL);
  
  MLint _minValue;  
  MLint _maxValue;
  
#ifdef ML_DEPRECATED
  

  
public:

  ML_DEPRECATED void setIntMaxValue(MLint maxValue);
  ML_DEPRECATED MLint getIntMaxValue() const;
  ML_DEPRECATED void setIntMinValue(MLint minValue);
  ML_DEPRECATED MLint getIntMinValue() const;
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  

  
public:
  
  IntField(const std::string &name, MLintPtr valuePtr);  
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};

#ifdef ML_DEPRECATED
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ML_DEPRECATED ToggleField : public Field 
{
  ML_CLASS_HEADER(ToggleField);
  
public:

  ToggleField();
  
  ToggleField(const std::string& name);

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

  void setIntValue(int intValue);
  
  void setToggleValue(bool b);
  
  void toggleValue();
  
  std::string getStringValue() const;
  
  int getIntValue() const;

  bool isOn() const;
  
protected:
  
  virtual void setValueFromField(const Field& field);

private:
  
  int* _valuePtr;

  int  _internalValue;

  void _initialize(const std::string& name="", int* valuePtr=NULL);
  
#ifdef ML_DEPRECATED
  

  
public:
  
  ML_DEPRECATED void switch_Value();
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  

  
public:
  
  ToggleField(const std::string &name, int* valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};

#endif // ML_DEPRECATED

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT EnumField : public Field 
{
  ML_CLASS_HEADER(EnumField);

public:

  EnumField();
  EnumField(const std::string& name);
  
  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);

  virtual  ~EnumField();

  void setStringValue(const std::string& value);
  
  void setStringValueDefaulted(const std::string& value, int defaultItem);
  
  void setEnumValue(int index);
  
  void updateEnumValue(int index);
  
  std::string getStringValue() const;

  const char* getStringValue(size_t index) const;
  
  int getEnumValue() const;
  
  size_t getNumEnumerationItems() const;
  
  virtual MLint isValidValue();

private:
  
  void _initialize(const std::string& name="", size_t numEnums=0, int* valuePtr=NULL);
  
  void _setEnumerationNames(const std::string enumNames[]);
  void _setEnumerationNames(const char* const* enumNames);
  void _setEnumerationNames(const std::vector<std::string> &enumNames);
  
  int* _valuePtr;

  int  _internalValue;


  size_t _enumNum;

  char** _enumNames;
  
  
#ifdef ML_DEPRECATED
  

  
public:
  
  inline ML_DEPRECATED size_t getEnumNum() const { return getNumEnumerationItems(); }
  
  
#endif // ML_DEPRECATED
  
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  

  
public:
  
  EnumField(const std::string &name, const std::string enumNames[], size_t enumNum, int *valuePtr);
  
  EnumField(const std::string &name, const char* const* enumNames, size_t enumNum, int *valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT FloatField : public Field 
{
  ML_CLASS_HEADER(FloatField);
  
public:

  FloatField();

  FloatField(const std::string& name);

  void setStringValue(const std::string& stringValue);
  
  void setFloatValue(float floatValue);

  void updateFloatValue(float floatValue);

  std::string getStringValue() const;
  
  float getFloatValue() const;
    
protected:
  virtual void setValueFromField(const Field& field);

  void _initialize(const std::string& name="", float* valuePtr=NULL);
  
  
  float* _valuePtr;

  float  _internalValue;

  float _minValue;  
  float _maxValue;
  
#ifdef ML_DEPRECATED


  
public:
  
  ML_DEPRECATED void setFloatMaxValue(float maxValue);
  ML_DEPRECATED float getFloatMaxValue() const;
  ML_DEPRECATED void setFloatMinValue(float minValue);
  ML_DEPRECATED float getFloatMinValue() const;
  
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  

  
public:  

  FloatField(const std::string& name, float *valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
  
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
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);
  
private:
  float _difference;
  
  void _initialize();
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  

  
public:
  
  ProgressField(const std::string& name, float *valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT DoubleField : public Field 
{
  ML_CLASS_HEADER(DoubleField);
  
  
public:
  
  DoubleField();

  DoubleField(const std::string& name);

  void setStringValue(const std::string& stringValue);
  
  void setDoubleValue(double doubleValue);

  void updateDoubleValue(double doubleValue);

  std::string getStringValue() const;
  
  double getDoubleValue() const;
    
protected:
  virtual void setValueFromField(const Field& field);

private:
  double* _valuePtr;
 
  double  _internalValue;
  
  void _initialize(const std::string& name="", double* valuePtr=NULL);

  double _minValue;  
  double _maxValue;
  
#ifdef ML_DEPRECATED


  
public:
  
  ML_DEPRECATED void setDoubleMaxValue(double maxValue);
  ML_DEPRECATED double getDoubleMaxValue() const;
  ML_DEPRECATED void setDoubleMinValue(double minValue);
  ML_DEPRECATED double getDoubleMinValue() const;

    
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER


  
public:

  DoubleField(const std::string& name, double *valuePtr);

  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
    
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT LongDoubleField : public Field 
{
  ML_CLASS_HEADER(LongDoubleField);

  
public:

  // Default constructor, do not use it.
  LongDoubleField();

  LongDoubleField(const std::string& name);

  void setStringValue(const std::string& stringValue);
  
  void setLongDoubleValue(MLldouble longDoubleValue);
  
  std::string getStringValue() const;
  
  MLldouble getLongDoubleValue() const;
    
protected:
  virtual void setValueFromField(const Field& field);

private:
  MLldouble _value;
  
  void _initialize(const std::string& name="");
  
  MLldouble _minValue;  
  MLldouble _maxValue;
  
#ifdef ML_DEPRECATED



public:
  
  ML_DEPRECATED void setLongDoubleMaxValue(MLldouble maxValue);
  ML_DEPRECATED MLldouble getLongDoubleMaxValue() const;
  ML_DEPRECATED void setLongDoubleMinValue(MLldouble minValue);
  ML_DEPRECATED MLldouble getLongDoubleMinValue() const;
    
#endif // ML_DEPRECATED
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT StringField : public Field 
{
  ML_CLASS_HEADER(StringField);
    
  
public:

  StringField();

  StringField(const std::string& name);

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

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

  std::string getStringValue() const;

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*/);
  
  std::string getStringValue() const;
  
  void notify();

};


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

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

  virtual ~OutputConnectorField();

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

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

  std::string getStringValue() const;
  
  OutputConnector& getOutputConnectorValue() const;

  virtual MLint isValidValue();

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

  virtual ~InputConnectorField();

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

   std::string getStringValue() const;

  InputConnector& getInputConnectorValue() const;

  virtual MLint isValidValue();

private:
  InputConnector* _valuePtr;
  
  void _initialize();
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT BaseField : public Field 
{
  ML_CLASS_HEADER(BaseField);
  
public:
  
  BaseField();

  BaseField(const std::string& name);

  ~BaseField();

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

  void setBaseValue(Base* basePointerValue);
  
  void setBaseValue(const RefCountedBasePtr& value);

  std::string getStringValue() const;
  
  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; }

protected:  
  virtual void setValueFromField(const Field& field);

private:  
  Base* _value;

  std::vector<const RuntimeType*> _allowedTypes;

  bool _unallowedType;
  bool _isRefCountedBase; 

  void _initialize(const std::string& name="");
  
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SoNodeField : public Field 
{
  ML_CLASS_HEADER(SoNodeField);
  
public:

  SoNodeField();  
  
  SoNodeField(const std::string& name);
  
  void setStringValue(const std::string& stringValue);

  void setSoNodeValue(SoNode* soNodeValue);
  
  std::string getStringValue() const;
  
  SoNode* getSoNodeValue() const;
  
protected:
  virtual void setValueFromField(const Field& field);

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

  void setPointerValue(void* voidPointerValue);
  
  std::string getStringValue() const;
  
  void* getPointerValue() const;
  
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);
  
  void setVector2Value(const Vector2& vectorValue);

  void updateVector2Value(const Vector2& vectorValue);

  inline void setVectorValue(const Vector2& vectorValue) { setVector2Value(vectorValue); } 
  
  std::string getStringValue() const;

  const Vector2& getVector2Value() const;

  inline const Vector2& getVectorValue() const { return getVector2Value(); }
      
protected:
  virtual void setValueFromField(const Field& field);

private:
  Vector2* _valuePtr;

  Vector2  _internalValue;

  void _initialize(const std::string& name="", Vector2* valuePtr=NULL);
  
  
#ifdef ML_DEPRECATED


  
public:
  
  inline ML_DEPRECATED void setVec2fValue(const Vector2& value) { setVector2Value(value); }
  inline ML_DEPRECATED const Vector2& getVec2fValue() const { return getVector2Value(); }
  
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER


  
public:  

  Vector2Field(const std::string& name, Vector2* valuePtr);  
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Vector2Field Vec2fField;
#endif // ML_DEPRECATED

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector3Field : public Field 
{
  ML_CLASS_HEADER(Vector3Field);
  
public:

  Vector3Field();

  Vector3Field(const std::string& name);
  
  void setStringValue(const std::string& stringValue);
  
  void setVector3Value(const Vector3& vectorValue);

  void updateVector3Value(const Vector3& vectorValue);

  inline void setVectorValue(const Vector3& vectorValue) { setVector3Value(vectorValue); }
  
  std::string getStringValue() const;
  
  const Vector3& getVector3Value() const;

  inline const Vector3& getVectorValue() const { return getVector3Value(); }
  
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Vector3* _valuePtr;

  Vector3  _internalValue;

  void _initialize(const std::string& name="", Vector3* valuePtr=NULL);

  
#ifdef ML_DEPRECATED



public:
  inline ML_DEPRECATED void setVec3fValue(const Vector3& value) { setVector3Value(value); }
  inline ML_DEPRECATED const Vector3& getVec3fValue() const { return getVector3Value(); }

  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER



public:

  Vector3Field(const std::string& name, Vector3* valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Vector3Field Vec3fField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector4Field : public Field 
{
  ML_CLASS_HEADER(Vector4Field);

public:
  
  Vector4Field();
  
  Vector4Field(const std::string& name);
  
  void setStringValue(const std::string& stringValue);
  
  void setVector4Value(const Vector4& vectorValue);

  void updateVector4Value(const Vector4& vectorValue);

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

  
  std::string getStringValue() const;

  const Vector4& getVector4Value() const;

  inline const Vector4& getVectorValue() const { return getVector4Value(); }
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Vector4* _valuePtr;

  Vector4  _internalValue;

  void _initialize(const std::string& name="", Vector4* valuePtr=NULL);
  
  
#ifdef ML_DEPRECATED


  
public:
  inline ML_DEPRECATED void setVec4fValue(const Vector4& value) { setVector4Value(value); }
  inline ML_DEPRECATED const Vector4& getVec4fValue() const { return getVector4Value(); }
  
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER



public:  

  Vector4Field(const std::string& name, Vector4* valuePtr);  
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Vector4Field Vec4fField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector5Field : public Field 
{
  ML_CLASS_HEADER(Vector5Field);
  

public:

  Vector5Field();
  
  Vector5Field(const std::string& name);
  
  void setStringValue(const std::string& stringValue);
  
  void setVector5Value(const Vector5& vectorValue);

  void updateVector5Value(const Vector5& vectorValue);

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

  std::string getStringValue() const;

  const Vector5& getVector5Value() const;

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

  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Vector5 _value;
  
  void _initialize(const std::string& name="");
  
  
#ifdef ML_DEPRECATED


  
public:
  
  inline ML_DEPRECATED void setVec5fValue(const Vector5& value) { setVector5Value(value); }
  inline ML_DEPRECATED const Vector5& getVec5fValue() const { return getVector5Value(); }
  
  
#endif // ML_DEPRECATED
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Vector5Field Vec5fField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector6Field : public Field 
{
  ML_CLASS_HEADER(Vector6Field);


public:

  Vector6Field();
    
  Vector6Field(const std::string& name);
  
  void setStringValue(const std::string& stringValue);
  
  void setVector6Value(const Vector6& vectorValue);

  void updateVector6Value(const Vector6& vectorValue);

  inline void setVectorValue(const Vector6& vectorValue) { setVector6Value(vectorValue); }
  
  std::string getStringValue() const;

  const Vector6& getVector6Value() const;

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

  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Vector6* _valuePtr;

  Vector6  _internalValue;

  void _initialize(const std::string& name="", Vector6* valuePtr=NULL);

#ifdef ML_DEPRECATED



public:

  inline ML_DEPRECATED void setVec6fValue(const Vector6& value) { setVector6Value(value); }
  inline ML_DEPRECATED const Vector6& getVec6fValue() const { return getVector6Value(); }
  
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  


public:

  Vector6Field(const std::string& name, Vector6* valuePtr);

  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Vector6Field Vec6fField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Vector10Field : public Field 
{
  ML_CLASS_HEADER(Vector10Field);

  
public:

  Vector10Field();  
  
  Vector10Field(const std::string& name);
  
  void setStringValue(const std::string& stringValue);
  
  void setVector10Value(const Vector10& vectorValue);

  void updateVector10Value(const Vector10& vectorValue);

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

  
  std::string getStringValue() const;

  const Vector10& getVector10Value() const;

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

  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Vector10 _value;
  
  void _initialize(const std::string& name="");

#ifdef ML_DEPRECATED


  
public:
  
  inline ML_DEPRECATED void setVec10fValue(const Vector10& value) { setVector10Value(value); }
  inline ML_DEPRECATED const Vector10& getVec10fValue() const { return getVector10Value(); }
  
  
#endif // ML_DEPRECATED
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Vector10Field Vec10fField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
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;
      
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER



public:  

  ColorField(const std::string& name, Vector3* valuePtr);

  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix2Field : public Field 
{
  ML_CLASS_HEADER(Matrix2Field);

public:
  Matrix2Field(const std::string& name="");

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

  void setMatrixValue(const Matrix2& matrixValue);
  
  void setMatrix2Value(const Matrix2& matrixValue);

  void updateMatrix2Value(const Matrix2& matrixValue);
  
  std::string getStringValue() const;
  
  const Matrix2& getMatrixValue() const;
  
  const Matrix2& getMatrix2Value() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Matrix2 _value;

#ifdef ML_DEPRECATED



public:
  inline ML_DEPRECATED void setMat2fValue(const Matrix2& value) { setMatrix2Value(value); }
  inline ML_DEPRECATED void setMat2Value(const Matrix2& value) { setMatrix2Value(value); }
  inline ML_DEPRECATED const Matrix2& getMat2Value() const { return getMatrix2Value(); }

  
#endif // ML_DEPRECATED
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Matrix2Field Mat2Field;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix3Field : public Field 
{
  ML_CLASS_HEADER(Matrix3Field);

public:
  Matrix3Field(const std::string& name="");

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

  void setMatrixValue(const Matrix3& matrixValue);

  void setMatrix3Value(const Matrix3& matrixValue);

  void updateMatrix3Value(const Matrix3& matrixValue);
  
  std::string getStringValue() const;
  
  const Matrix3& getMatrixValue() const;
  
  const Matrix3& getMatrix3Value() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Matrix3 _value;

#ifdef ML_DEPRECATED



public:
  inline ML_DEPRECATED void setMat3fValue(const Matrix3& value) { setMatrix3Value(value); }
  inline ML_DEPRECATED void setMat3Value(const Matrix3& value) { setMatrix3Value(value); }
  inline ML_DEPRECATED const Matrix3& getMat3Value() const { return getMatrix3Value(); }

  
#endif // ML_DEPRECATED
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Matrix3Field Mat3Field;
#endif // ML_DEPRECATED



//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT MatrixField : public Field 
{
  ML_CLASS_HEADER(MatrixField);

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

  void setStringValue(const std::string& stringValue);
  
  void setMatrixValue(const Matrix4& matrixValue);
  
  void setMatrix4Value(const Matrix4& matrixValue);
  
  void updateMatrix4Value(const Matrix4& matrixValue);
  
  std::string getStringValue() const;
  
  const Matrix4& getMatrixValue() const;
  
  const Matrix4& getMatrix4Value() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Matrix4* _valuePtr;
 
  Matrix4  _internalValue;

  void _initialize(const std::string& name="", Matrix4* valuePtr=0);
  
#ifdef ML_DEPRECATED


  
public:
  inline ML_DEPRECATED void setMat4fValue(const Matrix4& value) { setMatrix4Value(value); }
  inline ML_DEPRECATED void setMat4Value(const Matrix4& value) { setMatrix4Value(value); }
  inline ML_DEPRECATED const Matrix4& getMat4Value() const { return getMatrix4Value(); }
  
  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER



public:

  MatrixField(const std::string& name, Matrix4* valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix4Field : public MatrixField 
{
  ML_CLASS_HEADER(Matrix4Field);

public:
  Matrix4Field(const std::string& name="");
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Matrix4Field Mat4Field;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix5Field : public Field 
{
  ML_CLASS_HEADER(Matrix5Field);

public:
  Matrix5Field(const std::string& name="");

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

  void setMatrixValue(const Matrix5& matrixValue);

  void setMatrix5Value(const Matrix5& matrixValue);

  void updateMatrix5Value(const Matrix5& matrixValue);
  
  std::string getStringValue() const;
  
  const Matrix5& getMatrixValue() const;
  
  const Matrix5& getMatrix5Value() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Matrix5 _value;
  
  
#ifdef ML_DEPRECATED



public:
  inline ML_DEPRECATED void setMat5fValue(const Matrix5& value) { setMatrix5Value(value); }
  inline ML_DEPRECATED void setMat5Value(const Matrix5& value) { setMatrix5Value(value); }
  inline ML_DEPRECATED const Matrix5& getMat5Value() const { return getMatrix5Value(); }

  
#endif // ML_DEPRECATED
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Matrix5Field Mat5Field;
#endif // ML_DEPRECATED



//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Matrix6Field : public Field 
{
  ML_CLASS_HEADER(Matrix6Field);

public:
  Matrix6Field(const std::string& name="");

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

  void setMatrixValue(const Matrix6& matrixValue);

  void setMatrix6Value(const Matrix6& matrixValue);

  void updateMatrix6Value(const Matrix6& matrixValue);
  
  std::string getStringValue() const;
  
  const Matrix6& getMatrixValue() const;
  
  const Matrix6& getMatrix6Value() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  Matrix6 _value;

  
#ifdef ML_DEPRECATED



public:
  
  inline ML_DEPRECATED void setMat6fValue(const Matrix6& value) { setMatrix6Value(value); }
  inline ML_DEPRECATED void setMat6Value(const Matrix6& value) { setMatrix6Value(value); }
  inline ML_DEPRECATED const Matrix6& getMat6Value() const { return getMatrix6Value(); }

  
#endif // ML_DEPRECATED
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Matrix6Field Mat6Field;
#endif // ML_DEPRECATED

  

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT MLDataTypeField : public Field 
{
  ML_CLASS_HEADER(MLDataTypeField);

public:
  
  MLDataTypeField();
  
  MLDataTypeField(const std::string& name);
  
  void setStringValue(const std::string& stringValue);

  void setMLDataTypeValue(MLDataType dataType);

  std::string getStringValue() const;
  
  MLDataType getMLDataTypeValue() const;
  
private:
  MLDataType* _valuePtr;
  MLDataType  _internalValue;
  
  void _initialize(const std::string& name="", MLDataType* valuePtr=NULL);
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER



public:

  MLDataTypeField(const std::string& name, MLDataType* valuePtr);

  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT ImageVectorField : public Field 
{
  ML_CLASS_HEADER(ImageVectorField);

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

  void setStringValue(const std::string& stringValue);
  
  void setImageVectorValue(const ImageVector& imageVectorValue);

  void updateImageVectorValue(const ImageVector& imageVectorValue);

  std::string getStringValue() const;

  const ImageVector& getImageVectorValue() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  ImageVector* _valuePtr;

  ImageVector  _internalValue;

  void _initialize(const std::string& name="", ImageVector* valuePtr=NULL);
  
#ifdef ML_DEPRECATED



public:

  inline ML_DEPRECATED void setVectorValue(const ImageVector& value) { setImageVectorValue(value); }
  inline ML_DEPRECATED const ImageVector& getVectorValue() const { return getImageVectorValue(); }

  
#endif // ML_DEPRECATED
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  


public:

  ImageVectorField(const std::string& name, ImageVector* valuePtr);

  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef ImageVectorField VectorField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SubImageBoxField : public Field 
{
  ML_CLASS_HEADER(SubImageBoxField);

public:
  
  SubImageBoxField();
  
  SubImageBoxField(const std::string& name);
  
  void setStringValue(const std::string& stringValue);
  
  void setSubImageBoxValue(const SubImageBox& subImageBoxValue);

  void updateSubImageBoxValue(const SubImageBox& subImageBoxValue);

  std::string getStringValue() const;

  const SubImageBox& getSubImageBoxValue() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  SubImageBox* _valuePtr;
  SubImageBox  _internalValue;
  
  void _initialize(const std::string& name="", SubImageBox* valuePtr=NULL);

#ifdef ML_DEPRECATED



public:
  inline ML_DEPRECATED void setSubImgBoxValue(const SubImageBox& value) { setSubImageBoxValue(value); }
  inline ML_DEPRECATED const SubImageBox& getSubImgBoxValue() const { return getSubImageBoxValue(); }

  
#endif // ML_DEPRECATED
  
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER



public:

  SubImageBoxField(const std::string& name, SubImageBox* valuePtr);
  
  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER
  
  
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef SubImageBoxField SubImgBoxField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT SubImageBoxdField : public Field 
{
  ML_CLASS_HEADER(SubImageBoxdField);

public:
  
  SubImageBoxdField();
  
  SubImageBoxdField(const std::string& name);
  
  void setStringValue(const std::string& stringValue);
  
  void setSubImageBoxdValue(const SubImageBoxd& subImageBoxfValue);

  void updateSubImageBoxdValue(const SubImageBoxd& subImageBoxfValue);

  std::string getStringValue() const;

  const SubImageBoxd& getSubImageBoxdValue() const;
  
protected:
  virtual void setValueFromField(const Field& field);

private:
  SubImageBoxd* _valuePtr;

  SubImageBoxd  _internalValue;

  void _initialize(const std::string& name="", SubImageBoxd* valuePtr=NULL);
  
#ifdef ML_DEPRECATED



public:

  inline ML_DEPRECATED void setSubImgBoxValue(const SubImageBoxd& value) { setSubImageBoxdValue(value); }
  inline ML_DEPRECATED const SubImageBoxd& getSubImgBoxValue() const { return getSubImageBoxdValue(); }
  inline ML_DEPRECATED void setSubImgBoxfValue(const SubImageBoxd& value) { setSubImageBoxdValue(value); }
  inline ML_DEPRECATED const SubImageBoxd& getSubImgBoxfValue() const { return getSubImageBoxdValue(); }
  
  
#endif // ML_DEPRECATED
  
  
#ifdef ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER



public:

  SubImageBoxdField(const std::string& name, SubImageBoxd* valuePtr);

  
#endif // ML_DEPRECATED_FIELDS_WITH_VALUE_POINTER  
  
};

#ifdef ML_DEPRECATED



ML_DEPRECATED typedef SubImageBoxdField SubImgBoxfField;
#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT UniversalTypeField : public Field 
{
  ML_CLASS_HEADER(UniversalTypeField);

public:
  UniversalTypeField(const std::string& name="", MLDataType dt=-1);

  ~UniversalTypeField();

  virtual MLint isValidValue();
  
  virtual void setStringValue(const std::string& stringValue);
  
  virtual std::string getStringValue() const;
  
  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;


protected:
  virtual void _updateIsValidAndTypeDataFromOrigString();

  virtual void _updateIsValidAndStrValueFromTypeData();


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