Qt learning path (54): Custom drag and drop Data Objects

In the previous example, we used the drag-and-drop object QMimeData provided by the system to store drag-and-drop data. For example, we used QMimeData: setText () to create a Text object and QMimeData: urls () to create a URL object. However, if you want to use custom objects as drag-and-drop data, such as user-defined classes, QMimeData alone may not be that easy. To implement this operation, we can select one of the following three implementation methods: the first method does not need to inherit any classes, but there are some limitations: Drag and Drop will not happen, we must also convert custom data objects to QByteArray objects. If you want to support many types of drag-and-drop Data, you must use a QMimeData class for each type of data, this may cause a class explosion. If the data is large, this method may reduce the maintainability of the system. However, the last two implementations do not have these problems, or they can reduce these problems and give us full control. Let's take a look at an application and use QTableWidget for drag and drop operations. The drag and drop types include plain/text, plain/html, and plain/csv. If you use the first implementation method, our code will be as follows:

 
 

  
  
void MyTableWidget::mouseMoveEvent(QMouseEvent *event)  
  
  
{  
  
  
    if (event->buttons() & Qt::LeftButton) {  
  
  
        int distance = (event->pos() - startPos).manhattanLength();  
  
  
        if (distance >= QApplication::startDragDistance())  
  
  
            performDrag();  
  
  
    }  
  
  
    QTableWidget::mouseMoveEvent(event);  
  
  
}  
  
  
 
  
  
void MyTableWidget::performDrag()  
  
  
{  
  
  
    QString plainText = selectionAsPlainText();  
  
  
    if (plainText.isEmpty())  
  
  
        return;  
  
  
 
  
  
    QMimeData *mimeData = new QMimeData;  
  
  
    mimeData->setText(plainText);  
  
  
    mimeData->setHtml(toHtml(plainText));  
  
  
    mimeData->setData("text/csv", toCsv(plainText).toUtf8());  
  
  
 
  
  
    QDrag *drag = new QDrag(this);  
  
  
    drag->setMimeData(mimeData);  
  
  
    if (drag->exec(Qt::CopyAction | Qt::MoveAction) == Qt::MoveAction)  
  
  
        deleteSelection();  
  
  
}  
 
 

We should have easily understood this code: In the javasmdrag () function, we call setText () and setHTML () of QMimeData () the function stores plain/text and plain/html data, and uses setData () to store text/csv data as binary QByteArray.

 
 

  
  
QString MyTableWidget::toCsv(const QString &plainText)  
  
  
{  
  
  
    QString result = plainText;  
  
  
    result.replace("\\", "\\\\");  
  
  
    result.replace("\"", "\\\"");  
  
  
    result.replace("\t", "\", \"");  
  
  
    result.replace("\n", "\"\n\"");  
  
  
    result.prepend("\"");  
  
  
    result.append("\"");  
  
  
    return result;  
  
  
}  
  
  
 
  
  
QString MyTableWidget::toHtml(const QString &plainText)  
  
  
{  
  
  
    QString result = Qt::escape(plainText);  
  
  
    result.replace("\t", "<td>");  
  
  
    result.replace("\n", "\n<tr><td>");  
  
  
    result.prepend("<table>\n<tr><td>");  
  
  
    result.append("\n</table>");  
  
  
    return result;  
  
  
}  
 
 

The toCsv () and toHtml () functions extract and convert the data into csv and html data. For example, the following data

Red   Green   BlueCyan  Yellow  Magenta

Convert to csv format:

"Red", "Green", "Blue""Cyan", "Yellow", "Magenta"

Convert to html Format: <table>
<Tr> <td> Red <td> Green <td> Blue
<Tr> <td> Cyan <td> Yellow <td> Magenta
</Table> In the placed function, we use the following as before:

 
 

  
  
void MyTableWidget::dropEvent(QDropEvent *event)  
  
  
{  
  
  
    if (event->mimeData()->hasFormat("text/csv")) {  
  
  
        QByteArray csvData = event->mimeData()->data("text/csv");  
  
  
        QString csvText = QString::fromUtf8(csvData);  
  
  
        // ...  
  
  
        event->acceptProposedAction();  
  
  
    } else if (event->mimeData()->hasFormat("text/plain")) {  
  
  
        QString plainText = event->mimeData()->text();  
  
  
        // ...  
  
  
        event->acceptProposedAction();  
  
  
    }  
  
  
}  
 
 

Although we accept three data types, we only accept two types in this function. As for the html type, we hope that if you drag the QTableWidget data to an HTML editor, it will be automatically converted to html code, however, we do not plan to support dragging external html code to QTableWidget. To make this code work, we need to set setAcceptDrops (true) and setSelectionMode (ContiguousSelection) in the constructor ). Well, the above is the implementation of the first method we mentioned. The complete implementation code is not provided here. You can try it as needed. Next we will re-implement this requirement according to the second method.

 
 

  
  
