QMimeData: setting and getting the right MIME type

Using PySide, I construct a draggable label that works exactly how I want:

class DraggableLabel(QtGui.QLabel):
    def __init__(self, txt, parent):
        QtGui.QLabel.__init__(self, txt, parent)
        self.setStyleSheet("QLabel { background-color: rgb(255, 255, 0)}")
    def mouseMoveEvent(self, event):
        drag=QtGui.QDrag(self)
        dragMimeData=QtCore.QMimeData()  
        drag.setMimeData(dragMimeData) 
        drag.exec_(QtCore.Qt.MoveAction)

(Note a full example that uses DraggableLabel is pasted below). Unfortunately, I do not understand what is going on with QMimeData, and fear I am going to run into big problems when I use similar code in real-world examples.

In particular, I am worried that my reimplementation of mouseMoveEvent creates an instance of QMimeData without any argument passed: QtCore.QMimeData(). Is this normal? Within more complex widgets will I be OK if I keep doing that within the relevant event handler: will the program automatically create the right type of MIME data for dragging and dropping?

The reason I fear I am missing something is because at the Qt Drag and Drop documentation, it has lines of code like:

mimeData -> setText(commentEdit->toPlainText());

which seems decidedly not like just letting the program take care of things within a reimplementation of an event handler.

Also, the QMimeData Documentation discusses convenience functions to test, get, and set data, but those are for standard data types (e.g., text, urls). I have found no clear way to define such convenience functions for widgets like my draggable QLabel. Am I missing it? Is there a simple way to find out if I am dragging around a widget of type X?

Edit: I've tried the same code above with much more complicated widgets than QLabels, and it does not work.

Potentially relevant posts:

Dragging a QWidget in QT 5
How to Drag and Drop Custom Widgets?
https://stackoverflow.com/questions/18272650/fill-the-system-clipboard-with-data-of-custom-mime-type Python object in QMimeData

Important Caveat: if you just want to move a widget in a window, you do not need to invoke esoteric drag-drop mechanisms, but more vanilla event handling. See this: Dragging/Moving a QPushButton in PyQt.

Full working self-contained code example that incorporates the above:

# -*- coding: utf-8 -*-
from PySide import QtGui, QtCore

class LabelDrag(QtGui.QWidget):
    def __init__(self):
        QtGui.QWidget.__init__(self)    
        self.initUI()
    def initUI(self):
        self.lbl=DraggableLabel("Drag me", self)  
        self.setAcceptDrops(True)
        self.setGeometry(40,50,200,200)
        self.show()     
    def dragEnterEvent(self,event):
        event.accept()        
    def dropEvent(self, event):  
        self.lbl.move(event.pos())  #moves label to position once the movement finishes (dropped)
        event.accept()  

class DraggableLabel(QtGui.QLabel):
    def __init__(self, txt, parent):
        QtGui.QLabel.__init__(self, txt, parent)
        self.setStyleSheet("QLabel { background-color: rgb(255, 255, 0)}")
    def mouseMoveEvent(self, event):
        drag=QtGui.QDrag(self)
        dragMimeData=QtCore.QMimeData()  
        drag.setMimeData(dragMimeData) 
        drag.exec_(QtCore.Qt.MoveAction)

def main():
    import sys
    qt_app=QtGui.QApplication(sys.argv)
    myMover=LabelDrag()
    sys.exit(qt_app.exec_())

if __name__=="__main__":
    main()

Note I'm posting this at QtCentre as well, will post anything useful from there.

In my experience, MimeData is used to filter drag/drop operations so that the action actually makes sense. For instance, you shouldn't be able to drag your QLabel into the middle of a QTextEdit or your browsers address bar, or the desktop of your computer.

From the docs:

QMimeData is used to describe information that can be stored in the clipboard, and transferred via the drag and drop mechanism. QMimeData objects associate the data that they hold with the corresponding MIME types to ensure that information can be safely transferred between applications, and copied around within the same application.

If you were doing something standard, like dragging/dropping text from one place to another, you would use one of the standard MIME types (like setting the MIME data of your drag using dragMimeData.setText('your text') or equivalently dragMimeData.setData('text/plain', 'your text')). However, since you are doing something completely custom, you should probably specify a custom MIME type so that you can't accidentally do things that don't make sense.

So I would set the MIME data to something like dragMimeData.setData('MoveQLabel', QByteArray('any string you want')) which stores an arbitrary string for the MIME type MoveQLabel. This arbitrary string could be used to look up which widget you want to move at the end of the drag (maybe by storing it's position?).

You should modify your LabelDrag class above to check the MIME type of the event (use event.mimeData() to get the QMimeData object you set when you started the drag), and accept or reject the event depending on whether the MIME type matches MoveQLabel (or whatever you call your custom MIME type). This should be done in both the dragEnterEvent and dropEvent methods. You code would look something like:

def dragEnterEvent(self, event):
    # you may also need to check that event.mimeData() returns a valid QMimeData object
    if event.mimeData().hasFormat('MoveQLabel'):
        event.accept()
    else:
        event.reject()

If you also store some useful MIME data with the MIME type (aka something else instead of 'any string you want' above), you could use it to dynamically select, within LabelDrag.dropEvent, which widget it is that you want to move. You can access it through event.mimeData().data('MoveQLabel'). This means that your QWidget can handle moving multiple labels as it will always move the one that is being dropped.