Problem with QListView Drag & Drop

hello,

I have a problem with my QListView Drag & Drop. I am using Qt 5.1.

I have implemented a custom object and a custom model which I use with a standard QListView (if I substitute the list view with a QTreeView the code works perfectly).

When I set the view mode as IconMode the following happens :
If I drag & Drop an item in my list view it just disappears. The dropMimeData is never called.
While if I drag my item on top of another item it seems to work (i.e. the dragged item is being added as a child).
If the item is dragged into the empty space it just disappears.

if I set the view mode to ListMode the following happens :
If I drag an item over another item it just disappears, while if I drag it to the end of the list , the item is added at the bottom of the list.

so here is some code

Code:

#include <QApplication>
#include <QListView>
#include <QTreeView>
 
#include "ObjectBase.h"
#include "QtTreeModelBase.h"
 
int main(int argc, char **argv)
{
    QApplication a(argc, argv);
 
    QListView lw;
 
    cObjectBase* pRoot = new cObjectBase(NULL);
    pRoot->setObjectName("Root");
 
    for(int i = 1; i < 10; ++i)
   {
        cObjectBase* pChild = new cObjectBase(pRoot);
        pChild->setObjectName(QString("Item %1").arg(i));
    }
 
    QTreeModelBase* pTreeModelBase = new QTreeModelBase("Objects", pRoot, NULL);
    pTreeModelBase->Reset(pRoot);
 
    lw.setModel(pTreeModelBase);
 
    lw.setDragEnabled(true); 
    lw.viewport()->setAcceptDrops(true); 
    lw.setDefaultDropAction(Qt::MoveAction); 
    lw.setDropIndicatorShown(true); 
    lw.setViewMode(QListView::ListMode);
    lw.setDragDropMode(QAbstractItemView::InternalMove);
 
    lw.show();
 
    a.exec();
}

and here my object

Code:

#ifndef OBJECT_BASE_H
#define OBJECT_BASE_H
 
#include <QObject>
#include <QString>
 
#include <QtCore/QXmlStreamReader>
#include <QtCore/QXmlStreamWriter>
 
#include <QAbstractitemview>
 
class cObjectBase : public QObject
{
	Q_OBJECT
public:
	cObjectBase(cObjectBase* pParent);
	virtual ~cObjectBase();
 
	static const QString ObjectTag;
 
	virtual void SetParent(cObjectBase* pParent, bool bConsiderChildren);
	cObjectBase* GetParent()const;
	void AddChild(cObjectBase* pChild);
	void InsertChild(int row, cObjectBase *pChild);
	void SwapChildren(int oldRow, int newRow);
	cObjectBase* TakeChild(int row);
	cObjectBase* TakeChild(cObjectBase* pChild);
	int RowOfChild(cObjectBase* pChild) const;
	int ChildCount(bool bIgnoreManager) const;
	cObjectBase* ChildAt(int row) const;
	void RemoveAllChildren();  //will not delete children
 
	void WriteToXML(QXmlStreamWriter* pWriter, bool bSkipChildren, bool bDragDrop)const;
	virtual void WriteAttributesToXML(QXmlStreamWriter* pWriter, bool bDragDrop)const;
 
	void ReadFromXML(QXmlStreamReader* pReader, const QString& parentPath, bool bSkipChildren = false);
	virtual void ReadAttributesFromXML(QXmlStreamReader* pReader, bool bDragDrop);
 
protected:
	static const QString NameTag;
 
	cObjectBase* mpParent;
	QList<cObjectBase*> mChildren;
};
 
#endif

implemented as

Code:

#include "ObjectBase.h"
#include "QtTreeModelBase.h"
 
 
const QString cObjectBase::ObjectTag("Object");
 
 
cObjectBase::cObjectBase(cObjectBase* pParent) :
QObject(NULL), //not setting parents on purpose here
mpParent(pParent)
{
	setObjectName("New Object");
	if(pParent)
	{
		pParent->AddChild(this);
	}
}
 
cObjectBase::~cObjectBase()
{
	qDeleteAll(mChildren);
}
 
void cObjectBase::SetParent(cObjectBase* pParent, bool bConsiderChildren)
{
	if(bConsiderChildren)
	{
		if(mpParent)
		{
			if(mpParent != pParent)
			{
				mpParent->TakeChild(this);
			}
		}
 
		if(pParent)
		{
			pParent->AddChild(this);
		}
	}	
 
	mpParent = pParent;
}
 
