mlAbstractItemModel.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2011, 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_ABSTRACT_ITEM_MODEL_H
#define ML_ABSTRACT_ITEM_MODEL_H
 
 
 
#include <mlRefCountedBase.h>
 
#include <vector>
 
#include "MLItemModelSystem.h"
#include <mlVariant.h>
 
ML_START_NAMESPACE
 
//===========================================================================
 
class AbstractItemModel;
class ItemModelProxy;
 
class MLITEMMODEL_EXPORT ModelIndex
// This is analog to QModelIndex
// Note that we skip column and row attributes, they serve no special purpose for us
{
public:
  ModelIndex() : _model(nullptr), _userID(0) {}
  ModelIndex(const ModelIndex& other);
  ~ModelIndex();
 
  inline AbstractItemModel* model() const { return _model; }
 
  inline bool isValid() const { return _model != nullptr; }
 
  inline void* userPtr() const { return _userPtr; }
 
  inline size_t userID() const { return _userID; }
 
  Variant getData(int attributeIndex) const;
 
  const ModelIndex& operator= (const ModelIndex& index);
 
  bool operator== (const ModelIndex& index) const;
  bool operator!= (const ModelIndex& index) const;
 
private:
  friend class AbstractItemModel;
  ModelIndex(AbstractItemModel* model, void* userPtr);
  ModelIndex(AbstractItemModel* model, size_t userID);
 
  AbstractItemModel* _model;
  union {
    void* _userPtr;
    size_t _userID;
  };
};
 
//===========================================================================
 
class MLITEMMODEL_EXPORT AbstractItemModel : public RefCountedBase
{
  friend class ItemModelProxy;
 
public:
 
  virtual bool isFlat() const { return false; }
 
  virtual bool hasChildren(const ModelIndex& parent);
 
  virtual unsigned int getChildCount(const ModelIndex& parent) = 0;
 
  virtual ModelIndex getChild(const ModelIndex& parent, unsigned int index) = 0;
 
  virtual ModelIndex getParent(const ModelIndex& child) = 0;
 
 
  virtual int getAttributeCount() const = 0;
 
  virtual std::string getAttributeName(int index) const = 0;
 
  virtual Variant getAttributeDefault(int index) const;
 
  virtual int getAttributeIndex(const std::string& name);
 
 
  virtual Variant getData(const ModelIndex& item, int attributeIndex) = 0;
 
  virtual bool setData(const ModelIndex& item, int attributeIndex, const Variant& data,
                       void* skipListener = nullptr);
 
  virtual bool bulkSetData(const std::vector<ModelIndex>& items,
                           int attributeIndex, const Variant& data,
                           void* skipListener = nullptr);
 
  virtual bool bulkSetData(const std::vector<ModelIndex>& items,
                           int attributeIndex, const std::vector<Variant>& data,
                           void* skipListener = nullptr);
 
  ML_ABSTRACT_CLASS_HEADER(AbstractItemModel)
 
protected:
  friend class ModelIndex;
 
  AbstractItemModel() {}
 
  virtual bool rawSetData(const ModelIndex& item, int attributeIndex, const Variant& data) = 0;
 
  ModelIndex createIndex(void* data);
  ModelIndex createIndex(size_t data);
 
  virtual void incItemRefCount(void*) {}
  virtual void decItemRefCount(void*) {}
 
 
  virtual void notifyItemChanged(const ModelIndex& item, bool after,
                                 void* skipListener = nullptr);
 
  virtual void notifyItemsInserted(const ModelIndex& parent, unsigned int childIndex, unsigned int itemsInserted, bool after,
                                   void* skipListener = nullptr);
 
  virtual void notifyItemsRemoved(const ModelIndex& parent, unsigned int childIndex, unsigned int itemsRemoved, bool after,
                                  void* skipListener = nullptr);
 
  virtual void notifyItemsDataChanged(const std::vector<ModelIndex>& items,
                                      const std::vector<int>& attributeIndices,
                                      void* skipListener = nullptr);
};
 
ML_REFCOUNTED_PTR(AbstractItemModel)
 
//===========================================================================
// event classes
 
 
class MLITEMMODEL_EXPORT ItemModelEvent : public BaseEvent
{
public:
  ItemModelEvent() {}
  AbstractItemModel* model() const { return static_cast<AbstractItemModel*>(source()); }
 
  ML_ABSTRACT_CLASS_HEADER(ItemModelEvent)
};
 
//---------------------------------------------------------------------------
 
class MLITEMMODEL_EXPORT TwoPhaseItemModelEvent : public ItemModelEvent
{
public:
  TwoPhaseItemModelEvent(bool afterArg = false) : ItemModelEvent(), _after(afterArg) {}
  bool after() const { return _after; }
 
  ML_ABSTRACT_CLASS_HEADER(TwoPhaseItemModelEvent)
 
private:
  bool _after;
};
 
//---------------------------------------------------------------------------
 
class MLITEMMODEL_EXPORT ItemsInsertedEvent : public TwoPhaseItemModelEvent
{
public:
  ItemsInsertedEvent(const ModelIndex& parentIndex, unsigned int position, unsigned int itemsInserted, bool after);
 
  const ModelIndex& parentIndex() const { return _parentIndex; }
  unsigned int position() const { return _position; }
  unsigned int itemsInserted() const { return _itemsInserted; }
 
  ML_CLASS_HEADER(ItemsInsertedEvent)
 
private:
  ItemsInsertedEvent() {}
 
  ModelIndex _parentIndex;
  unsigned int _position;
  unsigned int _itemsInserted;
};
 
//---------------------------------------------------------------------------
 
class MLITEMMODEL_EXPORT ItemsRemovedEvent : public TwoPhaseItemModelEvent
{
public:
  ItemsRemovedEvent(const ModelIndex& parentIndex, unsigned int position, unsigned int itemsInserted, bool after);
 
  const ModelIndex& parentIndex() const { return _parentIndex; }
  unsigned int position() const { return _position; }
  unsigned int itemsRemoved() const { return _itemsRemoved; }
 
  ML_CLASS_HEADER(ItemsRemovedEvent)
 
private:
  ItemsRemovedEvent() {}
 
  ModelIndex _parentIndex;
  unsigned int _position;
  unsigned int _itemsRemoved;
};
 
//---------------------------------------------------------------------------
 
class MLITEMMODEL_EXPORT ItemChangedEvent : public TwoPhaseItemModelEvent
{
public:
  ItemChangedEvent(const ModelIndex& index, bool after);
 
  const ModelIndex& index() const { return _index; }
 
  ML_CLASS_HEADER(ItemChangedEvent)
 
private:
  ItemChangedEvent() {}
 
  ModelIndex _index;
};
 
//---------------------------------------------------------------------------
 
class MLITEMMODEL_EXPORT ItemsDataChangedEvent : public ItemModelEvent
{
public:
  ItemsDataChangedEvent(const std::vector<ModelIndex>& itemIndices,
    const std::vector<int>& attributeIndices);
 
  const std::vector<ModelIndex>& itemIndices() const { return _itemIndices; }
  const std::vector<int>& attributeIndices() const { return _attributeIndices; }
 
  ML_CLASS_HEADER(ItemsDataChangedEvent)
 
private:
  ItemsDataChangedEvent() {}
 
  std::vector<ModelIndex> _itemIndices;
  std::vector<int> _attributeIndices;
};
 
//===========================================================================
 
ML_END_NAMESPACE
 
#endif // __mlAbstractItemModel_H