@
void A::mousePressEvent(QMouseEvent *event)
{
QByteArray itemData;
QDataStream dataStream(&itemData, QIODevice::WriteOnly);

// the new function:
prepareDragData(event, dataStream);

QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-dnditemdata", itemData);
drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(QPixmap::grabWidget(this));
drag->setHotSpot(event->pos());

if (acceptDrops())
    drag->exec(Qt::MoveAction);
else
    drag->exec(Qt::CopyAction);

}

void A::prepareDragData(QMouseEvent *event, QDataStream &stream)
{
dataStream << QPoint(event->pos());
}

void B::prepareDragData(QMouseEvent *event, QDataStream &stream)
{
A::prepareDragData(event, stream);
dataStream << 25;
}
@

Additional notes:

• no more need of class variables for the dataStream
• no need for a QBuffer, the dataStream can work directly on a QByteArray

What would you suggest for the setting of the QByteArray? The point is, I want to make sure that subclasses don't need to take care about those things. I want the base class to take care of the clicked points and all the things which come again and again (like the definition of when I make a base class). If there is no other way, I can move the whole dnd code to the subclasses of course.
What do you mean by "it looks strange"? I actually took the dnd example from the website and changed a few things like adding my own object.

So please let me know how to make it better and what you would suggest for the problem of the subclass datastream writing.

@
mimeData->setData("application/x-dnditemdata", *itemData);
@

At this point in time, only the QPoint data has been written to the QDataStream and its underlying byte array.

Once you come back to class B's mousePressEvent function, you write some more data to the byte array, but that never reaches the QDrag object! QDrag takes a copy of the data. At the moment you write to the array in class B, the implicit sharing creates a deep copy of the array and in turn, you end up with two QByteArrays: one that's within the drag object, and one in class B, which is never used again.

As a side note: Your split of code looks very strange to me and in my opinion it cries for additional trouble in the future.

@
class B : public A
{
Q_OBJECT
public:
B(QWidget *parent = NULL, bool acceptDrops = true);
virtual ~B();

protected:
void paintEvent(QPaintEvent *);
void mousePressEvent(QMouseEvent *);
};
@

Here again both methods:

@
void A::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton)
dragStartPosition = event->pos();
itemData = new QByteArray();
b = new QBuffer(itemData);
b->open(QIODevice::WriteOnly);
dataStream.setDevice(b);
dataStream << QPoint(event->pos());
mimeData = new QMimeData;
mimeData->setData("application/x-dnditemdata", *itemData);
drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(QPixmap::grabWidget(this));
drag->setHotSpot(event->pos());
}
@

@
void B::mousePressEvent(QMouseEvent *event)
{
A::mousePressEvent(event);
quint16 val(4);
dataStream << val; //this one can never be read out again...
if (acceptDrops())
drag->exec(Qt::MoveAction);
else
drag->exec(Qt::CopyAction);
}
@

@
class A : public QWidget
{
public:
A(QWidget *parent = NULL, bool acceptDrops = true);
virtual ~A();

protected:
virtual void mousePressEvent(QMouseEvent *);

QPoint dragStartPosition;
QDrag *drag;
QDataStream dataStream;
QByteArray *itemData;
QBuffer *b;
QMimeData *mimeData;

};
@

Just create an object, call the output operator. Then destroy your object; create a new one and call it on your input operator working on the data you have written previously. Don't forget to close the file and re-open it or reset the file pointer to the beginning. Then use a debugger to see what's coming in from the stream. Also, have a look at the file, e.g. by using some hexdump utility. The data is usually pretty straight forward to interpret.

Once you're sure that this all works, go back to the DnD thingie.

@mlong: Why? Now itemData is a member as well. I should be able to delete it but I cannot see the memory leak of the implementation before.

Cheers,
Nikhil