mlListContainer.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_LIST_CONTAINER_H
#define ML_LIST_CONTAINER_H
 
 
 
// 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.
 
// ML-includes
#include "mlModuleIncludes.h"
#include "mlBaseInit.h"
 
 
 
#include "mlListBase.h"
#include "mlRangeCasts.h"
 
 
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);
 
    void handleNotification (Field *field) override;
 
    void activateAttachments () override;
 
    void beginSaveFields () override;
 
    void endSaveFields () override;
 
    
 
    void setHandleNotificationCB (ListContainerHandleNotificationCB *cb = nullptr,
        void *userData = nullptr);
 
 
    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 ();
 
 
    void notify();
 
    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;             
 
    BoolField* _fldAutoCopyAndTakeOwnership;    
    NotifyField* _fldCopyAndTakeOwnership;      
 
 
    int _lockNotification;               
 
 
private:
 
    ListBase *_listBasePtr;
 
    std::string _listStringBackup;
 
    ListContainerHandleNotificationCB *_handleNotificationCB;
 
    void*                              _handleNotificationUserData;
 
    void _copyAndTakeOwnership();
 
    ML_ABSTRACT_MODULE_CLASS_HEADER(ListContainerBase)
 
};
 
 
 
 
 
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------
 
  template <class T>
      class ListContainerTemplate : public ListContainerBase
  {
public:
 
    ListContainerTemplate (int inputNum, int outputNum);
 
    ~ListContainerTemplate () override {}
 
 
    virtual T *getList () { return _listPtr; }
 
 
    typename T::itemType _currentItem;
 
 
protected:
 
 
    bool setActiveList (Base *basePtr) override;
 
    ListBase *getInternalList () override { return &_list; }
 
    MLssize_t getId (MLssize_t index) override;
 
 
 
    void updatePropertyFields () override;
 
 
 
 
    void deleteItems (MLssize_t index, MLssize_t num) override;
 
    void insertItem (MLssize_t index, bool fromCurrentItem) override;
 
    bool modifyItem (MLssize_t index, Field *field, bool fromCurrentItem) override;
 
    void copyItemToTemplate (MLssize_t index) override;
 
    void copyTemplateToCurrent () override;
 
    void initItem (MLssize_t index) override;
 
 
 
    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)
{
 
    // 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 = addBase(listFieldName.c_str());
    _fldOutputList->setBaseValueAndAddAllowedType(_listPtr);
 
    // Add input list field
    listFieldName = std::string("in")+rtName;
    _fldInputList = addBase(listFieldName.c_str());
    _fldInputList->setBaseValueAndAddAllowedType<ListBase>(nullptr);
 
    // Allow handleNotification()
    _lockNotification = 0;
}
 
 
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 = nullptr;
    }
 
    return listValid;
}
 
 
template <class T>
MLssize_t ListContainerTemplate<T>::getId (MLssize_t index)
{
 
    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 ()
{
 
    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)
{
    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);
    }
}
 
 
template <class T>
void ListContainerTemplate<T>::insertItem (MLssize_t index, bool fromCurrentItem)
{
    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);
        }
    }
}
 
 
template <class T>
bool ListContainerTemplate<T>::modifyItem (MLssize_t index, Field *field, bool fromCurrentItem)
{
    bool modified = true;
 
    if (_listPtr && (index >= 0) && (index < static_cast<MLssize_t>(_listPtr->size())) )
    {
        if (fromCurrentItem){
 
          // Copy _currentItem to list item
          const MLssize_t oldId = (*_listPtr)[mlrange_cast<size_t>(index)].getId();
          (*_listPtr)[mlrange_cast<size_t>(index)] = _currentItem;
          (*_listPtr)[mlrange_cast<size_t>(index)].setId(oldId);
        }
        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;
}
 
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()
{
 
  _currentItem.setName( _fldNewName->getStringValue().c_str() );
 
}
 
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