MeVisLab/Standard/Sources/ML/MLBase/mlListContainer.h

Go to the documentation of this file.

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

//
// Defines the following classes:
// - ListContainerBase: An abstract ML module class implementing basic functionality 
//     for a list container module.
// - ListContainerTemplate: Class template for container modules for a specific list 
//     class. Can also be used as a base class for viewer or editor modules.
//----------------------------------------------------------------------------------



#ifndef __mlListContainer_H
#define __mlListContainer_H


// ML-includes
#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif
#ifndef __mlBaseInit_H
#include "mlBaseInit.h"
#endif


// Local includes
#ifndef __mlListBase_H
#include "mlListBase.h"
#endif
#ifndef __mlRangeCasts_H
#include "mlRangeCasts.h"
#endif


ML_START_NAMESPACE


typedef bool ListContainerHandleNotificationCB(void *usrData, Field* field);

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

class MLBASEEXPORT ListContainerBase : public Module
{
    
public:
    
    ListContainerBase():Module(0,0) {};
    
    ListContainerBase (ListBase *listBasePtr, int inputNum, int outputNum);
    


    virtual void handleNotification (Field *field);
    
    virtual void activateAttachments ();
    
    virtual void beginSaveFields ();
    
    virtual void endSaveFields ();
    
    
    
    void setHandleNotificationCB (ListContainerHandleNotificationCB *cb = NULL, 
        void *userData = NULL);
    
    


    virtual void doDeleteAll ();
    
    virtual void doDeleteItem (MLssize_t index);
    
    virtual void doInsertItem (MLssize_t index, bool fromCurrentItem);
    
    virtual void doModifyItem (MLssize_t index, Field *field, bool fromCurrentItem);

    virtual void doCopyItemToTemplate (MLssize_t index);

    virtual void doClearItem (MLssize_t index);

    virtual void doSelectItem (MLssize_t index);
    
    virtual void doUpdate ();
    
    
    BaseField* getOutputField() { return _fldOutputList; }

    // Returns the maximum number of items.
    MLint maxNumItems() const { return _fldMaxSize->getIntValue(); }

    enum OverflowModes
    {
        OvwNone = 0,             
        OvwRemoveFirst,          
        OvwRemoveLast,           
        OvwRemoveAll,            
        OvwRemoveNew,            
        OvwNumModes              
    };
    
    int overflowMode() const { return _fldOverflowMode->getEnumValue(); }

    
protected:
    


    virtual ListBase *getInternalList () = 0;
    
    virtual bool setActiveList (Base *basePtr) = 0;
    
    virtual bool ownsList () 
    { return !_fldInputList || (_listBasePtr != _fldInputList->getBaseValue()); }
    
    virtual MLssize_t getId (MLssize_t index) = 0;
    
    
    


    virtual bool isPropertyField (Field *field);
    
    virtual void resetPropertyFields ();
    
    virtual void updatePropertyFields () = 0;
    
    
    


    virtual void deleteItems (MLssize_t index, MLssize_t num) = 0;
    
    virtual void insertItem (MLssize_t index, bool fromCurrentItem) = 0;
    
    virtual bool modifyItem (MLssize_t index, Field *field, bool fromCurrentItem) = 0;

    virtual void copyItemToTemplate (MLssize_t index) = 0;

    virtual void copyTemplateToCurrent () = 0;
    
    virtual void initItem (MLssize_t index) = 0;

    
    



    virtual void updateListString (bool forceEnable = false);
    
    virtual void updateDisplay ();
    
    virtual void updateActionFields ();
    
    virtual void touchList (ListBase::ActionClass actionClass, MLssize_t id, MLssize_t index);
    
    
    
    

    
    BaseField *_fldOutputList;           
    BaseField *_fldInputList;            
    
    StringField *_fldListString;         
    IntField *_fldNumItems;              
    IntField *_fldIndex;                 
    
    BoolField *_fldPersistent;           
    BoolField *_fldListStringEnable;     
    BoolField *_fldOwnsList;             
    BoolField *_fldApplySelect;          
    
    IntField *_fldId;                    
    StringField *_fldName;               
    StringField *_fldNewName;            
    
    StringField *_fldActionClass;        
    IntField *_fldActionIndex;           
    IntField *_fldActionId;              
    IntField *_fldCurrentIndex;          
    
    EnumField *_fldOverflowMode;         
    IntField *_fldMaxSize;               
    
    NotifyField *_fldDelete;             
    NotifyField *_fldDeleteAll;          
    NotifyField *_fldInsert;             
    NotifyField *_fldAdd;                
    NotifyField *_fldUpdate;             

    BoolField *_fldUseInsertTemplate;    
    NotifyField *_fldCopyItemToTemplate; 
    NotifyField *_fldCopyTemplateToItem; 
    NotifyField *_fldClearItem;          

