MeVisLab/Standard/Sources/ML/MLCSO/CSOBase/CSORules/CSOGroupRules.h

Go to the documentation of this file.

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

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

#ifndef __CSOGroupRules_H
#define __CSOGroupRules_H


#include "MLCSOIncludes.h"


ML_START_NAMESPACE

class CSO;
class CSOGroup;


enum CSOGroupOverflowHandling {
  OVERFLOW_DELETE_FIRST = 0, 
  OVERFLOW_DELETE_LAST  = 1, 
  OVERFLOW_DELETE_ALL   = 2, 
  OVERFLOW_IGNORE_NEW   = 3, 
  NUM_OVERFLOW_MODES    = 4  
};

enum CSORemoveHandling {
  REMOVE_ALWAYS         = 0, 
  REMOVE_NEVER          = 1, 
  REMOVE_IF_IN_NO_GROUP = 2, 
  NUM_REMOVE_MODES      = 3  
};


class MLCSO_EXPORT CSOGroupRules 
{

public:

  CSOGroupRules(unsigned int numMaxCSOs = 0);
  ~CSOGroupRules();

  void reset();

  void setNumMaximumCSOs(unsigned int numMaxCSOs)                        { _numMaxCSOs = numMaxCSOs;             }
  unsigned int getNumMaximumCSOs() const                                 { return _numMaxCSOs;                   }
  void setOverflowHandling(CSOGroupOverflowHandling handling)            { _overflowHandling = handling;         }
  CSOGroupOverflowHandling getOverflowHandling() const                   { return _overflowHandling;             }
  void setRemoveFromGroupHandling(CSORemoveHandling handling)            { _removeFromGroupHandling = handling;  }
  CSORemoveHandling getRemoveFromGroupHandling() const                   { return _removeFromGroupHandling;      }
  void setDeleteGroupCSOHandling(CSORemoveHandling handling)             { _deleteGroupCSOHandling = handling;  }
  CSORemoveHandling getDeleteGroupCSOHandling() const                    { return _deleteGroupCSOHandling;      }
  bool mayAddCSO(CSOGroup& csoGroup) const;

  void applyTo(CSOGroup& csoGroup);
  CSO* addCSO(CSOGroup& csoGroup, bool useUndoRedo=true);
  bool addCSO(CSO& cso, CSOGroup& csoGroup, bool useUndoRedo=true);
  void applyDeletionRule(CSOGroup& csoGroup);


  static unsigned int getDefaultNumMaximumCSOs()                          { return 0;                     }
  static CSOGroupOverflowHandling getDefaultOverflowHandling ()           { return OVERFLOW_DELETE_FIRST; }
  static CSORemoveHandling getDefaultRemoveFromGroupHandling ()           { return REMOVE_IF_IN_NO_GROUP; }
  static CSORemoveHandling getDefaultDeleteGroupCSOHandling ()            { return REMOVE_IF_IN_NO_GROUP; }

  static const char* sOverflowHandlingStrings[NUM_OVERFLOW_MODES];
  static const char* sRemoveHandlingStrings[NUM_REMOVE_MODES];

protected:

  void _removeCSO(CSO& cso, CSOGroup& csoGroup, bool useUndoRedo=true);
  void _removeAllCSO(CSOGroup& csoGroup, bool useUndoRedo=true);

private:


  unsigned int _numMaxCSOs;

  CSOGroupOverflowHandling  _overflowHandling;

  CSORemoveHandling _removeFromGroupHandling;

  CSORemoveHandling _deleteGroupCSOHandling;

};



ML_END_NAMESPACE


#endif // __CSOGroupRules_H