cObjectBase* cObjectBase::GetParent()const 
{ 
	return mpParent; 
}
 
cObjectBase* cObjectBase::TakeChild(int row)
{
	cObjectBase* pItem = mChildren.takeAt(row);
	Q_ASSERT(pItem);
	pItem->mpParent = 0;
	return pItem;
}
 
cObjectBase* cObjectBase::TakeChild(cObjectBase* pChild)
{
	for (unsigned int row = 0; row < mChildren.count(); ++row)
	{
		cObjectBase* pMyChild = mChildren.at(row);
 
		if(pMyChild == pChild)
		{
			return TakeChild(row);
		}
	}
 
	return NULL;
}
 
void cObjectBase::InsertChild(int row, cObjectBase* pChild)
{ 
	pChild->mpParent = this; 
	mChildren.insert(row, pChild); 
}
 
void cObjectBase::AddChild(cObjectBase* pItem)
{ 
	pItem->SetParent(this, false);
	mChildren << pItem; 
}
 
void cObjectBase::SwapChildren(int oldRow, int newRow)
{ 
	mChildren.swap(oldRow, newRow); 
}
 
int cObjectBase::RowOfChild(cObjectBase* pChild) const
{ 
	return mChildren.indexOf(pChild);
}
 
int cObjectBase::ChildCount(bool bIgnoreManager) const 
{ 
	return mChildren.count(); 
}
 
cObjectBase* cObjectBase::ChildAt(int row) const 
{ 
	return mChildren.value(row); 
}
 
void cObjectBase::RemoveAllChildren()
{
	mChildren.clear();
}
 
const QString cObjectBase::NameTag("Name");
 
void cObjectBase::WriteToXML(QXmlStreamWriter* pWriter, bool bSkipChildren, bool bDragDrop) const
{
	pWriter->writeStartElement(ObjectTag);
 
	WriteAttributesToXML(pWriter, bDragDrop);
 
	foreach(cObjectBase* pChild, mChildren)
	{
		pChild->WriteToXML(pWriter, bSkipChildren, bDragDrop);
	}
 
	pWriter->writeEndElement(); //end "Object"
}
 
void cObjectBase::WriteAttributesToXML(QXmlStreamWriter* pWriter, bool bDragDrop)const
{
	pWriter->writeAttribute(NameTag, objectName());
}
 
void cObjectBase::ReadAttributesFromXML(QXmlStreamReader* pReader, bool bDragDrop)
{
	QString name = pReader->attributes().value(NameTag).toString();
	setObjectName(name);
}

and now the model

Code:

#ifndef QTREEMODELBASE_H
#define QTREEMODELBASE_H
 
#include <QAbstractItemModel>
 
#include <QtCore/QXmlStreamReader>
#include <QtCore/QXmlStreamWriter>
 
class QMimeData;
class cObjectBase;
 
class QTreeModelBase : public QAbstractItemModel
{
	Q_OBJECT
 
public:
	QTreeModelBase(QString columnName, cObjectBase *root, QObject *parent = 0 );
 
	void ResetRoot(cObjectBase* root);
	cObjectBase* GetRoot()const { return mpRootItem; }
 
	virtual Qt::ItemFlags flags( const QModelIndex &index ) const;
	virtual QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const;
 
	QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
 
	int rowCount( const QModelIndex &parent = QModelIndex() ) const;
	virtual int columnCount( const QModelIndex &parent = QModelIndex() ) const;
 
	QModelIndex index( int row, int column, const QModelIndex &parent = QModelIndex() ) const;
	virtual QModelIndex parent( const QModelIndex &index ) const;
 
	cObjectBase* GetBaseObject(const QModelIndex& index ) const;
 
	bool removeRows(int row, int count, const QModelIndex &parent=QModelIndex());
 
	QModelIndex GetObjectIndex(cObjectBase* pObjectBase, const QModelIndex& parent);
	QModelIndex GetObjectIndex(cObjectBase* pObjectBase);
 
	void Reset(cObjectBase* pObjectBase);
 
	Qt::DropActions supportedDragActions() const { return Qt::MoveAction; }
	Qt::DropActions supportedDropActions() const { return Qt::MoveAction; }
 
	QStringList mimeTypes() const;
	QMimeData *mimeData(const QModelIndexList &indexes) const;
	bool dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent);
 
protected:
	QString mColumnName;
	cObjectBase *mpRootItem;
 
private:
	void WriteObjectAndChildren(QXmlStreamWriter *writer, cObjectBase* pItem) const;
	bool ReadObjects(QXmlStreamReader* pReader, cObjectBase* pItem);
};
 