    BoolField *_fldUpToDate;             
    
    
    
    int _lockNotification;               
    
    
private:
    
    ListBase *_listBasePtr;
    
    std::string _listStringBackup;
    
    ListContainerHandleNotificationCB *_handleNotificationCB;

    void*                              _handleNotificationUserData;
    
    ML_ABSTRACT_MODULE_CLASS_HEADER(ListContainerBase)
        
};






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

  template <class T>
      class ListContainerTemplate : public ListContainerBase
  {
public:
    
    ListContainerTemplate (int inputNum, int outputNum);
    
    virtual ~ListContainerTemplate () {}
    
    
    virtual T *getList () { return _listPtr; }
    
    
    typename T::itemType _currentItem;
    
    
protected:
    

    
    virtual bool setActiveList (Base *basePtr);
    
    virtual ListBase *getInternalList () { return &_list; }
    
    virtual MLssize_t getId (MLssize_t index);
    
    
    


    virtual void updatePropertyFields ();
    
    
    
    


    virtual void deleteItems (MLssize_t index, MLssize_t num);
    
    virtual void insertItem (MLssize_t index, bool fromCurrentItem);
    
    virtual bool modifyItem (MLssize_t index, Field *field, bool fromCurrentItem);
    
    virtual void copyItemToTemplate (MLssize_t index);

    virtual void copyTemplateToCurrent ();

    virtual void initItem (MLssize_t index);
    
    
    
    T *_listPtr;
    
private:
    
    //------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------
    ListContainerTemplate(const ListContainerTemplate &)
    {
        ML_PRINT_FATAL_ERROR("ListContainerTemplate::ListContainerTemplate(const ListContainerTemplate &)",
            ML_PROGRAMMING_ERROR,
            "Usage of copy constructor of ListContainerTemplate is not supported.");
    }
    
    //------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------
    ListContainerTemplate& operator=(const ListContainerTemplate &)
    {
        ML_PRINT_FATAL_ERROR("ListContainerTemplate& ListContainerTemplate::operator=(const ListContainerTemplate &)",
            ML_PROGRAMMING_ERROR,
            "Usage of assignment operator of ListContainerTemplate is not supported.");
        return *this;
    }
    
    
    
    T _list;
    
};


template <class T>
ListContainerTemplate<T>::ListContainerTemplate (int inputNum, int outputNum)
: ListContainerBase(&_list, inputNum, outputNum), 
_listPtr(&_list)
{

    ML_TRACE_IN("template <class T>ListContainerTemplate<T>::ListContainerTemplate (int inputNum, int outputNum):ListContainerBase(&_list, inputNum, outputNum), _listPtr(&_list)");
  
    // Suppress handleNotification()
    _lockNotification = 1;
    
    // Get runtime type and name of this class and check for valid registration.
    const RuntimeType *rt = T::getClassTypeId();
    ML_CHECK_RUNTIME_TYPE(rt);
    std::string rtName = rt->getName();
    
    // Add output list field
    
    std::string listFieldName = std::string("out")+rtName;
    
    _fldOutputList = getFieldContainer()->addBase(listFieldName.c_str());
    _fldOutputList->setBaseValueAndAddAllowedType(_listPtr);
    
    // Add input list field
    listFieldName = std::string("in")+rtName;
    _fldInputList = getFieldContainer()->addBase(listFieldName.c_str());
    _fldInputList->setBaseValueAndAddAllowedType<ListBase>(NULL);
    
    // Allow handleNotification()
    _lockNotification = 0;
}


template <class T>
bool ListContainerTemplate<T>::setActiveList (Base *basePtr)
{

    ML_TRACE_IN("template <class T> bool ListContainerTemplate<T>::setActiveList (Base *basePtr)");

    bool listValid = false;
    
    if (basePtr && ML_BASE_IS_A(basePtr, T))
    {
        _listPtr = static_cast<T*>(basePtr);
        listValid = true;
    } else {
        _listPtr = NULL;
    }
    
    return listValid;
}


template <class T>
MLssize_t ListContainerTemplate<T>::getId (MLssize_t index)
{

    ML_TRACE_IN("template <class T> MLssize_t ListContainerTemplate<T>::getId (MLssize_tindex)");

    return (_listPtr && (index >= 0) && (index < static_cast<MLssize_t>(_listPtr->size())) ) 
        ? (*_listPtr)[mlrange_cast<size_t>(index)].getId() : -1;
}


