mlStandardItemModel.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_STANDARD_ITEM_MODEL_H
#define ML_STANDARD_ITEM_MODEL_H
 
 
 
#include <mlAbstractItemModel.h>
 
#include <vector>
#include <boost/unordered_map.hpp>
 
ML_START_NAMESPACE
 
class MLITEMMODEL_EXPORT StandardItemModel : public AbstractItemModel
{
public:
 
  struct Attribute
  {
    Attribute(const std::string& nameArg, const Variant& defaultValueArg = Variant()) {
      this->name = nameArg;
      this->defaultValue = defaultValueArg;
    }
 
    std::string name;
    Variant     defaultValue;
  };
 
  typedef std::vector<Attribute> AttributeVector;
 
  typedef boost::unordered_map<int, Variant> ItemData;
  typedef std::vector<ItemData>              ItemDataVector;
 
 
  StandardItemModel(const AttributeVector& attributes,
                    int hasChildrenAttribute = -1,
                    bool flat = false);
 
  StandardItemModel();
 
  bool isFlat() const override { return _isFlat; }
  bool hasChildren(const ModelIndex& parent) override;
  unsigned int getChildCount(const ModelIndex& parent) override;
  ModelIndex getChild(const ModelIndex& parent, unsigned int index) override;
  ModelIndex getParent(const ModelIndex& child) override;
  int getAttributeCount() const override;
  std::string getAttributeName(int index) const override;
  Variant getAttributeDefault(int index) const override;
  Variant getData(const ModelIndex& item, int attributeIndex) override;
  bool rawSetData(const ModelIndex& item, int attributeIndex, const Variant& data) override;
 
  virtual int getChildPosition(const ModelIndex& child);
 
  virtual void clear();
 
  virtual void insertItems(const ModelIndex& parent, unsigned int position,
                           const ItemDataVector& items);
 
  virtual ModelIndex addItem(const ModelIndex& parent, const ItemData&);
 
  virtual void removeItems(const ModelIndex& parent, unsigned int position, unsigned int numItems);
 
  bool implementsPersistence(PersistenceInterface iface) const override { return iface == Base::PersistenceByStream; }
  void writeTo(AbstractPersistenceOutputStream* stream) const override;
  void readFrom(AbstractPersistenceInputStream* stream, int version) override;
 
  ML_CLASS_HEADER(StandardItemModel)
 
protected:
  // StandardItemModel should only be deleted by the shared pointer -
  // embedding a StandardItemModel as a member of another class/struct, which is automatically
  // deleted, conflicts with the reference counting of the RefCountedBase class.
  ~StandardItemModel() override;
 
  // Sends event notifying listeners that the children of an item are requested for the first time.
  void notifyItemChildrenRequest(const ModelIndex& parent);
 
private:
  class ItemEntry
  {
  public:
    ItemEntry(ItemEntry* aParent = nullptr);
    ~ItemEntry();
 
    void writeTo(AbstractPersistenceOutputStream* stream, const std::vector<std::string>& attributeNames) const;
 
    void readFrom(AbstractPersistenceInputStream* stream, int version, const boost::unordered_map<std::string, int>& attributeIndices);
 
    ItemEntry* parent;
    ItemData   data;
    std::vector<ItemEntry*> children;
    bool incomplete;
  };
 
  ModelIndex itemToIndex(ItemEntry* entry);
  ItemEntry* indexToItem(const ModelIndex& index);
 
  AttributeVector _attributes;
 
  ItemEntry* _rootItem;
 
  ItemEntry* _incompleteParent;
 
  int _hasChildrenAttribute;
 
  bool _isFlat;
};
 
ML_REFCOUNTED_PTR(StandardItemModel)
 
//===========================================================================
// event classes
 
 
class MLITEMMODEL_EXPORT ItemChildrenRequestEvent : public ItemModelEvent
{
public:
  ItemChildrenRequestEvent(const ModelIndex& parentIndexArg) : _parentIndex(parentIndexArg) {}
 
  const ModelIndex& parentIndex() const { return _parentIndex; }
 
  ML_CLASS_HEADER(ItemChildrenRequestedEvent)
 
private:
  ItemChildrenRequestEvent() {}
 
  ModelIndex _parentIndex;
};
 
 
ML_END_NAMESPACE
 
#endif // __mlStandardItemModel_H