#endif // OBJECTTREEMODEL_H

implemented as

Code:

#include <QMetaObject>
#include <QMimeData>
 
#include "QtTreeModelBase.h"
#include "ObjectBase.h"
 
const QString MimeType = "cObjectBase.xml";
 
QTreeModelBase::QTreeModelBase(QString columnName, cObjectBase *root, QObject *parent ) : 
QAbstractItemModel( parent )
{
	mColumnName = columnName;
	mpRootItem = root;
}
 
void QTreeModelBase::ResetRoot(cObjectBase* root)
{
	mpRootItem = root;
}
 
Qt::ItemFlags QTreeModelBase::flags(const QModelIndex &index) const
{
	return Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsUserCheckable;
}
 
QVariant QTreeModelBase::data( const QModelIndex &index, int role) const
{
	if( !index.isValid() )
		return QVariant();
 
	cObjectBase* pItem = GetBaseObject(index);
 
	if(!pItem)
	{
		return QVariant();
	}
 
	if( role == Qt::DisplayRole )
	{
		switch( index.column() )
		{
		case 0:
			{
				QString name = pItem->objectName();
				return name;
			}
			break;
		default:
			break;
		}
	}
 
	return QVariant();
}
 
QVariant QTreeModelBase::headerData(int section, Qt::Orientation orientation, int role ) const
{
	if( role != Qt::DisplayRole || orientation != Qt::Horizontal )
		return QVariant();
 
	switch( section )
	{
	case 0:
		return mColumnName;
	default:
		return QVariant();
	}
}
 
int QTreeModelBase::rowCount(const QModelIndex &parent ) const
{
	if (parent.isValid() && parent.column() != 0)
		return 0;
 
	cObjectBase* pParentItem = GetBaseObject(parent);
	return pParentItem ? pParentItem->ChildCount(false) : 0;
}
 
int QTreeModelBase::columnCount(const QModelIndex &parent ) const
{
	return 1; //parent.isValid() ? 1 : 0;
}
 
QModelIndex QTreeModelBase::index(int row, int column, const QModelIndex &parent ) const
{
	if (!mpRootItem || row < 0 || column < 0 || column >= 1	|| (parent.isValid() && parent.column() != 0))
		return QModelIndex();
 
	cObjectBase* pParentItem = GetBaseObject(parent);
	Q_ASSERT(pParentItem);
 
	cObjectBase* pItem = pParentItem->ChildAt(row);
	if(pItem)
	{
		QModelIndex index = createIndex(row, column, pItem);
		return index;
	}
 
	return QModelIndex();
}
 
QModelIndex QTreeModelBase::parent(const QModelIndex &index) const
{
	if( !index.isValid() )
		return QModelIndex();
 
	cObjectBase* pChildItem = GetBaseObject(index);
	if(pChildItem)
	{
		cObjectBase* pParentItem = static_cast<cObjectBase*>(pChildItem->GetParent());
		if(pParentItem)
		{
			if(pParentItem == mpRootItem)
			{
				return QModelIndex();
			}
 
			cObjectBase* pGrandParentItem = static_cast<cObjectBase*>(pParentItem->GetParent());
			if(pGrandParentItem)
			{
				int row = pGrandParentItem->RowOfChild(pParentItem);
				return createIndex(row, 0, pParentItem);
			}
		}
	}
 
	return QModelIndex();
}
 
cObjectBase* QTreeModelBase::GetBaseObject(const QModelIndex& index ) const
{
	if( !index.isValid() )
	{
		return mpRootItem;
	}
 
	return static_cast<cObjectBase*>( index.internalPointer() );
}
 
bool QTreeModelBase::removeRows(int row, int count, const QModelIndex &parent)
{
	if(!mpRootItem)
	{
		return false;
	}
 
	cObjectBase* pItem = parent.isValid() ? GetBaseObject(parent) : mpRootItem;
	beginRemoveRows(parent, row, row + count - 1);
	for (int i = 0; i < count; ++i)
	{
		/*delete */pItem->TakeChild(row);
	}
	endRemoveRows();
	layoutChanged();
	return true;
}
 
