mlField.h

Go to the documentation of this file.

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

// ML-includes
#include "mlInitSystemML.h"
#include "mlRuntimeSubClass.h"
#include "mlFieldSensor.h"

ML_START_NAMESPACE

class OutputConnectorField;
class BaseField;
class SoNodeField;
class NotifyField;
class FieldContainer;

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Field
{

public:

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

  //---------------------------------------------------------------------------
  Field(const std::string& name = std::string());

  virtual ~Field();

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

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

  FieldContainer* getFieldContainer() const { return _fieldContainer; }


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

  //----------------------------------------------------------
  const std::string& getName() const                  { return _name; }

  void               setName(const std::string& name) { _name = name; }

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

  //----------------------------------------------------------
  bool isOutputOnly() const;

  void setOutputOnly(bool outputOnly = true);

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

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

  virtual void setStringValue(const std::string& value) =0;

  virtual std::string getStringValue() const =0;

  virtual MLint isValidValue(){ return 1; }


  void copyCStringValue(char* valueBuffer, MLint bufferSize);

  MLint getCStringValueSize(){ return static_cast<MLint>(getStringValue().size()); }


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

  //------------------------------------------------------------------------
  void        attachFieldSensor(FieldSensor* sensor);

  void        detachFieldSensor(FieldSensor* sensor);

  void        detachFieldSensors();

  void                attachField(OutputConnectorField* targetField);
  void                attachField(BaseField* targetField);
  void                attachField(SoNodeField* targetField);
  void                attachField(NotifyField* targetField);

  void                attachField(Field* targetField, bool propagateValueOnConnect);

  void                detachField(Field* targetField);

  void                detachSourceFields();

  void                detachDestinationFields();

  void                detachAllFields();

  size_t              getNumDestinationFields();

  Field*              getDestinationField(size_t index);

  size_t              getNumSourceFields();

  Field*              getSourceField(size_t index);

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

  void enableNotifications(bool flag);

  bool areNotificationsEnabled();

  static void enableNotificationsGlobally(bool flag);

  static bool areNotificationsEnabledGlobally();

  static MLint& enableNotificationsCounterState();

protected:
  void attachSourceField(Field* field);

  void detachSourceField(Field* field);

  void detachFieldInternal(Field* field);

  virtual void setValueFromField(const Field& field);

  std::string _name;

  std::vector <FieldSensor*>     _sensors;

  std::vector <Field*>           _destinationFields;

  std::vector <Field*>           _sourceFields;

  FieldContainer*                _fieldContainer;
  
  struct Flags {
    unsigned int observersWereRemovedInsideTouch:1; 
    unsigned int insideTouch:1;           
    unsigned int notifyAttachmentsFlag:1; 
    unsigned int outputOnly:1;            
  };

  Flags                          _flags;

  static MLint                   _enableNotifications;

private:
  friend class FieldContainer;

  void setFieldContainer(FieldContainer* container) { _fieldContainer = container; }

  ML_ABSTRACT_CLASS_HEADER(Field)


#ifdef ML_DEPRECATED



public:

  #define notifyAttachments touch

#if defined(WIN32) && defined(ML_WARN_DEPRECATED)
  #pragma deprecated("notifyAttachments")
#endif

  inline ML_DEPRECATED void deactivateAttachments() { enableNotifications(false); }
  inline ML_DEPRECATED void activateAttachments() { enableNotifications(true); }
  inline ML_DEPRECATED MLint isActiveAttachments() { return areNotificationsEnabled(); }
  inline ML_DEPRECATED static void disableNotifications() { enableNotificationsGlobally(false); }
  inline ML_DEPRECATED static void enableNotifications() { enableNotificationsGlobally(true); }
  inline ML_DEPRECATED static MLint isEnabledNotifications() { return areNotificationsEnabledGlobally(); }


#endif // ML_DEPRECATED


};

ML_END_NAMESPACE


//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std
{

  MLEXPORT std::ostream& operator<<(std::ostream& s, const ML_NAMESPACE::Field &v);

}


#endif // __mlField_H