const int itemCount = indexes.count();
Q_ASSERT(itemCount > 0);
+ if (itemCount == 1) {
+ return KItemListView::createDragPixmap(indexes);
+ }
// If more than one item is dragged, align the items inside a
// rectangular grid. The maximum grid size is limited to 5 x 5 items.
const QPixmap pixmap = m_view->createDragPixmap(selectedItems);
drag->setPixmap(pixmap);
+ // TODO: The vertical hotspot of -24 should be replaced by the
+ // height of the QCursor-pixmap.
+ const QPoint hotSpot(pixmap.width() / 2, -24);
+ drag->setHotSpot(hotSpot);
+
drag->exec(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction, Qt::CopyAction);
}
#include <QCursor>
#include <QGraphicsSceneMouseEvent>
+#include <QGraphicsView>
#include <QPainter>
#include <QPropertyAnimation>
#include <QStyle>
QPixmap KItemListView::createDragPixmap(const QSet<int>& indexes) const
{
- Q_UNUSED(indexes);
- return QPixmap();
+ QPixmap pixmap;
+
+ if (indexes.count() == 1) {
+ KItemListWidget* item = m_visibleItems.value(indexes.toList().first());
+ QGraphicsView* graphicsView = scene()->views()[0];
+ if (item && graphicsView) {
+ pixmap = item->createDragPixmap(0, graphicsView);
+ }
+ } else {
+ // TODO: Not implemented yet. Probably extend the interface
+ // from KItemListWidget::createDragPixmap() to return a pixmap
+ // that can be used for multiple indexes.
+ }
+
+ return pixmap;
}
void KItemListView::editRole(int index, const QByteArray& role)
/**
* @return Pixmap that is used for a drag operation based on the
- * items given by \a indexes. The default implementation returns
- * a null-pixmap.
+ * items given by \a indexes.
*/
virtual QPixmap createDragPixmap(const QSet<int>& indexes) const;
return QRectF();
}
+QPixmap KItemListWidget::createDragPixmap(const QStyleOptionGraphicsItem* option,
+ QWidget* widget)
+{
+ QPixmap pixmap(size().toSize());
+ pixmap.fill(Qt::transparent);
+
+ QPainter painter(&pixmap);
+
+ const bool oldAlternateBackground = m_alternateBackground;
+ setAlternateBackground(false);
+ paint(&painter, option, widget);
+ setAlternateBackground(oldAlternateBackground);
+
+ return pixmap;
+}
+
void KItemListWidget::dataChanged(const QHash<QByteArray, QVariant>& current,
const QSet<QByteArray>& roles)
{
*/
virtual QRectF expansionToggleRect() const;
+ /**
+ * @return Pixmap that is used when dragging an item. Per default the current state of the
+ * widget is returned as pixmap.
+ */
+ virtual QPixmap createDragPixmap(const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
+
signals:
void roleEditingCanceled(int index, const QByteArray& role, const QVariant& value);
void roleEditingFinished(int index, const QByteArray& role, const QVariant& value);
/**
* @return MIME-data for the items given by \a indexes. The default implementation
* returns 0. The ownership of the returned instance is in the hand of the
- * caller of this method.
+ * caller of this method. The method must be implemented if dragging of
+ * items should be possible.
*/
virtual QMimeData* createMimeData(const QSet<int>& indexes) const;
return QRectF(pos, QSizeF(toggleSize, toggleSize));
}
+QPixmap KStandardItemListWidget::createDragPixmap(const QStyleOptionGraphicsItem* option,
+ QWidget* widget)
+{
+ QPixmap pixmap = KItemListWidget::createDragPixmap(option, widget);
+ if (m_layout != DetailsLayout || styleOption().extendedSelectionRegion) {
+ return pixmap;
+ }
+
+ // Only return the content of the text-column as pixmap
+ const int leftClip = m_pixmapPos.x();
+
+ const TextInfo* textInfo = m_textInfo.value("text");
+ const int rightClip = textInfo->pos.x() +
+ textInfo->staticText.size().width() +
+ 2 * styleOption().padding;
+
+ QPixmap clippedPixmap(rightClip - leftClip + 1, pixmap.height());
+ clippedPixmap.fill(Qt::transparent);
+
+ QPainter painter(&clippedPixmap);
+ painter.drawPixmap(-leftClip, 0, pixmap);
+
+ return clippedPixmap;
+}
+
+
KItemListWidgetInformant* KStandardItemListWidget::createInformant()
{
return new KStandardItemListWidgetInformant();
virtual QRectF textFocusRect() const;
virtual QRectF expansionToggleRect() const;
virtual QRectF selectionToggleRect() const;
+ virtual QPixmap createDragPixmap(const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
static KItemListWidgetInformant* createInformant();
#include "placesitem.h"
#include <QAction>
#include <QDate>
+#include <QMimeData>
#include <QTimer>
#include <Solid/Device>
this, SLOT(slotStorageTeardownDone(Solid::ErrorType,QVariant)));
drive->eject();
} else {
-
+ const QString label = item->text();
+ const QString message = i18nc("@info", "The device '%1' is not a disk and cannot be ejected.", label);
+ emit errorMessage(message);
}
}
}
connect(access, SIGNAL(teardownDone(Solid::ErrorType,QVariant,QString)),
this, SLOT(slotStorageTeardownDone(Solid::ErrorType,QVariant)));
access->teardown();
- } else {
- const QString label = item->text();
- const QString message = i18nc("@info", "The device '%1' is not a disk and cannot be ejected.", label);
- emit errorMessage(message);
}
}
}
+QMimeData* PlacesItemModel::createMimeData(const QSet<int>& indexes) const
+{
+ KUrl::List urls;
+ QByteArray itemData;
+
+ QDataStream stream(&itemData, QIODevice::WriteOnly);
+
+ foreach (int index, indexes) {
+ const KUrl itemUrl = placesItem(index)->url();
+ if (itemUrl.isValid()) {
+ urls << itemUrl;
+ }
+ stream << index;
+ }
+
+ QMimeData* mimeData = new QMimeData();
+ if (!urls.isEmpty()) {
+ urls.populateMimeData(mimeData);
+ }
+
+ const QString internalMimeType = "application/x-dolphinplacesmodel-" +
+ QString::number((qptrdiff)this);
+ mimeData->setData(internalMimeType, itemData);
+
+ return mimeData;
+}
+
+bool PlacesItemModel::supportsDropping(int index) const
+{
+ Q_UNUSED(index);
+ return true;
+}
+
KUrl PlacesItemModel::convertedUrl(const KUrl& url)
{
KUrl newUrl = url;
void requestEject(int index);
void requestTeardown(int index);
+ /** @reimp */
+ virtual QMimeData* createMimeData(const QSet<int>& indexes) const;
+
+ /** @reimp */
+ virtual bool supportsDropping(int index) const;
+
/**
* @return Converts the URL, which contains "virtual" URLs for system-items like
* "search:/documents" into a Nepomuk-Query-URL that will be handled by