465 lines
16 KiB
C++
465 lines
16 KiB
C++
#include "timeline/TimelineWidget.h"
|
||
|
||
#include <algorithm>
|
||
#include <cmath>
|
||
|
||
#include <QFontMetrics>
|
||
#include <QMouseEvent>
|
||
#include <QPainter>
|
||
#include <QResizeEvent>
|
||
#include <QWheelEvent>
|
||
|
||
namespace {
|
||
|
||
static int pickMajorStep(double pixelsPerFrame) {
|
||
// 主刻度间距（帧）：保证屏幕上大约 ≥ 48px
|
||
const double targetPx = 48.0;
|
||
const double raw = targetPx / std::max(pixelsPerFrame, 1e-6);
|
||
static const int cand[] = {1, 2, 5, 10, 15, 20, 25, 50, 75, 100, 150, 200, 250, 500, 1000, 2000, 5000};
|
||
for (int c : cand) {
|
||
if (c >= raw) return c;
|
||
}
|
||
return cand[sizeof(cand) / sizeof(cand[0]) - 1];
|
||
}
|
||
|
||
static int pickMinorStep(int major) {
|
||
if (major >= 100) return major / 5;
|
||
if (major >= 20) return major / 4;
|
||
if (major >= 10) return major / 5;
|
||
if (major >= 5) return 1;
|
||
return 1;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
TimelineWidget::TimelineWidget(QWidget* parent)
|
||
: QWidget(parent) {
|
||
setMouseTracking(true);
|
||
// 单行紧凑：标尺 + 轨道（帧号画在播放头处，随坐标轴滚动）
|
||
setMinimumHeight(kRulerHeight + 18 + 6);
|
||
setFocusPolicy(Qt::StrongFocus);
|
||
setToolTip(QStringLiteral("片段时间轴(固定 0-600)：左键拖动播放头；滚轮：逐帧"));
|
||
}
|
||
|
||
void TimelineWidget::resizeEvent(QResizeEvent* e) {
|
||
QWidget::resizeEvent(e);
|
||
update();
|
||
}
|
||
|
||
void TimelineWidget::setFrameRange(int start, int end) {
|
||
(void)start;
|
||
(void)end;
|
||
update();
|
||
}
|
||
|
||
void TimelineWidget::setCurrentFrame(int frame) {
|
||
setFrameInternal(frame, false);
|
||
}
|
||
|
||
void TimelineWidget::setCurrentFrameProgrammatic(int frame) {
|
||
const int f = std::clamp(frame, kStart, kEnd - 1);
|
||
if (m_currentFrame == f) {
|
||
return;
|
||
}
|
||
m_currentFrame = f;
|
||
update();
|
||
}
|
||
|
||
void TimelineWidget::setSelectionRange(int start, int end) {
|
||
if (start < 0 || end < 0) {
|
||
m_selStart = -1;
|
||
m_selEnd = -1;
|
||
update();
|
||
return;
|
||
}
|
||
const int lo = std::min(start, end);
|
||
const int hi = std::max(start, end);
|
||
m_selStart = std::clamp(lo, kStart, kEnd - 1);
|
||
m_selEnd = std::clamp(hi, m_selStart, kEnd - 1);
|
||
update();
|
||
}
|
||
|
||
static void uniqSort(QVector<int>& v) {
|
||
std::sort(v.begin(), v.end());
|
||
v.erase(std::unique(v.begin(), v.end()), v.end());
|
||
}
|
||
|
||
static bool containsFrame(const QVector<int>& v, int f) {
|
||
return std::binary_search(v.begin(), v.end(), f);
|
||
}
|
||
|
||
void TimelineWidget::setKeyframeTracks(const QVector<int>& locFrames,
|
||
const QVector<int>& scaleFrames,
|
||
const QVector<int>& imgFrames,
|
||
const QVector<int>& visFrames) {
|
||
m_locFrames = locFrames;
|
||
m_scaleFrames = scaleFrames;
|
||
m_imgFrames = imgFrames;
|
||
m_visFrames = visFrames;
|
||
uniqSort(m_locFrames);
|
||
uniqSort(m_scaleFrames);
|
||
uniqSort(m_imgFrames);
|
||
uniqSort(m_visFrames);
|
||
|
||
bool ok = true;
|
||
if (m_selKeyKind == KeyKind::Location) ok = containsFrame(m_locFrames, m_selKeyFrame);
|
||
if (m_selKeyKind == KeyKind::UserScale) ok = containsFrame(m_scaleFrames, m_selKeyFrame);
|
||
if (m_selKeyKind == KeyKind::Image) ok = containsFrame(m_imgFrames, m_selKeyFrame);
|
||
if (m_selKeyKind == KeyKind::Visibility) ok = containsFrame(m_visFrames, m_selKeyFrame);
|
||
if (!ok) {
|
||
m_selKeyKind = KeyKind::None;
|
||
m_selKeyFrame = -1;
|
||
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
|
||
}
|
||
update();
|
||
}
|
||
|
||
void TimelineWidget::setToolKeyframeTracks(const QVector<int>& locFrames,
|
||
const QVector<int>& visFrames) {
|
||
m_locFrames = locFrames;
|
||
m_scaleFrames.clear();
|
||
m_imgFrames.clear();
|
||
m_visFrames = visFrames;
|
||
uniqSort(m_locFrames);
|
||
uniqSort(m_visFrames);
|
||
|
||
bool ok = true;
|
||
if (m_selKeyKind == KeyKind::Location) ok = containsFrame(m_locFrames, m_selKeyFrame);
|
||
if (m_selKeyKind == KeyKind::Visibility) ok = containsFrame(m_visFrames, m_selKeyFrame);
|
||
if (!ok) {
|
||
m_selKeyKind = KeyKind::None;
|
||
m_selKeyFrame = -1;
|
||
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
|
||
}
|
||
update();
|
||
}
|
||
|
||
QRect TimelineWidget::contentRect() const {
|
||
return QRect(contentLeft(), 3, contentWidth(), std::max(24, height() - 6));
|
||
}
|
||
|
||
QRect TimelineWidget::rulerRect() const {
|
||
const QRect c = contentRect();
|
||
return QRect(c.left(), c.top(), c.width(), kRulerHeight);
|
||
}
|
||
|
||
QRect TimelineWidget::keyAreaRect() const {
|
||
const QRect c = contentRect();
|
||
const QRect r = rulerRect();
|
||
const int top = r.bottom();
|
||
return QRect(c.left(), top, c.width(), std::max(1, c.bottom() - top));
|
||
}
|
||
|
||
double TimelineWidget::frameToXf(double frame) const {
|
||
const double pxf = double(contentWidth()) / double(std::max(1, kEnd - kStart));
|
||
return double(contentLeft()) + (frame - double(kStart)) * pxf;
|
||
}
|
||
|
||
int TimelineWidget::frameToX(int frame) const {
|
||
return int(std::lround(frameToXf(double(frame))));
|
||
}
|
||
|
||
double TimelineWidget::xToFramef(int x) const {
|
||
const double pxf = double(contentWidth()) / double(std::max(1, kEnd - kStart));
|
||
return double(kStart) + double(x - contentLeft()) / std::max(pxf, 1e-9);
|
||
}
|
||
|
||
int TimelineWidget::xToFrame(int x) const {
|
||
return int(std::lround(xToFramef(x)));
|
||
}
|
||
|
||
void TimelineWidget::setFrameInternal(int frame, bool commit) {
|
||
const int f = std::clamp(frame, kStart, kEnd - 1);
|
||
// 松手时若帧未变：只发 committed，禁止再发 scrubbed，否则主窗口会双次求值/刷新导致帧号与红线闪烁
|
||
if (m_currentFrame == f) {
|
||
if (commit) {
|
||
emit frameCommitted(f);
|
||
}
|
||
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);
|
||
|
||
p.fillRect(rect(), palette().base());
|
||
|
||
const QRect cr = contentRect();
|
||
const QRect kr = keyAreaRect();
|
||
const QRect rr = rulerRect();
|
||
const double fLeft = double(kStart);
|
||
const int visMin = kStart;
|
||
const int visMax = kEnd;
|
||
|
||
auto frameVisible = [&](int fr) { return fr >= visMin && fr <= visMax; };
|
||
|
||
// —— 区间：贯穿标尺+轨道，贴在时间坐标上 ——
|
||
if (m_selStart >= 0 && m_selEnd >= 0) {
|
||
const int x0 = frameToX(m_selStart);
|
||
const int x1 = frameToX(m_selEnd);
|
||
const int xa = std::min(x0, x1);
|
||
const int xb = std::max(x0, x1);
|
||
QRect sel(xa, cr.top(), xb - xa, cr.height());
|
||
sel = sel.intersected(cr);
|
||
if (sel.width() > 0) {
|
||
QColor c = palette().highlight().color();
|
||
c.setAlpha(72);
|
||
p.setPen(Qt::NoPen);
|
||
p.setBrush(c);
|
||
p.drawRoundedRect(sel, 3, 3);
|
||
p.setPen(QPen(palette().highlight().color(), 1));
|
||
p.setBrush(Qt::NoBrush);
|
||
p.drawRoundedRect(sel, 3, 3);
|
||
}
|
||
}
|
||
|
||
// —— 关键帧切分背景（仅轨道）：按可见范围切分，不因 m_end 隐藏尾部关键帧 ——
|
||
QVector<int> allK;
|
||
allK.reserve(m_locFrames.size() + m_scaleFrames.size() + m_imgFrames.size() + m_visFrames.size());
|
||
allK += m_locFrames;
|
||
allK += m_scaleFrames;
|
||
allK += m_imgFrames;
|
||
allK += m_visFrames;
|
||
std::sort(allK.begin(), allK.end());
|
||
allK.erase(std::unique(allK.begin(), allK.end()), allK.end());
|
||
|
||
const int v0 = visMin;
|
||
const int v1 = visMax;
|
||
QVector<int> cuts;
|
||
cuts.reserve(allK.size() + 4);
|
||
cuts.push_back(v0);
|
||
for (int k : allK) {
|
||
if (k > v0 && k < v1) {
|
||
cuts.push_back(k);
|
||
}
|
||
}
|
||
cuts.push_back(v1);
|
||
std::sort(cuts.begin(), cuts.end());
|
||
cuts.erase(std::unique(cuts.begin(), cuts.end()), cuts.end());
|
||
|
||
for (int i = 0; i + 1 < cuts.size(); ++i) {
|
||
const int a = cuts[i];
|
||
const int b = cuts[i + 1];
|
||
if (a >= b) continue;
|
||
const int x0 = frameToX(a);
|
||
const int x1 = frameToX(b);
|
||
if (x1 < kr.left() || x0 > kr.right()) continue;
|
||
QRect seg(std::max(x0, kr.left()), kr.top(), std::min(x1, kr.right()) - std::max(x0, kr.left()), kr.height());
|
||
if (seg.width() <= 0) continue;
|
||
QColor c = (i % 2) ? QColor(255, 255, 255, 28) : QColor(0, 0, 0, 12);
|
||
p.setPen(Qt::NoPen);
|
||
p.setBrush(c);
|
||
p.drawRect(seg);
|
||
}
|
||
|
||
const QColor rail = palette().mid().color();
|
||
p.setPen(Qt::NoPen);
|
||
p.setBrush(rail);
|
||
p.drawRoundedRect(kr, 4, 4);
|
||
|
||
// —— 关键帧：竖线贯穿标尺+轨道（位置钉在帧坐标上，随平移/缩放移动）——
|
||
auto drawKeyLine = [&](int fr, const QColor& col, KeyKind kind, int xOffPx) {
|
||
if (!frameVisible(fr)) return;
|
||
const int x = frameToX(fr) + xOffPx;
|
||
if (x < cr.left() - 4 || x > cr.right() + 4) return;
|
||
const bool sel = (m_selKeyFrame == fr && m_selKeyKind == kind);
|
||
QPen pen(col, sel ? 3.2 : 2.0);
|
||
pen.setCapStyle(Qt::FlatCap);
|
||
p.setPen(pen);
|
||
p.drawLine(x, cr.top() + 1, x, cr.bottom() - 1);
|
||
const int yb = kr.bottom() - 4;
|
||
QPolygonF dia;
|
||
dia << QPointF(x, yb - 5) << QPointF(x + 4, yb) << QPointF(x, yb + 4) << QPointF(x - 4, yb);
|
||
p.setPen(Qt::NoPen);
|
||
p.setBrush(col);
|
||
p.drawPolygon(dia);
|
||
};
|
||
|
||
for (int fr : m_imgFrames) drawKeyLine(fr, QColor(70, 130, 240), KeyKind::Image, -3);
|
||
for (int fr : m_locFrames) drawKeyLine(fr, QColor(240, 110, 40), KeyKind::Location, -1);
|
||
for (int fr : m_scaleFrames) drawKeyLine(fr, QColor(80, 190, 90), KeyKind::UserScale, 1);
|
||
for (int fr : m_visFrames) drawKeyLine(fr, QColor(160, 100, 230), KeyKind::Visibility, 3);
|
||
|
||
// —— 标尺底与刻度文字（与帧一一对应，随 view 滚动）——
|
||
p.setPen(Qt::NoPen);
|
||
p.setBrush(palette().alternateBase());
|
||
p.drawRoundedRect(rr, 3, 3);
|
||
|
||
const double pxf = double(contentWidth()) / double(std::max(1, kEnd - kStart));
|
||
const int major = pickMajorStep(pxf);
|
||
const int minor = pickMinorStep(major);
|
||
QPen minorPen(QColor(60, 60, 60, 100));
|
||
minorPen.setWidth(1);
|
||
QPen majorPen(QColor(35, 35, 35, 170));
|
||
majorPen.setWidth(1);
|
||
QFont rulerFont = font();
|
||
rulerFont.setPointSize(std::max(7, rulerFont.pointSize() - 1));
|
||
p.setFont(rulerFont);
|
||
|
||
for (int f = static_cast<int>(std::floor(fLeft / minor) * minor); f <= visMax + minor; f += minor) {
|
||
if (f < visMin - minor) continue;
|
||
const double xf = frameToXf(f);
|
||
if (xf < rr.left() - 2 || xf > rr.right() + 2) continue;
|
||
const int xi = int(std::lround(xf));
|
||
const bool isMajor = (major > 0) && (f % major == 0);
|
||
p.setPen(isMajor ? majorPen : minorPen);
|
||
const int tickH = isMajor ? 8 : 4;
|
||
p.drawLine(xi, rr.bottom() - tickH, xi, rr.bottom());
|
||
if (isMajor && pxf > 0.28) {
|
||
p.setPen(QColor(25, 25, 25, 235));
|
||
const QString txt = QString::number(f);
|
||
const int tw = QFontMetrics(rulerFont).horizontalAdvance(txt);
|
||
int tx = xi - tw / 2;
|
||
tx = std::clamp(tx, rr.left() + 1, rr.right() - tw - 1);
|
||
p.drawText(tx, rr.top() + QFontMetrics(rulerFont).ascent() + 1, txt);
|
||
}
|
||
}
|
||
|
||
// 播放头 + 帧号（钉在轴上，与红线同一 x）
|
||
const int cx = frameToX(m_currentFrame);
|
||
p.setPen(QPen(QColor(220, 55, 55, 250), 2.0));
|
||
p.drawLine(QPoint(cx, cr.top()), QPoint(cx, cr.bottom()));
|
||
|
||
QFont bf = font();
|
||
bf.setBold(true);
|
||
p.setFont(bf);
|
||
QFontMetrics fm(bf);
|
||
const QString ft = QString::number(m_currentFrame);
|
||
const int tw = fm.horizontalAdvance(ft);
|
||
const int ph = fm.height() + 3;
|
||
const int pw = tw + 10;
|
||
int px = cx - pw / 2;
|
||
if (pw <= cr.width() - 4) {
|
||
px = std::clamp(px, cr.left() + 2, cr.right() - pw - 2);
|
||
} else {
|
||
px = cr.left() + 2;
|
||
}
|
||
const int py = cr.top() + 1;
|
||
p.setPen(QPen(QColor(180, 40, 40), 1));
|
||
p.setBrush(QColor(255, 245, 245, 245));
|
||
p.drawRoundedRect(px, py, pw, ph, 3, 3);
|
||
p.setPen(QColor(20, 20, 20));
|
||
p.drawText(px + 5, py + fm.ascent() + 1, ft);
|
||
}
|
||
|
||
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 cr = contentRect();
|
||
const int mx = e->pos().x();
|
||
const int my = e->pos().y();
|
||
|
||
auto trySelectKey = [&](KeyKind kind, const QVector<int>& frames, int xOff) -> bool {
|
||
const int nearest = findNearestFrameInTrack(frames, f);
|
||
if (nearest < 0) return false;
|
||
const int xk = frameToX(nearest) + xOff;
|
||
if (std::abs(mx - xk) > 9) return false;
|
||
if (my < cr.top() || my > cr.bottom()) return false;
|
||
m_selKeyKind = kind;
|
||
m_selKeyFrame = nearest;
|
||
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
|
||
update();
|
||
return true;
|
||
};
|
||
|
||
if (trySelectKey(KeyKind::Visibility, m_visFrames, 3) || trySelectKey(KeyKind::Image, m_imgFrames, -3)
|
||
|| trySelectKey(KeyKind::Location, m_locFrames, -1) || trySelectKey(KeyKind::UserScale, m_scaleFrames, 1)) {
|
||
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;
|
||
all += m_visFrames;
|
||
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 double steps = e->angleDelta().y() / 120.0;
|
||
const int delta = (steps > 0) ? 1 : -1;
|
||
// 滚轮只走 scrubbed：避免每格同时 scrub+committed 造成双次 refresh 与帧号闪烁
|
||
setFrameInternal(m_currentFrame + delta, false);
|
||
e->accept();
|
||
}
|