MeVisLab/Standard/Sources/ML/MLCSO/CSOBase/CSOAttributes.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __CSOAttributes_H
#define __CSOAttributes_H


#include "MLCSOIncludes.h"
#include "CSODefines.h"
#include "CSOPathPoints.h"


#include <mlVariant.h>


ML_START_NAMESPACE

class CSO;
class CSOGroup;


template < typename T >
bool CSOWriteValueToStream(std::ostream& out, const T& value, bool asBinary)
{
  Variant v(value);
  v.write(out, asBinary);
  if (!asBinary) { out << std::endl; }
  return !out.bad();
}

template <>
inline bool CSOWriteValueToStream<Variant>(std::ostream& out, const Variant& value, bool asBinary)
{
  value.write(out, asBinary);
  if (!asBinary) { out << std::endl; }
  return !out.bad();
}

template <>
inline bool CSOWriteValueToStream<CSOPathPoints>(std::ostream& out, const CSOPathPoints& value, bool asBinary)
{
  Variant numPathPoints(value.numPathPoints());
  numPathPoints.write(out, asBinary);
  if (!asBinary) { Variant::writeValue(out, " ", asBinary); }

  for (int k = 0; k < numPathPoints.toInt(); ++k)
  {
    Vector3 pos = value.getPosAt(k);
    for (int i = 0; i < 3; ++i) 
    {
      Variant::writeValue(out, pos[i], asBinary);
      if (!asBinary) { Variant::writeValue(out, " ", asBinary); }
    }
  }
  if (!asBinary) { out << std::endl; }
  return !out.bad();
}


template < typename T >
bool CSOReadValueFromStream(std::istream& in, T& value, bool asBinary)
{
  Variant v;
  v.read(in, asBinary);
  if (!asBinary) { in.ignore(); }
  if (v.isValid())
  {
    value = v.asType<T>();
    return !in.bad();
  }
  else 
  {
    return false;
  }
}

template <>
inline bool CSOReadValueFromStream<Variant>(std::istream& in, Variant& value, bool asBinary)
{
  value.read(in, asBinary);
  if (!asBinary) { in.ignore(); }
  return !in.bad();
}

template <>
inline bool CSOReadValueFromStream<CSOPathPoints>(std::istream& in, CSOPathPoints& value, bool asBinary)
{
  Variant numPathPoints;
  numPathPoints.read(in, asBinary);
  if (!numPathPoints.isValid())
  {
    return false;
  }

  for (int k = 0; k < numPathPoints.toInt(); ++k)
  {
    Vector3 pos;
    for (int i = 0; i < 3; ++i) 
    {
      Variant::readValue(in, pos[i], asBinary);
    }
    value.appendPosition(pos);
  }
  if (!asBinary) { in.ignore(); }
  return !in.bad();
}


class MLCSO_EXPORT CSOAttributes
{

public:

  CSOAttributes();
  ~CSOAttributes();

  void reset();

  bool writeToStream(std::ostream& outStream, bool asBinary) const;
  bool readFromStream(std::istream& inStream, bool asBinary, short version);

  bool saveTo(std::ostream& outStream) const;
  bool saveToASCII(std::ostream& outStream) const;

  void loadFrom(std::istream& inStream, short version, bool swapBytes);
  void loadFromASCII(std::istream& inStream, short version);

  void setCSO(CSO* cso);
  void setCSOGroup(CSOGroup* group);

  std::string label;   
  std::string description;

  int timePointIndex;
  bool showState;
  bool voxelizeState;
  bool editableState;

  Vector3 pathPointColor;
  float pathPointAlpha;
  int pathPointStyle;
  float pathPointWidth;

  int seedPointStyle;
  float seedPointSize;
  Vector3 seedPointColor;
  float seedPointAlpha;

  int voxelWriteMode;
  float voxelWriteValue;


  void setUserData(const std::string& name, Variant value);
  Variant getUserData(const std::string& name) const;
  void getUserDataNames(std::vector< std::string >& names) const;
  void removeUserData(const std::string& name);


private:

  void sendAttributesChangedPreEvent();
  void sendAttributesChangedPostEvent();

  CSO* _associatedCSO;
  CSOGroup* _associatedCSOGroup;

  std::map < std::string, Variant > _variantMap;
};



ML_END_NAMESPACE


#endif // __CSOAttributes_H