rename spline-widget -> spline

Adjust usages.

1 files changed, 652 insertions, 0 deletions

diff --git a/spline/spline-widget.cpp b/spline/spline-widget.cpp
new file mode 100644
index 00000000..c7dd5e5a
--- /dev/null
+++ b/spline/spline-widget.cpp
@@ -0,0 +1,652 @@
+/* Copyright (c) 2012-2016 Stanislaw Halik <sthalik@misaki.pl>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ */
+
+#include "compat/util.hpp"
+#include "spline-widget.hpp"
+#include <QPainter>
+#include <QPainterPath>
+#include <QPaintEvent>
+#include <QPen>
+#include <QPixmap>
+#include <QList>
+#include <QPoint>
+#include <QString>
+#include <QRect>
+#include <QApplication>
+#include <QStyle>
+#include <QMouseEvent>
+
+#include <QDebug>
+
+#include <cmath>
+#include <algorithm>
+
+spline_widget::spline_widget(QWidget *parent) :
+    QWidget(parent),
+    _config(nullptr),
+    snap_x(0),
+    snap_y(0),
+    _x_step(10),
+    _y_step(10),
+    moving_control_point_idx(-1),
+    _draw_function(true),
+    _preview_only(false)
+{
+    setMouseTracking(true);
+    setFocusPolicy(Qt::ClickFocus);
+    setCursor(Qt::ArrowCursor);
+}
+
+spline_widget::~spline_widget()
+{
+    if (connection)
+        QObject::disconnect(connection);
+}
+
+void spline_widget::setConfig(spline* spl)
+{
+    if (spl != _config)
+    {
+        if (connection)
+        {
+            QObject::disconnect(connection);
+            connection = QMetaObject::Connection();
+        }
+
+        if (spl)
+        {
+            mem<spline::settings> s = spl->get_settings();
+            connection = connect(s.get(), &spline::settings::recomputed,
+                                 this, [this]() { reload_spline(); },
+                                 Qt::QueuedConnection);
+        }
+
+        _config = spl;
+        _background = QPixmap();
+        update_range();
+    }
+}
+
+QColor spline_widget::colorBezier() const
+{
+    return spline_color;
+}
+
+void spline_widget::setColorBezier(QColor color)
+{
+    spline_color = color;
+    update();
+}
+
+void spline_widget::force_redraw()
+{
+    _background = QPixmap();
+    update();
+}
+
+void spline_widget::set_preview_only(bool val)
+{
+    _preview_only = val;
+}
+
+bool spline_widget::is_preview_only() const
+{
+    return _preview_only;
+}
+
+void spline_widget::drawBackground()
+{
+    _background = QPixmap(width(), height());
+
+    QPainter painter(&_background);
+
+    painter.fillRect(rect(), palette().color(QPalette::Light));
+
+    QColor bg_color(112, 154, 209);
+    if (!isEnabled() && !_preview_only)
+        bg_color = QColor(176,176,180);
+    painter.fillRect(pixel_bounds, bg_color);
+
+    QFont font;
+    font.setPointSize(8);
+    painter.setFont(font);
+    QFontMetrics metrics(font);
+
+    QColor color__(176, 190, 209, 127);
+
+    if (!isEnabled())
+        color__ = QColor(70, 90, 100, 96);
+
+    const QPen pen(color__, 1, Qt::SolidLine, Qt::FlatCap);
+
+    const int ystep = _y_step, xstep = _x_step;
+    const qreal maxx = _config->max_input();
+    const qreal maxy = _config->max_output();
+
+    // horizontal grid
+    for (int i = 0; i <= maxy; i += ystep)
+    {
+        const int y = int(pixel_bounds.height() - i * c.y() + pixel_bounds.y());
+        drawLine(painter,
+                 QPoint(pixel_bounds.x(), y),
+                 QPoint(pixel_bounds.x() + pixel_bounds.width(), y),
+                 pen);
+        painter.drawText(QRectF(10,
+                                y - metrics.height()/2.,
+                                pixel_bounds.left(),
+                                metrics.height()),
+                         QString::number(i));
+    }
+
+    // vertical grid
+    for (int i = 0; i <= maxx; i += xstep)
+    {
+        const int x = iround(pixel_bounds.x() + i * c.x());
+        drawLine(painter,
+                 QPoint(x, pixel_bounds.y()),
+                 QPoint(x, pixel_bounds.y() + pixel_bounds.height()),
+                 pen);
+        const QString text = QString::number(i);
+        painter.drawText(QRectF(x - metrics.width(text)/2.,
+                                pixel_bounds.height() + 10 + metrics.height(),
+                                metrics.width(text),
+                                metrics.height()),
+                         text);
+    }
+}
+
+void spline_widget::drawFunction()
+{
+    _function = _background;
+    QPainter painter(&_function);
+    painter.setRenderHint(QPainter::Antialiasing, true);
+
+    const points_t points = _config->get_points();
+
+    if (moving_control_point_idx >= 0 &&
+        moving_control_point_idx < points.size())
+    {
+        const QPen pen(Qt::white, 1, Qt::SolidLine, Qt::FlatCap);
+        const QPointF prev_ = point_to_pixel(QPointF(0, 0));
+        QPoint prev(iround(prev_.x()), iround(prev_.y()));
+        for (int i = 0; i < points.size(); i++)
+        {
+            const QPointF tmp_ = point_to_pixel(points[i]);
+            const QPoint tmp(iround(tmp_.x()), iround(tmp_.y()));
+            drawLine(painter, prev, tmp, pen);
+            prev = tmp;
+        }
+    }
+
+    const QColor color = progn
+                         (
+                             if (!isEnabled() && !_preview_only)
+                             {
+                                 QColor color(spline_color);
+                                 const int avg = int(float(color.red() + color.green() + color.blue())/3);
+                                 return QColor(int(float(color.red() + avg) * .5f),
+                                               int(float(color.green() + avg) * .5f),
+                                               int(float(color.blue() + avg) * .5f),
+                                               96);
+                             }
+                             else
+                             {
+                                 QColor color(spline_color);
+                                 color.setAlphaF(color.alphaF() * .9);
+                                 return color;
+                             }
+                         );
+
+    painter.setPen(QPen(color, 1.75, Qt::SolidLine, Qt::FlatCap));
+
+//#define DEBUG_SPLINE
+#ifndef DEBUG_SPLINE
+    static constexpr double step_ = 3./3;
+
+    const double maxx = _config->max_input();
+    const double step = step_ / c.x();
+
+    QPainterPath path;
+
+    path.moveTo(point_to_pixel(QPointF(0, 0)));
+
+    for (double k = 0; k < maxx; k += step*3)
+    {
+        const float next_1(_config->get_value_no_save(k + step*1));
+        const float next_2(_config->get_value_no_save(k + step*2));
+        const float next_3(_config->get_value_no_save(k + step*3));
+
+        const QPointF b(point_to_pixel_(QPointF(k + step*1, qreal(next_1)))),
+                      c(point_to_pixel_(QPointF(k + step*2, qreal(next_2)))),
+                      d(point_to_pixel_(QPointF(k + step*3, qreal(next_3))));
+
+        path.cubicTo(b, c, d);
+    }
+
+    painter.drawPath(path);
+#else
+    static constexpr int line_length_pixels = 3;
+    const qreal max = _config->maxInput();
+    const qreal step = clamp(line_length_pixels / c.x(), 5e-2, max);
+    QPointF prev = point_to_pixel(QPoint(0, 0));
+    for (qreal i = 0; i < max; i += step)
+    {
+        const qreal val = qreal(_config->get_value_no_save(i));
+        const QPointF cur = point_to_pixel(QPointF(i, val));
+        painter.drawLine(prev, cur);
+        prev = cur;
+    }
+    {
+        const qreal maxx = _config->maxInput();
+        const qreal maxy = qreal(_config->get_value_no_save(maxx));
+        painter.drawLine(QPointF(prev), point_to_pixel_(QPointF(maxx, maxy)));
+    }
+#endif
+
+    const int alpha = !isEnabled() ? 64 : 120;
+    if (!_preview_only)
+    {
+        for (int i = 0; i < points.size(); i++)
+        {
+            drawPoint(painter,
+                      point_to_pixel(points[i]),
+                      QColor(200, 200, 210, alpha),
+                      isEnabled() ? QColor(50, 100, 120, 200) : QColor(200, 200, 200, 96));
+        }
+    }
+}
+
+void spline_widget::paintEvent(QPaintEvent *e)
+{
+    if (!_config)
+        return;
+
+    QPainter p(this);
+
+    if (_background.isNull())
+    {
+        _draw_function = true;
+        drawBackground();
+    }
+
+    if (_draw_function)
+    {
+        _draw_function = false;
+        drawFunction();
+    }
+
+    p.drawPixmap(e->rect(), _function);
+
+    // If the Tracker is active, the 'Last Point' it requested is recorded.
+    // Show that point on the graph, with some lines to assist.
+    // This new feature is very handy for tweaking the curves!
+    QPointF last;
+    if (_config->get_last_value(last) && isEnabled())
+        drawPoint(p, point_to_pixel(last), QColor(255, 0, 0, 120));
+}
+
+void spline_widget::drawPoint(QPainter& painter, const QPointF& pos, const QColor& colBG, const QColor& border)
+{
+    painter.save();
+    painter.setPen(QPen(border, 1, Qt::SolidLine, Qt::PenCapStyle::FlatCap));
+    painter.setBrush(colBG);
+    painter.drawEllipse(QRectF(pos.x() - point_size,
+                                pos.y() - point_size,
+                                point_size*2, point_size*2));
+    painter.restore();
+}
+
+void spline_widget::drawLine(QPainter& painter, const QPoint& start, const QPoint& end, const QPen& pen)
+{
+    painter.save();
+    painter.setPen(pen);
+    painter.setBrush(Qt::NoBrush);
+    painter.drawLine(start, end);
+    painter.restore();
+}
+
+void spline_widget::mousePressEvent(QMouseEvent *e)
+{
+    if (!_config || !isEnabled() || !is_in_bounds(e->pos()))
+    {
+        clearFocus();
+        return;
+    }
+
+    const int point_pixel_closeness_limit = get_closeness_limit();
+
+    points_t points = _config->get_points();
+    if (e->button() == Qt::LeftButton)
+    {
+        bool bTouchingPoint = false;
+        moving_control_point_idx = -1;
+        for (int i = 0; i < points.size(); i++)
+        {
+            if (point_within_pixel(points[i], e->pos()))
+            {
+                bTouchingPoint = true;
+                moving_control_point_idx = int(i);
+                break;
+            }
+        }
+        if (!bTouchingPoint)
+        {
+            bool too_close = false;
+            const QPoint pos = e->pos();
+
+            for (int i = 0; i < points.size(); i++)
+            {
+                const QPointF pt = point_to_pixel(points[i]);
+                const qreal x = std::fabs(pt.x() - pos.x());
+                if (point_pixel_closeness_limit >= x)
+                {
+                    too_close = true;
+                    break;
+                }
+            }
+
+            if (!too_close)
+            {
+                _config->add_point(pixel_coord_to_point(e->pos()));
+                show_tooltip(e->pos());
+            }
+        }
+    }
+
+    if (e->button() == Qt::RightButton)
+    {
+        if (_config)
+        {
+            int found_pt = -1;
+            for (int i = 0; i < points.size(); i++)
+            {
+                if (point_within_pixel(points[i], e->pos()))
+                {
+                    found_pt = i;
+                    break;
+                }
+            }
+
+            if (found_pt != -1)
+            {
+                _config->remove_point(found_pt);
+            }
+            moving_control_point_idx = -1;
+        }
+    }
+    _draw_function = true;
+    update();
+}
+
+void spline_widget::mouseMoveEvent(QMouseEvent *e)
+{
+    if (_preview_only && _config)
+    {
+        show_tooltip(e->pos());
+        clearFocus();
+        return;
+    }
+
+    if (!_config || !isEnabled() || !isActiveWindow() || (moving_control_point_idx != -1 && !hasFocus()))
+    {
+        clearFocus();
+        return;
+    }
+
+    const int i = moving_control_point_idx;
+    const points_t points = _config->get_points();
+    const int sz = points.size();
+
+    if (i >= 0 && i < sz)
+    {
+        const int point_pixel_closeness_limit = get_closeness_limit();
+        bool overlap = false;
+
+        const QPoint pix = progn(
+            // takes snap into account
+            const QPointF pix_ = point_to_pixel(pixel_coord_to_point(e->pos()));
+            return QPoint(int(pix_.x()), int(pix_.y()));
+        );
+
+        QPointF new_pt = pixel_coord_to_point(e->pos());
+
+        if (i + 1 < points.size())
+        {
+            const QPointF other_pix = point_to_pixel(points[i+1]);
+            overlap |= other_pix.x() - pix.x() < point_pixel_closeness_limit;
+        }
+        if (i != 0)
+        {
+            const QPointF other_pix = point_to_pixel(points[i-1]);
+            overlap |= pix.x() - other_pix.x() < point_pixel_closeness_limit;
+        }
+
+        if (overlap)
+            new_pt.setX(points[i].x());
+
+        _config->move_point(i, new_pt);
+        _draw_function = true;
+
+        setCursor(Qt::ClosedHandCursor);
+        show_tooltip(pix, new_pt);
+        update();
+    }
+    else if (sz)
+    {
+        int i;
+        bool is_on_point = is_on_pt(e->pos(), &i);
+
+        if (is_on_point)
+        {
+            setCursor(Qt::CrossCursor);
+            show_tooltip(e->pos(), points[i]);
+        }
+        else
+        {
+            setCursor(Qt::ArrowCursor);
+            if (is_in_bounds(e->pos()))
+                show_tooltip(e->pos());
+            else
+                QToolTip::hideText();
+        }
+    }
+}
+
+void spline_widget::mouseReleaseEvent(QMouseEvent *e)
+{
+    if (!_config || !isEnabled() || !isActiveWindow() || !hasFocus())
+    {
+        clearFocus();
+        return;
+    }
+
+    if (e->button() == Qt::LeftButton)
+    {
+        {
+            if (is_on_pt(e->pos(), nullptr))
+                setCursor(Qt::CrossCursor);
+            else
+                setCursor(Qt::ArrowCursor);
+        }
+        moving_control_point_idx = -1;
+        _draw_function = true;
+
+        if (is_in_bounds(e->pos()))
+            show_tooltip(e->pos());
+        else
+            QToolTip::hideText();
+
+        update();
+    }
+}
+
+void spline_widget::reload_spline()
+{
+    // don't recompute here as the value's about to be recomputed in the callee
+    update_range();
+}
+
+int spline_widget::get_closeness_limit()
+{
+    return std::max(iround(snap_x * c.x()), 1);
+}
+
+void spline_widget::show_tooltip(const QPoint& pos, const QPointF& value_)
+{
+    const QPointF value = QPoint(0, 0) == value_ ? pixel_coord_to_point(pos) : value_;
+
+    double x = value.x(), y = value.y();
+
+    if (_preview_only)
+        y = _config->get_value_no_save(x);
+
+    const int x_ = iround(x), y_ = iround(y);
+
+    using std::fabs;
+
+    if (fabs(x_ - x) < 1e-3)
+        x = x_;
+    if (fabs(y_ - y) < 1e-3)
+        y = y_;
+
+    const bool is_fusion = QStringLiteral("fusion") == QApplication::style()->objectName();
+    const int add_x = (is_fusion ? 25 : 0), add_y = (is_fusion ? 15 : 0);
+
+    const QPoint pix(int(pos.x()) + add_x, int(pos.y()) + add_y);
+
+    QToolTip::showText(mapToGlobal(pix),
+                       QStringLiteral("value: %1x%2").arg(x).arg(y),
+                       this,
+                       rect(),
+                       0);
+}
+
+bool spline_widget::is_in_bounds(const QPoint& pos) const
+{
+    static constexpr int grace = point_size * 3;
+    static constexpr int bottom_grace = int(point_size * 1.5);
+    return (pos.x() + grace        > pixel_bounds.left() &&
+            pos.x() - grace        < pixel_bounds.right() &&
+            pos.y() + grace        > pixel_bounds.top() &&
+            pos.y() - bottom_grace < pixel_bounds.bottom());
+}
+
+void spline_widget::update_range()
+{
+    if (!_config)
+        return;
+
+    const int w = width(), h = height();
+    const int mwl = 40, mhl = 20;
+    const int mwr = 15, mhr = 35;
+
+    pixel_bounds = QRect(mwl, mhl, (w - mwl - mwr), (h - mhl - mhr));
+    c = QPointF(pixel_bounds.width() / _config->max_input(), pixel_bounds.height() / _config->max_output());
+    _draw_function = true;
+
+    _background = QPixmap();
+    _function = QPixmap();
+
+    update();
+}
+
+bool spline_widget::point_within_pixel(const QPointF& pt, const QPoint &pixel)
+{
+    const QPointF tmp = pixel - point_to_pixel(pt);
+    return QPointF::dotProduct(tmp, tmp) < point_size * point_size;
+}
+
+void spline_widget::focusOutEvent(QFocusEvent* e)
+{
+    if (moving_control_point_idx != -1)
+        QToolTip::hideText();
+    moving_control_point_idx = -1;
+    _draw_function = true;
+    lower();
+    setCursor(Qt::ArrowCursor);
+    e->accept();
+}
+
+QPointF spline_widget::pixel_coord_to_point(const QPoint& point)
+{
+    qreal x = (point.x() - pixel_bounds.x()) / c.x();
+    qreal y = (pixel_bounds.height() - point.y() + pixel_bounds.y()) / c.y();
+
+    static constexpr int c = 1000;
+
+    if (snap_x > 0)
+    {
+        x += snap_x * .5;
+        x -= std::fmod(x, snap_x);
+        // truncate after few decimal places to reduce rounding errors.
+        // round upward to nearest.
+        x = int(x * c + .5/c) / double(c);
+    }
+    if (snap_y > 0)
+    {
+        y += snap_y * .5;
+        y -= std::fmod(y, snap_y);
+        // idem
+        y = int(y * c + .5/c) / double(c);
+    }
+
+    if (x < 0)
+        x = 0;
+    if (x > _config->max_input())
+        x = _config->max_input();
+
+    if (y < 0)
+        y = 0;
+    if (y > _config->max_output())
+        y = _config->max_output();
+
+    return QPointF(x, y);
+}
+
+QPointF spline_widget::point_to_pixel_(const QPointF& point)
+{
+    return QPointF(pixel_bounds.x() + point.x() * c.x(),
+                   pixel_bounds.y() + pixel_bounds.height() - point.y() * c.y());
+}
+
+QPoint spline_widget::point_to_pixel(const QPointF& point)
+{
+    QPointF pt(point_to_pixel_(point));
+
+    return QPoint(iround(pt.x()), iround(pt.y()));
+}
+
+void spline_widget::resizeEvent(QResizeEvent *)
+{
+    update_range();
+}
+
+bool spline_widget::is_on_pt(const QPoint& pos, int* pt)
+{
+    if (!_config)
+    {
+        if (pt)
+            *pt = -1;
+        return false;
+    }
+
+    const points_t points = _config->get_points();
+
+    for (int i = 0; i < points.size(); i++)
+    {
+        if (point_within_pixel(points[i], pos))
+        {
+            if (pt)
+                *pt = i;
+            return true;
+        }
+    }
+
+    if (pt)
+        *pt = -1;
+    return false;
+}