Code/Sandbox/Plugins/EditorCommon/DragDrop.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2 #include "StdAfx.h"
   3 #include "DragDrop.h"
   4
   5 #include "QTrackingTooltip.h"
   6
   7 #include <QDrag>
   8 #include <QFontMetrics>
   9 #include <QTimer>
  10 #include <QUrl>
  11 #include <qevent.h>
  12 #include <unordered_map>
  13
  14 //Notes for future usage:
  15 //CDrag object can be retrived from a drag event
  16 // QDrag* const pDrag = pDragEvent->source()->findChild<QDrag*>();
  17
  18 namespace Private_DragDrop
  19 {
  20
  21 class CDragTooltip
  22 {
  23 public:
  24         enum class EDisplayMode
  25         {
  26                 Clear = 0,
  27                 Text,
  28                 Pixmap
  29         };
  30
  31 private:
  32         struct SScope
  33         {
  34                 EDisplayMode m_displayMode;
  35                 QString m_text;
  36                 QPixmap m_pixmap;
  37
  38                 SScope()
  39                         : m_displayMode(EDisplayMode::Clear)
  40                 {
  41                 }
  42         };
  43
  44 public:
  45         static CDragTooltip& GetInstance()
  46         {
  47                 static CDragTooltip theInstance;
  48                 return theInstance;
  49         }
  50
  51         void StartDrag()
  52         {
  53                 m_scopes.clear();
  54                 m_bDragging = true;
  55                 m_timer.start(0);
  56
  57                 m_defaultScope = SScope();
  58         }
  59
  60         void StopDrag()
  61         {
  62                 m_bDragging = false;
  63                 m_timer.stop();
  64                 Update();
  65         }
  66
  67         void SetText(QWidget* pWidget, const QString& text)
  68         {
  69                 SScope& scope = GetScope(pWidget);
  70                 scope.m_displayMode = EDisplayMode::Text;
  71                 scope.m_text = text;
  72         }
  73
  74         void SetPixmap(QWidget* pWidget, const QPixmap& pixmap)
  75         {
  76                 SScope& scope = GetScope(pWidget);
  77                 scope.m_displayMode = EDisplayMode::Pixmap;
  78                 scope.m_pixmap = pixmap;
  79         }
  80
  81         void Clear(QWidget* pWidget)
  82         {
  83                 SScope& scope = GetScope(pWidget);
  84                 scope.m_displayMode = EDisplayMode::Clear;
  85         }
  86
  87         void SetDefaultPixmap(const QPixmap& pixmap)
  88         {
  89                 m_defaultScope.m_displayMode = EDisplayMode::Pixmap;
  90                 m_defaultScope.m_pixmap = pixmap;
  91         }
  92
  93         void SetCursorOffset(const QPoint& point)
  94         {
  95                 m_trackingTooltip->SetPosCursorOffset(point);
  96         }
  97
  98         void Update()
  99         {
 100                 if (!m_bDragging)
 101                 {
 102                         /*
 103                         QTrackingTooltip::HideTooltip(&m_trackingTooltip);
 104                         return;
 105                         */
 106                 }
 107
 108                 QWidget* const pSubject = qApp->widgetAt(QCursor::pos());
 109                 const SScope& scope = pSubject ? GetScope(pSubject) : m_defaultScope;
 110
 111                 if (scope.m_displayMode == EDisplayMode::Clear)
 112                 {
 113                         QTrackingTooltip::HideTooltip(m_trackingTooltip.data());
 114                 }
 115                 else
 116                 {
 117                         // Pixmap and text are mutually exclusive for a label.
 118                         if (scope.m_displayMode == EDisplayMode::Text)
 119                         {
 120                                 m_trackingTooltip->SetText(scope.m_text);
 121                         }
 122                         else if (scope.m_displayMode == EDisplayMode::Pixmap)
 123                         {
 124                                 m_trackingTooltip->SetPixmap(scope.m_pixmap);
 125                         }
 126
 127                         QTrackingTooltip::ShowTrackingTooltip(m_trackingTooltip);
 128                 }
 129         }
 130
 131 private:
 132         CDragTooltip()
 133                 : m_trackingTooltip(new QTrackingTooltip(), &QObject::deleteLater)
 134                 , m_bDragging(false)
 135         {
 136                 QObject::connect(&m_timer, &QTimer::timeout, [this]() { Update(); });
 137         }
 138
 139         SScope& GetScope(QObject* pSubject)
 140         {
 141                 if (m_scopes.find(pSubject) == m_scopes.end())
 142                 {
 143                         m_scopes[pSubject].reset(new SScope(m_defaultScope));
 144                 }
 145                 return *m_scopes[pSubject];
 146         }
 147
 148 private:
 149         std::unordered_map<const QObject*, std::unique_ptr<SScope>> m_scopes;
 150         SScope m_defaultScope;
 151         QSharedPointer<QTrackingTooltip> m_trackingTooltip;
 152         QTimer m_timer;
 153         bool m_bDragging;
 154 };
 155
 156 } // namespace PrivateDragDrop
 157
 158 QString CDragDropData::GetMimeFormatForType(const char* type)
 159 {
 160         QString typeStr(type);
 161         typeStr = typeStr.simplified();
 162         typeStr.replace(' ', '_');
 163
 164         return QString("application/crytek;type=\"%1\"").arg(type);
 165 }
 166
 167 const CDragDropData* CDragDropData::FromDragDropEvent(const QDropEvent* event)
 168 {
 169         return FromMimeDataSafe(event->mimeData());
 170 }
 171
 172 const CDragDropData* CDragDropData::FromMimeData(const QMimeData* mimeData)
 173 {
 174         return static_cast<const CDragDropData*>(mimeData);
 175 }
 176
 177 const CDragDropData* CDragDropData::FromMimeDataSafe(const QMimeData* mimeData)
 178 {
 179         const CDragDropData* result = qobject_cast<const CDragDropData*>(mimeData);
 180         CRY_ASSERT_MESSAGE(result, "The QMimeData is not of type CDragDropData");
 181         return result;
 182 }
 183
 184 QByteArray CDragDropData::GetCustomData(const char* type) const
 185 {
 186         return QMimeData::data(GetMimeFormatForType(type));
 187 }
 188
 189 bool CDragDropData::HasFilePaths() const
 190 {
 191         // List of accepted MIME formats (in this order).
 192         return hasUrls();
 193         //These formats are not currently supported but are part of the mime types you get when drag&dropping from Windows explorer
 194 /*
 195                 || hasFormat(QStringLiteral("application/x-qt-windows-mime;value=\"FileName\""))
 196                 || hasFormat(QStringLiteral("application/x-qt-windows-mime;value=\"FileNameW\""));
 197 */
 198 }
 199
 200 QStringList CDragDropData::GetFilePaths() const
 201 {
 202         //TODO : test drag&drop of several files from browser
 203         QStringList filePaths;
 204
 205         // List of accepted MIME formats (in this order).
 206         if (hasUrls())
 207         {
 208                 QList<QUrl> urls = QMimeData::urls();
 209                 QList<QUrl>::const_iterator it = urls.constBegin();
 210
 211                 for (; it != urls.constEnd(); ++it)
 212                         filePaths.append((*it).toLocalFile());
 213         }
 214
 215         return filePaths;
 216 }
 217
 218 void CDragDropData::SetCustomData(const char* type, const QByteArray& data)
 219 {
 220         QMimeData::setData(GetMimeFormatForType(type), data);
 221 }
 222
 223 bool CDragDropData::HasCustomData(const char* type) const
 224 {
 225         return QMimeData::hasFormat(GetMimeFormatForType(type));
 226 }
 227
 228 void CDragDropData::ShowDragText(QWidget* pWidget, const QString& what)
 229 {
 230         using namespace Private_DragDrop;
 231         CDragTooltip::GetInstance().SetText(pWidget, what);
 232 }
 233
 234 void CDragDropData::ShowDragPixmap(QWidget* pWidget, const QPixmap& what, const QPoint& pixmapCursorOffset /*= QPoint()*/)
 235 {
 236         using namespace Private_DragDrop;
 237         CDragTooltip::GetInstance().SetPixmap(pWidget, what);
 238
 239         if(!pixmapCursorOffset.isNull())
 240                 CDragTooltip::GetInstance().SetCursorOffset(pixmapCursorOffset);
 241 }
 242
 243 void CDragDropData::ClearDragTooltip(QWidget* pWidget)
 244 {
 245         using namespace Private_DragDrop;
 246         CDragTooltip::GetInstance().Clear(pWidget);
 247 }
 248
 249 void CDragDropData::StartDrag(QObject* pDragSource, Qt::DropActions supportedActions, QMimeData* pMimeData, const QPixmap* pPixmap, const QPoint& pixmapCursorOffset /*= QPoint()*/)
 250 {
 251         using namespace Private_DragDrop;
 252         QDrag* const pDrag = new QDrag(pDragSource);
 253         pDrag->setMimeData(pMimeData);
 254         CDragTooltip& tooltip = CDragTooltip::GetInstance();
 255         tooltip.StartDrag();
 256         CDragDropData* const pDragDropData = (CDragDropData*)pMimeData;
 257         if (pDragDropData && pPixmap)
 258         {
 259                 tooltip.SetDefaultPixmap(*pPixmap);
 260                 if (!pixmapCursorOffset.isNull())
 261                         tooltip.SetCursorOffset(pixmapCursorOffset);
 262         }
 263         pDrag->exec(supportedActions);
 264         tooltip.StopDrag();
 265 }