QModelIndex QTreeModelBase::GetObjectIndex(cObjectBase* pObjectBase, const QModelIndex& parent)
{
	int myRowCount = rowCount(parent);
 
	for(int row = 0; row < myRowCount; ++row)
	{
		QModelIndex i = index(row, 0, parent);
 
		if(i.isValid())
		{
			cObjectBase* pObject = GetBaseObject(i);
			if(pObject == pObjectBase)
			{
				return i;
			}
 
			QModelIndex r = GetObjectIndex(pObjectBase, i);
			if(r.isValid())
			{
				cObjectBase* pObj = GetBaseObject(i);
				if(pObj == pObjectBase)
				{
					return r;
				}
			}
		}
	}
 
	return QModelIndex();
}
 
QModelIndex QTreeModelBase::GetObjectIndex(cObjectBase* pObjectBase)
{
	cObjectBase* pParentObject = pObjectBase->GetParent();
 
	QList<cObjectBase*> parentsList;
 
	while(pParentObject && pParentObject != mpRootItem)
	{
		parentsList.push_front(pParentObject);
 
		pParentObject = pParentObject->GetParent();
	}
 
	QModelIndex parentIndex = QModelIndex();
 
	if(!parentsList.isEmpty())
	{
		cObjectBase* pCurrentItem = (*parentsList.begin());
		parentsList.pop_front();
		parentIndex = GetObjectIndex(pCurrentItem, parentIndex);
 
		while(pCurrentItem && !parentsList.isEmpty())
		{
			pCurrentItem = (*parentsList.begin());
			parentsList.pop_front();
			parentIndex = GetObjectIndex(pCurrentItem, parentIndex);
		}
	}
 
	QModelIndex returnIndex = parentIndex;
 
	return returnIndex;
}
 
void QTreeModelBase::Reset(cObjectBase* pObjectBase)
{
	beginResetModel();
	ResetRoot(pObjectBase);
	endResetModel();
}
 
 
QStringList QTreeModelBase::mimeTypes() const
{
	return QStringList() << MimeType;
}
 
 
QMimeData* QTreeModelBase::mimeData(const QModelIndexList &indexes) const
{
	Q_ASSERT(indexes.count());
	if (indexes.count() != 1)
	{
		return NULL;
	}
 
	cObjectBase* pItem = GetBaseObject(indexes.at(0));
 
	if(pItem)
	{
		QMimeData* pMimeData = new QMimeData;
		QByteArray xmlData;
		QXmlStreamWriter writer(&xmlData);
		WriteObjectAndChildren(&writer, pItem);
		static const int MaxCompression = 9;
		pMimeData->setData(MimeType, qCompress(xmlData, MaxCompression));
		return pMimeData;
	}
 
	return NULL;
}
 
 
bool QTreeModelBase::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
	if (action == Qt::IgnoreAction)
		return true;
 
	if (action != Qt::MoveAction || column > 0 || !mimeData || !mimeData->hasFormat(MimeType))
		return false;
 
	cObjectBase* pItem = GetBaseObject(parent);
 
	if(pItem) 
	{
		QByteArray xmlData = qUncompress(mimeData->data(MimeType));
		QXmlStreamReader reader(xmlData);
		if (row == -1)
		{
			row = parent.isValid() ? parent.row() : mpRootItem->ChildCount(true);
		}
		beginInsertRows(parent, row, row);
		bool bDropped = ReadObjects(&reader, pItem);
		endInsertRows();
		return bDropped;
	}
	return false;
}
 
void QTreeModelBase::WriteObjectAndChildren(QXmlStreamWriter* pWriter, cObjectBase* pItem) const
{
	if(pItem != mpRootItem) 
	{
		pItem->WriteToXML(pWriter, false, true);
	}
}
 
bool QTreeModelBase::ReadObjects(QXmlStreamReader* pReader, cObjectBase* pItem)
{
	while(!pReader->atEnd()) 
	{
		pReader->readNext();
		if(pReader->isStartElement()) 
		{
			if(pReader->name() == cObjectBase::ObjectTag)
			{
				cObjectBase* pNewObject = new cObjectBase(NULL);
				pNewObject->ReadAttributesFromXML(pReader, true);
 
				pItem->AddChild(pNewObject);
				pItem = pNewObject;			
			}
		}
		else if(pReader->isEndElement()) 
		{
			if(pReader->name() == cObjectBase::ObjectTag)
			{
				Q_ASSERT(pItem);
				pItem = pItem->GetParent();
				Q_ASSERT(pItem);
			}
		}
	}
	return true;
}

can anyone see why I have got the drag and drop bug ?
I saw that apparently there was a bug in an earlier version of Qt that sounds very similar but it is claimed fixed.

https://bugreports.qt-project.org/browse/QTBUG-31061