QMimeData * DraggableListWidget::mimeData ( const QList<QListWidgetItem *> items ) const
{
QString texts;
foreach (QListWidgetItem *item, items)
{
texts += item->text();
}
QMimeData *mimeData = new QMimeData();
mimeData->setText(texts);
return mimeData;
}
void QLineEditPrivate::drag()
{
Q_Q(QLineEdit);
dndTimer.stop();
QMimeData *data = new QMimeData;
data->setText(control->selectedText());
QDrag *drag = new QDrag(q);
drag->setMimeData(data);
Qt::DropAction action = drag->start();
if (action == Qt::MoveAction && !control->isReadOnly() && drag->target() != q)
control->removeSelection();
}
/*!
* \author Anders Fernström
* \date 2006-01-23
*
* \brief If the mimedata that should be insertet contain text,
* create a new mimedata object that only contains text, otherwise
* text format is insertet also - don't want that for inputcells.
*/
void MyTextEdit::insertFromMimeData(const QMimeData *source)
{
if( source->hasText() )
{
QMimeData *newSource = new QMimeData();
newSource->setText( source->text() );
QTextBrowser::insertFromMimeData( newSource );
delete newSource;
}
else
QTextBrowser::insertFromMimeData( source );
}
void ExtendedTableWidget::mouseMoveEvent(QMouseEvent * event)
{
QTableWidgetItem *item = itemAt(event->pos());
if (item) {
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
mimeData->setText(item->text());
mimeData->setData(NUMBER_MIMETYPE, "");
drag->setMimeData(mimeData);
drag->start(Qt::CopyAction | Qt::MoveAction);
}
}
void Pasteboard::writePlainText(const String& text, SmartReplaceOption smartReplaceOption)
{
#ifndef QT_NO_CLIPBOARD
QMimeData* md = new QMimeData;
QString qtext = text;
qtext.replace(QChar(0xa0), QLatin1Char(' '));
md->setText(qtext);
if (smartReplaceOption == CanSmartReplace)
md->setData(QLatin1String("application/vnd.qtwebkit.smartpaste"), QByteArray());
QGuiApplication::clipboard()->setMimeData(md, m_selectionMode ? QClipboard::Selection : QClipboard::Clipboard);
#endif
}
void WorksheetPrivate::copy()
{
QTextCursor cr = ws->textCursor();
if (cr.hasSelection())
{
QString text = cr.selectedText();
text.replace(QChar(QChar::ParagraphSeparator), "\n");
QMimeData *data = new QMimeData;
data->setText(text);
QApplication::clipboard()->setMimeData(data);
}
}
void ExperimentGraphBlockItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (QLineF(event->screenPos(), event->buttonDownScreenPos(Qt::LeftButton)).length() < 5) //QApplication::startDragDistance())//not enough dragged?
return;
QDrag *drag = new QDrag(event->widget());
QMimeData *mime = new QMimeData;
mime->setText("Test123");
drag->setMimeData(mime);
drag->exec();
//setCursor(Qt::OpenHandCursor);
}
void Pasteboard::writeURL(const KURL& url, const String&, Frame*)
{
ASSERT(!url.isEmpty());
#ifndef QT_NO_CLIPBOARD
QMimeData* md = new QMimeData;
QString urlString = url.string();
md->setText(urlString);
md->setUrls(QList<QUrl>() << url);
QGuiApplication::clipboard()->setMimeData(md, m_selectionMode ? QClipboard::Selection : QClipboard::Clipboard);
#endif
}
void ImageWIdget::makeDrag()
{
QDrag *dr = new QDrag(this);
// The data to be transferred by the drag and drop operation is contained in a QMimeData object
QMimeData *data = new QMimeData;
data->setText(myS.img.image_file);
// Assign ownership of the QMimeData object to the QDrag object.
dr->setMimeData(data);
// Start the drag and drop operation
dr->start();
}
// ************************************************************
void SymbolWidget::mouseMoveEvent(QMouseEvent*)
{
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
mimeData->setText("QucsComponent:"+theModel());
drag->setMimeData(mimeData);
drag->setPixmap( QPixmap(empty_xpm));
drag->setHotSpot(QPoint(drag->pixmap().width()/2,drag->pixmap().height()));
drag->exec();
}
void NowPlayingListWidget::mousePressEvent(QMouseEvent *event)
{
//after checking if we are in presence of a drag operation, we can then encapsulate
//the data to be sent and let start the drag operation
if (event->button() == Qt::LeftButton && itemAt(event->pos())) {
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData();
mimeData->setText(itemAt(event->pos())->text()); //who receives expects plain text data
drag->setMimeData(mimeData);
drag->exec();
}
}
void BlockNavigationTreeWidget::performDrag()
{
QTreeWidgetItem *item = currentItem();
if(item)
{
QMimeData *mimeData = new QMimeData;
QString text = item->text(0);
mimeData->setText(item->text(0));
QDrag* drag = new QDrag(this);
drag->setMimeData(mimeData);
m_DropAction = drag->exec( Qt::CopyAction );
}
}
/**
* This is overridden in order to properly convert Icons back
* to their original text.
*/
QMimeData *PsiTextView::createMimeDataFromSelection() const
{
QTextDocument *doc = new QTextDocument();
QTextCursor cursor(doc);
cursor.insertFragment(textCursor().selection());
QString text = PsiRichText::convertToPlainText(doc);
delete doc;
QMimeData *data = new QMimeData;
data->setText(text);
data->setHtml(Qt::convertFromPlainText(text));
return data;
}
QMimeData *WindowModelBase::mimeData(const QModelIndexList &indexes) const
{
if (indexes.isEmpty ()) {
return nullptr;
}
QMimeData *data = new QMimeData ();
data->setHtml (selectionAsHtml ());
data->setText (selectionAsText (m_delimiter));
return data;
}
void ResultsJsInterface::pushToClipboard(const QString &mimeType, const QString &data, const QString &html)
{
QMimeData *mimeData = new QMimeData();
if (mimeType == "text/plain")
mimeData->setText(data);
if ( ! html.isEmpty())
mimeData->setHtml(html);
QClipboard *clipboard = QApplication::clipboard();
clipboard->setMimeData(mimeData, QClipboard::Clipboard);
}
void PDFSelection::Private::textRequestFinished()
{
if(textReply->error() != QNetworkReply::NoError) {
qDebug() << "Error in selection" << textReply->errorString();
return;
}
QMimeData *mimeData = new QMimeData;
mimeData->setText(textReply->readAll());
QApplication::clipboard()->setMimeData(mimeData);
textReply->deleteLater();
textReply = 0;
}
void ClassItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (QLineF(event->screenPos(), event->buttonDownScreenPos(Qt::LeftButton)).length() < QApplication::startDragDistance()) {
return;
}
qfLogFuncFrame();
setCursor(Qt::ClosedHandCursor);
QDrag *drag = new QDrag(event->widget());
QMimeData *mime = new QMimeData;
drag->setMimeData(mime);
{
QVariantMap m;
auto &dt = data();
int slot_ix = dt.startSlotIndex();
int class_ix = dt.classIndex();
m[QStringLiteral("slotIndex")] = slot_ix;
m[QStringLiteral("classIndex")] = class_ix;
QJsonDocument jsd = QJsonDocument::fromVariant(m);
QString mime_text = QString::fromUtf8(jsd.toJson());
qfDebug() << "mime:" << mime_text;
mime->setText(mime_text);
QPixmap pixmap(rect().size().toSize());
pixmap.fill(Qt::white);
QPainter painter(&pixmap);
//painter.translate(15, 15);
painter.setRenderHint(QPainter::Antialiasing);
QStyleOptionGraphicsItem opt;
paint(&painter, &opt, 0);
{
m_classText->paint(&painter, &opt, nullptr);
painter.translate(m_courseText->pos());
m_courseText->paint(&painter, &opt, nullptr);
painter.translate(m_classdefsText->pos() - m_courseText->pos());
m_classdefsText->paint(&painter, &opt, nullptr);
}
painter.end();
//pixmap.setMask(pixmap.createHeuristicMask());
drag->setPixmap(pixmap);
drag->setHotSpot(QPoint(5 * ganttScene()->displayUnit(), 0));
}
Qt::DropAction act = drag->exec();
qfDebug() << "drag exit:" << act;
if(act == Qt::MoveAction) {
}
setCursor(Qt::ArrowCursor);
}
void QgsClipboard::setData( const QString& mimeType, const QByteArray& data, const QString* text )
{
QMimeData *mdata = new QMimeData();
mdata->setData( mimeType, data );
if ( text )
{
mdata->setText( *text );
}
// Transfers ownership to the clipboard object
#ifndef Q_OS_WIN
QApplication::clipboard()->setMimeData( mdata, QClipboard::Selection );
#endif
QApplication::clipboard()->setMimeData( mdata, QClipboard::Clipboard );
}
void QDragLabel::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton){
QDrag* drag = new QDrag(this);
QMimeData* mime = new QMimeData;
mime->setText(this->class_name);
mime->setImageData(this->pixmap()->toImage());
drag->setMimeData(mime);
drag->setPixmap(*this->pixmap());
Qt::DropAction dropAction = drag->exec();
}
}
void KIOPasteTest::testPasteJob()
{
QFETCH(QList<QUrl>, urls);
QFETCH(bool, data);
QFETCH(bool, cut);
QFETCH(QString, expectedFileName);
QMimeData mimeData;
bool isDir = false;
bool isFile = false;
if (!urls.isEmpty()) {
mimeData.setUrls(urls);
QFileInfo fileInfo(urls.first().toLocalFile());
isDir = fileInfo.isDir();
isFile = fileInfo.isFile();
}
if (data) {
mimeData.setText(QStringLiteral("Hello world"));
}
KIO::setClipboardDataCut(&mimeData, cut);
QTemporaryDir destTempDir;
QVERIFY(destTempDir.isValid());
const QString destDir = destTempDir.path();
KIO::Job *job = KIO::paste(&mimeData, QUrl::fromLocalFile(destDir), KIO::HideProgressInfo);
QSignalSpy spy(job, SIGNAL(itemCreated(QUrl)));
QVERIFY(spy.isValid());
job->setUiDelegate(0);
const bool expectedSuccess = !expectedFileName.isEmpty();
QCOMPARE(job->exec(), expectedSuccess);
if (expectedSuccess) {
const QString destFile = destDir + '/' + expectedFileName;
QVERIFY2(QFile::exists(destFile), qPrintable(expectedFileName));
if (isDir) {
QVERIFY(QFileInfo(destFile).isDir());
} else {
QVERIFY(QFileInfo(destFile).isFile());
QFile file(destFile);
QVERIFY(file.open(QIODevice::ReadOnly));
QCOMPARE(QString(file.readAll()), QString("Hello world"));
}
if (cut) {
QVERIFY(!QFile::exists(urls.first().toLocalFile()));
} else {
QVERIFY(QFile::exists(urls.first().toLocalFile()));
}
QCOMPARE(spy.count(), isFile || cut ? 1 : 2);
QCOMPARE(spy.at(0).at(0).value<QUrl>().toLocalFile(), destFile);
}
}
void DesignDocumentControllerView::toClipboard() const
{
QClipboard *clipboard = QApplication::clipboard();
QMimeData *data = new QMimeData;
data->setText(toText());
QStringList imports;
foreach (const Import &import, model()->imports())
imports.append(import.toString());
data->setData("QmlDesigner::imports", stringListToArray(imports));
clipboard->setMimeData(data);
}
void ProjectListWidget::startDrag()
{
QListWidgetItem *item = currentItem();
if (item) {
QMimeData *mimeData = new QMimeData;
mimeData->setText(item->text());
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(QPixmap(":/images/person.png"));
if (drag->start(Qt::MoveAction) == Qt::MoveAction)
delete item;
}
}
//! [5]
void ColorItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (QLineF(event->screenPos(), event->buttonDownScreenPos(Qt::LeftButton))
.length() < QApplication::startDragDistance()) {
return;
}
QDrag *drag = new QDrag(event->widget());
QMimeData *mime = new QMimeData;
drag->setMimeData(mime);
//! [5]
//! [6]
static int n = 0;
if (n++ > 2 && (qrand() % 3) == 0) {
QImage image(":/images/head.png");
mime->setImageData(image);
drag->setPixmap(QPixmap::fromImage(image).scaled(30, 40));
drag->setHotSpot(QPoint(15, 30));
//! [6]
//! [7]
} else {
mime->setColorData(color);
mime->setText(QString("#%1%2%3")
.arg(color.red(), 2, 16, QLatin1Char('0'))
.arg(color.green(), 2, 16, QLatin1Char('0'))
.arg(color.blue(), 2, 16, QLatin1Char('0')));
QPixmap pixmap(34, 34);
pixmap.fill(Qt::white);
QPainter painter(&pixmap);
painter.translate(15, 15);
painter.setRenderHint(QPainter::Antialiasing);
paint(&painter, 0, 0);
painter.end();
pixmap.setMask(pixmap.createHeuristicMask());
drag->setPixmap(pixmap);
drag->setHotSpot(QPoint(15, 20));
}
//! [7]
//! [8]
drag->exec();
setCursor(Qt::OpenHandCursor);
}
void UrlIconLabel::mouseMoveEvent(QMouseEvent *event)
{
if (event->buttons() == Qt::LeftButton
&& (event->pos() - m_dragStartPos).manhattanLength() > QApplication::startDragDistance()
&& m_webView) {
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
mimeData->setText(QString::fromUtf8(m_webView->url().toEncoded()));
QList<QUrl> urls;
urls.append(m_webView->url());
mimeData->setUrls(urls);
drag->setMimeData(mimeData);
drag->exec();
}
}
QMimeData* CFormulatorDoc::copyToMimeData( CRootNode *pRootNode, QImage *pImage )
{
Q_ASSERT( pRootNode );
if( !QApplication::clipboard() ) return 0;
QString mmlTextData = exportMathML( pRootNode );
QByteArray mmlBinaryData;
QDataStream ar( &mmlBinaryData, QIODevice::WriteOnly );
pRootNode->Store( ar );
QMimeData *mimeData = new QMimeData();
mimeData->setText( mmlTextData );
mimeData->setData( FORMULATOR_MIME_FORMAT, mmlBinaryData );
if( pImage ) mimeData->setImageData( *pImage );
return mimeData;
}
QMimeData *LiteEditorWidget::createMimeDataFromSelection() const
{
QTextCursor cursor = textCursor();
if (!cursor.hasSelection()) {
return 0;
}
QMimeData *mimeData = new QMimeData;
QString text = cursor.selectedText();
convertToPlainText(text);
mimeData->setText(text);
// Copy the selected text as HTML
mimeData->setHtml(cursorToHtml(cursor));
return mimeData;
}
void PeerShowWidget::performDrag()
{
QString u = this->iurl+"\t"+this->nuri+"\t"+this->n;
qDebug()<<"performDrag()"<<u;
if(!u.isNull())
{
QMimeData *mimeData = new QMimeData;
mimeData->setText(u);
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(QPixmap(u));
drag->exec(Qt::MoveAction);
}
}
void NodeCombat::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (QLineF(event->screenPos(), event->buttonDownScreenPos(Qt::LeftButton))
.length() < QApplication::startDragDistance()) {
return;
}
QDrag *drag = new QDrag(event->widget());
QMimeData *mime = new QMimeData;
drag->setMimeData(mime);
mime->setText(QString("%1").arg(getId()));
drag->exec();
}
QMimeData * LocationsRunner::mimeDataForMatch(const Plasma::QueryMatch &match)
{
const QString data = match.data().toString();
if (!data.isEmpty()) {
QUrl url(data);
QList<QUrl> list;
list << url;
QMimeData *result = new QMimeData();
result->setUrls(list);
result->setText(data);
return result;
}
return 0;
}
QList<Task*> SubalignmentToClipboardTask::onSubTaskFinished(Task *subTask) {
QList<Task*> result;
CHECK(subTask == prepareDataTask, result);
CHECK(!prepareDataTask->getStateInfo().isCoR(), result);
QString clipboardData = prepareDataTask->getResult();
if ("RTF" == formatId) {
QMimeData *reportRichTextMime = new QMimeData();
reportRichTextMime->setHtml(clipboardData);
reportRichTextMime->setText(clipboardData);
QApplication::clipboard()->setMimeData(reportRichTextMime);
} else {
QApplication::clipboard()->setText(clipboardData);
}
return result;
}
