MeVisLab/Standard/Sources/Shared/MLItemModel/mlStandardItemModel.h

Go to the documentation of this file.

// **InsertLicense** code
//===========================================================================

//===========================================================================

#ifndef __mlStandardItemModel_H
#define __mlStandardItemModel_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& name, const Variant& defaultValue = Variant()) {
      this->name = name;
      this->defaultValue = defaultValue;
    }

    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);

  StandardItemModel();

  virtual ~StandardItemModel();

  virtual bool hasChildren(const ModelIndex& parent);
  virtual unsigned int getChildCount(const ModelIndex& parent);
  virtual ModelIndex getChild(const ModelIndex& parent, unsigned int index);
  virtual ModelIndex getParent(const ModelIndex& child);
  virtual int getAttributeCount() const;
  virtual std::string getAttributeName(int index) const;
  virtual Variant getAttributeDefault(int index) const;
  virtual Variant getData(const ModelIndex& item, int attributeIndex);
  virtual bool rawSetData(const ModelIndex& item, int attributeIndex, const Variant& data);

  virtual void clear();

  virtual void insertItems(const ModelIndex& parent, unsigned int position,
                           const ItemDataVector& items);

  virtual void removeItems(const ModelIndex& parent, unsigned int position, unsigned int numItems);
  

  virtual bool implementsPersistence(PersistenceInterface iface) const { return iface == Base::PersistenceByStream; }
  virtual void writeTo(AbstractPersistenceOutputStream* stream) const;
  virtual void readFrom(AbstractPersistenceInputStream* stream, int version);

  ML_CLASS_HEADER(StandardItemModel)

protected:
  // send 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 = NULL);
    ~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;
};

ML_REFCOUNTED_PTR(StandardItemModel)

//===========================================================================
// event classes





class MLITEMMODEL_EXPORT ItemChildrenRequestEvent : public ItemModelEvent
{
public:
  ItemChildrenRequestEvent(const ModelIndex& parentIndex) : _parentIndex(parentIndex) {}

  const ModelIndex& parentIndex() const { return _parentIndex; }

  ML_CLASS_HEADER(ItemChildrenRequestedEvent)

private:
  ItemChildrenRequestEvent() {}

  ModelIndex _parentIndex;
};


ML_END_NAMESPACE

#endif // __mlStandardItemModel_H