class TableMimeData : public QMimeData  
  
  
{  
  
  
    Q_OBJECT  
  
  
 
  
  
public:  
  
  
    TableMimeData(const QTableWidget *tableWidget,  
  
  
                  const QTableWidgetSelectionRange &range);  
  
  
 
  
  
    const QTableWidget *tableWidget() const { return myTableWidget; }  
  
  
    QTableWidgetSelectionRange range() const { return myRange; }  
  
  
    QStringList formats() const;  
  
  
 
  
  
protected:  
  
  
    QVariant retrieveData(const QString &format,  
  
  
                          QVariant::Type preferredType) const;  
  
  
 
  
  
private:  
  
  
    static QString toHtml(const QString &plainText);  
  
  
    static QString toCsv(const QString &plainText);  
  
  
 
  
  
    QString text(int row, int column) const;  
  
  
    QString rangeAsPlainText() const;  
  
  
 
  
  
    const QTableWidget *myTableWidget;  
  
  
    QTableWidgetSelectionRange myRange;  
  
  
    QStringList myFormats;  
  
  
};  
 
 

To avoid storing specific data, we store the table and the coordinate pointer of the selected region.

 
 

  
  
TableMimeData::TableMimeData(const QTableWidget *tableWidget,  
  
  
                             const QTableWidgetSelectionRange &range)  
  
  
{  
  
  
    myTableWidget = tableWidget;  
  
  
    myRange = range;  
  
  
    myFormats << "text/csv" << "text/html" << "text/plain";  
  
  
}  
  
  
 
  
  
QStringList TableMimeData::formats() const 
  
  
{  
  
  
    return myFormats;  
  
  
} 
 
 

In the constructor, We initialize private variables. The formats () function returns a list of data types supported by MIME data objects. This list is not sequential, but the best practice is to put the "most suitable" type first. For applications that support multiple types, the first suitable type of storage is sometimes used directly.

 
 

  
  
QVariant TableMimeData::retrieveData(const QString &format,  
  
  
                                     QVariant::Type preferredType) const 
  
  
{  
  
  
    if (format == "text/plain") {  
  
  
        return rangeAsPlainText();  
  
  
    } else if (format == "text/csv") {  
  
  
        return toCsv(rangeAsPlainText());  
  
  
    } else if (format == "text/html") {  
  
  
        return toHtml(rangeAsPlainText());  
  
  
    } else {  
  
  
        return QMimeData::retrieveData(format, preferredType);  
  
  
    }  
  
  
} 
 
 

The retrieveData () function returns the given MIME type as QVariant. The value of the format parameter is usually one of the return values of the formats () function, but we cannot assume that it must be one of the values, because not all applications will pass the formats () function checks the MIME type. Some return functions, such as text (), html (), urls (), imageData (), colorData (), and data () are actually retrieveData () in QMimeData () function. The second parameter preferredType indicates the type of data we should store in QVariant. Here, we simply ignore it, and in the else statement, we assume that QMimeData will automatically convert it to the required type.

 
 

  
  
void MyTableWidget::dropEvent(QDropEvent *event)  
  
  
{  
  
  
    const TableMimeData *tableData =  
  
  
            qobject_cast<const TableMimeData *>(event->mimeData());  
  
  
 
  
  
    if (tableData) {  
  
  
        const QTableWidget *otherTable = tableData->tableWidget();  
  
  
        QTableWidgetSelectionRange otherRange = tableData->range();  
  
  
        // ...  
  
  
        event->acceptProposedAction();  
  
  
    } else if (event->mimeData()->hasFormat("text/csv")) {  
  
  
        QByteArray csvData = event->mimeData()->data("text/csv");  
  
  
        QString csvText = QString::fromUtf8(csvData);  
  
  
        // ...  
  
  
        event->acceptProposedAction();  
  
  
    } else if (event->mimeData()->hasFormat("text/plain")) {  
  
  
        QString plainText = event->mimeData()->text();  
  
  
        // ...  
  
  
        event->acceptProposedAction();  
  
  
    }  
  
  
    QTableWidget::mouseMoveEvent(event);  
  
  
} 
 
 

In the placed function, we need to select the data type according to our own definition. We use the qobject_cast macro to convert the data type. If the conversion succeeds, the data comes from the same application. Therefore, we directly set the QTableWidget data. If the conversion fails, we use the general processing method.

This article is from the "bean space" blog, please be sure to keep this source http://devbean.blog.51cto.com/448512/288742