1726 lines
58 KiB
C++
1726 lines
58 KiB
C++
|
|
|
|
#include "toonzqt/functionpanel.h"
|
|
|
|
// TnzQt includes
|
|
#include "toonzqt/functionselection.h"
|
|
#include "toonzqt/functionsegmentviewer.h"
|
|
#include "toonzqt/imageutils.h"
|
|
#include "functionpaneltools.h"
|
|
#include "toonzqt/gutil.h"
|
|
|
|
// TnzLib includes
|
|
#include "toonz/tframehandle.h"
|
|
#include "toonz/doubleparamcmd.h"
|
|
#include "toonz/toonzfolders.h"
|
|
|
|
// TnzBase includes
|
|
#include "tdoubleparam.h"
|
|
#include "tdoublekeyframe.h"
|
|
#include "tunit.h"
|
|
|
|
// TnzCore includes
|
|
#include "tcommon.h"
|
|
|
|
// Qt includes
|
|
#include <QPainter>
|
|
#include <QMouseEvent>
|
|
#include <QWheelEvent>
|
|
#include <QMenu>
|
|
#include <QSettings>
|
|
|
|
#include <cmath>
|
|
|
|
namespace {
|
|
|
|
void drawCircle(QPainter &painter, double x, double y, double r) {
|
|
painter.drawEllipse(x - r, y - r, 2 * r, 2 * r);
|
|
}
|
|
void drawCircle(QPainter &painter, const QPointF &p, double r) {
|
|
painter.drawEllipse(p.x() - r, p.y() - r, 2 * r, 2 * r);
|
|
}
|
|
void drawSquare(QPainter &painter, double x, double y, double r) {
|
|
painter.drawRect(x - r, y - r, 2 * r, 2 * r);
|
|
}
|
|
void drawSquare(QPainter &painter, const QPointF &p, double r) {
|
|
drawSquare(painter, p.x(), p.y(), r);
|
|
}
|
|
|
|
void drawRoundedSquare(QPainter &painter, const QPointF &p, double r) {
|
|
painter.drawRoundRect(p.x() - r, p.y() - r, 2 * r, 2 * r, 99, 99);
|
|
}
|
|
|
|
double norm2(const QPointF &p) { return p.x() * p.x() + p.y() * p.y(); }
|
|
|
|
class FunctionPanelZoomer final : public ImageUtils::ShortcutZoomer {
|
|
FunctionPanel *m_panel;
|
|
|
|
public:
|
|
FunctionPanelZoomer(FunctionPanel *panel)
|
|
: ShortcutZoomer(panel), m_panel(panel) {}
|
|
|
|
bool zoom(bool zoomin, bool resetZoom) override {
|
|
if (resetZoom)
|
|
m_panel->fitGraphToWindow();
|
|
else {
|
|
double f = 1.25;
|
|
double sc = zoomin ? f : 1.0 / f;
|
|
QPoint center(m_panel->width() / 2, m_panel->height() / 2);
|
|
m_panel->zoom(sc, sc, center);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
//=============================================================================
|
|
//
|
|
// Ruler
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class Ruler {
|
|
double m_minValue, m_step;
|
|
int m_labelPeriod, m_labelOffset, m_tickCount;
|
|
|
|
double m_unit, m_pan, m_vOrigin;
|
|
int m_x0, m_x1;
|
|
int m_minLabelDistance, m_minDistance;
|
|
double m_minStep;
|
|
|
|
public:
|
|
Ruler();
|
|
|
|
// unit,pan define the world to viewport transformation: pixel = value * unit
|
|
// + pan
|
|
// note: unit can be <0 (e.g. in the vertical rulers)
|
|
// use vOrigin!=0 when there is a offset between values and labels
|
|
// (e.g. frame=0 is visualized as 1)
|
|
void setTransform(double unit, double pan, double vOrigin = 0) {
|
|
m_unit = unit;
|
|
m_pan = pan;
|
|
m_vOrigin = vOrigin;
|
|
}
|
|
|
|
void setRange(int x0, int x1) {
|
|
m_x0 = x0;
|
|
m_x1 = x1;
|
|
} // [x0,x1] is the pixel range
|
|
|
|
// set minimum distance (pixel) between two consecutive labels
|
|
void setMinLabelDistance(int distance) { m_minLabelDistance = distance; }
|
|
// set minimum distance (pixel) between two consecutive ticks
|
|
void setMinDistance(int distance) { m_minDistance = distance; }
|
|
|
|
// use setMinStep to define a minimum tick (e.g. for integer rulers as 'frame'
|
|
// call setMinStep(1);)
|
|
void setMinStep(double step) { m_minStep = step; }
|
|
|
|
void compute(); // call compute() once, before calling the following methods
|
|
|
|
int getTickCount() const { return m_tickCount; }
|
|
double getTick(int index) const { return m_minValue + index * m_step; }
|
|
bool isLabel(int index) const {
|
|
return ((m_labelOffset + index) % m_labelPeriod) == 0;
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Ruler::Ruler()
|
|
: m_minValue(0)
|
|
, m_step(1)
|
|
, m_labelPeriod(2)
|
|
, m_labelOffset(0)
|
|
, m_tickCount(0)
|
|
, m_unit(1)
|
|
, m_pan(0)
|
|
, m_x0(0)
|
|
, m_x1(100)
|
|
, m_minLabelDistance(20)
|
|
, m_minDistance(5)
|
|
, m_minStep(0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Ruler::compute() {
|
|
assert(m_x0 < m_x1);
|
|
assert(m_unit != 0.0);
|
|
assert(m_minLabelDistance > 0);
|
|
assert(m_minDistance >= 0);
|
|
// compute m_step (world distance between two adjacent ticks)
|
|
// and m_labelPeriod (number of ticks between two adjacent labels)
|
|
|
|
// the distance (world units) between two labels must be >=
|
|
// minLabelWorldDistance
|
|
const double absUnit = std::abs(m_unit);
|
|
const double minLabelWorldDistance = m_minLabelDistance / absUnit;
|
|
const double minWorldDistance = m_minDistance / absUnit;
|
|
|
|
// we want the minimum step with:
|
|
// step*labelPeriod (i.e. label distance) >= minLabelWorldDistance
|
|
// step (i.e. tick distance) >= minWorldDistance
|
|
// Note: labelPeriod alternates between 5 and 2 => labelPeriod' =
|
|
// 7-labelPeriod
|
|
m_step = 1;
|
|
m_labelPeriod = 5;
|
|
if (m_step * m_labelPeriod >= minLabelWorldDistance &&
|
|
m_step >= minWorldDistance) {
|
|
while (m_step >= minLabelWorldDistance &&
|
|
m_step / (7 - m_labelPeriod) >= minWorldDistance) {
|
|
m_labelPeriod = 7 - m_labelPeriod;
|
|
m_step /= m_labelPeriod;
|
|
}
|
|
} else {
|
|
do {
|
|
m_step *= m_labelPeriod;
|
|
m_labelPeriod =
|
|
7 - m_labelPeriod; // m_labelPeriod alternates between 5 and 2
|
|
} while (m_step * m_labelPeriod < minLabelWorldDistance ||
|
|
m_step < minWorldDistance);
|
|
}
|
|
|
|
if (m_step >= minLabelWorldDistance) {
|
|
m_labelPeriod = 1;
|
|
}
|
|
|
|
if (m_step * m_labelPeriod < m_minStep) {
|
|
m_step = m_minStep;
|
|
m_labelPeriod = 1;
|
|
} else if (m_step < m_minStep) {
|
|
m_step *= m_labelPeriod;
|
|
m_labelPeriod = 1;
|
|
}
|
|
|
|
// compute range
|
|
double v0 = (m_x0 - m_pan) / m_unit; // left margin (world units)
|
|
double v1 = (m_x1 - m_pan) / m_unit; // right margin (world units)
|
|
if (m_unit < 0) tswap(v0, v1);
|
|
int i0 =
|
|
tfloor((v0 - m_vOrigin) / m_step); // largest tick <=v0 is i0 * m_step
|
|
int i1 =
|
|
tceil((v1 - m_vOrigin) / m_step); // smallest tick >=v1 is i1 * m_step
|
|
m_minValue = i0 * m_step + m_vOrigin;
|
|
m_tickCount = i1 - i0 + 1;
|
|
|
|
m_labelOffset = i0 >= 0 ? (i0 % m_labelPeriod)
|
|
: (m_labelPeriod - ((-i0) % m_labelPeriod));
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
//=============================================================================
|
|
//
|
|
// FunctionPanel::Gadget
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
FunctionPanel::Gadget::Gadget(FunctionPanel::Handle handle, int kIndex,
|
|
const QPointF &p, int rx, int ry,
|
|
const QPointF &pointPos)
|
|
: m_handle(handle)
|
|
, m_kIndex(kIndex)
|
|
, m_hitRegion(QRect((int)p.x() - rx, (int)p.y() - ry, 2 * rx, 2 * ry))
|
|
, m_pos(p)
|
|
, m_pointPos(pointPos)
|
|
, m_channel(0)
|
|
, m_keyframePosition(0) {}
|
|
|
|
//=============================================================================
|
|
//
|
|
// FunctionPanel
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
FunctionPanel::FunctionPanel(QWidget *parent)
|
|
: QDialog(parent)
|
|
, m_functionTreeModel(0)
|
|
, m_viewTransform()
|
|
, m_valueAxisX(50)
|
|
, m_frameAxisY(50)
|
|
, m_graphViewportY(50)
|
|
, m_frameHandle(0)
|
|
, m_dragTool(0)
|
|
, m_currentFrameStatus(0)
|
|
, m_selection(0)
|
|
, m_curveShape(SMOOTH) {
|
|
setWindowTitle(tr("Function Curves"));
|
|
|
|
m_viewTransform.translate(50, 200);
|
|
m_viewTransform.scale(5, -1);
|
|
|
|
setFocusPolicy(Qt::ClickFocus);
|
|
setMouseTracking(true);
|
|
m_highlighted.handle = None;
|
|
m_highlighted.gIndex = -1;
|
|
m_cursor.visible = false;
|
|
m_cursor.frame = m_cursor.value = 0;
|
|
m_curveLabel.text = "";
|
|
m_curveLabel.curve = 0;
|
|
|
|
// load the dialog size
|
|
TFilePath fp(ToonzFolder::getMyModuleDir() + TFilePath(mySettingsFileName));
|
|
QSettings mySettings(toQString(fp), QSettings::IniFormat);
|
|
|
|
mySettings.beginGroup("Dialogs");
|
|
setGeometry(
|
|
mySettings.value("FunctionCurves", QRect(500, 500, 400, 300)).toRect());
|
|
mySettings.endGroup();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
FunctionPanel::~FunctionPanel() {
|
|
// save the dialog size
|
|
TFilePath fp(ToonzFolder::getMyModuleDir() + TFilePath(mySettingsFileName));
|
|
QSettings mySettings(toQString(fp), QSettings::IniFormat);
|
|
|
|
mySettings.beginGroup("Dialogs");
|
|
mySettings.setValue("FunctionCurves", geometry());
|
|
mySettings.endGroup();
|
|
|
|
delete m_dragTool;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double FunctionPanel::getPixelRatio(TDoubleParam *curve) const {
|
|
double framePixelSize = xToFrame(1) - xToFrame(0);
|
|
assert(framePixelSize > 0);
|
|
double valuePixelSize = fabs(yToValue(curve, 1) - yToValue(curve, 0));
|
|
assert(valuePixelSize > 0);
|
|
return framePixelSize / valuePixelSize;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double FunctionPanel::frameToX(double f) const {
|
|
return m_viewTransform.m11() * f + m_viewTransform.dx();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double FunctionPanel::xToFrame(double x) const {
|
|
return (x - m_viewTransform.dx()) / m_viewTransform.m11();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double FunctionPanel::valueToY(TDoubleParam *curve, double v) const {
|
|
const double bigNumber = 1.0e9;
|
|
TMeasure *m = curve->getMeasure();
|
|
if (m) {
|
|
const TUnit *unit = m->getCurrentUnit();
|
|
v = unit->convertTo(v);
|
|
}
|
|
return tcrop(m_viewTransform.m22() * v + m_viewTransform.dy(), -bigNumber,
|
|
bigNumber);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double FunctionPanel::yToValue(TDoubleParam *curve, double y) const {
|
|
double v = (y - m_viewTransform.dy()) / m_viewTransform.m22();
|
|
TMeasure *m = curve->getMeasure();
|
|
if (m) {
|
|
const TUnit *unit = m->getCurrentUnit();
|
|
v = unit->convertFrom(v);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::pan(int dx, int dy) {
|
|
QTransform m;
|
|
m.translate(dx, dy);
|
|
m_viewTransform *= m;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::zoom(double sx, double sy, const QPoint ¢er) {
|
|
QTransform m;
|
|
m.translate(center.x(), center.y());
|
|
m.scale(sx, sy);
|
|
m.translate(-center.x(), -center.y());
|
|
m_viewTransform *= m;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPointF FunctionPanel::getWinPos(TDoubleParam *curve, double frame,
|
|
double value) const {
|
|
return QPointF(frameToX(frame), valueToY(curve, value));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPointF FunctionPanel::getWinPos(TDoubleParam *curve, double frame) const {
|
|
return getWinPos(curve, frame, curve->getValue(frame));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPointF FunctionPanel::getWinPos(TDoubleParam *curve,
|
|
const TDoubleKeyframe &kf) const {
|
|
return getWinPos(curve, kf.m_frame, kf.m_value);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int FunctionPanel::getCurveDistance(TDoubleParam *curve, const QPoint &winPos) {
|
|
double frame = xToFrame(winPos.x());
|
|
double value = curve->getValue(frame);
|
|
double curveY = valueToY(curve, value);
|
|
return std::abs(curveY - winPos.y());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
FunctionTreeModel::Channel *FunctionPanel::findClosestChannel(
|
|
const QPoint &winPos, int maxWinDistance) {
|
|
FunctionTreeModel::Channel *closestChannel = 0;
|
|
int minDistance = maxWinDistance;
|
|
int i;
|
|
for (i = 0; i < m_functionTreeModel->getActiveChannelCount(); i++) {
|
|
FunctionTreeModel::Channel *channel =
|
|
m_functionTreeModel->getActiveChannel(i);
|
|
TDoubleParam *curve = channel->getParam();
|
|
int distance = getCurveDistance(curve, winPos);
|
|
if (distance < minDistance) {
|
|
closestChannel = channel;
|
|
minDistance = distance;
|
|
}
|
|
}
|
|
return closestChannel;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TDoubleParam *FunctionPanel::findClosestCurve(const QPoint &winPos,
|
|
int maxWinDistance) {
|
|
FunctionTreeModel::Channel *closestChannel =
|
|
findClosestChannel(winPos, maxWinDistance);
|
|
return closestChannel ? closestChannel->getParam() : 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// return the gadget index (-1 if no gadget is close enough)
|
|
int FunctionPanel::findClosestGadget(const QPoint &winPos, Handle &handle,
|
|
int maxDistance) {
|
|
// search only handles close enough (i.e. distance<maxDistance)
|
|
int minDistance = maxDistance;
|
|
int k = -1;
|
|
for (int i = 0; i < m_gadgets.size(); i++) {
|
|
if (m_gadgets[i].m_hitRegion.contains(winPos)) {
|
|
QPoint p;
|
|
double d = (m_gadgets[i].m_hitRegion.center() - winPos).manhattanLength();
|
|
if (d < minDistance) {
|
|
k = i;
|
|
minDistance = d;
|
|
}
|
|
}
|
|
}
|
|
if (k >= 0) {
|
|
handle = m_gadgets[k].m_handle;
|
|
return k; // m_gadgets[k].m_kIndex;
|
|
} else {
|
|
handle = None;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TDoubleParam *FunctionPanel::getCurrentCurve() const {
|
|
FunctionTreeModel::Channel *currentChannel =
|
|
m_functionTreeModel ? m_functionTreeModel->getCurrentChannel() : 0;
|
|
if (!currentChannel)
|
|
return 0;
|
|
else
|
|
return currentChannel->getParam();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPainterPath FunctionPanel::getSegmentPainterPath(TDoubleParam *curve,
|
|
int segmentIndex, int x0,
|
|
int x1) {
|
|
double frame0 = xToFrame(x0), frame1 = xToFrame(x1);
|
|
int kCount = curve->getKeyframeCount();
|
|
int step = 1;
|
|
if (kCount > 0) {
|
|
if (segmentIndex < 0)
|
|
frame1 = std::min(
|
|
frame1, curve->keyframeIndexToFrame(0)); // before first keyframe
|
|
else if (segmentIndex >= kCount - 1)
|
|
frame0 = std::max(frame0, curve->keyframeIndexToFrame(
|
|
kCount - 1)); // after last keyframe
|
|
else {
|
|
// between keyframes
|
|
TDoubleKeyframe kf = curve->getKeyframe(segmentIndex);
|
|
frame0 = std::max(frame0, kf.m_frame);
|
|
double f = curve->keyframeIndexToFrame(segmentIndex + 1);
|
|
frame1 = std::min(frame1, f);
|
|
step = kf.m_step;
|
|
}
|
|
}
|
|
if (frame0 >= frame1) return QPainterPath();
|
|
double frame;
|
|
double df = xToFrame(3) - xToFrame(0);
|
|
|
|
if (m_curveShape == SMOOTH) {
|
|
frame = frame0;
|
|
} else // FRAME_BASED
|
|
{
|
|
frame = (double)tfloor(frame0);
|
|
df = std::max(df, 1.0);
|
|
}
|
|
|
|
QPainterPath path;
|
|
if (0 <= segmentIndex && segmentIndex < kCount && step > 1) {
|
|
// step>1
|
|
path.moveTo(getWinPos(curve, frame));
|
|
|
|
int f0 = curve->keyframeIndexToFrame(segmentIndex);
|
|
int vFrame = f0 + tfloor(tfloor(frame - f0), step);
|
|
double vValue = curve->getValue(vFrame);
|
|
assert(vFrame <= frame);
|
|
assert(vFrame + step > frame);
|
|
while (vFrame + step < frame1) {
|
|
vValue = curve->getValue(vFrame);
|
|
path.lineTo(getWinPos(curve, vFrame, vValue));
|
|
vFrame += step;
|
|
path.lineTo(getWinPos(curve, vFrame, vValue));
|
|
vValue = curve->getValue(vFrame);
|
|
path.lineTo(getWinPos(curve, vFrame, vValue));
|
|
}
|
|
path.lineTo(getWinPos(curve, frame1, vValue));
|
|
path.lineTo(getWinPos(curve, frame1, curve->getValue(frame1, true)));
|
|
} else {
|
|
// step = 1
|
|
path.moveTo(getWinPos(curve, frame));
|
|
while (frame + df < frame1) {
|
|
frame += df;
|
|
path.lineTo(getWinPos(curve, frame));
|
|
}
|
|
path.lineTo(getWinPos(curve, frame1, curve->getValue(frame1, true)));
|
|
}
|
|
return path;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::drawCurrentFrame(QPainter &painter) {
|
|
int currentframe = 0;
|
|
if (m_frameHandle) currentframe = m_frameHandle->getFrame();
|
|
int x = frameToX(currentframe);
|
|
if (m_currentFrameStatus == 0)
|
|
painter.setPen(Qt::magenta);
|
|
else if (m_currentFrameStatus == 1)
|
|
painter.setPen(Qt::white);
|
|
else
|
|
painter.setPen(m_selectedColor);
|
|
int y = m_graphViewportY + 1;
|
|
painter.drawLine(x - 1, y, x - 1, height());
|
|
painter.drawLine(x + 1, y, x + 1, height());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::drawFrameGrid(QPainter &painter) {
|
|
QFontMetrics fm(painter.font());
|
|
|
|
// ruler background
|
|
painter.setPen(Qt::NoPen);
|
|
painter.setBrush(getRulerBackground());
|
|
painter.drawRect(0, 0, width(), m_frameAxisY);
|
|
|
|
// draw ticks and labels
|
|
Ruler ruler;
|
|
ruler.setTransform(m_viewTransform.m11(), m_viewTransform.dx(), -1);
|
|
ruler.setRange(m_valueAxisX, width());
|
|
ruler.setMinLabelDistance(fm.width("-8888") + 2);
|
|
ruler.setMinDistance(5);
|
|
ruler.setMinStep(1);
|
|
ruler.compute();
|
|
for (int i = 0; i < ruler.getTickCount(); i++) {
|
|
double f = ruler.getTick(i);
|
|
bool isLabel = ruler.isLabel(i);
|
|
int x = frameToX(f);
|
|
painter.setPen(m_textColor);
|
|
int y = m_frameAxisY;
|
|
painter.drawLine(x, y - (isLabel ? 4 : 2), x, y);
|
|
painter.setPen(getFrameLineColor());
|
|
painter.drawLine(x, m_graphViewportY, x, height());
|
|
if (isLabel) {
|
|
painter.setPen(m_textColor);
|
|
QString labelText = QString::number(f + 1);
|
|
painter.drawText(x - fm.width(labelText) / 2, y - 6, labelText);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::drawValueGrid(QPainter &painter) {
|
|
TDoubleParam *curve = getCurrentCurve();
|
|
if (!curve) return;
|
|
|
|
QFontMetrics fm(painter.font());
|
|
|
|
// ruler background
|
|
painter.setPen(Qt::NoPen);
|
|
painter.setBrush(getRulerBackground());
|
|
painter.drawRect(0, 0, m_valueAxisX, height());
|
|
|
|
Ruler ruler;
|
|
ruler.setTransform(m_viewTransform.m22(), m_viewTransform.dy());
|
|
ruler.setRange(m_graphViewportY, height());
|
|
ruler.setMinLabelDistance(fm.height() + 2);
|
|
ruler.setMinDistance(5);
|
|
ruler.compute();
|
|
|
|
painter.setBrush(Qt::NoBrush);
|
|
for (int i = 0; i < ruler.getTickCount(); i++) {
|
|
double v = ruler.getTick(i);
|
|
bool isLabel = ruler.isLabel(i);
|
|
int y = tround(m_viewTransform.m22() * v +
|
|
m_viewTransform.dy()); // valueToY(curve, v);
|
|
painter.setPen(m_textColor);
|
|
int x = m_valueAxisX;
|
|
painter.drawLine(x - (isLabel ? 5 : 2), y, x, y);
|
|
|
|
painter.setPen(getValueLineColor());
|
|
painter.drawLine(x, y, width(), y);
|
|
|
|
if (isLabel) {
|
|
painter.setPen(m_textColor);
|
|
QString labelText = QString::number(v);
|
|
painter.drawText(std::max(0, x - 5 - fm.width(labelText)),
|
|
y + fm.height() / 2, labelText);
|
|
}
|
|
}
|
|
if (false && ruler.getTickCount() > 10) {
|
|
double value = ruler.getTick(9);
|
|
double dv = fabs(ruler.getTick(10));
|
|
double frame = 10;
|
|
double df = dv * getPixelRatio(curve);
|
|
QPointF p0 = getWinPos(curve, frame, value);
|
|
QPointF p1 = getWinPos(curve, frame + df, value + dv);
|
|
|
|
painter.setPen(Qt::magenta);
|
|
painter.drawRect(p0.x(), p0.y(), (p1 - p0).x(), (p1 - p0).y());
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::drawOtherCurves(QPainter &painter) {
|
|
painter.setRenderHint(QPainter::Antialiasing, false);
|
|
painter.setBrush(Qt::NoBrush);
|
|
int x0 = m_valueAxisX;
|
|
int x1 = width();
|
|
|
|
QPen solidPen;
|
|
QPen dashedPen;
|
|
QVector<qreal> dashes;
|
|
dashes << 4 << 4;
|
|
dashedPen.setDashPattern(dashes);
|
|
|
|
for (int i = 0; i < m_functionTreeModel->getActiveChannelCount(); i++) {
|
|
FunctionTreeModel::Channel *channel =
|
|
m_functionTreeModel->getActiveChannel(i);
|
|
if (channel->isCurrent()) continue;
|
|
TDoubleParam *curve = channel->getParam();
|
|
QColor color =
|
|
curve == m_curveLabel.curve ? m_selectedColor : getOtherCurvesColor();
|
|
solidPen.setColor(color);
|
|
dashedPen.setColor(color);
|
|
painter.setBrush(Qt::NoBrush);
|
|
|
|
int kCount = curve->getKeyframeCount();
|
|
if (kCount == 0) {
|
|
// no control points
|
|
painter.setPen(dashedPen);
|
|
painter.drawPath(getSegmentPainterPath(curve, 0, x0, x1));
|
|
}
|
|
// draw control points and handles
|
|
else {
|
|
for (int k = -1; k < kCount; k++) {
|
|
painter.setPen((k < 0 || k >= kCount - 1) ? dashedPen : solidPen);
|
|
painter.drawPath(getSegmentPainterPath(curve, k, x0, x1));
|
|
}
|
|
painter.setPen(m_textColor);
|
|
painter.setBrush(m_subColor);
|
|
for (int k = 0; k < kCount; k++) {
|
|
double frame = curve->keyframeIndexToFrame(k);
|
|
QPointF p = getWinPos(curve, frame, curve->getValue(frame));
|
|
painter.drawRect(p.x() - 1, p.y() - 1, 3, 3);
|
|
QPointF p2 = getWinPos(curve, frame, curve->getValue(frame, true));
|
|
if (p2.y() != p.y()) {
|
|
painter.drawRect(p2.x() - 1, p2.y() - 1, 3, 3);
|
|
painter.setPen(solidPen);
|
|
painter.drawLine(p, p2);
|
|
painter.setPen(m_textColor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
painter.setBrush(Qt::NoBrush);
|
|
painter.setPen(m_textColor);
|
|
painter.setRenderHint(QPainter::Antialiasing, false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::updateGadgets(TDoubleParam *curve) {
|
|
m_gadgets.clear();
|
|
|
|
TDoubleKeyframe oldKf;
|
|
oldKf.m_type = TDoubleKeyframe::None;
|
|
|
|
int keyframeCount = curve->getKeyframeCount();
|
|
|
|
for (int i = 0; i != keyframeCount; ++i) {
|
|
const int pointHitRadius = 10, handleHitRadius = 6;
|
|
|
|
TDoubleKeyframe kf = curve->getKeyframe(i);
|
|
kf.m_value = curve->getValue(
|
|
kf.m_frame); // Some keyframe values do NOT correspond to the
|
|
// actual displayed curve value (eg with expressions)
|
|
// Build keyframe positions
|
|
QPointF p = getWinPos(curve, kf.m_frame);
|
|
QPointF pLeft = p;
|
|
|
|
if (i == keyframeCount - 1 &&
|
|
curve
|
|
->isCycleEnabled()) // This is probably OBSOLETE. I don't think the
|
|
p = getWinPos(curve, kf.m_frame,
|
|
curve->getValue(
|
|
kf.m_frame,
|
|
true)); // GUI allows cycling single curves nowadays...
|
|
// However, is the assignment correct?
|
|
// Add keyframe gadget(s)
|
|
m_gadgets.push_back(Gadget(Point, i, p, pointHitRadius, pointHitRadius));
|
|
|
|
TPointD currentPointRight(kf.m_frame, kf.m_value);
|
|
TPointD currentPointLeft(currentPointRight);
|
|
|
|
// If the previous segment or the current segment are not keyframe based,
|
|
// the curve can have two different values in kf.m_frame
|
|
if (i > 0 &&
|
|
(!TDoubleKeyframe::isKeyframeBased(
|
|
kf.m_type) || // Keyframe-based are the above mentioned curves
|
|
!TDoubleKeyframe::isKeyframeBased(
|
|
curve->getKeyframe(i - 1)
|
|
.m_type))) // where values stored in keyframes are not used
|
|
{ // to calculate the actual curve values.
|
|
currentPointLeft.y = curve->getValue(kf.m_frame, true);
|
|
pLeft = getWinPos(curve, currentPointLeft);
|
|
m_gadgets.push_back(
|
|
Gadget(Point, i, pLeft, pointHitRadius, pointHitRadius));
|
|
}
|
|
|
|
// Add handle gadgets (eg the speed or ease handles)
|
|
if (getSelection()->isSelected(curve, i)) {
|
|
// Left handle
|
|
switch (oldKf.m_type) {
|
|
case TDoubleKeyframe::SpeedInOut: {
|
|
TPointD speedIn = curve->getSpeedIn(i);
|
|
if (norm2(speedIn) > 0) {
|
|
QPointF q = getWinPos(curve, currentPointLeft + speedIn);
|
|
m_gadgets.push_back(
|
|
Gadget(SpeedIn, i, q, handleHitRadius, handleHitRadius, pLeft));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TDoubleKeyframe::EaseInOut: {
|
|
QPointF q = getWinPos(curve, kf.m_frame + kf.m_speedIn.x);
|
|
m_gadgets.push_back(Gadget(EaseIn, i, q, 6, 15));
|
|
break;
|
|
}
|
|
|
|
case TDoubleKeyframe::EaseInOutPercentage: {
|
|
double easeIn = kf.m_speedIn.x * (kf.m_frame - oldKf.m_frame) * 0.01;
|
|
QPointF q = getWinPos(curve, kf.m_frame + easeIn);
|
|
m_gadgets.push_back(Gadget(EaseInPercentage, i, q, 6, 15));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Right handle
|
|
if (i != keyframeCount - 1) {
|
|
switch (kf.m_type) {
|
|
case TDoubleKeyframe::SpeedInOut: {
|
|
TPointD speedOut = curve->getSpeedOut(i);
|
|
if (norm2(speedOut) > 0) {
|
|
QPointF q = getWinPos(curve, currentPointRight + speedOut);
|
|
m_gadgets.push_back(
|
|
Gadget(SpeedOut, i, q, handleHitRadius, handleHitRadius, p));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TDoubleKeyframe::EaseInOut: {
|
|
QPointF q = getWinPos(curve, kf.m_frame + kf.m_speedOut.x);
|
|
m_gadgets.push_back(Gadget(EaseOut, i, q, 6, 15));
|
|
break;
|
|
}
|
|
|
|
case TDoubleKeyframe::EaseInOutPercentage: {
|
|
double segmentWidth = curve->keyframeIndexToFrame(i + 1) - kf.m_frame;
|
|
double easeOut = segmentWidth * kf.m_speedOut.x * 0.01;
|
|
|
|
QPointF q = getWinPos(curve, kf.m_frame + easeOut);
|
|
m_gadgets.push_back(Gadget(EaseOutPercentage, i, q, 6, 15));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
oldKf = kf;
|
|
}
|
|
|
|
// Add group gadgets (ie those that can be added when multiple channels share
|
|
// the same keyframe data)
|
|
int channelCount = m_functionTreeModel->getActiveChannelCount();
|
|
|
|
// Using a map of vectors. Yes, really. The *ideal* way would be that of
|
|
// copying the first keyframes
|
|
// vector, and then comparing it with the others from each channel - keeping
|
|
// the common data only...
|
|
|
|
typedef std::map<double, std::vector<TDoubleKeyframe>>
|
|
KeyframeTable; // frame -> { keyframes }
|
|
KeyframeTable keyframes;
|
|
|
|
for (int i = 0; i != channelCount; ++i) {
|
|
FunctionTreeModel::Channel *channel =
|
|
m_functionTreeModel->getActiveChannel(i);
|
|
if (!channel) continue;
|
|
|
|
TDoubleParam *curve = channel->getParam();
|
|
for (int j = 0; j != curve->getKeyframeCount(); ++j) {
|
|
TDoubleKeyframe kf = curve->getKeyframe(
|
|
j); // Well... this stuff gets called upon *painting* o_o'
|
|
keyframes[kf.m_frame].push_back(
|
|
kf); // It's bound to be slow. Do we really need it?
|
|
}
|
|
}
|
|
|
|
int groupHandleY = m_graphViewportY - 6;
|
|
|
|
KeyframeTable::iterator it, iEnd(keyframes.end()),
|
|
iLast(keyframes.empty() ? iEnd : --iEnd);
|
|
for (KeyframeTable::iterator it = keyframes.begin(); it != keyframes.end();
|
|
++it) {
|
|
assert(!it->second.empty());
|
|
|
|
double frame = it->first; // redundant, already in the key... oh well
|
|
QPointF p(frameToX(frame), groupHandleY);
|
|
|
|
Gadget gadget((FunctionPanel::Handle)100, -1, p, 6,
|
|
6); // No idea what the '100' type value mean...
|
|
gadget.m_keyframePosition = frame;
|
|
|
|
m_gadgets.push_back(gadget);
|
|
|
|
TDoubleKeyframe kf = it->second[0];
|
|
|
|
if ((int)it->second.size() < channelCount) continue;
|
|
|
|
// All channels had this keyframe - so, add further gadgets about stuff...
|
|
|
|
for (int i = 1; i < channelCount; ++i) {
|
|
// Find out if keyframes data differs
|
|
const TDoubleKeyframe &kf2 = it->second[i];
|
|
|
|
if (kf.m_type != kf2.m_type || kf.m_speedOut.x != kf2.m_speedOut.x)
|
|
kf.m_type = TDoubleKeyframe::None;
|
|
if (kf.m_prevType != kf2.m_prevType || kf.m_speedIn.x != kf2.m_speedIn.x)
|
|
kf.m_prevType = TDoubleKeyframe::None;
|
|
}
|
|
|
|
// NOTE: EaseInOutPercentage are currently NOT SUPPORTED - they would be
|
|
// harder to code and
|
|
// controversial, since the handle position depends on the *segment
|
|
// size* too.
|
|
// So, keyframe data could be shared, but adjacent segment lengths
|
|
// could not...
|
|
|
|
if (it != iLast && (kf.m_type == TDoubleKeyframe::SpeedInOut ||
|
|
kf.m_type == TDoubleKeyframe::EaseInOut) &&
|
|
kf.m_speedOut.x != 0) {
|
|
QPointF p(frameToX(frame + kf.m_speedOut.x), groupHandleY);
|
|
Gadget gadget((FunctionPanel::Handle)101, -1, p, 6, 15); // type value...
|
|
gadget.m_keyframePosition = frame;
|
|
m_gadgets.push_back(gadget);
|
|
}
|
|
|
|
if ((kf.m_prevType == TDoubleKeyframe::SpeedInOut ||
|
|
kf.m_prevType == TDoubleKeyframe::EaseInOut) &&
|
|
kf.m_speedIn.x != 0) {
|
|
QPointF p(frameToX(frame + kf.m_speedIn.x), groupHandleY);
|
|
Gadget gadget((FunctionPanel::Handle)102, -1, p, 6, 15); // type value...
|
|
gadget.m_keyframePosition = frame;
|
|
m_gadgets.push_back(gadget);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::drawCurrentCurve(QPainter &painter) {
|
|
FunctionTreeModel::Channel *channel =
|
|
m_functionTreeModel ? m_functionTreeModel->getCurrentChannel() : 0;
|
|
if (!channel) return;
|
|
TDoubleParam *curve = channel->getParam();
|
|
|
|
painter.setRenderHint(QPainter::Antialiasing, true);
|
|
QColor color = Qt::red;
|
|
QPen solidPen(color);
|
|
QPen dashedPen(color);
|
|
QVector<qreal> dashes;
|
|
dashes << 4 << 4;
|
|
dashedPen.setDashPattern(dashes);
|
|
painter.setBrush(Qt::NoBrush);
|
|
|
|
int x0 = m_valueAxisX;
|
|
int x1 = width();
|
|
|
|
// draw curve
|
|
int kCount = curve->getKeyframeCount();
|
|
if (kCount == 0) {
|
|
// no control points
|
|
painter.setPen(dashedPen);
|
|
painter.drawPath(getSegmentPainterPath(curve, 0, x0, x1));
|
|
} else {
|
|
for (int k = -1; k < kCount; k++) {
|
|
if (k < 0 || k >= kCount - 1) {
|
|
painter.setPen(dashedPen);
|
|
painter.drawPath(getSegmentPainterPath(curve, k, x0, x1));
|
|
} else {
|
|
TDoubleKeyframe::Type segmentType = curve->getKeyframe(k).m_type;
|
|
QColor color = Qt::red;
|
|
if (segmentType == TDoubleKeyframe::Expression ||
|
|
segmentType == TDoubleKeyframe::SimilarShape ||
|
|
segmentType == TDoubleKeyframe::File)
|
|
color = QColor(185, 0, 0);
|
|
if (getSelection()->isSegmentSelected(curve, k))
|
|
solidPen.setWidth(2);
|
|
else
|
|
solidPen.setWidth(0);
|
|
solidPen.setColor(color);
|
|
painter.setPen(solidPen);
|
|
painter.drawPath(getSegmentPainterPath(curve, k, x0, x1));
|
|
}
|
|
}
|
|
}
|
|
painter.setPen(QPen(m_textColor, 0));
|
|
|
|
// draw control points
|
|
updateGadgets(curve);
|
|
painter.setPen(m_textColor);
|
|
for (int j = 0; j < (int)m_gadgets.size(); j++) {
|
|
const Gadget &g = m_gadgets[j];
|
|
if (g.m_handle == SpeedIn || g.m_handle == SpeedOut)
|
|
painter.drawLine(g.m_pointPos, g.m_pos);
|
|
}
|
|
solidPen.setWidth(0);
|
|
solidPen.setColor(Qt::red);
|
|
painter.setPen(solidPen);
|
|
for (int j = 0; j < (int)m_gadgets.size() - 1; j++)
|
|
if (m_gadgets[j].m_handle == Point && m_gadgets[j + 1].m_handle &&
|
|
m_gadgets[j + 1].m_handle != 100 &&
|
|
m_gadgets[j].m_pos.x() == m_gadgets[j + 1].m_pos.x())
|
|
painter.drawLine(m_gadgets[j].m_pos, m_gadgets[j + 1].m_pos);
|
|
|
|
painter.setRenderHint(QPainter::Antialiasing, false);
|
|
for (int j = 0; j < (int)m_gadgets.size(); j++) {
|
|
const Gadget &g = m_gadgets[j];
|
|
int i = g.m_kIndex;
|
|
int r = 1;
|
|
QPointF p = g.m_pos;
|
|
double easeDx = 0, easeHeight = 15, easeTick = 2;
|
|
bool isSelected = getSelection()->isSelected(curve, i);
|
|
bool isHighlighted =
|
|
m_highlighted.handle == g.m_handle && m_highlighted.gIndex == j;
|
|
switch (g.m_handle) {
|
|
case Point:
|
|
painter.setBrush(isSelected ? QColor(255, 126, 0) : m_subColor);
|
|
painter.setPen(m_textColor);
|
|
r = isHighlighted ? 3 : 2;
|
|
drawSquare(painter, p, r);
|
|
break;
|
|
|
|
case SpeedIn:
|
|
case SpeedOut:
|
|
painter.setBrush(m_subColor);
|
|
painter.setPen(m_textColor);
|
|
r = isHighlighted ? 3 : 2;
|
|
drawRoundedSquare(painter, p, r);
|
|
break;
|
|
|
|
case EaseIn:
|
|
case EaseOut:
|
|
case EaseInPercentage:
|
|
case EaseOutPercentage:
|
|
painter.setBrush(Qt::NoBrush);
|
|
painter.setPen(isHighlighted ? QColor(255, 126, 0) : m_textColor);
|
|
painter.drawLine(p.x(), p.y() - easeHeight, p.x(), p.y() + easeHeight);
|
|
if (g.m_handle == EaseIn || g.m_handle == EaseInPercentage)
|
|
easeDx = easeTick;
|
|
else
|
|
easeDx = -easeTick;
|
|
painter.drawLine(p.x(), p.y() - easeHeight, p.x() + easeDx,
|
|
p.y() - easeHeight - easeTick);
|
|
painter.drawLine(p.x(), p.y() + easeHeight, p.x() + easeDx,
|
|
p.y() + easeHeight + easeTick);
|
|
break;
|
|
|
|
painter.setBrush(
|
|
Qt::NoBrush); // isSelected ? QColor(255,126,0) : Qt::white);
|
|
painter.setPen(isHighlighted ? QColor(255, 126, 0) : m_selectedColor);
|
|
painter.drawLine(p.x(), p.y() - 15, p.x(), p.y() + 15);
|
|
break;
|
|
}
|
|
}
|
|
|
|
painter.setRenderHint(QPainter::Antialiasing, false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::drawGroupKeyframes(QPainter &painter) {
|
|
FunctionTreeModel::Channel *channel =
|
|
m_functionTreeModel ? m_functionTreeModel->getCurrentChannel() : 0;
|
|
if (!channel) return;
|
|
QColor color = Qt::red;
|
|
QPen solidPen(color);
|
|
QPen dashedPen(color);
|
|
QVector<qreal> dashes;
|
|
dashes << 4 << 4;
|
|
dashedPen.setDashPattern(dashes);
|
|
painter.setBrush(Qt::NoBrush);
|
|
|
|
int x0 = m_valueAxisX;
|
|
int x1 = width();
|
|
|
|
solidPen.setWidth(0);
|
|
solidPen.setColor(Qt::red);
|
|
painter.setPen(solidPen);
|
|
|
|
std::vector<double> keyframes;
|
|
int y = 0;
|
|
for (int j = 0; j < (int)m_gadgets.size(); j++) {
|
|
const Gadget &g = m_gadgets[j];
|
|
int i = g.m_kIndex;
|
|
int r = 1;
|
|
QPointF p = g.m_pos;
|
|
double easeDx = 0, easeHeight = 15, easeTick = 2;
|
|
bool isSelected = false; // getSelection()->isSelected(curve, i);
|
|
bool isHighlighted =
|
|
m_highlighted.handle == g.m_handle && m_highlighted.gIndex == j;
|
|
painter.setBrush(isSelected ? QColor(255, 126, 0) : m_subColor);
|
|
painter.setPen(m_textColor);
|
|
r = isHighlighted ? 3 : 2;
|
|
QPainterPath pp;
|
|
int d = 2;
|
|
int h = 4;
|
|
switch (g.m_handle) {
|
|
case 100:
|
|
drawSquare(painter, p, r);
|
|
y = p.y();
|
|
keyframes.push_back(p.x());
|
|
break;
|
|
case 101:
|
|
d = -d;
|
|
// Note: NO break!
|
|
case 102:
|
|
painter.setBrush(Qt::NoBrush);
|
|
painter.setPen(isHighlighted ? QColor(255, 126, 0) : m_textColor);
|
|
pp.moveTo(p + QPointF(d, -h));
|
|
pp.lineTo(p + QPointF(0, -h));
|
|
pp.lineTo(p + QPointF(0, h));
|
|
pp.lineTo(p + QPointF(d, h));
|
|
painter.drawPath(pp);
|
|
break;
|
|
}
|
|
}
|
|
painter.setPen(m_textColor);
|
|
for (int i = 0; i + 1 < (int)keyframes.size(); i++) {
|
|
painter.drawLine(keyframes[i] + 3, y, keyframes[i + 1] - 3, y);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::paintEvent(QPaintEvent *e) {
|
|
m_gadgets.clear();
|
|
|
|
QPainter painter(this);
|
|
QFont font("Arial", 8);
|
|
painter.setFont(font);
|
|
QFontMetrics fm(font);
|
|
|
|
// define ruler sizes
|
|
m_valueAxisX = fm.width("-888.88") + 2;
|
|
m_frameAxisY = fm.height() + 2;
|
|
m_graphViewportY = m_frameAxisY + 12;
|
|
int ox = m_valueAxisX;
|
|
int oy0 = m_graphViewportY;
|
|
int oy1 = m_frameAxisY;
|
|
|
|
// QRect bounds(0,0,width(),height());
|
|
|
|
// draw functions background
|
|
painter.setBrush(getBGColor());
|
|
painter.setPen(Qt::NoPen);
|
|
painter.drawRect(ox, oy0, width() - ox, height() - oy0);
|
|
|
|
painter.setClipRect(ox, 0, width() - ox, height());
|
|
drawCurrentFrame(painter);
|
|
drawFrameGrid(painter);
|
|
|
|
painter.setClipRect(0, oy0, width(), height() - oy0);
|
|
drawValueGrid(painter);
|
|
|
|
// draw axes
|
|
painter.setClipping(false);
|
|
painter.setPen(m_textColor);
|
|
painter.drawLine(0, oy0, width(), oy0);
|
|
painter.drawLine(ox, oy1, width(), oy1);
|
|
painter.drawLine(ox, 0, ox, height());
|
|
|
|
// draw curves
|
|
painter.setClipRect(ox + 1, oy0 + 1, width() - ox - 1, height() - oy0 - 1);
|
|
drawOtherCurves(painter);
|
|
drawCurrentCurve(painter);
|
|
|
|
painter.setClipping(false);
|
|
painter.setClipRect(ox + 1, oy1 + 1, width() - ox - 1, oy0 - oy1 - 1);
|
|
drawGroupKeyframes(painter);
|
|
painter.setClipRect(ox + 1, oy0 + 1, width() - ox - 1, height() - oy0 - 1);
|
|
|
|
// tool
|
|
if (m_dragTool) m_dragTool->draw(painter);
|
|
|
|
// cursor
|
|
if (m_cursor.visible) {
|
|
painter.setClipRect(ox + 1, oy0 + 1, width() - ox - 1, height() - oy0 - 1);
|
|
painter.setPen(getOtherCurvesColor());
|
|
int x = frameToX(m_cursor.frame);
|
|
painter.drawLine(x, oy0 + 1, x, oy0 + 10);
|
|
QString text = QString::number(tround(m_cursor.frame) + 1);
|
|
painter.drawText(x - fm.width(text) / 2, oy0 + 10 + fm.height(), text);
|
|
|
|
TDoubleParam *currentCurve = getCurrentCurve();
|
|
if (currentCurve) {
|
|
const TUnit *unit = 0;
|
|
if (currentCurve->getMeasure())
|
|
unit = currentCurve->getMeasure()->getCurrentUnit();
|
|
double displayValue = m_cursor.value;
|
|
if (unit) displayValue = unit->convertTo(displayValue);
|
|
// painter.setClipRect(0,oy0,height(),height()-oy0);
|
|
int y = valueToY(currentCurve, m_cursor.value);
|
|
painter.drawLine(ox, y, ox + 10, y);
|
|
painter.drawText(m_origin.x() + 10, y + 4, QString::number(displayValue));
|
|
}
|
|
}
|
|
|
|
// curve name
|
|
if (m_curveLabel.text != "") {
|
|
painter.setClipRect(ox, oy0, width() - ox, height() - oy0);
|
|
painter.setPen(m_selectedColor);
|
|
painter.drawLine(m_curveLabel.curvePos, m_curveLabel.labelPos);
|
|
painter.drawText(m_curveLabel.labelPos,
|
|
QString::fromStdString(m_curveLabel.text));
|
|
}
|
|
|
|
// painter.setPen(Qt::black);
|
|
// painter.drawText(QPointF(70,70),
|
|
// "f0=" + QString::number(xToFrame(ox)) +
|
|
// " f1=" + QString::number(xToFrame(width())));
|
|
|
|
// painter.setPen(Qt::black);
|
|
// painter.setBrush(Qt::NoBrush);
|
|
// painter.drawRect(ox+10,oy+10,width()-ox-20,height()-oy-20);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::mousePressEvent(QMouseEvent *e) {
|
|
m_cursor.visible = false;
|
|
|
|
// m_dragTool should be 0. just in case...
|
|
assert(m_dragTool == 0);
|
|
m_dragTool = 0;
|
|
|
|
if (e->button() == Qt::MidButton) {
|
|
// mid mouse click => panning
|
|
bool xLocked = e->pos().x() <= m_valueAxisX;
|
|
bool yLocked = e->pos().y() <= m_valueAxisX;
|
|
m_dragTool = new PanDragTool(this, xLocked, yLocked);
|
|
m_dragTool->click(e);
|
|
return;
|
|
} else if (e->button() == Qt::RightButton) {
|
|
// right mouse click => open context menu
|
|
openContextMenu(e);
|
|
return;
|
|
}
|
|
|
|
QPoint winPos = e->pos();
|
|
Handle handle = None;
|
|
const int maxDistance = 20;
|
|
int closestGadgetId = findClosestGadget(e->pos(), handle, maxDistance);
|
|
|
|
if (e->pos().x() > m_valueAxisX && e->pos().y() < m_frameAxisY &&
|
|
closestGadgetId < 0 && (e->modifiers() & Qt::ControlModifier) == 0) {
|
|
// click on topbar => frame zoom
|
|
m_dragTool = new ZoomDragTool(this, ZoomDragTool::FrameZoom);
|
|
} else if (e->pos().x() < m_valueAxisX && e->pos().y() > m_graphViewportY) {
|
|
// click on topbar => value zoom
|
|
m_dragTool = new ZoomDragTool(this, ZoomDragTool::ValueZoom);
|
|
} else if (m_currentFrameStatus == 1 && m_frameHandle != 0 &&
|
|
closestGadgetId < 0) {
|
|
// click on current frame => move frame
|
|
m_currentFrameStatus = 2;
|
|
m_dragTool = new MoveFrameDragTool(this, m_frameHandle);
|
|
}
|
|
|
|
if (0 <= closestGadgetId && closestGadgetId < (int)m_gadgets.size()) {
|
|
if (handle == 100) // group move gadget
|
|
{
|
|
MovePointDragTool *dragTool = new MovePointDragTool(this, 0);
|
|
dragTool->selectKeyframes(m_gadgets[closestGadgetId].m_keyframePosition);
|
|
m_dragTool = dragTool;
|
|
} else if (handle == 101 || handle == 102) {
|
|
m_dragTool = new MoveGroupHandleDragTool(
|
|
this, m_gadgets[closestGadgetId].m_keyframePosition, handle);
|
|
}
|
|
}
|
|
|
|
if (m_dragTool) {
|
|
m_dragTool->click(e);
|
|
return;
|
|
}
|
|
|
|
FunctionTreeModel::Channel *currentChannel =
|
|
m_functionTreeModel ? m_functionTreeModel->getCurrentChannel() : 0;
|
|
if (!currentChannel ||
|
|
getCurveDistance(currentChannel->getParam(), winPos) > maxDistance &&
|
|
closestGadgetId < 0) {
|
|
// if current channel is undefined or its curve is too far from the clicked
|
|
// point
|
|
// the user is possibly trying to select a different curve
|
|
FunctionTreeModel::Channel *channel =
|
|
findClosestChannel(winPos, maxDistance);
|
|
if (channel) {
|
|
channel->setIsCurrent(true);
|
|
// Open folder
|
|
FunctionTreeModel::ChannelGroup *channelGroup =
|
|
channel->getChannelGroup();
|
|
if (!channelGroup->isOpen())
|
|
channelGroup->getModel()->setExpandedItem(channelGroup->createIndex(),
|
|
true);
|
|
currentChannel = channel;
|
|
getSelection()->selectNone();
|
|
}
|
|
}
|
|
|
|
if (currentChannel) {
|
|
TDoubleParam *currentCurve = currentChannel->getParam();
|
|
if (currentCurve) {
|
|
int kIndex =
|
|
closestGadgetId >= 0 ? m_gadgets[closestGadgetId].m_kIndex : -1;
|
|
if (kIndex >= 0) {
|
|
// keyframe clicked
|
|
if (handle == FunctionPanel::Point) {
|
|
// select point (if needed)
|
|
if (!getSelection()->isSelected(currentCurve, kIndex)) {
|
|
// shift-click => add to selection
|
|
if (0 == (e->modifiers() & Qt::ShiftModifier))
|
|
getSelection()->deselectAllKeyframes();
|
|
getSelection()->select(currentCurve, kIndex);
|
|
}
|
|
// move selected point(s)
|
|
MovePointDragTool *dragTool =
|
|
new MovePointDragTool(this, currentCurve);
|
|
if (getSelection()->getSelectedSegment().first != 0) {
|
|
// if a segment is selected then move only the clicked point
|
|
dragTool->addKeyframe2(kIndex);
|
|
} else {
|
|
dragTool->setSelection(getSelection());
|
|
}
|
|
m_dragTool = dragTool;
|
|
} else {
|
|
m_dragTool =
|
|
new MoveHandleDragTool(this, currentCurve, kIndex, handle);
|
|
}
|
|
} else {
|
|
// no keyframe clicked
|
|
int curveDistance =
|
|
getCurveDistance(currentChannel->getParam(), winPos);
|
|
bool isKeyframeable = true;
|
|
bool isGroup = abs(winPos.y() - (m_graphViewportY - 5)) < 5;
|
|
if (0 != (e->modifiers() & Qt::ControlModifier) &&
|
|
(curveDistance < maxDistance || isGroup) && isKeyframeable) {
|
|
// ctrl-clicked near curve => create a new keyframe
|
|
double frame = tround(xToFrame(winPos.x()));
|
|
MovePointDragTool *dragTool =
|
|
new MovePointDragTool(this, isGroup ? 0 : currentCurve);
|
|
// if(curveDistance>=maxDistance)
|
|
// dragTool->m_channelGroup =
|
|
// currentChannel->getChannelGroup();
|
|
dragTool->createKeyframe(frame);
|
|
dragTool->selectKeyframes(frame);
|
|
m_dragTool = dragTool;
|
|
|
|
/*
|
|
int kIndex = dragTool->createKeyframe(frame);
|
|
if(kIndex!=-1)
|
|
{
|
|
getSelection()->deselectAllKeyframes();
|
|
getSelection()->select(currentCurve, kIndex);
|
|
m_dragTool = dragTool;
|
|
}
|
|
*/
|
|
// assert(0);
|
|
} else if (curveDistance < maxDistance) {
|
|
// clicked near curve (but far from keyframes)
|
|
getSelection()->deselectAllKeyframes();
|
|
double frame = xToFrame(winPos.x());
|
|
int k0 = currentCurve->getPrevKeyframe(frame);
|
|
int k1 = currentCurve->getNextKeyframe(frame);
|
|
if (k0 >= 0 && k1 == k0 + 1) {
|
|
// select and move the segment
|
|
getSelection()->selectSegment(currentCurve, k0);
|
|
MovePointDragTool *dragTool =
|
|
new MovePointDragTool(this, currentCurve);
|
|
dragTool->addKeyframe2(k0);
|
|
dragTool->addKeyframe2(k1);
|
|
m_dragTool = dragTool;
|
|
} else {
|
|
// start a rectangular selection
|
|
m_dragTool = new RectSelectTool(this, currentCurve);
|
|
}
|
|
} else {
|
|
// nothing clicked: start a rectangular selection
|
|
getSelection()->deselectAllKeyframes();
|
|
m_dragTool = new RectSelectTool(this, currentCurve);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_dragTool) m_dragTool->click(e);
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::mouseReleaseEvent(QMouseEvent *e) {
|
|
if (m_dragTool) m_dragTool->release(e);
|
|
delete m_dragTool;
|
|
m_dragTool = 0;
|
|
m_cursor.visible = true;
|
|
m_currentFrameStatus = 0;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::mouseMoveEvent(QMouseEvent *e) {
|
|
if (e->buttons()) {
|
|
if (m_dragTool) m_dragTool->drag(e);
|
|
} else {
|
|
m_cursor.frame = xToFrame(e->pos().x());
|
|
m_cursor.value = 0;
|
|
m_cursor.visible = true;
|
|
|
|
TDoubleParam *currentCurve = getCurrentCurve();
|
|
if (currentCurve) {
|
|
Handle handle = None;
|
|
int gIndex = findClosestGadget(e->pos(), handle, 20);
|
|
if (m_highlighted.handle != handle || m_highlighted.gIndex != gIndex) {
|
|
m_highlighted.handle = handle;
|
|
m_highlighted.gIndex = gIndex;
|
|
}
|
|
m_cursor.value = yToValue(currentCurve, e->pos().y());
|
|
}
|
|
|
|
double currentFrame = m_frameHandle ? m_frameHandle->getFrame() : 0;
|
|
if (m_highlighted.handle == None &&
|
|
std::abs(e->pos().x() - frameToX(currentFrame)) < 5)
|
|
m_currentFrameStatus = 1;
|
|
else
|
|
m_currentFrameStatus = 0;
|
|
|
|
FunctionTreeModel::Channel *closestChannel =
|
|
findClosestChannel(e->pos(), 20);
|
|
if (closestChannel && m_highlighted.handle == None) {
|
|
TDoubleParam *curve = closestChannel->getParam();
|
|
if (m_functionTreeModel->getActiveChannelCount() <= 1)
|
|
//|| closestChannel == m_functionTreeModel->getCurrentChannel())
|
|
curve = 0;
|
|
if (curve && m_curveLabel.curve != curve) {
|
|
m_curveLabel.curve = curve;
|
|
QString channelName = closestChannel->data(Qt::DisplayRole).toString();
|
|
QString parentChannelName =
|
|
closestChannel->getChannelGroup()->data(Qt::DisplayRole).toString();
|
|
QString name = parentChannelName + QString(", ") + channelName;
|
|
m_curveLabel.text = name.toStdString();
|
|
|
|
// in order to avoid run off the right-end of visible area
|
|
int textWidth = fontMetrics().width(name) + 30;
|
|
double frame = xToFrame(width() - textWidth);
|
|
|
|
m_curveLabel.curvePos = getWinPos(curve, frame).toPoint();
|
|
m_curveLabel.labelPos = m_curveLabel.curvePos + QPoint(20, -10);
|
|
}
|
|
} else {
|
|
m_curveLabel.text = "";
|
|
m_curveLabel.curve = 0;
|
|
}
|
|
|
|
update();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::keyPressEvent(QKeyEvent *e) {
|
|
FunctionPanelZoomer(this).exec(e);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::enterEvent(QEvent *) {
|
|
m_cursor.visible = true;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::leaveEvent(QEvent *) {
|
|
m_cursor.visible = false;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::wheelEvent(QWheelEvent *e) {
|
|
double factor = exp(0.002 * (double)e->delta());
|
|
zoom(factor, factor, e->pos());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::fitGraphToWindow(bool currentCurveOnly) {
|
|
double f0 = 0, f1 = -1;
|
|
double v0 = 0, v1 = -1;
|
|
|
|
for (int i = 0; i < m_functionTreeModel->getActiveChannelCount(); i++) {
|
|
FunctionTreeModel::Channel *channel =
|
|
m_functionTreeModel->getActiveChannel(i);
|
|
TDoubleParam *curve = channel->getParam();
|
|
if (currentCurveOnly && curve != getCurrentCurve()) continue;
|
|
|
|
const TUnit *unit = 0;
|
|
if (curve->getMeasure()) unit = curve->getMeasure()->getCurrentUnit();
|
|
int n = curve->getKeyframeCount();
|
|
if (n == 0) {
|
|
double v = curve->getDefaultValue();
|
|
if (unit) v = unit->convertTo(v);
|
|
if (v0 > v1)
|
|
v0 = v1 = v;
|
|
else if (v > v1)
|
|
v1 = v;
|
|
else if (v < v0)
|
|
v0 = v;
|
|
} else {
|
|
TDoubleKeyframe k = curve->getKeyframe(0);
|
|
double fa = k.m_frame;
|
|
k = curve->getKeyframe(n - 1);
|
|
double fb = k.m_frame;
|
|
if (f0 > f1) {
|
|
f0 = fa;
|
|
f1 = fb;
|
|
} else {
|
|
f0 = qMin(f0, fa);
|
|
f1 = qMax(f1, fb);
|
|
}
|
|
double v = curve->getValue(fa);
|
|
if (unit) v = unit->convertTo(v);
|
|
if (v0 > v1) v0 = v1 = v;
|
|
int m = 50;
|
|
for (int j = 0; j < m; j++) {
|
|
double t = (double)j / (double)(m - 1);
|
|
double v = curve->getValue((1 - t) * fa + t * fb);
|
|
if (unit) v = unit->convertTo(v);
|
|
v0 = qMin(v0, v);
|
|
v1 = qMax(v1, v);
|
|
}
|
|
}
|
|
}
|
|
if (f0 >= f1 || v0 >= v1) {
|
|
m_viewTransform = QTransform();
|
|
m_viewTransform.translate(m_valueAxisX, 200);
|
|
m_viewTransform.scale(5, -1);
|
|
} else {
|
|
double mx = (width() - m_valueAxisX - 20) / (f1 - f0);
|
|
double my = -(height() - m_graphViewportY - 20) / (v1 - v0);
|
|
double dx = m_valueAxisX + 10 - f0 * mx;
|
|
double dy = m_graphViewportY + 10 - v1 * my;
|
|
m_viewTransform = QTransform(mx, 0, 0, my, dx, dy);
|
|
}
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::fitSelectedPoints() { fitGraphToWindow(true); }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::fitCurve() { fitGraphToWindow(); }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::fitRegion(double f0, double v0, double f1, double v1) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void setSegmentType(FunctionSelection *selection, TDoubleParam *curve,
|
|
int segmentIndex, TDoubleKeyframe::Type type) {
|
|
selection->selectSegment(curve, segmentIndex);
|
|
KeyframeSetter setter(curve, segmentIndex);
|
|
setter.setType(type);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::openContextMenu(QMouseEvent *e) {
|
|
QAction linkHandlesAction(tr("Link Handles"), 0);
|
|
QAction unlinkHandlesAction(tr("Unlink Handles"), 0);
|
|
QAction resetHandlesAction(tr("Reset Handles"), 0);
|
|
QAction deleteKeyframeAction(tr("Delete"), 0);
|
|
QAction insertKeyframeAction(tr("Set Key"), 0);
|
|
QAction activateCycleAction(tr("Activate Cycle"), 0);
|
|
QAction deactivateCycleAction(tr("Deactivate Cycle"), 0);
|
|
QAction setLinearAction(tr("Linear Interpolation"), 0);
|
|
QAction setSpeedInOutAction(tr("Speed In / Speed Out Interpolation"), 0);
|
|
QAction setEaseInOutAction(tr("Ease In / Ease Out Interpolation"), 0);
|
|
QAction setEaseInOut2Action(tr("Ease In / Ease Out (%) Interpolation"), 0);
|
|
QAction setExponentialAction(tr("Exponential Interpolation"), 0);
|
|
QAction setExpressionAction(tr("Expression Interpolation"), 0);
|
|
QAction setFileAction(tr("File Interpolation"), 0);
|
|
QAction setConstantAction(tr("Constant Interpolation"), 0);
|
|
QAction setSimilarShapeAction(tr("Similar Shape Interpolation"), 0);
|
|
QAction fitSelectedAction(tr("Fit Selection"), 0);
|
|
QAction fitAllAction(tr("Fit"), 0);
|
|
QAction setStep1Action(tr("Step 1"), 0);
|
|
QAction setStep2Action(tr("Step 2"), 0);
|
|
QAction setStep3Action(tr("Step 3"), 0);
|
|
QAction setStep4Action(tr("Step 4"), 0);
|
|
|
|
TDoubleParam *curve = getCurrentCurve();
|
|
int segmentIndex = -1;
|
|
if (!curve) return;
|
|
TDoubleKeyframe kf;
|
|
double frame = xToFrame(e->pos().x());
|
|
|
|
// build menu
|
|
QMenu menu(0);
|
|
if (m_highlighted.handle == Point && m_highlighted.gIndex >= 0 &&
|
|
m_gadgets[m_highlighted.gIndex].m_handle != 100) {
|
|
kf = curve->getKeyframe(m_gadgets[m_highlighted.gIndex].m_kIndex);
|
|
if (kf.m_linkedHandles)
|
|
menu.addAction(&unlinkHandlesAction);
|
|
else
|
|
menu.addAction(&linkHandlesAction);
|
|
menu.addAction(&resetHandlesAction);
|
|
menu.addAction(&deleteKeyframeAction);
|
|
} else {
|
|
int k0 = curve->getPrevKeyframe(frame);
|
|
int k1 = curve->getNextKeyframe(frame);
|
|
if (k0 == curve->getKeyframeCount() - 1) // after last keyframe
|
|
{
|
|
if (curve->isCycleEnabled())
|
|
menu.addAction(&deactivateCycleAction);
|
|
else
|
|
menu.addAction(&activateCycleAction);
|
|
}
|
|
menu.addAction(&insertKeyframeAction);
|
|
if (k0 >= 0 && k1 >= 0) {
|
|
menu.addSeparator();
|
|
segmentIndex = k0;
|
|
kf = curve->getKeyframe(k0);
|
|
menu.addAction(&setLinearAction);
|
|
if (kf.m_type == TDoubleKeyframe::Linear)
|
|
setLinearAction.setEnabled(false);
|
|
menu.addAction(&setSpeedInOutAction);
|
|
if (kf.m_type == TDoubleKeyframe::SpeedInOut)
|
|
setSpeedInOutAction.setEnabled(false);
|
|
menu.addAction(&setEaseInOutAction);
|
|
if (kf.m_type == TDoubleKeyframe::EaseInOut)
|
|
setEaseInOutAction.setEnabled(false);
|
|
menu.addAction(&setEaseInOut2Action);
|
|
if (kf.m_type == TDoubleKeyframe::EaseInOutPercentage)
|
|
setEaseInOut2Action.setEnabled(false);
|
|
menu.addAction(&setExponentialAction);
|
|
if (kf.m_type == TDoubleKeyframe::Exponential)
|
|
setExponentialAction.setEnabled(false);
|
|
menu.addAction(&setExpressionAction);
|
|
if (kf.m_type == TDoubleKeyframe::Expression)
|
|
setExpressionAction.setEnabled(false);
|
|
menu.addAction(&setSimilarShapeAction);
|
|
if (kf.m_type == TDoubleKeyframe::SimilarShape)
|
|
setSimilarShapeAction.setEnabled(false);
|
|
menu.addAction(&setFileAction);
|
|
if (kf.m_type == TDoubleKeyframe::File) setFileAction.setEnabled(false);
|
|
menu.addAction(&setConstantAction);
|
|
if (kf.m_type == TDoubleKeyframe::Constant)
|
|
setConstantAction.setEnabled(false);
|
|
menu.addSeparator();
|
|
if (kf.m_step != 1) menu.addAction(&setStep1Action);
|
|
if (kf.m_step != 2) menu.addAction(&setStep2Action);
|
|
if (kf.m_step != 3) menu.addAction(&setStep3Action);
|
|
if (kf.m_step != 4) menu.addAction(&setStep4Action);
|
|
menu.addSeparator();
|
|
}
|
|
}
|
|
if (!getSelection()->isEmpty()) menu.addAction(&fitSelectedAction);
|
|
menu.addAction(&fitAllAction);
|
|
|
|
// curve shape type
|
|
QAction curveShapeSmoothAction(tr("Smooth"), 0);
|
|
QAction curveShapeFrameBasedAction(tr("Frame Based"), 0);
|
|
QMenu curveShapeSubmenu(tr("Curve Shape"), 0);
|
|
menu.addSeparator();
|
|
curveShapeSubmenu.addAction(&curveShapeSmoothAction);
|
|
curveShapeSubmenu.addAction(&curveShapeFrameBasedAction);
|
|
menu.addMenu(&curveShapeSubmenu);
|
|
|
|
curveShapeSmoothAction.setCheckable(true);
|
|
curveShapeSmoothAction.setChecked(m_curveShape == SMOOTH);
|
|
curveShapeFrameBasedAction.setCheckable(true);
|
|
curveShapeFrameBasedAction.setChecked(m_curveShape == FRAME_BASED);
|
|
|
|
// Store m_highlighted due to the following exec()
|
|
Highlighted highlighted(m_highlighted);
|
|
|
|
// execute menu
|
|
QAction *action = menu.exec(e->globalPos()); // Will process events, possibly
|
|
// altering m_highlighted
|
|
// (MAC-verified)
|
|
if (action == &linkHandlesAction) // Let's just *hope* that doesn't happen to
|
|
// m_gadgets though... :/
|
|
{
|
|
if (m_gadgets[highlighted.gIndex].m_handle != 100)
|
|
KeyframeSetter(curve, m_gadgets[highlighted.gIndex].m_kIndex)
|
|
.linkHandles();
|
|
} else if (action == &unlinkHandlesAction) {
|
|
if (m_gadgets[highlighted.gIndex].m_handle != 100)
|
|
KeyframeSetter(curve, m_gadgets[highlighted.gIndex].m_kIndex)
|
|
.unlinkHandles();
|
|
} else if (action == &resetHandlesAction) {
|
|
kf.m_speedIn = TPointD(-5, 0);
|
|
kf.m_speedOut = -kf.m_speedIn;
|
|
curve->setKeyframe(kf);
|
|
} else if (action == &deleteKeyframeAction) {
|
|
KeyframeSetter::removeKeyframeAt(curve, kf.m_frame);
|
|
} else if (action == &insertKeyframeAction) {
|
|
KeyframeSetter(curve).createKeyframe(tround(frame));
|
|
} else if (action == &activateCycleAction) {
|
|
KeyframeSetter::enableCycle(curve, true);
|
|
} else if (action == &deactivateCycleAction) {
|
|
KeyframeSetter::enableCycle(curve, false);
|
|
} else if (action == &setLinearAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::Linear);
|
|
else if (action == &setSpeedInOutAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::SpeedInOut);
|
|
else if (action == &setEaseInOutAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::EaseInOut);
|
|
else if (action == &setEaseInOut2Action)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::EaseInOutPercentage);
|
|
else if (action == &setExponentialAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::Exponential);
|
|
else if (action == &setExpressionAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::Expression);
|
|
else if (action == &setSimilarShapeAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::SimilarShape);
|
|
else if (action == &setFileAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex, TDoubleKeyframe::File);
|
|
else if (action == &setConstantAction)
|
|
setSegmentType(getSelection(), curve, segmentIndex,
|
|
TDoubleKeyframe::Constant);
|
|
else if (action == &fitSelectedAction)
|
|
fitSelectedPoints();
|
|
else if (action == &fitAllAction)
|
|
fitCurve();
|
|
else if (action == &setStep1Action)
|
|
KeyframeSetter(curve, segmentIndex).setStep(1);
|
|
else if (action == &setStep2Action)
|
|
KeyframeSetter(curve, segmentIndex).setStep(2);
|
|
else if (action == &setStep3Action)
|
|
KeyframeSetter(curve, segmentIndex).setStep(3);
|
|
else if (action == &setStep4Action)
|
|
KeyframeSetter(curve, segmentIndex).setStep(4);
|
|
|
|
else if (action == &curveShapeSmoothAction)
|
|
m_curveShape = SMOOTH;
|
|
else if (action == &curveShapeFrameBasedAction)
|
|
m_curveShape = FRAME_BASED;
|
|
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::setFrameHandle(TFrameHandle *frameHandle) {
|
|
if (m_frameHandle == frameHandle) return;
|
|
if (m_frameHandle) m_frameHandle->disconnect(this);
|
|
m_frameHandle = frameHandle;
|
|
if (isVisible() && m_frameHandle) {
|
|
connect(m_frameHandle, SIGNAL(frameSwitched()), this,
|
|
SLOT(onFrameSwitched()));
|
|
update();
|
|
}
|
|
assert(m_selection);
|
|
m_selection->setFrameHandle(frameHandle);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::showEvent(QShowEvent *) {
|
|
if (m_frameHandle)
|
|
connect(m_frameHandle, SIGNAL(frameSwitched()), this,
|
|
SLOT(onFrameSwitched()));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::hideEvent(QHideEvent *) {
|
|
if (m_frameHandle) m_frameHandle->disconnect(this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void FunctionPanel::onFrameSwitched() { update(); }
|