|
|
#include "Visualization/VisualizationDragDropContainer.h"
|
|
|
#include "DragDropHelper.h"
|
|
|
#include "SqpApplication.h"
|
|
|
#include "Visualization/VisualizationDragWidget.h"
|
|
|
|
|
|
#include "Common/VisualizationDef.h"
|
|
|
|
|
|
#include <QDrag>
|
|
|
#include <QDragEnterEvent>
|
|
|
#include <QVBoxLayout>
|
|
|
|
|
|
#include <cmath>
|
|
|
#include <memory>
|
|
|
|
|
|
Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
|
|
|
|
|
|
struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
|
|
|
|
|
|
QVBoxLayout *m_Layout;
|
|
|
QStringList m_AcceptedMimeTypes;
|
|
|
QStringList m_MergeAllowedMimeTypes;
|
|
|
VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
|
|
|
= [](auto mimeData) { return true; };
|
|
|
|
|
|
explicit VisualizationDragDropContainerPrivate(QWidget *widget)
|
|
|
{
|
|
|
m_Layout = new QVBoxLayout(widget);
|
|
|
m_Layout->setContentsMargins(0, 0, 0, 0);
|
|
|
}
|
|
|
|
|
|
bool acceptMimeData(const QMimeData *data) const
|
|
|
{
|
|
|
for (const auto &type : m_AcceptedMimeTypes) {
|
|
|
if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
bool allowMergeMimeData(const QMimeData *data) const
|
|
|
{
|
|
|
for (const auto &type : m_MergeAllowedMimeTypes) {
|
|
|
if (data->hasFormat(type)) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
bool hasPlaceHolder() const
|
|
|
{
|
|
|
return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
|
|
|
}
|
|
|
|
|
|
VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
|
|
|
{
|
|
|
VisualizationDragWidget *dragWidget = nullptr;
|
|
|
|
|
|
for (auto child : parent->children()) {
|
|
|
auto widget = qobject_cast<VisualizationDragWidget *>(child);
|
|
|
if (widget && widget->isVisible()) {
|
|
|
if (widget->frameGeometry().contains(pos)) {
|
|
|
dragWidget = widget;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return dragWidget;
|
|
|
}
|
|
|
|
|
|
bool cursorIsInContainer(QWidget *container) const
|
|
|
{
|
|
|
auto adustNum = 18; // to be safe, in case of scrollbar on the side
|
|
|
auto containerRect = QRect(QPoint(), container->contentsRect().size())
|
|
|
.adjusted(adustNum, adustNum, -adustNum, -adustNum);
|
|
|
return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
|
|
|
: QWidget{parent},
|
|
|
impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
|
|
|
{
|
|
|
setAcceptDrops(true);
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
|
|
|
{
|
|
|
impl->m_Layout->addWidget(dragWidget);
|
|
|
disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
|
|
|
connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
|
|
|
&VisualizationDragDropContainer::startDrag);
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::insertDragWidget(int index,
|
|
|
VisualizationDragWidget *dragWidget)
|
|
|
{
|
|
|
impl->m_Layout->insertWidget(index, dragWidget);
|
|
|
disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
|
|
|
connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
|
|
|
&VisualizationDragDropContainer::startDrag);
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
|
|
|
{
|
|
|
impl->m_AcceptedMimeTypes = mimeTypes;
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
|
|
|
{
|
|
|
impl->m_MergeAllowedMimeTypes = mimeTypes;
|
|
|
}
|
|
|
|
|
|
int VisualizationDragDropContainer::countDragWidget() const
|
|
|
{
|
|
|
auto nbGraph = 0;
|
|
|
for (auto child : children()) {
|
|
|
if (qobject_cast<VisualizationDragWidget *>(child)) {
|
|
|
nbGraph += 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return nbGraph;
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::setAcceptMimeDataFunction(
|
|
|
VisualizationDragDropContainer::AcceptMimeDataFunction fun)
|
|
|
{
|
|
|
impl->m_AcceptMimeDataFun = fun;
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
|
|
|
const QPoint &dragPosition)
|
|
|
{
|
|
|
auto &helper = sqpApp->dragDropHelper();
|
|
|
helper.resetDragAndDrop();
|
|
|
|
|
|
// Note: The management of the drag object is done by Qt
|
|
|
auto drag = new QDrag{dragWidget};
|
|
|
drag->setHotSpot(dragPosition);
|
|
|
|
|
|
auto mimeData = dragWidget->mimeData();
|
|
|
drag->setMimeData(mimeData);
|
|
|
|
|
|
auto pixmap = QPixmap(dragWidget->size());
|
|
|
dragWidget->render(&pixmap);
|
|
|
drag->setPixmap(pixmap);
|
|
|
|
|
|
auto image = pixmap.toImage();
|
|
|
mimeData->setImageData(image);
|
|
|
mimeData->setUrls({helper.imageTemporaryUrl(image)});
|
|
|
|
|
|
if (impl->m_Layout->indexOf(dragWidget) >= 0) {
|
|
|
helper.setCurrentDragWidget(dragWidget);
|
|
|
|
|
|
if (impl->cursorIsInContainer(this)) {
|
|
|
auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
|
|
|
helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
|
|
|
dragWidget->setVisible(false);
|
|
|
}
|
|
|
|
|
|
// Note: The exec() is blocking on windows but not on linux and macOS
|
|
|
drag->exec(Qt::MoveAction | Qt::CopyAction);
|
|
|
}
|
|
|
else {
|
|
|
qCWarning(LOG_VisualizationDragDropContainer())
|
|
|
<< tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
|
|
|
"VisualizationDragWidget is not found in this container.");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
|
|
|
{
|
|
|
if (impl->acceptMimeData(event->mimeData())) {
|
|
|
event->acceptProposedAction();
|
|
|
|
|
|
auto &helper = sqpApp->dragDropHelper();
|
|
|
|
|
|
if (!impl->hasPlaceHolder()) {
|
|
|
auto dragWidget = helper.getCurrentDragWidget();
|
|
|
|
|
|
if (dragWidget) {
|
|
|
// If the drag&drop is internal to the visualization, entering the container hide
|
|
|
// the dragWidget which was hidden by the dragLeaveEvent
|
|
|
auto parentWidget
|
|
|
= qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
|
|
|
if (parentWidget) {
|
|
|
dragWidget->setVisible(false);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
|
|
|
|
|
|
if (dragWidgetHovered) {
|
|
|
auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
|
|
|
|
|
|
if (dragWidget) {
|
|
|
auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
|
|
|
if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
|
|
|
// Correction of the index if the drop occurs in the same container
|
|
|
// and if the drag is started from the visualization (in that case, the
|
|
|
// dragWidget is hidden)
|
|
|
hoveredWidgetIndex += 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
|
|
|
}
|
|
|
else {
|
|
|
helper.insertPlaceHolder(impl->m_Layout, 0);
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
// do nothing
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
event->ignore();
|
|
|
}
|
|
|
|
|
|
QWidget::dragEnterEvent(event);
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
|
|
|
{
|
|
|
Q_UNUSED(event);
|
|
|
|
|
|
auto &helper = sqpApp->dragDropHelper();
|
|
|
|
|
|
if (!impl->cursorIsInContainer(this)) {
|
|
|
helper.removePlaceHolder();
|
|
|
|
|
|
auto dragWidget = helper.getCurrentDragWidget();
|
|
|
if (dragWidget) {
|
|
|
// dragWidget has a value only if the drag is started from the visualization
|
|
|
// In that case, shows the drag widget at its original place
|
|
|
// So the drag widget doesn't stay hidden if the drop occurs outside the visualization
|
|
|
// drop zone (It is not possible to catch a drop event outside of the application)
|
|
|
|
|
|
if (dragWidget) {
|
|
|
dragWidget->setVisible(true);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
// Leave event probably received for a child widget.
|
|
|
// Do nothing.
|
|
|
// Note: The DragLeave event, doesn't have any mean to determine who sent it.
|
|
|
}
|
|
|
|
|
|
QWidget::dragLeaveEvent(event);
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
|
|
|
{
|
|
|
if (impl->acceptMimeData(event->mimeData())) {
|
|
|
auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
|
|
|
if (dragWidgetHovered) {
|
|
|
auto canMerge = impl->allowMergeMimeData(event->mimeData());
|
|
|
|
|
|
auto nbDragWidget = countDragWidget();
|
|
|
if (nbDragWidget > 0) {
|
|
|
auto graphHeight = qMax(size().height() / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
|
|
|
|
|
|
auto dropIndex = floor(event->pos().y() / graphHeight);
|
|
|
auto zoneSize = qMin(graphHeight / 3.0, 150.0);
|
|
|
|
|
|
auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
|
|
|
auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
|
|
|
|
|
|
auto &helper = sqpApp->dragDropHelper();
|
|
|
auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
|
|
|
|
|
|
if (isOnTop || isOnBottom) {
|
|
|
if (isOnBottom) {
|
|
|
dropIndex += 1;
|
|
|
}
|
|
|
|
|
|
if (helper.getCurrentDragWidget()) {
|
|
|
auto dragWidgetIndex
|
|
|
= impl->m_Layout->indexOf(helper.getCurrentDragWidget());
|
|
|
if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
|
|
|
// Correction of the index if the drop occurs in the same container
|
|
|
// and if the drag is started from the visualization (in that case, the
|
|
|
// dragWidget is hidden)
|
|
|
dropIndex += 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (dropIndex != placeHolderIndex) {
|
|
|
helper.insertPlaceHolder(impl->m_Layout, dropIndex);
|
|
|
}
|
|
|
}
|
|
|
else if (canMerge) {
|
|
|
// drop on the middle -> merge
|
|
|
if (impl->hasPlaceHolder()) {
|
|
|
helper.removePlaceHolder();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
qCWarning(LOG_VisualizationDragDropContainer())
|
|
|
<< tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
|
|
|
"container");
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
// No hovered drag widget, the mouse is probably hover the placeHolder
|
|
|
// Do nothing
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
event->ignore();
|
|
|
}
|
|
|
|
|
|
QWidget::dragMoveEvent(event);
|
|
|
}
|
|
|
|
|
|
void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
|
|
|
{
|
|
|
if (impl->acceptMimeData(event->mimeData())) {
|
|
|
auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
|
|
|
if (impl->hasPlaceHolder()) {
|
|
|
auto &helper = sqpApp->dragDropHelper();
|
|
|
|
|
|
auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
|
|
|
|
|
|
if (dragWidget) {
|
|
|
auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
|
|
|
if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
|
|
|
// Correction of the index if the drop occurs in the same container
|
|
|
// and if the drag is started from the visualization (in that case, the
|
|
|
// dragWidget is hidden)
|
|
|
droppedIndex -= 1;
|
|
|
}
|
|
|
|
|
|
dragWidget->setVisible(true);
|
|
|
}
|
|
|
|
|
|
event->acceptProposedAction();
|
|
|
|
|
|
helper.removePlaceHolder();
|
|
|
|
|
|
emit dropOccured(droppedIndex, event->mimeData());
|
|
|
}
|
|
|
else {
|
|
|
qCWarning(LOG_VisualizationDragDropContainer())
|
|
|
<< tr("VisualizationDragDropContainer::dropEvent, couldn't drop because the "
|
|
|
"placeHolder is not found.");
|
|
|
Q_ASSERT(false);
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
event->ignore();
|
|
|
}
|
|
|
|
|
|
QWidget::dropEvent(event);
|
|
|
}
|
|
|
|
