372 lines
15 KiB
C++
372 lines
15 KiB
C++
#include "Document/ProjectWorkspace.h"
|
|
#include "IO/ProjectStore.h"
|
|
#include "Rendering/EditorCanvas.h"
|
|
#include "UI/NativeLayerList.h"
|
|
#include <QApplication>
|
|
#include <QDrag>
|
|
#include <QDragEnterEvent>
|
|
#include <QDragMoveEvent>
|
|
#include <QDropEvent>
|
|
#include <QKeyEvent>
|
|
#include <QMimeData>
|
|
#include <QMouseEvent>
|
|
#include <QPainter>
|
|
#include <QPainterPath>
|
|
#include <QScrollBar>
|
|
|
|
const QString NativeLayerList::maskType = QStringLiteral("com.compositor.layer-mask");
|
|
const QString NativeLayerList::sourceType = QStringLiteral("com.compositor.layer-list");
|
|
|
|
namespace {
|
|
// A glyph drawn black over a white halo.
|
|
void drawHaloed(QPainter &painter, const QPainterPath &path, double width)
|
|
{
|
|
painter.setBrush(Qt::NoBrush);
|
|
painter.setPen(QPen(Qt::white, width + 2.4, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
|
|
painter.drawPath(path);
|
|
painter.setPen(QPen(Qt::black, width, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
|
|
painter.drawPath(path);
|
|
}
|
|
}
|
|
|
|
void LayerColumn::paintEvent(QPaintEvent *)
|
|
{
|
|
if (!indicator)
|
|
return;
|
|
QPainter painter(this);
|
|
QColor accent = palette().color(QPalette::Highlight);
|
|
if (!indicatorFills) {
|
|
painter.fillRect(*indicator, accent);
|
|
return;
|
|
}
|
|
accent.setAlphaF(0.3);
|
|
painter.fillRect(*indicator, accent);
|
|
painter.setPen(QPen(palette().color(QPalette::Highlight), 2));
|
|
painter.drawRect(indicator->adjusted(1, 1, -1, -1));
|
|
}
|
|
|
|
std::unique_ptr<QMimeData> NativeLayerList::dragData(const LayerCell &cell) const
|
|
{
|
|
// The pressed row, with the selection it belongs to.
|
|
const QSet<QUuid> selected = m_session.selectedLayerIDs();
|
|
const bool whole = selected.contains(cell.layerID());
|
|
QStringList lines;
|
|
for (const ImageLayer &row : m_rows) {
|
|
if (row.id == cell.layerID() || (whole && selected.contains(row.id)))
|
|
lines << uuidString(row.id);
|
|
}
|
|
auto data = std::make_unique<QMimeData>();
|
|
data->setData(ProjectWorkspace::layerType, lines.join(QLatin1Char('\n')).toUtf8());
|
|
data->setData(sourceType, m_dragToken.toUtf8());
|
|
return data;
|
|
}
|
|
|
|
// Alt offers a copy alone; plain drags move or copy.
|
|
void NativeLayerList::startDrag(LayerCell &cell, Qt::KeyboardModifiers modifiers)
|
|
{
|
|
if (!m_session.canEditLayers())
|
|
return;
|
|
const bool copying = modifiers.testFlag(Qt::AltModifier) && !modifiers.testFlag(Qt::ControlModifier);
|
|
auto *drag = new QDrag(this);
|
|
drag->setMimeData(dragData(cell).release());
|
|
drag->setPixmap(cell.grab());
|
|
if (copying)
|
|
drag->setDragCursor(CanvasView::duplicateCursor(devicePixelRatio()).pixmap(), Qt::CopyAction);
|
|
drag->exec(copying ? Qt::CopyAction : Qt::MoveAction | Qt::CopyAction, copying ? Qt::CopyAction : Qt::MoveAction);
|
|
}
|
|
|
|
void NativeLayerList::startMaskDrag(LayerThumbnailButton &thumbnail)
|
|
{
|
|
auto *data = new QMimeData;
|
|
data->setData(maskType, uuidString(thumbnail.layerID).toUtf8());
|
|
auto *drag = new QDrag(this);
|
|
drag->setMimeData(data);
|
|
drag->setPixmap(thumbnail.grab());
|
|
drag->exec(Qt::CopyAction);
|
|
}
|
|
|
|
// Dragged rows in order, folder contents left out; strangers none.
|
|
std::vector<QUuid> NativeLayerList::draggedLayers(const QMimeData &data) const
|
|
{
|
|
const std::vector<QUuid> dropped = ProjectWorkspace::layerIDs(data);
|
|
const QSet<QUuid> dragged(dropped.begin(), dropped.end());
|
|
QSet<QUuid> carried;
|
|
for (const QUuid &id : dragged)
|
|
carried.unite(m_session.descendantIDs(id));
|
|
std::vector<QUuid> result;
|
|
for (const ImageLayer &row : m_rows) {
|
|
if (dragged.contains(row.id) && !carried.contains(row.id))
|
|
result.push_back(row.id);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::optional<LayerDropTarget> NativeLayerList::dropTarget(const QMimeData &data, Qt::DropActions offered, QPoint listPoint) const
|
|
{
|
|
if (data.hasFormat(effectType)) {
|
|
// An effect lands on whichever row is under the pointer.
|
|
const int row = rowAt(listPoint);
|
|
const std::optional<LayerEffectSelection> source = draggedEffect(data);
|
|
if (row < 0 || !source || !m_session.canCopyEffect(source->kind, source->layerID, m_rows[row].id))
|
|
return std::nullopt;
|
|
return LayerDropTarget{.row = row, .onRow = true, .atBottom = false, .copying = true};
|
|
}
|
|
if (data.hasFormat(maskType)) {
|
|
// A mask lands on whichever row is under the pointer.
|
|
const int row = rowAt(listPoint);
|
|
const std::optional<QUuid> source = ProjectWorkspace::layerID(QString::fromUtf8(data.data(maskType)));
|
|
if (row < 0 || !source || !m_session.canCopyMask(*source, m_rows[row].id))
|
|
return std::nullopt;
|
|
return LayerDropTarget{.row = row, .onRow = true, .atBottom = false, .copying = true};
|
|
}
|
|
// Only this list's rows; canPlaceLayer covers canEditLayers.
|
|
if (!data.hasFormat(ProjectWorkspace::layerType) || QString::fromUtf8(data.data(sourceType)) != m_dragToken)
|
|
return std::nullopt;
|
|
const std::vector<QUuid> ids = draggedLayers(data);
|
|
if (ids.empty())
|
|
return std::nullopt;
|
|
// Swift duplicates when the source offers a copy alone (Alt).
|
|
const bool copying = offered == Qt::CopyAction;
|
|
const QPoint inColumn = m_column->mapFrom(viewport(), viewport()->mapFrom(this, listPoint));
|
|
int row = int(m_rows.size());
|
|
bool onRow = false;
|
|
for (size_t each = 0; each < m_cells.size(); ++each) {
|
|
const QRect box = m_cells[each]->geometry();
|
|
if (inColumn.y() < box.top() - 1) {
|
|
row = int(each);
|
|
break;
|
|
}
|
|
if (inColumn.y() > box.bottom() + 1)
|
|
continue;
|
|
// A folder's middle half takes the drop in.
|
|
const bool middle = std::abs(inColumn.y() - box.center().y()) <= box.height() / 4;
|
|
onRow = m_rows[each].isGroup && middle;
|
|
row = onRow || inColumn.y() < box.center().y() ? int(each) : int(each) + 1;
|
|
break;
|
|
}
|
|
const std::optional<QUuid> parent = onRow ? std::optional(m_rows[row].id) : row < int(m_rows.size()) ? m_rows[row].parentID : std::nullopt;
|
|
for (const QUuid &id : ids) {
|
|
if (!m_session.canPlaceLayer(id, parent))
|
|
return std::nullopt;
|
|
}
|
|
return LayerDropTarget{.row = row, .onRow = onRow, .atBottom = row == int(m_rows.size()), .copying = copying};
|
|
}
|
|
|
|
bool NativeLayerList::acceptDrop(const QMimeData &data, Qt::DropActions offered, QPoint listPoint)
|
|
{
|
|
const std::optional<LayerDropTarget> target = dropTarget(data, offered, listPoint);
|
|
if (!target)
|
|
return false;
|
|
if (data.hasFormat(effectType)) {
|
|
const LayerEffectSelection source = draggedEffect(data).value();
|
|
m_session.copyEffect(source.kind, source.layerID, m_rows[target->row].id);
|
|
return true;
|
|
}
|
|
if (data.hasFormat(maskType)) {
|
|
m_session.copyMask(ProjectWorkspace::layerID(QString::fromUtf8(data.data(maskType))).value(), m_rows[target->row].id);
|
|
return true;
|
|
}
|
|
const std::vector<QUuid> ids = draggedLayers(data);
|
|
// Where the drop lands is worked out once.
|
|
const std::optional<QUuid> parent = target->onRow ? std::optional(m_rows[target->row].id)
|
|
: target->atBottom ? std::nullopt
|
|
: m_rows[target->row].parentID;
|
|
const std::optional<QUuid> above = target->onRow || target->atBottom ? std::nullopt : std::optional(m_rows[target->row].id);
|
|
// Above a row the last lands nearest; in folders, first.
|
|
std::vector<QUuid> order = ids;
|
|
if (target->onRow)
|
|
std::reverse(order.begin(), order.end());
|
|
const bool several = ids.size() > 1;
|
|
m_session.beginEdit(target->copying ? (several ? QStringLiteral("Duplicate Layers") : QStringLiteral("Duplicate Layer"))
|
|
: (several ? QStringLiteral("Move Layers") : QStringLiteral("Move Layer")));
|
|
bool placed = false;
|
|
for (const QUuid &id : order) {
|
|
const bool done = target->copying ? m_session.duplicateLayer(id, parent, above, target->atBottom)
|
|
: m_session.placeLayer(id, parent, above, target->atBottom);
|
|
placed = done || placed;
|
|
}
|
|
// The moved layers stay selected, to drag on together.
|
|
if (placed && !target->copying)
|
|
m_session.selectLayers(QSet<QUuid>(ids.begin(), ids.end()), ids.front());
|
|
m_session.endEdit();
|
|
return placed;
|
|
}
|
|
|
|
void NativeLayerList::showIndicator(const std::optional<LayerDropTarget> &target)
|
|
{
|
|
m_column->indicator = std::nullopt;
|
|
if (target && target->onRow) {
|
|
m_column->indicator = m_cells[size_t(target->row)]->geometry();
|
|
m_column->indicatorFills = true;
|
|
} else if (target) {
|
|
const int y = target->atBottom ? m_cells.back()->geometry().bottom() + 1 : m_cells[size_t(target->row)]->geometry().top() - 1;
|
|
m_column->indicator = QRect(0, y - 1, m_column->width(), 2);
|
|
m_column->indicatorFills = false;
|
|
}
|
|
m_column->update();
|
|
}
|
|
|
|
// The list moves, or copies what Alt offers alone.
|
|
void NativeLayerList::dragEnterEvent(QDragEnterEvent *event)
|
|
{
|
|
const std::optional<LayerDropTarget> target = dropTarget(*event->mimeData(), event->possibleActions(), viewport()->mapToParent(event->position().toPoint()));
|
|
showIndicator(target);
|
|
if (!target)
|
|
return;
|
|
event->setDropAction(target->copying ? Qt::CopyAction : Qt::MoveAction);
|
|
event->accept();
|
|
}
|
|
|
|
void NativeLayerList::dragMoveEvent(QDragMoveEvent *event)
|
|
{
|
|
// Near an edge the list scrolls, as the table does.
|
|
const QPoint inViewport = event->position().toPoint();
|
|
m_dragPoint = inViewport;
|
|
m_dragData = event->mimeData();
|
|
m_dragActions = event->possibleActions();
|
|
autoscroll(inViewport, *event->mimeData(), event->possibleActions());
|
|
const std::optional<LayerDropTarget> target = dropTarget(*event->mimeData(), event->possibleActions(), viewport()->mapToParent(inViewport));
|
|
if (!target) {
|
|
event->ignore();
|
|
return;
|
|
}
|
|
event->setDropAction(target->copying ? Qt::CopyAction : Qt::MoveAction);
|
|
event->accept();
|
|
}
|
|
|
|
void NativeLayerList::autoscroll(QPoint inViewport, const QMimeData &data, Qt::DropActions offered)
|
|
{
|
|
const int margin = 16;
|
|
const int overshoot = inViewport.y() < margin ? inViewport.y() - margin : std::max(0, inViewport.y() - (viewport()->height() - margin));
|
|
if (overshoot != 0)
|
|
verticalScrollBar()->setValue(verticalScrollBar()->value() + overshoot);
|
|
// Held at the edge, the timer scrolls on; elsewhere, rests.
|
|
if (overshoot != 0 && !m_edgeScroll.isActive())
|
|
m_edgeScroll.start();
|
|
else if (overshoot == 0)
|
|
m_edgeScroll.stop();
|
|
showIndicator(dropTarget(data, offered, viewport()->mapToParent(inViewport)));
|
|
}
|
|
|
|
void NativeLayerList::dragLeaveEvent(QDragLeaveEvent *)
|
|
{
|
|
m_edgeScroll.stop();
|
|
m_dragData = nullptr;
|
|
showIndicator(std::nullopt);
|
|
}
|
|
|
|
void NativeLayerList::dropEvent(QDropEvent *event)
|
|
{
|
|
m_edgeScroll.stop();
|
|
m_dragData = nullptr;
|
|
showIndicator(std::nullopt);
|
|
const bool copying = event->possibleActions() == Qt::CopyAction;
|
|
if (!acceptDrop(*event->mimeData(), event->possibleActions(), viewport()->mapToParent(event->position().toPoint())))
|
|
return;
|
|
event->setDropAction(copying ? Qt::CopyAction : Qt::MoveAction);
|
|
event->accept();
|
|
}
|
|
|
|
// Photoshop's create and release clipping pointers, haloed.
|
|
QCursor NativeLayerList::clippingCursor(bool releasing, double ratio)
|
|
{
|
|
QPixmap pixmap(QSize(30, 28) * ratio);
|
|
pixmap.setDevicePixelRatio(ratio);
|
|
pixmap.fill(Qt::transparent);
|
|
QPainter painter(&pixmap);
|
|
painter.setRenderHint(QPainter::Antialiasing, true);
|
|
// An arrow turning down and right, at the left.
|
|
QPainterPath arrow(QPointF(4, 3));
|
|
arrow.lineTo(QPointF(4, 12));
|
|
arrow.lineTo(QPointF(14, 12));
|
|
arrow.moveTo(QPointF(10.5, 8.5));
|
|
arrow.lineTo(QPointF(14, 12));
|
|
arrow.lineTo(QPointF(10.5, 15.5));
|
|
drawHaloed(painter, arrow, 1.8);
|
|
// A box with a badge: plus creates, minus releases.
|
|
QPainterPath box;
|
|
box.addRoundedRect(QRectF(12, 11, 15, 12), 2, 2);
|
|
drawHaloed(painter, box, 1.6);
|
|
QPainterPath badge;
|
|
badge.addEllipse(QPointF(25, 12), 4.5, 4.5);
|
|
painter.setPen(QPen(Qt::white, 1.4));
|
|
painter.setBrush(Qt::black);
|
|
painter.drawPath(badge);
|
|
painter.setPen(QPen(Qt::white, 1.4, Qt::SolidLine, Qt::RoundCap));
|
|
painter.drawLine(QPointF(22.5, 12), QPointF(27.5, 12));
|
|
if (!releasing)
|
|
painter.drawLine(QPointF(25, 9.5), QPointF(25, 14.5));
|
|
return QCursor(pixmap, 3, 3);
|
|
}
|
|
|
|
QCursor NativeLayerList::cursorFor(QPoint listPoint, Qt::KeyboardModifiers modifiers) const
|
|
{
|
|
const int row = rowAt(listPoint);
|
|
if (row < 0 || !(modifiers & (Qt::AltModifier | Qt::ControlModifier)))
|
|
return QCursor(Qt::ArrowCursor);
|
|
const ImageLayer &layer = m_rows[size_t(row)];
|
|
LayerCell &cell = *m_cells[size_t(row)];
|
|
const QPoint inCell = cell.mapFrom(this, listPoint);
|
|
const double ratio = devicePixelRatio();
|
|
// Ctrl over a thumbnail loads it as a selection.
|
|
if (modifiers.testFlag(Qt::ControlModifier)) {
|
|
for (const LayerThumbnailButton *thumbnail : {&cell.thumbnail(), &cell.maskThumbnail()}) {
|
|
if (thumbnail->isVisible() && thumbnail->isEnabled() && thumbnail->geometry().contains(inCell))
|
|
return CanvasView::loadSelectionCursor(ratio);
|
|
}
|
|
return QCursor(Qt::ArrowCursor);
|
|
}
|
|
const bool editable = m_session.canEditLayers();
|
|
// A mask copies, the row duplicates, the strip clips.
|
|
if (cell.maskThumbnail().isVisible() && cell.maskThumbnail().geometry().contains(inCell))
|
|
return editable ? CanvasView::duplicateCursor(ratio) : QCursor(Qt::ArrowCursor);
|
|
if (!isClippingZone(cell, inCell))
|
|
return editable ? CanvasView::duplicateCursor(ratio) : QCursor(Qt::ArrowCursor);
|
|
if (!m_session.canToggleClippingMask(layer.id))
|
|
return QCursor(Qt::ArrowCursor);
|
|
return clippingCursor(layer.maskSourceID.has_value(), ratio);
|
|
}
|
|
|
|
// A modifier changed: the cursor is worked out again.
|
|
void NativeLayerList::refreshCursor()
|
|
{
|
|
viewport()->setCursor(m_hover ? cursorFor(*m_hover, QApplication::keyboardModifiers()) : QCursor(Qt::ArrowCursor));
|
|
}
|
|
|
|
void NativeLayerList::showEvent(QShowEvent *event)
|
|
{
|
|
QScrollArea::showEvent(event);
|
|
// Alt pressed anywhere changes the cursor over the rows.
|
|
qApp->installEventFilter(this);
|
|
}
|
|
|
|
void NativeLayerList::hideEvent(QHideEvent *event)
|
|
{
|
|
qApp->removeEventFilter(this);
|
|
QScrollArea::hideEvent(event);
|
|
}
|
|
|
|
// Alt, Ctrl or hover over rows sets the cursor.
|
|
bool NativeLayerList::eventFilter(QObject *watched, QEvent *event)
|
|
{
|
|
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
|
|
const int key = static_cast<QKeyEvent *>(event)->key();
|
|
if (key == Qt::Key_Alt || key == Qt::Key_Control)
|
|
refreshCursor();
|
|
} else if (event->type() == QEvent::MouseMove && watched->isWidgetType() && isAncestorOf(static_cast<QWidget *>(watched))) {
|
|
const auto *mouse = static_cast<QMouseEvent *>(event);
|
|
m_hover = mapFromGlobal(mouse->globalPosition().toPoint());
|
|
viewport()->setCursor(cursorFor(*m_hover, mouse->modifiers()));
|
|
}
|
|
return QScrollArea::eventFilter(watched, event);
|
|
}
|
|
|
|
bool NativeLayerList::viewportEvent(QEvent *event)
|
|
{
|
|
if (event->type() == QEvent::Leave) {
|
|
m_hover = std::nullopt;
|
|
viewport()->setCursor(QCursor(Qt::ArrowCursor));
|
|
}
|
|
return QScrollArea::viewportEvent(event);
|
|
}
|