// -------------------------------------------------------------------------------
QMimeData* CCollectionModel::mimeData( const QModelIndexList& indexes ) const
// -------------------------------------------------------------------------------
{
//std::cout<<"CCollectionModel::mimeData()"<<std::endl;
Q_ASSERT( NULLPTR != mpCollection );
if ( !mpCollection )
return NULLPTR;
if ( indexes.isEmpty() )
return NULLPTR;
QModelIndex firstIndex = indexes.first();
if ( !firstIndex.isValid() )
return NULLPTR;
CTreeInformationElement* pTIE = mapIndexToIE( firstIndex );
if ( !pTIE )
return NULLPTR;
QByteArray encodedData;
encodedData.append( mpCollection->toXML( pTIE ).toUtf8() );
debugTrace( "[CCollectionModel::mimeData] encodedData = '" + encodedData + "'" );
//std::cout<<"[DragContent]"<<QString(encodedData).toStdString()<<"[/DragContent]"<<std::endl;
// TODO: Check whether the encoding for umlauts, accents, etc. is correct.
// If not it might be accomplished like this:
//QTextStream t( &encodedData, QIODevice::WriteOnly );
//t.setCodec( "UTF-8" );
//t << mpCollection->toXML( pTIE );
QMimeData* pMimeData = new QMimeData();
pMimeData->setData( TUXCARDS_DRAGDROP_TYPE, encodedData );
return pMimeData;
}
void SeList::mouseMoveEvent(QMouseEvent* e)
{
if ((Mpressed) && ((Mpos - e->pos()).manhattanLength() > 4))
{
Mpressed = false;
QListWidgetItem *item = itemAt(Mpos);
if (!item)
return;
QMimeData *mimeData = new QMimeData;
QString pageName = item->data(Qt::UserRole).toString();
mimeData->setData("page/magic", "1" + pageName.toLocal8Bit());
mimeData->setText("1" + pageName);
QDrag *dr = new QDrag(this);
dr->setMimeData(mimeData);
const QPixmap& pm = IconManager::instance()->loadPixmap("doc.png");
dr->setPixmap(pm);
// dr->setDragCursor(pm, Qt::CopyAction);
// dr->setDragCursor(pm, Qt::MoveAction);
dr->exec(Qt::CopyAction | Qt::MoveAction);
QApplication::setOverrideCursor(Qt::ArrowCursor);
}
}
QVariantMap cloneData(const QMimeData &data)
{
QStringList formats;
for ( const auto &mime : data.formats() ) {
// ignore uppercase mimetypes (e.g. UTF8_STRING, TARGETS, TIMESTAMP)
// and internal type to check clipboard owner
if ( !mime.isEmpty() && mime[0].isLower() )
formats.append(mime);
}
return cloneData(data, formats);
}
//virtual
QMimeData * EffectsListWidget::mimeData(const QList<QTreeWidgetItem *> list) const
{
QDomDocument doc;
bool transitionMode = false;
foreach(QTreeWidgetItem *item, list) {
if (item->flags() & Qt::ItemIsDragEnabled) {
int type = item->data(0, TypeRole).toInt();
if (type == EffectsList::TRANSITION_TYPE) {
transitionMode = true;
}
QStringList info = item->data(0, IdRole).toStringList();
const QDomElement e = itemEffect(type, info);
if (!e.isNull())
doc.appendChild(doc.importNode(e, true));
}
}
QMimeData *mime = new QMimeData;
QByteArray data;
data.append(doc.toString().toUtf8());
mime->setData(transitionMode ? "kdenlive/transitionslist" : "kdenlive/effectslist", data);
return mime;
}
QMimeData *TableModelAnovaWithinSubjectCells::mimeData(const QModelIndexList &indexes) const
{
QMimeData *mimeData = new QMimeData();
QByteArray encodedData;
QDataStream dataStream(&encodedData, QIODevice::WriteOnly);
dataStream << indexes.length();
foreach (const QModelIndex &index, indexes)
{
if (index.isValid())
{
Term term = _variables.at(index.row());
dataStream << term.asQString();
}
}
mimeData->setData("application/vnd.list.variable", encodedData);
return mimeData;
}
QMimeData* BasketTreeListView::mimeData(const QList<QTreeWidgetItem *> items) const
{
QString mimeType = TREE_ITEM_MIME_STRING;
QByteArray data = QByteArray();
QDataStream out(&data, QIODevice::WriteOnly);
if(items.isEmpty())
return new QMimeData();
for (int i = 0; i < items.count(); ++i) {
BasketListViewItem *basketItem = static_cast<BasketListViewItem*>(items[i]);
out << basketItem->basket()->basketName() << basketItem->basket()->folderName()
<< basketItem->basket()->icon();
}
QMimeData *mimeData = new QMimeData();
mimeData->setData(mimeType, data);
return mimeData;
}
void KIOPasteTest::testCut()
{
QMimeData *mimeData = new QMimeData;
QUrl localURL1(QStringLiteral("file:///tmp/Mat%C3%A9riel"));
QUrl localURL2(QStringLiteral("file:///tmp"));
QList<QUrl> localURLs; localURLs << localURL1 << localURL2;
KUrlMimeData::setUrls(QList<QUrl>(), localURLs, mimeData);
KIO::setClipboardDataCut(mimeData, true);
QVERIFY(mimeData->hasUrls());
const QList<QUrl> lst = KUrlMimeData::urlsFromMimeData(mimeData);
QCOMPARE(lst.count(), 2);
QCOMPARE(lst[0].url(), localURL1.url());
QCOMPARE(lst[1].url(), localURL2.url());
const bool isCut = KIO::isClipboardDataCut(mimeData);
QVERIFY(isCut);
delete mimeData;
}
void QtRosterWidget::mouseMoveEvent(QMouseEvent *event)
{
if (!(event->buttons() & Qt::LeftButton)) {
return;
}
if ((event->pos() - dragStartPosition).manhattanLength()< QApplication::startDragDistance()) {
return;
}
clickedIndex=indexAt(event->pos());
if (!clickedIndex.isValid()) {
return;
}
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData();
RosterItem* item = static_cast<RosterItem*>(clickedIndex.internalPointer());
ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);
std::string jid=contact->getJID().toString();
QString str=QString::P2QSTRING(jid);
mimeData->setText(str);
drag->setMimeData(mimeData);
drag->exec(Qt::CopyAction | Qt::MoveAction);
}
void DragableLabel::mousePressEvent(QMouseEvent *event)
{
QPoint hotSpot = event->pos();
QMimeData *mimeData = new QMimeData;
mimeData->setText(this->text());
mimeData->setData("application/x-hotspot",
QByteArray::number(hotSpot.x()) + " " + QByteArray::number(hotSpot.y()));
QPixmap pixmap(this->size());
this->render(&pixmap);
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(pixmap);
drag->setHotSpot(hotSpot);
Qt::DropAction dropAction = drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction);
if (dropAction == Qt::MoveAction)
this->close();
}
void KIOPasteTest::testPopulate()
{
QMimeData *mimeData = new QMimeData;
// Those URLs don't have to exist.
QUrl mediaURL(QStringLiteral("media:/hda1/tmp/Mat%C3%A9riel"));
QUrl localURL(QStringLiteral("file:///tmp/Mat%C3%A9riel"));
QList<QUrl> kdeURLs; kdeURLs << mediaURL;
QList<QUrl> mostLocalURLs; mostLocalURLs << localURL;
KUrlMimeData::setUrls(kdeURLs, mostLocalURLs, mimeData);
QVERIFY(mimeData->hasUrls());
const QList<QUrl> lst = KUrlMimeData::urlsFromMimeData(mimeData);
QCOMPARE(lst.count(), 1);
QCOMPARE(lst[0].url(), mediaURL.url());
const bool isCut = KIO::isClipboardDataCut(mimeData);
QVERIFY(!isCut);
delete mimeData;
}
QMimeData* DisplayModel::mimeData(const QModelIndexList& indexes) const
{
DatabaseLocker lock(db_);
QMimeData *mimeData = new QMimeData();
QList<QUrl> list;
for (const QModelIndex &index: indexes)
{
if (index.isValid())
{
QStandardItem* qitem = this->itemFromIndex(index);
file_hash_t hash = qitem->data(IMAGE_QVARIANT_ROLE).value<file_hash_t>();
ImageDescription_ptr desc = db_->images().get_image_description(hash);
list << QUrl("file:///" + db_->images().storage_location() + "/" + desc->path);
}
}
mimeData->setUrls(list);
return mimeData;
}
QMimeData *StatsListModel::mimeData(const QModelIndexList &indexes) const
{
QMimeData *mimeData = new QMimeData();
QByteArray encodedData;
QDataStream stream(&encodedData, QIODevice::WriteOnly);
foreach (QModelIndex index, indexes) {
if (index.isValid()) {
int ind = data(index, Qt::UserRole).toInt();
int alpha = data(index, Qt::UserRole+1).toInt();
QModelIndex checkindex = StatsListModel::createIndex(index.row(), 1, 999);
bool draw = data(checkindex, Qt::CheckStateRole).toBool();
bool drawgrid = data(index, Qt::UserRole+2).toBool();
QString name = data(index, Qt::DisplayRole).toString();
stream << ind << alpha << draw << drawgrid << name;
}
}
mimeData->setData("application/YUView-Statistics", encodedData);
return mimeData;
}
QMimeData *BookmarksModel::mimeData(const QModelIndexList &indexes) const
{
QMimeData *mimeData = new QMimeData();
QByteArray data;
QDataStream stream(&data, QIODevice::WriteOnly);
QList<QUrl> urls;
foreach (const QModelIndex &index, indexes) {
if (index.column() != 0 || !index.isValid())
continue;
QByteArray encodedData;
QBuffer buffer(&encodedData);
buffer.open(QBuffer::ReadWrite);
XbelWriter writer;
const BookmarkNode *parentNode = node(index);
writer.write(&buffer, parentNode);
stream << encodedData;
urls.append(index.data(BookmarksModel::UrlRole).toUrl());
}
mimeData->setData(MIMETYPE, data);
mimeData->setUrls(urls);
return mimeData;
}
void DummyBlock::mousePressEvent(QMouseEvent *event)
{
cout << "Starting Drag" << endl;
QByteArray itemData;
QDataStream dataStream(&itemData, QIODevice::WriteOnly);
dataStream << QPoint(event->pos());
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-dnditemdata", itemData);
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setHotSpot(event->pos());
drag->setPixmap(this->grab());
if (drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction) == Qt::MoveAction)
{
// this->close();
}
}
QMimeData *GraphModel::mimeData(const QModelIndexList &indexes) const
{
if(QApplication::keyboardModifiers() & Qt::ShiftModifier)
{
QMimeData *mimeData = new QMimeData();
QByteArray encodedData;
QDataStream stream(&encodedData, QIODevice::WriteOnly);
foreach (const QModelIndex &index, indexes)
{
if (index.isValid())
{
GraphItem *item = static_cast<GraphItem *>(index.internalPointer());
QVariant uData = PointerHolder<GraphItem *>::ToQVariant(item);
stream << uData;
}
}
mimeData->setData("application/tree.userdata", encodedData);
return mimeData;
}
void VSCDeviceTree::mousePressEvent(QMouseEvent *event)
{
VDC_DEBUG( "%s \n",__FUNCTION__);
// Get current selection
QTreeWidgetItem *selectedItem = currentItem();
if (event->buttons() & Qt::RightButton)
{
return;
}
// If the selected Item exists
if (selectedItem)
{
VSCDeviceIPC *pIpc = dynamic_cast<VSCDeviceIPC * >(selectedItem);
//VSCDeviceIPC *pIpc = (VSCDeviceIPC * )(selectedItem);
// Create data
if (pIpc)
{
u32 nId = pIpc->GetDeviceId();
VDC_DEBUG( "%s id %d\n",__FUNCTION__, nId);
QMimeData *mimeData = new QMimeData();
mimeData->setText(QString::number(nId));
// Create drag
QPixmap pixmap(":/device/resources/camera1.png");
QPainter painter(&pixmap);
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(pixmap);
drag->setHotSpot(QPoint(drag->pixmap().width()/2,
drag->pixmap().height()/2));
drag->exec();
}
}
QTreeWidget::mousePressEvent(event);
}
//! [0]
void MainWindow::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton
&& iconLabel->geometry().contains(event->pos())) {
//! [1]
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
mimeData->setText(commentEdit->toPlainText());
drag->setMimeData(mimeData);
//! [1]
drag->setPixmap(iconPixmap);
Qt::DropAction dropAction = drag->exec();
//! [0]
QString actionText;
switch (dropAction) {
case Qt::CopyAction:
actionText = tr("The text was copied.");
break;
case Qt::MoveAction:
actionText = tr("The text was moved.");
break;
case Qt::LinkAction:
actionText = tr("The text was linked.");
break;
case Qt::IgnoreAction:
actionText = tr("The drag was ignored.");
break;
default:
actionText = tr("Unknown action.");
break;
}
statusBar()->showMessage(actionText);
//! [2]
}
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
QMimeData* md = new QMimeData;
QString text = frame->editor()->selectedText();
text.replace(QChar(0xa0), QLatin1Char(' '));
md->setText(text);
QString markup = createMarkup(selectedRange, 0, AnnotateForInterchange, false, AbsoluteURLs);
#ifdef Q_OS_MAC
markup.prepend(QLatin1String("<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" /></head><body>"));
markup.append(QLatin1String("</body></html>"));
md->setData(QLatin1String("text/html"), markup.toUtf8());
#else
md->setHtml(markup);
#endif
#ifndef QT_NO_CLIPBOARD
QApplication::clipboard()->setMimeData(md, m_selectionMode ? QClipboard::Selection : QClipboard::Clipboard);
#endif
if (canSmartCopyOrDelete)
md->setData("application/vnd.qtwebkit.smartpaste", QByteArray());
}
bool drag( Token *token )
{
if ( !token )
return false;
bool ret = false;
bool stacked = token->parentWidget() && qobject_cast<TokenDropTarget*>( token->parentWidget() );
if (stacked)
token->hide();
QPixmap pixmap( token->size() );
token->render( &pixmap );
QDrag *drag = new QDrag( token );
QMimeData *data = new QMimeData;
QByteArray itemData;
QDataStream dataStream( &itemData, QIODevice::WriteOnly );
// dataStream << child->name() << child->iconName() << child->value();
data->setData( m_mimeType, itemData );
drag->setMimeData( data );
drag->setPixmap( pixmap );
drag->setHotSpot ( pixmap.rect().center() );
Qt::DropAction dropAction = drag->exec( Qt::CopyAction | Qt::MoveAction, Qt::CopyAction );
if ( stacked )
{
if ( dropAction != Qt::MoveAction && dropAction != Qt::CopyAction ) // dragged out
{
// TODO: nice poof animation? ;-)
delete token;
ret = true; // THIS IS IMPORTANT
}
// anyway, tell daddy to wipe empty rows NOW
static_cast<TokenDropTarget*>(parent())->deleteEmptyRows();
}
return ret;
}
void DraggableLabel::mousePressEvent(QMouseEvent *event)
{
if(!m_drag)
{
QWidget::mousePressEvent(event);
return;
}
if (event->button() == Qt::LeftButton)
{
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
QByteArray data;
QDataStream str(&data, QIODevice::WriteOnly);
str << labelLayout->getLabelPos(this);
if(m_drag && !m_drop && labelLayout)
{
DataFilter *f = labelLayout->getFilterTabs()->getCurrFilter();
str.writeRawData((const char*)&f, sizeof(DataFilter*));
mimeData->setData("analyzer/dragLabel", data);
}
else
mimeData->setData("analyzer/dropLabel", data);
drag->setMimeData(mimeData);
QPixmap pixmap(size());
this->render(&pixmap);
drag->setPixmap(pixmap);
drag->exec();
delete drag;
event->accept();
}
}
void CopyAsController::onActionTriggered( QAction *action )
{
AbstractModelStreamEncoder* encoder = action->data().value<AbstractModelStreamEncoder* >();
const AbstractModelSelection* selection = mSelectionControl->modelSelection();
AbstractModelStreamEncoderConfigEditor* configEditor =
mModelCodecViewManager->createConfigEditor( encoder );
if( configEditor )
{
CopyAsDialog* dialog = new CopyAsDialog( encoder->remoteTypeName(), configEditor );
dialog->setData( mModel, selection );
if( !dialog->exec() )
return;
}
QApplication::setOverrideCursor( Qt::WaitCursor );
QByteArray exportData;
QBuffer exportDataBuffer( &exportData );
exportDataBuffer.open( QIODevice::WriteOnly );
ModelStreamEncodeThread *encodeThread =
new ModelStreamEncodeThread( this, &exportDataBuffer, mModel, selection, encoder );
encodeThread->start();
while( !encodeThread->wait(100) )
QApplication::processEvents( QEventLoop::ExcludeUserInputEvents | QEventLoop::ExcludeSocketNotifiers, 100 );
delete encodeThread;
exportDataBuffer.close();
QMimeData *mimeData = new QMimeData;
mimeData->setData( encoder->remoteClipboardMimeType(), exportData );
QApplication::clipboard()->setMimeData( mimeData, QClipboard::Clipboard );
QApplication::restoreOverrideCursor();
}
QMimeData * PartsBinListView::mimeData(const QList<QListWidgetItem *> items) const {
if (items.count()>1) {
throw "PartsBinListView::mimeData too many items";
}
if(items.count()==1) {
QListWidgetItem * item = items.at(0);
ModelPart * modelPart = itemModelPart(item);
QByteArray itemData;
QDataStream dataStream(&itemData, QIODevice::WriteOnly);
dataStream << modelPart->moduleID() << QPointF(0,0);
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-dnditemdata", itemData);
mimeData->setData("action", "part-reordering");
return mimeData;
} else {
return QListWidget::mimeData(items);
}
}
void
TreeView::startDrag( Qt::DropActions supportedActions )
{
QList<QPersistentModelIndex> pindexes;
QModelIndexList indexes;
foreach( const QModelIndex& idx, selectedIndexes() )
{
if ( ( m_proxyModel->flags( idx ) & Qt::ItemIsDragEnabled ) )
{
indexes << idx;
pindexes << idx;
}
}
if ( indexes.count() == 0 )
return;
qDebug() << "Dragging" << indexes.count() << "indexes";
QMimeData* data = m_proxyModel->mimeData( indexes );
if ( !data )
return;
QDrag* drag = new QDrag( this );
drag->setMimeData( data );
QPixmap p;
if ( data->hasFormat( "application/tomahawk.metadata.artist" ) )
p = TomahawkUtils::createDragPixmap( TomahawkUtils::MediaTypeArtist, indexes.count() );
else if ( data->hasFormat( "application/tomahawk.metadata.album" ) )
p = TomahawkUtils::createDragPixmap( TomahawkUtils::MediaTypeAlbum, indexes.count() );
else
p = TomahawkUtils::createDragPixmap( TomahawkUtils::MediaTypeTrack, indexes.count() );
drag->setPixmap( p );
drag->setHotSpot( QPoint( -20, -20 ) );
drag->exec( supportedActions, Qt::CopyAction );
}
QString PsiTextView::getTextHelper(bool html) const
{
PsiTextView *ptv = (PsiTextView *)this;
QTextCursor cursor = ptv->textCursor();
int position = ptv->verticalScrollBar()->value();
bool unselectAll = false;
if (!textCursor().hasSelection()) {
#if QT_VERSION == 0x040701
// workaround for crash when deleting last character with backspace (qt-4.7.1)
// http://bugreports.qt.nokia.com/browse/QTBUG-15857
QTextCursor tempCursor = QTextCursor(ptv->document());
tempCursor.movePosition(QTextCursor::Start);
ptv->setTextCursor(tempCursor);
#endif
ptv->selectAll();
unselectAll = true;
}
QMimeData *mime = createMimeDataFromSelection();
QString result;
if (html)
result = mime->html();
else
result = mime->text();
delete mime;
// we need to restore original position if selectAll()
// was called, because setTextCursor() (which is necessary
// to clear selection) will move vertical scroll bar
if (unselectAll) {
cursor.clearSelection();
ptv->setTextCursor(cursor);
ptv->verticalScrollBar()->setValue(position);
}
return result;
}
// ドラッグアンドドロップ開始
void GridLabel::startDragAndDrop(QMouseEvent *ev)
{
Q_UNUSED(ev);
EditData::ImageData *p = m_pEditData->getImageDataFromNo(m_Index);
if (!p)
{
return;
}
QImage img = p->Image.copy(m_pEditData->getCatchRect().toRect());
QPixmap pix = QPixmap::fromImage(img);
QByteArray itemData;
QDataStream stream(&itemData, QIODevice::WriteOnly);
RectF rect = m_pEditData->getCatchRect();
// stream << rect << mScale << m_Index ;
stream << rect.left() << rect.top() << rect.right() << rect.bottom() << mScale << m_Index;
QMimeData *mimeData = new QMimeData;
mimeData->setData("editor/selected-image", itemData);
QPainter painter;
painter.begin(&pix);
painter.fillRect(pix.rect(), QColor(127, 127, 127, 127));
painter.end();
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(pix);
drag->setHotSpot(QPoint((rect.right() - rect.left()) / 2, (rect.bottom() - rect.top()) / 2));
// qDebug() << "x:" << ev->pos().x() << " y:" << ev->pos().y() ;
m_pEditData->setDraggingImage(true);
drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction);
m_pEditData->setDraggingImage(false);
}
void QMwStructuresWidget::mouseMoveEvent(QMouseEvent *event)
{
QTreeWidget::mouseMoveEvent(event);
//return;
if (!(event->buttons() & Qt::LeftButton))
return;
// if ((event->pos() - this->dragStartPos).manhattanLength() < QApplication::startDragDistance())
// return;
QTreeWidgetItem *draggedItem = this->itemAt(this->dragStartPos);
MwBaseResource *selectedResource = QMwStructuresWidget::GetMwResourceFromItem(draggedItem);
if (selectedResource == 0)
return;
switch (this->dragMode)
{
case QMwStructuresWidget::DragMode_None:
{
QDrag *drag = new QDrag(this);
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/mwresource", MwString((unsigned int)selectedResource).GetCharContents());
mimeData->setData("application/twitem", MwString((unsigned int)draggedItem).GetCharContents());
drag->setMimeData(mimeData);
QString iconName;
if (EditorUtils::resourceTypeIcons.GetValue(selectedResource->resourceType, iconName))
drag->setPixmap(QPixmap(iconName));
this->dragMode = QMwStructuresWidget::DragMode_Resource;
drag->exec(Qt::CopyAction | Qt::MoveAction);
break;
}
}
}
QMimeData *QHaikuClipboard::mimeData(QClipboard::Mode mode)
{
QMimeData *mimeData = new QMimeData();
if (mode != QClipboard::Clipboard)
return mimeData;
if (!be_clipboard->Lock())
return mimeData;
const BMessage *clipboard = be_clipboard->Data();
if (clipboard) {
char *name = Q_NULLPTR;
uint32 type = 0;
int32 count = 0;
for (int i = 0; clipboard->GetInfo(B_MIME_TYPE, i, &name, &type, &count) == B_OK; i++) {
const void *data = Q_NULLPTR;
int32 dataLen = 0;
const status_t status = clipboard->FindData(name, B_MIME_TYPE, &data, &dataLen);
if (dataLen && (status == B_OK)) {
const QString format = QString::fromLatin1(name);
if (format == QStringLiteral("text/plain")) {
mimeData->setText(QString::fromLocal8Bit(reinterpret_cast<const char*>(data), dataLen));
} else if (format == QStringLiteral("text/html")) {
mimeData->setHtml(QString::fromLocal8Bit(reinterpret_cast<const char*>(data), dataLen));
} else {
mimeData->setData(format, QByteArray(reinterpret_cast<const char*>(data), dataLen));
}
}
}
}
be_clipboard->Unlock();
return mimeData;
}
void TrackView::editCopy()
{
if (0 == getTrackCount()) {
QApplication::beep();
return;
}
QRect selection = getSelection();
QVector<struct CopyEntry> copyEntries;
for (int track = selection.left(); track <= selection.right(); ++track) {
const SyncTrack *t = getTrack(track);
for (int row = selection.top(); row <= selection.bottom(); ++row) {
if (t->isKeyFrame(row)) {
CopyEntry ce;
ce.track = track - selection.left();
ce.keyFrame = t->getKeyFrame(row);
ce.keyFrame.row -= selection.top();
copyEntries.push_back(ce);
}
}
}
int buffer_width = selection.width();
int buffer_height = selection.height();
size_t buffer_size = copyEntries.size();
QByteArray data;
data.append((char *)&buffer_width, sizeof(int));
data.append((char *)&buffer_height, sizeof(int));
data.append((char *)&buffer_size, sizeof(size_t));
data.append((char *)copyEntries.data(), sizeof(CopyEntry) * copyEntries.size());
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-gnu-rocket", data);
QApplication::clipboard()->setMimeData(mimeData);
}
void Drag::mouseMoveEvent(QMouseEvent *event)
{
if (!m_data->widget)
return;
if (!(event->buttons() & Qt::LeftButton))
return;
if ((event->globalPos() - m_data->dragStartPosition).manhattanLength()
< QApplication::startDragDistance())
return;
TypeDescriptor_ptr descriptor =
m_data->widget->getReflective();
Holder holder (descriptor->create_holder());
m_data->widget->toHolder(holder);
if (core::utils::calculate_size(holder) < GSIM_DRAG_MAX_SIZE)
{
QDrag * drag = new QDrag(m_data->qwidget);
QMimeData * mimeData = new QMimeData;
std::ostringstream oss;
json::write(oss, descriptor, holder);
mimeData->setText(oss.str().c_str());
drag->setMimeData(mimeData);
/* Qt::DropAction dropAction = */ drag->exec(Qt::CopyAction);
}
else
{
QMessageBox::information(m_data->qwidget, "Information",
"Drag events have been disabled for performance reasons.");
}
}
QMimeData *ContactListEdit::createMimeDataFromSelection() const
{
//QTextEdit::createMimeDataFromSelection();
QString textMime;
QMimeData *mimeData = new QMimeData ();
QTextCursor cursor = textCursor();
int posStart = cursor.selectionStart();
int posEnd = cursor.selectionEnd();
QTextBlock block = this->document()->findBlock(posStart);
QTextBlock endBlock = this->document()->findBlock(posEnd);
endBlock = endBlock.next();
while (block.isValid() && block != endBlock)
{
for (QTextBlock::iterator i = block.begin(); !i.atEnd(); ++i)
{
int position = i.fragment().position();
//qDebug() << i.fragment().position();
if (position >= posEnd) break;
if (position >= posStart)
{
QTextCharFormat format = i.fragment().charFormat();
bool isImage = format.isImageFormat();
if (isImage)
{
//qDebug() << format.toImageFormat().name();
textMime += format.toImageFormat().name();
}
else
textMime += i.fragment().text();
}
}
block = block.next();
}
mimeData->setText(textMime);
return mimeData;
}
