311 lines
10 KiB
C++
311 lines
10 KiB
C++
#include "timeline/TimelineWidget.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <QMouseEvent>
|
|
#include <QPainter>
|
|
#include <QWheelEvent>
|
|
|
|
namespace {
|
|
|
|
int clampFrame(int f, int a, int b) {
|
|
if (a > b) std::swap(a, b);
|
|
return std::clamp(f, a, b);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TimelineWidget::TimelineWidget(QWidget* parent)
|
|
: QWidget(parent) {
|
|
setMouseTracking(true);
|
|
setMinimumHeight(28);
|
|
setFocusPolicy(Qt::StrongFocus);
|
|
}
|
|
|
|
void TimelineWidget::setFrameRange(int start, int end) {
|
|
if (m_start == start && m_end == end) {
|
|
return;
|
|
}
|
|
m_start = start;
|
|
m_end = end;
|
|
m_currentFrame = clampFrame(m_currentFrame, m_start, m_end);
|
|
update();
|
|
}
|
|
|
|
void TimelineWidget::setCurrentFrame(int frame) {
|
|
setFrameInternal(frame, false);
|
|
}
|
|
|
|
void TimelineWidget::setSelectionRange(int start, int end) {
|
|
if (start < 0 || end < 0) {
|
|
m_selStart = -1;
|
|
m_selEnd = -1;
|
|
update();
|
|
return;
|
|
}
|
|
m_selStart = clampFrame(std::min(start, end), m_start, m_end);
|
|
m_selEnd = clampFrame(std::max(start, end), m_start, m_end);
|
|
update();
|
|
}
|
|
|
|
void TimelineWidget::setKeyframeTracks(const core::Project::Entity* e) {
|
|
m_locFrames.clear();
|
|
m_scaleFrames.clear();
|
|
m_imgFrames.clear();
|
|
if (!e) {
|
|
update();
|
|
return;
|
|
}
|
|
m_locFrames.reserve(e->locationKeys.size());
|
|
for (const auto& k : e->locationKeys) m_locFrames.push_back(k.frame);
|
|
m_scaleFrames.reserve(e->userScaleKeys.size());
|
|
for (const auto& k : e->userScaleKeys) m_scaleFrames.push_back(k.frame);
|
|
m_imgFrames.reserve(e->imageFrames.size());
|
|
for (const auto& k : e->imageFrames) m_imgFrames.push_back(k.frame);
|
|
|
|
auto uniqSort = [](QVector<int>& v) {
|
|
std::sort(v.begin(), v.end());
|
|
v.erase(std::unique(v.begin(), v.end()), v.end());
|
|
};
|
|
uniqSort(m_locFrames);
|
|
uniqSort(m_scaleFrames);
|
|
uniqSort(m_imgFrames);
|
|
// 轨道变了：若当前选中的关键帧不再存在，则清除
|
|
auto contains = [](const QVector<int>& v, int f) {
|
|
return std::binary_search(v.begin(), v.end(), f);
|
|
};
|
|
bool ok = true;
|
|
if (m_selKeyKind == KeyKind::Location) ok = contains(m_locFrames, m_selKeyFrame);
|
|
if (m_selKeyKind == KeyKind::UserScale) ok = contains(m_scaleFrames, m_selKeyFrame);
|
|
if (m_selKeyKind == KeyKind::Image) ok = contains(m_imgFrames, m_selKeyFrame);
|
|
if (!ok) {
|
|
m_selKeyKind = KeyKind::None;
|
|
m_selKeyFrame = -1;
|
|
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
|
|
}
|
|
update();
|
|
}
|
|
|
|
QRect TimelineWidget::trackRect() const {
|
|
const int pad = 8;
|
|
const int h = height();
|
|
return QRect(pad, 0, std::max(1, width() - pad * 2), h);
|
|
}
|
|
|
|
int TimelineWidget::xToFrame(int x) const {
|
|
const QRect r = trackRect();
|
|
if (r.width() <= 1) return m_start;
|
|
const double t = std::clamp((x - r.left()) / double(r.width() - 1), 0.0, 1.0);
|
|
const int span = std::max(1, m_end - m_start);
|
|
const int f = m_start + int(std::round(t * span));
|
|
return clampFrame(f, m_start, m_end);
|
|
}
|
|
|
|
int TimelineWidget::frameToX(int frame) const {
|
|
const QRect r = trackRect();
|
|
if (r.width() <= 1) return r.left();
|
|
const int f = clampFrame(frame, m_start, m_end);
|
|
const int span = std::max(1, m_end - m_start);
|
|
const double t = double(f - m_start) / double(span);
|
|
return r.left() + int(std::round(t * (r.width() - 1)));
|
|
}
|
|
|
|
void TimelineWidget::setFrameInternal(int frame, bool commit) {
|
|
const int f = clampFrame(frame, m_start, m_end);
|
|
if (m_currentFrame == f && !commit) {
|
|
return;
|
|
}
|
|
m_currentFrame = f;
|
|
update();
|
|
emit frameScrubbed(f);
|
|
if (commit) {
|
|
emit frameCommitted(f);
|
|
}
|
|
}
|
|
|
|
void TimelineWidget::paintEvent(QPaintEvent*) {
|
|
QPainter p(this);
|
|
p.setRenderHint(QPainter::Antialiasing, true);
|
|
|
|
const QRect r = rect();
|
|
p.fillRect(r, palette().base());
|
|
|
|
const QRect tr = trackRect().adjusted(0, 8, 0, -8);
|
|
const QColor rail = palette().mid().color();
|
|
p.setPen(Qt::NoPen);
|
|
p.setBrush(rail);
|
|
p.drawRoundedRect(tr, 6, 6);
|
|
|
|
// selection range
|
|
if (m_selStart >= 0 && m_selEnd >= 0) {
|
|
const int x0 = frameToX(m_selStart);
|
|
const int x1 = frameToX(m_selEnd);
|
|
QRect sel(QPoint(std::min(x0, x1), tr.top()), QPoint(std::max(x0, x1), tr.bottom()));
|
|
sel = sel.adjusted(0, 2, 0, -2);
|
|
QColor c = palette().highlight().color();
|
|
c.setAlpha(50);
|
|
p.setBrush(c);
|
|
p.drawRoundedRect(sel, 4, 4);
|
|
}
|
|
|
|
auto drawDots = [&](const QVector<int>& frames, const QColor& c, int y) {
|
|
p.setBrush(c);
|
|
p.setPen(Qt::NoPen);
|
|
for (int f : frames) {
|
|
if (f < m_start || f > m_end) continue;
|
|
const int x = frameToX(f);
|
|
const bool sel =
|
|
(m_selKeyFrame == f)
|
|
&& ((m_selKeyKind == KeyKind::Image && &frames == &m_imgFrames)
|
|
|| (m_selKeyKind == KeyKind::Location && &frames == &m_locFrames)
|
|
|| (m_selKeyKind == KeyKind::UserScale && &frames == &m_scaleFrames));
|
|
if (sel) {
|
|
p.setPen(QPen(palette().highlight().color(), 2.0));
|
|
p.setBrush(c);
|
|
p.drawEllipse(QPointF(x, y), 4.4, 4.4);
|
|
p.setPen(Qt::NoPen);
|
|
} else {
|
|
p.drawEllipse(QPointF(x, y), 2.6, 2.6);
|
|
}
|
|
}
|
|
};
|
|
|
|
const int yMid = tr.center().y();
|
|
drawDots(m_imgFrames, QColor(80, 160, 255, 230), yMid - 6);
|
|
drawDots(m_locFrames, QColor(255, 120, 0, 230), yMid);
|
|
drawDots(m_scaleFrames, QColor(140, 220, 140, 230), yMid + 6);
|
|
|
|
// current frame caret
|
|
const int cx = frameToX(m_currentFrame);
|
|
p.setPen(QPen(palette().highlight().color(), 2.0));
|
|
p.drawLine(QPoint(cx, tr.top() - 6), QPoint(cx, tr.bottom() + 6));
|
|
}
|
|
|
|
static bool hitDot(const QPoint& pos, int dotX, int dotY, int radiusPx) {
|
|
const int dx = pos.x() - dotX;
|
|
const int dy = pos.y() - dotY;
|
|
return (dx * dx + dy * dy) <= (radiusPx * radiusPx);
|
|
}
|
|
|
|
static int findNearestFrameInTrack(const QVector<int>& frames, int frame) {
|
|
if (frames.isEmpty()) return -1;
|
|
const auto it = std::lower_bound(frames.begin(), frames.end(), frame);
|
|
if (it == frames.begin()) return *it;
|
|
if (it == frames.end()) return frames.back();
|
|
const int a = *(it - 1);
|
|
const int b = *it;
|
|
return (std::abs(frame - a) <= std::abs(b - frame)) ? a : b;
|
|
}
|
|
|
|
static void findIntervalAround(const QVector<int>& allFrames, int frame, int& outA, int& outB) {
|
|
outA = -1;
|
|
outB = -1;
|
|
if (allFrames.size() < 2) return;
|
|
const auto it = std::upper_bound(allFrames.begin(), allFrames.end(), frame);
|
|
if (it == allFrames.begin() || it == allFrames.end()) return;
|
|
outA = *(it - 1);
|
|
outB = *it;
|
|
}
|
|
|
|
void TimelineWidget::mousePressEvent(QMouseEvent* e) {
|
|
if (e->button() == Qt::RightButton) {
|
|
emit contextMenuRequested(mapToGlobal(e->pos()), xToFrame(e->pos().x()));
|
|
return;
|
|
}
|
|
if (e->button() == Qt::LeftButton) {
|
|
m_pressPos = e->pos();
|
|
m_moved = false;
|
|
m_dragging = true;
|
|
setFrameInternal(xToFrame(e->pos().x()), false);
|
|
e->accept();
|
|
return;
|
|
}
|
|
QWidget::mousePressEvent(e);
|
|
}
|
|
|
|
void TimelineWidget::mouseMoveEvent(QMouseEvent* e) {
|
|
if (m_dragging) {
|
|
if ((e->pos() - m_pressPos).manhattanLength() > 3) {
|
|
m_moved = true;
|
|
}
|
|
setFrameInternal(xToFrame(e->pos().x()), false);
|
|
e->accept();
|
|
return;
|
|
}
|
|
QWidget::mouseMoveEvent(e);
|
|
}
|
|
|
|
void TimelineWidget::mouseReleaseEvent(QMouseEvent* e) {
|
|
if (m_dragging && e->button() == Qt::LeftButton) {
|
|
m_dragging = false;
|
|
const int f = xToFrame(e->pos().x());
|
|
setFrameInternal(f, true);
|
|
|
|
// 点击（非拖拽）时做选中：关键帧或区间
|
|
if (!m_moved) {
|
|
const QRect tr = trackRect().adjusted(0, 8, 0, -8);
|
|
const int yMid = tr.center().y();
|
|
const int yImg = yMid - 6;
|
|
const int yLoc = yMid;
|
|
const int ySc = yMid + 6;
|
|
const int rad = 7;
|
|
|
|
auto trySelectKey = [&](KeyKind kind, const QVector<int>& frames, int laneY) -> bool {
|
|
const int nearest = findNearestFrameInTrack(frames, f);
|
|
if (nearest < 0) return false;
|
|
const int x = frameToX(nearest);
|
|
if (hitDot(e->pos(), x, laneY, rad)) {
|
|
m_selKeyKind = kind;
|
|
m_selKeyFrame = nearest;
|
|
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
|
|
update();
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
// 先尝试命中关键帧（按 lane 优先）
|
|
if (trySelectKey(KeyKind::Image, m_imgFrames, yImg)
|
|
|| trySelectKey(KeyKind::Location, m_locFrames, yLoc)
|
|
|| trySelectKey(KeyKind::UserScale, m_scaleFrames, ySc)) {
|
|
// 选中关键帧时清掉区间
|
|
if (m_selStart >= 0 && m_selEnd >= 0) {
|
|
m_selStart = -1;
|
|
m_selEnd = -1;
|
|
emit intervalSelectionChanged(m_selStart, m_selEnd);
|
|
}
|
|
} else {
|
|
// 未命中关键帧：尝试选中由关键帧切分出的区间（使用三轨道的并集）
|
|
QVector<int> all = m_locFrames;
|
|
all += m_scaleFrames;
|
|
all += m_imgFrames;
|
|
std::sort(all.begin(), all.end());
|
|
all.erase(std::unique(all.begin(), all.end()), all.end());
|
|
int a = -1, b = -1;
|
|
findIntervalAround(all, f, a, b);
|
|
if (a >= 0 && b >= 0) {
|
|
setSelectionRange(a, b);
|
|
emit intervalSelectionChanged(m_selStart, m_selEnd);
|
|
// 选中区间时清掉关键帧选中
|
|
if (m_selKeyKind != KeyKind::None) {
|
|
m_selKeyKind = KeyKind::None;
|
|
m_selKeyFrame = -1;
|
|
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
e->accept();
|
|
return;
|
|
}
|
|
QWidget::mouseReleaseEvent(e);
|
|
}
|
|
|
|
void TimelineWidget::wheelEvent(QWheelEvent* e) {
|
|
const int delta = (e->angleDelta().y() > 0) ? 1 : -1;
|
|
setFrameInternal(m_currentFrame + delta, true);
|
|
e->accept();
|
|
}
|
|
|