984 lines
30 KiB
C++
984 lines
30 KiB
C++
|
|
|
|
#include "toonzqt/tonecurvefield.h"
|
|
#include "toonzqt/fxhistogramrender.h"
|
|
#include "toonzqt/intpairfield.h"
|
|
#include "toonzqt/checkbox.h"
|
|
|
|
#include <QPainter>
|
|
#include <QPainterPath>
|
|
#include <QStackedWidget>
|
|
#include <QMouseEvent>
|
|
#include <QApplication>
|
|
#include <QHBoxLayout>
|
|
#include <QComboBox>
|
|
#include <QLabel>
|
|
|
|
using namespace DVGui;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
namespace
|
|
{
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double getPercentAtPoint(QPointF point, QPainterPath path)
|
|
{
|
|
int i;
|
|
for (i = 1; i < 100; i++) {
|
|
double p = double(i) * 0.01;
|
|
QPointF pathPoint = path.pointAtPercent(p);
|
|
if (abs(pathPoint.x() - point.x()) < 3 && abs(pathPoint.y() - point.y()) < 3)
|
|
return p;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QList<QPointF> getIntersectedPoint(QRectF rect, QPainterPath path)
|
|
{
|
|
int y0 = rect.top();
|
|
int y1 = rect.bottom();
|
|
QList<QPointF> points;
|
|
double g = 1.0 / 256.0;
|
|
QPointF prec = path.pointAtPercent(0);
|
|
QPointF point = path.pointAtPercent(g);
|
|
int j = 0;
|
|
for (j = 2; j < 256; j++) {
|
|
QPointF next = path.pointAtPercent(double(j) * g);
|
|
if (prec.y() >= y0 && prec.y() <= y1) {
|
|
if (point.y() < y0)
|
|
points.push_back(QPointF(prec.x(), y0));
|
|
else if (point.y() > y1)
|
|
points.push_back(QPointF(prec.x(), y1));
|
|
}
|
|
if (next.y() >= y0 && next.y() <= y1) {
|
|
if (point.y() < y0)
|
|
points.push_back(QPointF(next.x(), y0));
|
|
else if (point.y() > y1)
|
|
points.push_back(QPointF(next.x(), y1));
|
|
}
|
|
prec = point;
|
|
point = next;
|
|
}
|
|
return points;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double qtNorm2(const QPointF &p)
|
|
{
|
|
return p.x() * p.x() + p.y() * p.y();
|
|
}
|
|
|
|
double qtNorm(const QPointF &p)
|
|
{
|
|
return sqrt(qtNorm2(p));
|
|
}
|
|
|
|
QPointF qtNormalize(const QPointF &p)
|
|
{
|
|
double n = qtNorm(p);
|
|
assert(n != 0.0);
|
|
return (1.0 / n) * p;
|
|
}
|
|
|
|
double qtDistance2(const QPointF &p1, const QPointF &p2)
|
|
{
|
|
return qtNorm2(p2 - p1);
|
|
}
|
|
|
|
double qtDistance(const QPointF &p1, const QPointF &p2)
|
|
{
|
|
return qtNorm(p2 - p1);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPointF getNewFirstHandlePoint(const QPointF &p, const QPointF &nextP, const QPointF &oldHandlePoint)
|
|
{
|
|
bool canMove = (nextP.x() - p.x() > 16);
|
|
int yDistance = nextP.y() - p.y();
|
|
double sign = (yDistance != 0) ? yDistance / abs(yDistance) : 1;
|
|
double t = qtDistance(p, oldHandlePoint);
|
|
if (!canMove) {
|
|
QPointF normalizedP = (yDistance != 0) ? qtNormalize(nextP - p) : QPoint(1, 1);
|
|
return QPointF(p + QPointF(t * normalizedP));
|
|
} else if (abs(oldHandlePoint.x() - p.x()) < 16)
|
|
return QPointF(p.x() + 16, p.y() + sign * sqrt(t * t - 16 * 16));
|
|
return oldHandlePoint;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPointF getNewSecondHandlePoint(const QPointF &p, const QPointF &nextP, const QPointF &oldHandlePoint)
|
|
{
|
|
bool canMove = (nextP.x() - p.x() > 16);
|
|
int yDistance = p.y() - nextP.y();
|
|
double sign = (yDistance != 0) ? yDistance / abs(yDistance) : 1;
|
|
double s = qtDistance(oldHandlePoint, nextP);
|
|
if (!canMove) {
|
|
QPointF normalizedP = (yDistance != 0) ? qtNormalize(nextP - p) : QPoint(1, 1);
|
|
return QPointF(nextP - QPointF(s * normalizedP));
|
|
} else if (abs(nextP.x() - oldHandlePoint.x()) < 16)
|
|
return QPointF(nextP.x() - 16, nextP.y() + sign * sqrt(s * s - 16 * 16));
|
|
return oldHandlePoint;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
} //anonymous namespace
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//=============================================================================
|
|
// ChennelCurveEditor
|
|
//=============================================================================
|
|
|
|
ChennelCurveEditor::ChennelCurveEditor(QWidget *parent, HistogramView *histogramView)
|
|
: QWidget(parent), m_histogramView(histogramView), m_currentControlPointIndex(-1), m_mouseButton(Qt::NoButton), m_curveHeight(256), m_LeftRightMargin(42), m_TopMargin(9), m_BottomMargin(48), m_isLinear(false)
|
|
{
|
|
setFixedSize(m_curveHeight + 2 * m_LeftRightMargin + 2,
|
|
m_curveHeight + m_TopMargin + m_BottomMargin);
|
|
setAttribute(Qt::WA_KeyCompression);
|
|
setFocusPolicy(Qt::StrongFocus);
|
|
setMouseTracking(true);
|
|
|
|
m_histogramView->setDrawnWidget(this);
|
|
m_histogramView->setGraphHeight(m_curveHeight);
|
|
m_histogramView->setGraphAlphaMask(120);
|
|
m_verticalChannelBar = new ChannelBar(0, m_histogramView->getChannelBarColor(), false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::setPoints(QList<TPointD> points)
|
|
{
|
|
if (!m_points.isEmpty())
|
|
m_points.clear();
|
|
int i;
|
|
for (i = 0; i < points.size(); i++) {
|
|
QPointF p = strokeToViewPoint(points.at(i));
|
|
m_points.push_back(p);
|
|
}
|
|
/*--ポイント位置に合わせてスライダも更新する--*/
|
|
int firstIndex = 3;
|
|
int lastIndex = m_points.size() - 4;
|
|
emit firstLastXPostionChanged(viewToStrokePoint(m_points.at(firstIndex)).x,
|
|
viewToStrokePoint(m_points.at(lastIndex)).x);
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QList<TPointD> ChennelCurveEditor::getPoints()
|
|
{
|
|
QList<TPointD> points;
|
|
if (m_points.isEmpty())
|
|
return points;
|
|
int i;
|
|
for (i = 0; i < m_points.size(); i++)
|
|
points.push_back(viewToStrokePoint(m_points.at(i)));
|
|
return points;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::setFirstLastXPosition(std::pair<int, int> values, bool isDragging)
|
|
{
|
|
if (!isDragging) {
|
|
emit controlPointChanged(false);
|
|
return;
|
|
}
|
|
|
|
QPointF newX0 = strokeToViewPoint(TPointD(values.first, 0));
|
|
QPointF newX1 = strokeToViewPoint(TPointD(values.second, 0));
|
|
|
|
int indexX0 = 3;
|
|
int indexX1 = m_points.size() - 4;
|
|
QPointF x0 = m_points.at(indexX0);
|
|
QPointF x1 = m_points.at(indexX1);
|
|
if (x0.x() != newX0.x()) {
|
|
QPointF delta(newX0.x() - x0.x(), 0);
|
|
moveCentralControlPoint(indexX0, delta);
|
|
update();
|
|
}
|
|
if (x1.x() != newX1.x()) {
|
|
QPointF delta(newX1.x() - x1.x(), 0);
|
|
moveCentralControlPoint(indexX1, delta);
|
|
update();
|
|
}
|
|
m_currentControlPointIndex = -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::setLinear(bool isLinear)
|
|
{
|
|
if (m_isLinear == isLinear)
|
|
return;
|
|
m_isLinear = isLinear;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPointF ChennelCurveEditor::checkPoint(const QPointF p)
|
|
{
|
|
QPointF checkedP = p;
|
|
int y0 = m_TopMargin + 1;
|
|
int y1 = m_curveHeight + m_TopMargin;
|
|
if (p.y() < y0)
|
|
checkedP = QPointF(checkedP.x(), y0);
|
|
if (p.y() > y1)
|
|
checkedP = QPointF(checkedP.x(), y1);
|
|
int x0 = m_LeftRightMargin + 1;
|
|
int x1 = m_curveHeight + m_LeftRightMargin;
|
|
if (p.x() < x0)
|
|
checkedP = QPointF(x0, checkedP.y());
|
|
if (p.x() > x1)
|
|
checkedP = QPointF(x1, checkedP.y());
|
|
return checkedP;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPointF ChennelCurveEditor::strokeToViewPoint(const TPointD p)
|
|
{
|
|
double x = p.x + m_LeftRightMargin + 1;
|
|
double y = height() - m_BottomMargin - p.y;
|
|
return QPointF(x, y);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TPointD ChennelCurveEditor::viewToStrokePoint(const QPointF &p)
|
|
{
|
|
double x = p.x() - m_LeftRightMargin - 1;
|
|
double y = m_curveHeight - (p.y() - m_TopMargin);
|
|
return TThickPoint(x, y);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int ChennelCurveEditor::getClosestPointIndex(const QPointF &pos, double &minDistance2) const
|
|
{
|
|
int closestPointIndex = -1;
|
|
minDistance2 = 0;
|
|
int i;
|
|
for (i = 0; i < (int)m_points.size(); i++) {
|
|
double distance2 = qtDistance2(pos, m_points.at(i));
|
|
if (closestPointIndex < 0 || distance2 < minDistance2) {
|
|
minDistance2 = distance2;
|
|
closestPointIndex = i;
|
|
}
|
|
}
|
|
return closestPointIndex;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::movePoint(int index, const QPointF delta)
|
|
{
|
|
QPointF p = m_points.at(index);
|
|
p += delta;
|
|
setPoint(index, p);
|
|
|
|
int firstIndex = 3;
|
|
int lastIndex = m_points.size() - 4;
|
|
if (index == firstIndex)
|
|
emit firstLastXPostionChanged(viewToStrokePoint(p).x, viewToStrokePoint(m_points.at(lastIndex)).x);
|
|
if (index == lastIndex)
|
|
emit firstLastXPostionChanged(viewToStrokePoint(m_points.at(firstIndex)).x, viewToStrokePoint(p).x);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::setPoint(int index, const QPointF p)
|
|
{
|
|
m_points.removeAt(index);
|
|
m_points.insert(index, p);
|
|
|
|
int firstIndex = 3;
|
|
int lastIndex = m_points.size() - 4;
|
|
if (index == firstIndex)
|
|
emit firstLastXPostionChanged(viewToStrokePoint(p).x, viewToStrokePoint(m_points.at(lastIndex)).x);
|
|
if (index == lastIndex)
|
|
emit firstLastXPostionChanged(viewToStrokePoint(m_points.at(firstIndex)).x, viewToStrokePoint(p).x);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::moveCurrentControlPoint(const QPointF delta)
|
|
{
|
|
assert(m_currentControlPointIndex != -1);
|
|
int pointCount = m_points.size();
|
|
/*- セグメントを動かした場合 -*/
|
|
if (isCentralControlPoint(m_currentControlPointIndex))
|
|
moveCentralControlPoint(m_currentControlPointIndex, delta);
|
|
/*- 左のハンドルを動かした場合 -*/
|
|
else if (isLeftControlPoint(m_currentControlPointIndex)) {
|
|
QPointF p0 = m_points.at(m_currentControlPointIndex) + QPointF(0, delta.y());
|
|
setPoint(m_currentControlPointIndex, p0);
|
|
if (m_currentControlPointIndex < pointCount - 5) {
|
|
QPointF p2 = m_points.at(m_currentControlPointIndex + 2) - QPointF(0, delta.y());
|
|
setPoint(m_currentControlPointIndex + 2, p2);
|
|
}
|
|
emit controlPointChanged(true);
|
|
}
|
|
/*- 右のハンドルを動かした場合 -*/
|
|
else {
|
|
assert(isRightControlPoint(m_currentControlPointIndex));
|
|
QPointF p0 = m_points.at(m_currentControlPointIndex) + QPointF(0, delta.y());
|
|
setPoint(m_currentControlPointIndex, p0);
|
|
if (m_currentControlPointIndex > 4) {
|
|
QPointF p2 = m_points.at(m_currentControlPointIndex - 2) - QPointF(0, delta.y());
|
|
setPoint(m_currentControlPointIndex - 2, p2);
|
|
}
|
|
emit controlPointChanged(true);
|
|
}
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::moveCentralControlPoint(int index, const QPointF delta)
|
|
{
|
|
int pointCount = m_points.size();
|
|
|
|
assert(index < pointCount - 3 && index > 2);
|
|
|
|
QPointF p = m_points.at(index);
|
|
QPointF d = delta;
|
|
//Trovo il valore di delta im modo tale che il punto di controllo non sia trascinato fuori dal range consentito
|
|
int newX = p.x() + delta.x();
|
|
int newY = p.y() + delta.y();
|
|
QPointF newPoint = checkPoint(QPoint(newX, newY));
|
|
d = newPoint - p;
|
|
|
|
QPointF nextP = m_points.at(index + 3);
|
|
QPointF precP = m_points.at(index - 3);
|
|
double nextDistance = nextP.x() - (p.x() + d.x());
|
|
double precDistance = (p.x() + d.x()) - precP.x();
|
|
|
|
//Caso particolare: Punto di controllo corrente == primo visibile,
|
|
// Punto di controllo successivo == l'ultimo visibile
|
|
if (index == 3 && index + 3 == pointCount - 4) {
|
|
setPoint(index + 1, getNewFirstHandlePoint(p, nextP, m_points.at(index + 1)));
|
|
setPoint(index + 2, getNewSecondHandlePoint(p, nextP, m_points.at(index + 2)));
|
|
if (nextDistance < 0)
|
|
d = QPointF(nextP.x() - p.x(), d.y());
|
|
}
|
|
//Caso particolare: Punto di controllo corrente == ultimo visibile,
|
|
// Punto di controllo precedente == primo visibile
|
|
else if (index - 3 == 3 && index == pointCount - 4) {
|
|
setPoint(index - 2, getNewFirstHandlePoint(precP, p, m_points.at(index - 2)));
|
|
setPoint(index - 1, getNewSecondHandlePoint(precP, p, m_points.at(index - 1)));
|
|
if (precDistance < 0)
|
|
d = QPointF(precP.x() - p.x(), d.y());
|
|
}
|
|
//Altrimenti calcolo il nuovo delta
|
|
else if (nextDistance < 16)
|
|
d = QPointF(nextP.x() - p.x() - 16, d.y());
|
|
else if (precDistance < 16)
|
|
d = QPointF(precP.x() - p.x() + 16, d.y());
|
|
|
|
//Punto di controllo speciale: il primo visualizzato.
|
|
if (index == 3) {
|
|
QPointF dY = QPointF(0, d.y());
|
|
movePoint(index - 1, dY);
|
|
movePoint(index - 2, dY);
|
|
movePoint(index - 3, dY);
|
|
}
|
|
//Punto di controllo speciale: l'ultimo visualizzato.
|
|
if (index == pointCount - 4) {
|
|
QPointF dY = QPointF(0, d.y());
|
|
movePoint(index + 1, dY);
|
|
movePoint(index + 2, dY);
|
|
movePoint(index + 3, dY);
|
|
}
|
|
if (index > 3)
|
|
movePoint(index - 1, d);
|
|
if (index < pointCount - 4)
|
|
movePoint(index + 1, d);
|
|
movePoint(index, d);
|
|
emit controlPointChanged(true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/* Se due punti di controllo sono troppo vicini uno dei due viene eliminato.
|
|
Ritorna vero se un punto viene eliminato.
|
|
|
|
Prima di richiamare il metodo nel move andava fatto questo controllo!!!
|
|
//Se il punto di controllo successivo, o precente, e' l'utlimo, o il primo, blocco il
|
|
// movimento altrimenti elimino il punto di controllo successivo e richiamo il move.
|
|
int nextPX = m_points.at(index+3).x();
|
|
if(nextPX>m_margin && nextPX<=w && newX>nextPX)
|
|
{
|
|
if(index+3 == pointCount-4) d = QPointF(0, d.y());
|
|
else
|
|
{
|
|
moveCentralControlPoint(index, d);
|
|
return;
|
|
}
|
|
}
|
|
int precPX = m_points.at(index-3).x();
|
|
if(precPX>=m_margin && precPX<=w && newX<precPX)
|
|
{
|
|
if(index-3 == 3) d = QPointF(0, d.y());
|
|
else
|
|
{
|
|
moveCentralControlPoint(index, d);
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool ChennelCurveEditor::eraseControlPointWhileMove(int index, const QPointF delta)
|
|
{
|
|
int pointCount = m_points.size();
|
|
QPointF p = m_points.at(index);
|
|
QPointF nextP = m_points.at(index+3);
|
|
QPointF precP = m_points.at(index-3);
|
|
double nextDistance = abs((p.x()+delta.x())-nextP.x());
|
|
double precDistance = abs((p.x()+delta.x())-precP.x());
|
|
|
|
if(nextDistance>16 && precDistance>16) return false;
|
|
|
|
//Se vado troppo vicino al punto di controllo precedente, o successivo, lo elimino.
|
|
if(nextDistance<=16)
|
|
{
|
|
//Caso particolare: il successivo e' l'ultimo visibile; non posso eliminare l'ultimo punto di controllo visibile.
|
|
if(index+3 == pointCount-4)
|
|
{
|
|
//Se il punto di controllo in index e' il primo visibile sto gestendo il
|
|
// primo e l'ultimo punto, entrambi non possono essere eliminati.
|
|
if(index == 3)
|
|
{
|
|
setPoint(index+1,nextP);
|
|
setPoint(index+2,p+delta);
|
|
return false;
|
|
}
|
|
else //Altrimenti elimino il penultimo.
|
|
{
|
|
removeControlPoint(index);
|
|
m_currentControlPointIndex += 3;
|
|
return true;
|
|
}
|
|
}
|
|
removeControlPoint(index+3);
|
|
return true;
|
|
}
|
|
if(precDistance<=16)
|
|
{
|
|
//Caso particolare: il precedente e' il primo visibile; non posso eliminare il primo punto di controllo visibile.
|
|
if(index-3 == 3)
|
|
{
|
|
//Se il punto di controllo in index e' l'ultimo visibile sto gestendo il
|
|
// primo e l'ultimo punto, entrambi non possono essere eliminati.
|
|
if(index == pointCount-4)
|
|
{
|
|
setPoint(index-1,precP);
|
|
setPoint(index-2,p+delta);
|
|
return false;
|
|
}
|
|
else //Altrimenti elimino il secondo.
|
|
{
|
|
removeControlPoint(index);
|
|
return true;
|
|
}
|
|
}
|
|
removeControlPoint(index-3);
|
|
m_currentControlPointIndex += 3;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::addControlPoint(double percent)
|
|
{
|
|
QPainterPath path = getPainterPath();
|
|
QPointF p = path.pointAtPercent(percent);
|
|
|
|
//Cerco il punto di controllo precedente
|
|
int pointCount = m_points.size();
|
|
int beforeControlPointIndex;
|
|
for (beforeControlPointIndex = pointCount - 1; beforeControlPointIndex >= 0; beforeControlPointIndex--) {
|
|
QPointF point = m_points.at(beforeControlPointIndex);
|
|
if (isCentralControlPoint(beforeControlPointIndex) && point.x() < p.x())
|
|
break;
|
|
}
|
|
|
|
if (beforeControlPointIndex == 0 || beforeControlPointIndex == pointCount - 4)
|
|
return;
|
|
|
|
QPointF p0 = checkPoint(m_points.at(beforeControlPointIndex));
|
|
//Se sono troppo vicino al punto di controllo precedente ritorno
|
|
if (abs(p.x() - p0.x()) <= 16)
|
|
return;
|
|
double beforeControlPointPercent = getPercentAtPoint(p0, path);
|
|
QPointF p1 = checkPoint(m_points.at(beforeControlPointIndex + 1));
|
|
QPointF p2 = checkPoint(m_points.at(beforeControlPointIndex + 2));
|
|
QPointF p3 = checkPoint(m_points.at(beforeControlPointIndex + 3));
|
|
//Se sono troppo vicino al punto di controllo successivo ritorno
|
|
if (abs(p3.x() - p.x()) <= 16)
|
|
return;
|
|
double nextControlPointPercent = getPercentAtPoint(p3, path);
|
|
|
|
//Calcolo la velocita' e quindi il coiffciente angolare.
|
|
double t = percent * 100 / (nextControlPointPercent - beforeControlPointPercent);
|
|
double s = t - 1;
|
|
QPointF speed = 3.0 * ((p1 - p0) * s * s + 2 * (p2 - p0) * s * t + (p3 - p2) * t * t);
|
|
double m = speed.y() / speed.x();
|
|
|
|
int newControlPointIndex = beforeControlPointIndex + 3;
|
|
m_points.insert(newControlPointIndex - 1, QPointF(p.x() - 16, p.y() - 16 * m));
|
|
m_points.insert(newControlPointIndex, p);
|
|
m_points.insert(newControlPointIndex + 1, QPointF(p.x() + 16, p.y() + 16 * m));
|
|
|
|
m_currentControlPointIndex = newControlPointIndex;
|
|
emit controlPointAdded(newControlPointIndex);
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::removeCurrentControlPoint()
|
|
{
|
|
removeControlPoint(m_currentControlPointIndex);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::removeControlPoint(int index)
|
|
{
|
|
//Non posso eliminare il primo punto di controllo visibile quindi lo rimetto in condizione iniziale
|
|
if (index <= 4) {
|
|
setPoint(0, strokeToViewPoint(TPointD(-40, 0)));
|
|
setPoint(1, strokeToViewPoint(TPointD(-20, 0)));
|
|
setPoint(2, strokeToViewPoint(TPointD(-20, 0)));
|
|
setPoint(3, strokeToViewPoint(TPointD(0, 0)));
|
|
setPoint(4, strokeToViewPoint(TPointD(16, 16)));
|
|
update();
|
|
emit controlPointChanged(false);
|
|
return;
|
|
}
|
|
//Non posso eliminare il l'ultimo punto di controllo visibile quindi lo rimetto in condizione iniziale
|
|
if (index >= m_points.size() - 5) {
|
|
int i = m_points.size() - 5;
|
|
setPoint(i, strokeToViewPoint(TPointD(239, 239)));
|
|
setPoint(i + 1, strokeToViewPoint(TPointD(255, 255)));
|
|
setPoint(i + 2, strokeToViewPoint(TPointD(275, 255)));
|
|
setPoint(i + 3, strokeToViewPoint(TPointD(275, 255)));
|
|
setPoint(i + 4, strokeToViewPoint(TPointD(295, 255)));
|
|
update();
|
|
emit controlPointChanged(false);
|
|
return;
|
|
}
|
|
|
|
int firstIndex = 0;
|
|
if (isCentralControlPoint(index))
|
|
firstIndex = index - 1;
|
|
else if (isLeftControlPoint(index))
|
|
firstIndex = index;
|
|
else
|
|
firstIndex = index - 2;
|
|
|
|
m_points.removeAt(firstIndex);
|
|
m_points.removeAt(firstIndex);
|
|
m_points.removeAt(firstIndex);
|
|
|
|
emit controlPointRemoved(firstIndex + 1);
|
|
m_currentControlPointIndex = firstIndex - 2;
|
|
update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QPainterPath ChennelCurveEditor::getPainterPath()
|
|
{
|
|
int pointCount = m_points.size();
|
|
if (pointCount == 0)
|
|
return QPainterPath();
|
|
|
|
QPointF p0 = m_points.at(0);
|
|
QPainterPath path(p0);
|
|
int i;
|
|
for (i = 1; i < pointCount; i++) {
|
|
QPointF p1 = m_points.at(i);
|
|
QPointF p2 = m_points.at(++i);
|
|
QPointF p3 = m_points.at(++i);
|
|
path.moveTo(p0);
|
|
if (!m_isLinear)
|
|
path.cubicTo(p1, p2, p3);
|
|
else
|
|
path.lineTo(p3);
|
|
p0 = p3;
|
|
}
|
|
|
|
//Cerco le eventuali intersezioni con il bordo.
|
|
QRectF rect(m_LeftRightMargin, m_TopMargin, m_curveHeight, m_curveHeight);
|
|
QRectF r = path.boundingRect();
|
|
if (!rect.contains(QRect(rect.left(), r.top(), rect.width(), r.height()))) {
|
|
QList<QPointF> points = getIntersectedPoint(rect, path);
|
|
//Se trovo punti di intersezione (per come e' definita la curva devono essere pari)
|
|
// faccio l'unione del path calcolato e di nuovi path lineari.
|
|
int j = 0;
|
|
for (j = 0; j < points.size(); j++) {
|
|
QPointF p0 = points.at(j);
|
|
QPointF p1 = points.at(++j);
|
|
QPainterPath line(p0);
|
|
line.lineTo(p1);
|
|
path.addPath(line);
|
|
}
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::paintEvent(QPaintEvent *e)
|
|
{
|
|
QPainter painter(this);
|
|
|
|
//Disegno il reticolato
|
|
painter.setRenderHint(QPainter::Antialiasing, false);
|
|
painter.setPen(QColor(250, 250, 250));
|
|
int i;
|
|
int d = m_curveHeight * 0.25;
|
|
for (i = 1; i < 16; i++) {
|
|
// linee orizzontali
|
|
int delta = m_TopMargin + 16 * i;
|
|
int j;
|
|
for (j = 1; j < 4; j++)
|
|
painter.drawLine(QPoint((j - 1) * d + m_LeftRightMargin + 1, delta), QPoint(j * d + m_LeftRightMargin - 1, delta));
|
|
painter.drawLine(QPoint((4 - 1) * d + m_LeftRightMargin + 1, delta), QPoint(4 * d + m_LeftRightMargin, delta));
|
|
// linee verticali
|
|
delta = m_LeftRightMargin + 1 + 16 * i;
|
|
if (i % 4 == 0)
|
|
continue;
|
|
for (j = 1; j < 5; j++)
|
|
painter.drawLine(QPoint(delta, (j - 1) * d + m_TopMargin), QPoint(delta, j * d + m_TopMargin - 1));
|
|
}
|
|
|
|
//Disegno l'histogram.
|
|
m_histogramView->draw(&painter, QPoint(m_LeftRightMargin - 10, 0));
|
|
|
|
//Disegno la barra verticale a sinistra.
|
|
m_verticalChannelBar->draw(&painter, QPoint(0, -2)); //-1 == m_topMargin- il margine della barra(=10+1).
|
|
|
|
QRectF r = rect().adjusted(m_LeftRightMargin, m_TopMargin, -m_LeftRightMargin, -m_BottomMargin);
|
|
//Disegno la curva entro i limiti del grafo
|
|
painter.setClipRect(r, Qt::IntersectClip);
|
|
QPainterPath path = getPainterPath();
|
|
if (path.isEmpty())
|
|
return;
|
|
painter.setRenderHint(QPainter::Antialiasing, true);
|
|
painter.setPen(Qt::black);
|
|
painter.setBrush(Qt::NoBrush);
|
|
painter.drawPath(path);
|
|
|
|
//Disegno i punti di controllo (esclusi i primi tre e gli ultimi tre)
|
|
r = r.adjusted(-5, -5, 5, 5);
|
|
int n = m_points.size();
|
|
QPointF p = m_points.at(3);
|
|
for (i = 3; i < n - 3; i++) {
|
|
QBrush brush(Qt::white);
|
|
int rad = 3;
|
|
QPointF nextP = m_points.at(i + 1);
|
|
if (isCentralControlPoint(i))
|
|
rad = 4;
|
|
else if (m_isLinear) {
|
|
p = nextP;
|
|
continue;
|
|
}
|
|
if (m_currentControlPointIndex == i)
|
|
brush = QBrush(Qt::black);
|
|
painter.setBrush(brush);
|
|
painter.setPen(Qt::black);
|
|
|
|
if (!m_isLinear) {
|
|
if (isLeftControlPoint(i))
|
|
painter.drawLine(p, nextP);
|
|
else if (isCentralControlPoint(i) && i < n - 4)
|
|
painter.drawLine(p, nextP);
|
|
}
|
|
QPainterPath circle;
|
|
QRectF pointRect(p.x() - rad, p.y() - rad, 2 * rad, 2 * rad);
|
|
if (r.contains(pointRect))
|
|
#if QT_VERSION >= 0x050000
|
|
painter.setClipRect(pointRect.adjusted(-1, -1, 1, 1));
|
|
#else
|
|
painter.setClipRect(pointRect.adjusted(-1, -1, 1, 1), Qt::UniteClip);
|
|
#endif
|
|
circle.addEllipse(pointRect);
|
|
painter.fillPath(circle, brush);
|
|
painter.drawPath(circle);
|
|
p = nextP;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::mouseMoveEvent(QMouseEvent *e)
|
|
{
|
|
if (m_mouseButton == Qt::LeftButton && m_currentControlPointIndex != -1) {
|
|
QPoint pos = e->pos();
|
|
QPointF posF = QPointF(pos.x(), pos.y());
|
|
moveCurrentControlPoint(posF - m_points.at(m_currentControlPointIndex));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::mousePressEvent(QMouseEvent *e)
|
|
{
|
|
m_mouseButton = e->button();
|
|
setFocus();
|
|
if (m_mouseButton == Qt::LeftButton) {
|
|
QPoint pos = e->pos();
|
|
QPointF posF = QPointF(pos.x(), pos.y());
|
|
double minDistance;
|
|
int controlPointIndex = getClosestPointIndex(posF, minDistance);
|
|
|
|
//Se la distanza e' piccola seleziono il control point corrente
|
|
if (minDistance < 20)
|
|
m_currentControlPointIndex = controlPointIndex;
|
|
else {
|
|
m_currentControlPointIndex = -1;
|
|
//Se sono sufficentemente lontano da un punto di controllo, ma abbastanza vicino alla curva
|
|
// aggiungo un punto di controllo
|
|
double percent = getPercentAtPoint(posF, getPainterPath());
|
|
if (percent != 0 && minDistance > 20)
|
|
addControlPoint(percent);
|
|
}
|
|
update();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::mouseReleaseEvent(QMouseEvent *e)
|
|
{
|
|
/*-- マウスドラッグ中はプレビューを更新しない。ここで初めて更新 --*/
|
|
if (m_mouseButton == Qt::LeftButton &&
|
|
m_currentControlPointIndex != -1 &&
|
|
e->button() == Qt::LeftButton)
|
|
emit controlPointChanged(false);
|
|
m_mouseButton = Qt::NoButton;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::keyPressEvent(QKeyEvent *e)
|
|
{
|
|
if (e->key() == Qt::Key_Delete)
|
|
removeCurrentControlPoint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::enterEvent(QEvent *)
|
|
{
|
|
m_mouseButton = Qt::NoButton;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::leaveEvent(QEvent *)
|
|
{
|
|
m_mouseButton = Qt::NoButton;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
bool ChennelCurveEditor::eventFilter(QObject *object, QEvent *event)
|
|
{
|
|
if (event->type() == QEvent::Shortcut ||
|
|
event->type() == QEvent::ShortcutOverride) {
|
|
if (!object->inherits("FxSettings")) {
|
|
event->accept();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::focusInEvent(QFocusEvent *fe)
|
|
{
|
|
QWidget::focusInEvent(fe);
|
|
qApp->installEventFilter(this);
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
void ChennelCurveEditor::focusOutEvent(QFocusEvent *fe)
|
|
{
|
|
m_currentControlPointIndex = -1;
|
|
emit focusOut();
|
|
QWidget::focusOutEvent(fe);
|
|
qApp->removeEventFilter(this);
|
|
update();
|
|
}
|
|
|
|
//=============================================================================
|
|
// ToneCurveField
|
|
//=============================================================================
|
|
|
|
ToneCurveField::ToneCurveField(QWidget *parent, FxHistogramRender *fxHistogramRender)
|
|
: QWidget(parent), m_toneCurveStackedWidget(0)
|
|
{
|
|
setFixedWidth(368);
|
|
|
|
int currentChannelIndex = 0;
|
|
|
|
QVBoxLayout *mainLayout = new QVBoxLayout(this);
|
|
mainLayout->setMargin(0);
|
|
mainLayout->setSpacing(0);
|
|
|
|
QStringList channels;
|
|
channels << "RGBA"
|
|
<< "RGB"
|
|
<< "Red"
|
|
<< "Green"
|
|
<< "Blue"
|
|
<< "Alpha";
|
|
int channelCount = channels.size();
|
|
|
|
//lista canali: label+comboBox
|
|
QWidget *channelListWidget = new QWidget(this);
|
|
QHBoxLayout *channelListLayout = new QHBoxLayout(channelListWidget);
|
|
channelListLayout->setMargin(0);
|
|
channelListLayout->setSpacing(0);
|
|
QLabel *channelLabel = new QLabel(tr("Channel:"), channelListWidget);
|
|
channelListLayout->addWidget(channelLabel);
|
|
m_channelListChooser = new QComboBox(channelListWidget);
|
|
m_channelListChooser->setFixedSize(100, 20);
|
|
m_channelListChooser->addItems(channels);
|
|
m_channelListChooser->setCurrentIndex(currentChannelIndex);
|
|
channelListLayout->addWidget(m_channelListChooser);
|
|
channelListWidget->setLayout(channelListLayout);
|
|
mainLayout->addWidget(channelListWidget, 0, Qt::AlignCenter);
|
|
|
|
//stack widget dei grafi
|
|
m_toneCurveStackedWidget = new QStackedWidget(this);
|
|
Histograms *histograms = new Histograms(0, true);
|
|
fxHistogramRender->setHistograms(histograms);
|
|
int i;
|
|
for (i = 0; i < channelCount; i++) {
|
|
ChennelCurveEditor *c = new ChennelCurveEditor(this, histograms->getHistogramView(i));
|
|
m_toneCurveStackedWidget->addWidget(c);
|
|
connect(c, SIGNAL(firstLastXPostionChanged(int, int)), this, SLOT(onFirstLastXPostionChanged(int, int)));
|
|
}
|
|
|
|
QWidget *w = new QWidget(this);
|
|
QHBoxLayout *layout = new QHBoxLayout(w);
|
|
layout->setMargin(0);
|
|
layout->setSpacing(0);
|
|
layout->addWidget(m_toneCurveStackedWidget);
|
|
w->setLayout(layout);
|
|
mainLayout->addWidget(w, 0, Qt::AlignHCenter);
|
|
m_toneCurveStackedWidget->setCurrentIndex(currentChannelIndex);
|
|
|
|
//stack widget degli slider
|
|
m_sliderStackedWidget = new QStackedWidget(this);
|
|
for (i = 0; i < channelCount; i++) {
|
|
IntPairField *intPairSlider = new IntPairField(this);
|
|
intPairSlider->setFixedHeight(20);
|
|
intPairSlider->setLabelsEnabled(false);
|
|
intPairSlider->setRange(0, 255);
|
|
intPairSlider->setValues(std::make_pair(0, 255));
|
|
m_sliderStackedWidget->addWidget(intPairSlider);
|
|
connect(intPairSlider, SIGNAL(valuesChanged(bool)), this, SLOT(sliderValueChanged(bool)));
|
|
}
|
|
mainLayout->addWidget(m_sliderStackedWidget);
|
|
m_sliderStackedWidget->setCurrentIndex(currentChannelIndex);
|
|
|
|
mainLayout->addSpacing(10);
|
|
m_isLinearCheckBox = new CheckBox(QString("Linear"), this);
|
|
mainLayout->addWidget(m_isLinearCheckBox, 0, Qt::AlignHCenter);
|
|
connect(m_isLinearCheckBox, SIGNAL(clicked(bool)), SLOT(setLinearManually(bool)));
|
|
connect(m_isLinearCheckBox, SIGNAL(toggled(bool)), SLOT(setLinear(bool)));
|
|
|
|
connect(m_channelListChooser, SIGNAL(currentIndexChanged(int)), m_toneCurveStackedWidget, SLOT(setCurrentIndex(int)));
|
|
connect(m_channelListChooser, SIGNAL(currentIndexChanged(int)), m_sliderStackedWidget, SLOT(setCurrentIndex(int)));
|
|
connect(m_channelListChooser, SIGNAL(currentIndexChanged(int)), this, SIGNAL(currentChannelIndexChanged(int)));
|
|
|
|
setLayout(mainLayout);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToneCurveField::setCurrentChannel(int currentChannel)
|
|
{
|
|
m_channelListChooser->setCurrentIndex(currentChannel);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ChennelCurveEditor *ToneCurveField::getChannelEditor(int channel) const
|
|
{
|
|
ChennelCurveEditor *c = dynamic_cast<ChennelCurveEditor *>(m_toneCurveStackedWidget->widget(channel));
|
|
assert(c);
|
|
return c;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ChennelCurveEditor *ToneCurveField::getCurrentChannelEditor() const
|
|
{
|
|
return getChannelEditor(m_toneCurveStackedWidget->currentIndex());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
IntPairField *ToneCurveField::getCurrentSlider() const
|
|
{
|
|
return dynamic_cast<IntPairField *>(m_sliderStackedWidget->currentWidget());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToneCurveField::sliderValueChanged(bool isDragging)
|
|
{
|
|
std::pair<int, int> values = getCurrentSlider()->getValues();
|
|
getCurrentChannelEditor()->setFirstLastXPosition(values, isDragging);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToneCurveField::onFirstLastXPostionChanged(int x0, int x1)
|
|
{
|
|
std::pair<int, int> values = getCurrentSlider()->getValues();
|
|
if (values.first != x0 || values.second != x1)
|
|
getCurrentSlider()->setValues(std::make_pair(x0, x1));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToneCurveField::setIsLinearCheckBox(bool isChecked)
|
|
{
|
|
if (m_isLinearCheckBox->isChecked() == isChecked)
|
|
return;
|
|
m_isLinearCheckBox->setChecked(isChecked);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToneCurveField::setLinear(bool isLinear)
|
|
{
|
|
int i;
|
|
for (i = 0; i < m_sliderStackedWidget->count(); i++)
|
|
getChannelEditor(i)->setLinear(isLinear);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToneCurveField::setLinearManually(bool isLinear)
|
|
{
|
|
emit isLinearChanged(isLinear);
|
|
}
|