template <class T>
void ListContainerTemplate<T>::updatePropertyFields ()
{

    ML_TRACE_IN("template <class T> void ListContainerTemplate<T>::updatePropertyFields ()");

    const MLssize_t index = _fldIndex->getIntValue();
    
    if (_listPtr && (index >= 0) && (index < static_cast<MLssize_t>(_listPtr->size())) )
    {
        _lockNotification++;
        
        const BaseItem *item = &(*_listPtr)[mlrange_cast<size_t>(index)];
        
        _fldId->setIntValue(item->getId());
        _fldName->setStringValue(item->name() ? item->name() : "");
        
        _lockNotification--;
    }
}


template <class T>
void ListContainerTemplate<T>::deleteItems (MLssize_t index, MLssize_t num)
{

    ML_TRACE_IN("template <class T> void ListContainerTemplate<T>::deleteItems (MLssize_t index, MLssize_t num)");

    ML_TRY{
      typename T::iterator it;
      const MLssize_t listSize = static_cast<MLssize_t>(_listPtr->size());
      if (_listPtr && (index >= 0) && (index < listSize) && (num > 0))
      {
          if (index+num > listSize){
              num = listSize-index;
          }
          it = _listPtr->begin()+index;
          _listPtr->erase(it, it+num);
      }
    }
    ML_CATCH_RETHROW;
}


template <class T>
void ListContainerTemplate<T>::insertItem (MLssize_t index, bool fromCurrentItem)
{

    ML_TRACE_IN("template <class T> void ListContainerTemplate<T>::insertItem (MLssize_t index, bool fromCurrentItem)");

    ML_TRY{
      if (_listPtr && (index >= 0) && (index <= static_cast<MLssize_t>(_listPtr->size())) )
      {
          if (fromCurrentItem)
          {
              // Generate new id and store in _currentItem
              _currentItem.setId(_listPtr->newId());
              // Insert copy of _currentItem
              _listPtr->insert(_listPtr->begin()+index, _currentItem);
            
          } else {
            
              typename T::itemType tmpItem;
              // Insert new item and initialize
              _listPtr->insert(_listPtr->begin()+index, tmpItem);

              // explicitly set the name to an empty string, 
              // because the initial name is a NULL pointer using an item's standard constructor
              (*_listPtr)[mlrange_cast<size_t>(index)].setName("");

              initItem(index);
          }
      }
    }
    ML_CATCH_RETHROW;
}


template <class T>
bool ListContainerTemplate<T>::modifyItem (MLssize_t index, Field *field, bool fromCurrentItem)
{

    ML_TRACE_IN("template <class T> bool ListContainerTemplate<T>::modifyItem (MLssize_t index, Field *field, bool fromCurrentItem)");

    ML_TRY{
      bool modified = true;
    
      if (_listPtr && (index >= 0) && (index < static_cast<MLssize_t>(_listPtr->size())) )
      {
          if (fromCurrentItem){
            
              // Copy _currentItem to list item
              (*_listPtr)[mlrange_cast<size_t>(index)] = _currentItem;
          }
          else if (field == _fldId)
          {
              // Reject change to item id
              _fldId->setIntValue((*_listPtr)[mlrange_cast<size_t>(index)].getId());
              modified = false;
          }else if (field == _fldName) {
              // Change item name
              (*_listPtr)[mlrange_cast<size_t>(index)].setName(_fldName->getStringValue().c_str());
          } else {
              // Not a property field
              modified = false;
          }
      } else {
          // Invalid item or list
          modified = false;
      }
    
      return modified;
    }
    ML_CATCH_RETHROW;
}

template <class T>
void ListContainerTemplate<T>::copyItemToTemplate(MLssize_t index)
{

  ML_TRACE_IN("template <class T> void ListContainerTemplate<T>::copyItemToTemplate(MLssize_t index)");

  typename T::itemType *item= &(*_listPtr)[mlrange_cast<size_t>(index)];

  _fldNewName->setStringValue( item->name() ? item->name() : "" );

}

template <class T>
void ListContainerTemplate<T>::copyTemplateToCurrent()
{

  ML_TRACE_IN("template <class T> void ListContainerTemplate<T>::copyTemplateToCurrent()");

  _currentItem.setName( _fldNewName->getStringValue().c_str() );

}

template <class T>
void ListContainerTemplate<T>::initItem (MLssize_t index)
{

    ML_TRACE_IN("template <class T> void ListContainerTemplate<T>::initItem (MLssize_t index)");

    typename T::itemType *item= &(*_listPtr)[mlrange_cast<size_t>(index)];

    if (item->getId() == 0) {
      // only assign a new id if the id is 0, 
      // because we do not want to assign a new id if the clear-field is triggered
      // (0 is the initial id of an item, the first id returned by newId is 1)
      item->setId(_listPtr->newId());
    }

    item->setName("");

}


ML_END_NAMESPACE

#endif // __mlListContainer_H