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

Go to the documentation of this file.

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

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

#ifndef __mlAbstractItemModel_H
#define __mlAbstractItemModel_H

#include <mlRefCountedBase.h>

#include <vector>

#include "MLItemModelSystem.h"
#include <mlVariant.h>

ML_START_NAMESPACE

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

class AbstractItemModel;

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(NULL), _userID(0) {}

  inline AbstractItemModel* model() const { return _model; }

  inline bool isValid() const { return _model != NULL; }

  inline void* userPtr() const { return _userPtr; }

  inline size_t userID() const { return _userID; }

  Variant getData(int attributeIndex) const;

  bool operator== (const ModelIndex& index) const;
  bool operator!= (const ModelIndex& index) const;

private:
  friend class AbstractItemModel;
  ModelIndex(AbstractItemModel* model, void* userPtr) : _model(model), _userPtr(userPtr) {}
  ModelIndex(AbstractItemModel* model, size_t userID) : _model(model), _userID(userID) {}

  AbstractItemModel* _model;
  union {
    void* _userPtr;
    size_t _userID;
  };
};

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

class MLITEMMODEL_EXPORT AbstractItemModel : public RefCountedBase
{
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 = NULL);
  
  virtual bool bulkSetData(const std::vector<ModelIndex>& items,
                           int attributeIndex, const Variant& data,
                           void* skipListener = NULL);

  virtual bool bulkSetData(const std::vector<ModelIndex>& items,
                           int attributeIndex, const std::vector<Variant>& data,
                           void* skipListener = NULL);

  ML_ABSTRACT_CLASS_HEADER(AbstractItemModel)
  
protected:  
  AbstractItemModel() {}

  virtual bool rawSetData(const ModelIndex& item, int attributeIndex, const Variant& data) = 0;

  ModelIndex createIndex(void* data);
  ModelIndex createIndex(size_t data);
  

  virtual void notifyItemChanged(const ModelIndex& item, bool after,
                                 void* skipListener = NULL);

  virtual void notifyItemsInserted(const ModelIndex& parent, unsigned int childIndex, unsigned int itemsInserted, bool after,
                                   void* skipListener = NULL); 

  virtual void notifyItemsRemoved(const ModelIndex& parent, unsigned int childIndex, unsigned int itemsRemoved, bool after,
                                  void* skipListener = NULL); 

  virtual void notifyItemsDataChanged(const std::vector<ModelIndex>& items,
                                      const std::vector<int>& attributeIndices,
                                      void* skipListener = NULL); 
};

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 after = false) : ItemModelEvent(), _after(after) {}
  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