cleanup qfc

Issue: #44

Remove confusing logic and retarded comments by the usual offender. Change
prototypes a bit for clarity's sake again.

1 files changed, 89 insertions, 99 deletions

diff --git a/qfunctionconfigurator/qfunctionconfigurator.cpp b/qfunctionconfigurator/qfunctionconfigurator.cpp
index a197dadb..17431986 100644
--- a/qfunctionconfigurator/qfunctionconfigurator.cpp
+++ b/qfunctionconfigurator/qfunctionconfigurator.cpp
@@ -1,10 +1,12 @@
-/* Copyright (c) 2011-2012 Stanislaw Halik <sthalik@misaki.pl>
- *                         Adapted to FaceTrackNoIR by Wim Vriend.
+/* Copyright (c) 2011-2014 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.
  */
 
+// Adapted to FaceTrackNoIR by Wim Vriend.
+
 #include "qfunctionconfigurator/qfunctionconfigurator.h"
 #include <QPainter>
 #include <QPaintEvent>
@@ -25,35 +27,33 @@
 
 static const int pointSize = 5;
 
-QFunctionConfigurator::QFunctionConfigurator(QWidget *parent)
-    : QWidget(parent)
+QFunctionConfigurator::QFunctionConfigurator(QWidget *parent) :
+    QWidget(parent),
+    _config(nullptr),
+    moving_control_point_idx(-1),
+    _draw_function(true)
 {
-    movingPoint = -1;
-    _config = 0;
-    _draw_background = true;
-    _draw_function = true;
     update_range();
     setMouseTracking(true);
 }
 
-void QFunctionConfigurator::setConfig(FunctionConfig* config) {
+void QFunctionConfigurator::setConfig(FunctionConfig* config, const QString& name) {
     QSettings settings("opentrack");
     QString currentFile = settings.value ( "SettingsFile", QCoreApplication::applicationDirPath() + "/settings/default.ini" ).toString();
     QSettings iniFile( currentFile, QSettings::IniFormat );
 
     config->loadSettings(iniFile, name);
     _config = config;
-    _draw_function = _draw_background = true;
+    _draw_function = true;
     update_range();
     update();
 }
 
-void QFunctionConfigurator::saveSettings(QString settingsFile) {
-    QSettings iniFile( settingsFile, QSettings::IniFormat );						// Application settings (in INI-file)
+void QFunctionConfigurator::saveSettings(QString settingsFile, const QString& name) {
+    QSettings iniFile(settingsFile, QSettings::IniFormat);
 
-    if (_config) {
+    if (_config)
         _config->saveSettings(iniFile, name);
-    }
 }
 
 void QFunctionConfigurator::drawBackground()
@@ -61,11 +61,13 @@ void QFunctionConfigurator::drawBackground()
     if (!_config)
         return;
     _background = QPixmap(width(), height());
+    
     QPainter painter(&_background);
     painter.fillRect(rect(), QColor::fromRgb(204, 204, 204));
     painter.setRenderHint(QPainter::Antialiasing);
+    
     QColor bg_color(112, 154, 209);
-    painter.fillRect(range, bg_color);
+    painter.fillRect(pixel_bounds, bg_color);
 
     QFont font;
     font.setPointSize(8);
@@ -79,61 +81,59 @@ void QFunctionConfigurator::drawBackground()
     const int maxy = _config->maxOutput();
 
     // horizontal grid
-
     for (int i = 0; i < maxy; i += xstep)
     {
-        double y = range.height() - i * c.y() + range.y();
+        double y = pixel_bounds.height() - i * c.y() + pixel_bounds.y();
         drawLine(&painter,
-                 QPointF(range.x(), y),
-                 QPointF(range.x() + range.width(), y),
+                 QPointF(pixel_bounds.x(), y),
+                 QPointF(pixel_bounds.x() + pixel_bounds.width(), y),
                  pen);
         painter.drawText(QRectF(10,
                                 y - metrics.height()/2,
-                                range.left(),
+                                pixel_bounds.left(),
                                 metrics.height()),
                          QString::number(i));
     }
 
     {
         const int i = maxy;
-        double y = range.height() - i * c.y() + range.y();
+        double y = pixel_bounds.height() - i * c.y() + pixel_bounds.y();
         drawLine(&painter,
-                 QPointF(range.x(), y),
-                 QPointF(range.x() + range.width(), y),
+                 QPointF(pixel_bounds.x(), y),
+                 QPointF(pixel_bounds.x() + pixel_bounds.width(), y),
                  pen);
         painter.drawText(QRectF(10,
                                 y - metrics.height()/2,
-                                range.x() - 10,
+                                pixel_bounds.x() - 10,
                                 metrics.height()),
                          QString::number(i));
     }
 
     // vertical grid
-
     for (int i = 0; i < maxx; i += ystep)
     {
-        double x = range.x() + i * c.x();
+        double x = pixel_bounds.x() + i * c.x();
         drawLine(&painter,
-                 QPointF(x, range.y()),
-                 QPointF(x, range.y() + range.height()),
+                 QPointF(x, pixel_bounds.y()),
+                 QPointF(x, pixel_bounds.y() + pixel_bounds.height()),
                  pen);
         const QString text = QString::number(i);
         painter.drawText(QRectF(x - metrics.width(text)/2,
-                                range.height() + 10 + metrics.height(),
+                                pixel_bounds.height() + 10 + metrics.height(),
                                 metrics.width(text),
                                 metrics.height()),
                          text);
     }
     {
         const int i = maxx;
-        double x = range.x() + i * c.x();
+        double x = pixel_bounds.x() + i * c.x();
         drawLine(&painter,
-                 QPointF(x, range.y()),
-                 QPointF(x, range.y() + range.height()),
+                 QPointF(x, pixel_bounds.y()),
+                 QPointF(x, pixel_bounds.y() + pixel_bounds.height()),
                  pen);
         const QString text = QString::number(i);
         painter.drawText(QRectF(x - metrics.width(text)/2,
-                                range.height() + 10 + metrics.height(),
+                                pixel_bounds.height() + 10 + metrics.height(),
                                 metrics.width(text),
                                 metrics.height()),
                          text);
@@ -144,9 +144,6 @@ void QFunctionConfigurator::drawFunction()
 {
     if (!_config)
         return;
-    int i;
-    QPointF prevPoint;
-    QPointF currentPoint;
 
     _function = QPixmap(_background);
     QPainter painter(&_function);
@@ -156,19 +153,18 @@ void QFunctionConfigurator::drawFunction()
 
     QList<QPointF> points = _config->getPoints();
 
-    for (i = 0; i < points.size(); i++) {
-        currentPoint = point_to_pixel( points[i] );		// Get the next point and convert it to Widget measures
-        drawPoint(&painter, currentPoint, QColor(200, 200, 210, 120));
-        lastPoint = currentPoint;											// Remember which point is the rightmost in the graph
+    for (int i = 0; i < points.size(); i++) {
+        drawPoint(&painter,
+                  point_to_pixel(points[i]),
+                  QColor(200, 200, 210, 120));
     }
 
+    QPen pen(spline_color, 1.2, Qt::SolidLine);
 
-    QPen pen(colBezier, 1.2, Qt::SolidLine);
-
-    prevPoint = point_to_pixel( QPointF(0,0) );		// Start at the Axis
-    double max = _config->maxInput();
+    static const constexpr double step = 1.02;
+    const double max = _config->maxInput();
+    
     QPointF prev = point_to_pixel(QPointF(0, 0));
-    const double step = 1.01;
     for (double i = 0; i < max; i += step) {
         double val = _config->getValue(i);
         QPointF cur = point_to_pixel(QPointF(i, val));
@@ -180,66 +176,54 @@ void QFunctionConfigurator::drawFunction()
 
 void QFunctionConfigurator::paintEvent(QPaintEvent *e)
 {
-    QPointF prevPoint;
-    QPointF currentPoint;
-    QPointF actualPos;
-    int i;
-
     QPainter p(this);
     p.setRenderHint(QPainter::Antialiasing);
 
-    if (_draw_background) {
+    if (_background.isNull())
         drawBackground();
-        _draw_background = false;
-    }
     p.drawPixmap(e->rect(), _background);
 
     if (_draw_function) {
-        drawFunction();						// Draw the Function on a Pixmap
         _draw_function = false;
+        drawFunction();
     }
-    p.drawPixmap(e->rect(), _function);						// Always draw the background and the function
+    p.drawPixmap(e->rect(), _function);
 
     if (_config) {
         QPen pen(Qt::white, 1, Qt::SolidLine);
         QList<QPointF> points = _config->getPoints();
-        if (movingPoint >= 0 && movingPoint < points.size()) {
-            prevPoint = point_to_pixel( QPointF(0,0) );				// Start at the Axis
-            for (i = 0; i < points.size(); i++) {
-                currentPoint = point_to_pixel( points[i] );		// Get the next point and convert it to Widget measures
-                drawLine(&p, prevPoint, currentPoint, pen);
-                prevPoint = currentPoint;
+        if (moving_control_point_idx >= 0 && moving_control_point_idx < points.size()) {
+            QPointF prev;
+            for (int i = 0; i < points.size(); i++) {
+                auto tmp = point_to_pixel(points[i]);
+                drawLine(&p, prev, tmp, pen);
+                prev = tmp;
             }
             pen.setWidth(1);
             pen.setColor( Qt::white );
             pen.setStyle( Qt::DashLine );
-            actualPos = point_to_pixel(points[movingPoint]);
-            drawLine(&p, QPoint(range.left(), actualPos.y()), QPoint(actualPos.x(), actualPos.y()), pen);
-            drawLine(&p, QPoint(actualPos.x(), actualPos.y()), QPoint(actualPos.x(), range.height() + range.top()), pen);
+            QPointF pixel_pos = point_to_pixel(points[moving_control_point_idx]);
+            drawLine(&p, QPoint(pixel_bounds.left(), pixel_pos.y()), QPoint(pixel_pos.x(), pixel_pos.y()), pen);
+            drawLine(&p, QPoint(pixel_pos.x(), pixel_pos.y()), QPoint(pixel_pos.x(), pixel_bounds.height() + pixel_bounds.top()), pen);
         }
 
-        //
         // 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!
-        //
-        if (_config->getLastPoint( currentPoint )) {
-            actualPos = point_to_pixel( QPointF(fabs(currentPoint.x()), fabs(currentPoint.y())) );
-            drawPoint(&p, actualPos, QColor(255, 0, 0, 120));
+        QPointF last;
+        if (_config->getLastPoint(last)) {
+            QPointF pixel_pos = point_to_pixel( QPointF(fabs(last.x()), fabs(last.y())) );
+            drawPoint(&p, pixel_pos, QColor(255, 0, 0, 120));
 
             pen.setWidth(1);
             pen.setColor( Qt::black );
             pen.setStyle( Qt::SolidLine );
-            drawLine(&p, QPoint(range.left(), actualPos.y()), QPoint(actualPos.x(), actualPos.y()), pen);
-            drawLine(&p, QPoint(actualPos.x(), actualPos.y()), QPoint(actualPos.x(), range.width()), pen);
+            drawLine(&p, QPoint(pixel_bounds.left(), pixel_pos.y()), QPoint(pixel_pos.x(), pixel_pos.y()), pen);
+            drawLine(&p, QPoint(pixel_pos.x(), pixel_pos.y()), QPoint(pixel_pos.x(), pixel_bounds.width()), pen);
         }
-
     }
 }
 
-//
-// Draw the handle, to move the Bezier-curve.
-//
 void QFunctionConfigurator::drawPoint(QPainter *painter, const QPointF &pos, QColor colBG )
 {
     painter->save();
@@ -251,7 +235,7 @@ void QFunctionConfigurator::drawPoint(QPainter *painter, const QPointF &pos, QCo
     painter->restore();
 }
 
-void QFunctionConfigurator::drawLine(QPainter *painter, const QPointF &start, const QPointF &end, QPen pen)
+void QFunctionConfigurator::drawLine(QPainter *painter, const QPointF &start, const QPointF &end, QPen &pen)
 {
     painter->save();
     painter->setPen(pen);
@@ -267,12 +251,12 @@ void QFunctionConfigurator::mousePressEvent(QMouseEvent *e)
     QList<QPointF> points = _config->getPoints();
     if (e->button() == Qt::LeftButton) {
         bool bTouchingPoint = false;
-        movingPoint = -1;
+        moving_control_point_idx = -1;
         if (_config) {
             for (int i = 0; i < points.size(); i++) {
                 if ( point_within_pixel(points[i], e->pos() ) ) {
                     bTouchingPoint = true;
-                    movingPoint = i;
+                    moving_control_point_idx = i;
                     timer.restart();
                     break;
                 }
@@ -296,7 +280,7 @@ void QFunctionConfigurator::mousePressEvent(QMouseEvent *e)
             if (found_pt != -1) {
                 _config->removePoint(found_pt);
             }
-            movingPoint = -1;
+            moving_control_point_idx = -1;
         }
     }
     _draw_function = true;
@@ -307,29 +291,33 @@ void QFunctionConfigurator::mouseMoveEvent(QMouseEvent *e)
 {
     if (!_config)
         return;
+    
+    static const constexpr int min_refresh_delay = 25;
+    
+    if (timer.isValid() && timer.elapsed() < min_refresh_delay)
+        return;
+    
+    static const constexpr int refresh_delay = 50;
     QList<QPointF> points = _config->getPoints();
-    const int refresh_delay = 50;
 
-    if (movingPoint >= 0 && movingPoint < points.size()) {
+    if (moving_control_point_idx >= 0 && moving_control_point_idx < points.size()) {
         setCursor(Qt::ClosedHandCursor);
 
         if (timer.isValid() && timer.elapsed() > refresh_delay)
         {
             timer.restart();
             QPointF new_pt = pixel_coord_to_point(e->pos());
-            points[movingPoint] = new_pt;
-            _config->movePoint(movingPoint, new_pt);
+            points[moving_control_point_idx] = new_pt;
+            _config->movePoint(moving_control_point_idx, new_pt);
             _draw_function = true;
             update();
         }
     }
     else {
         bool bTouchingPoint = false;
-        if (_config) {
-            for (int i = 0; i < points.size(); i++) {
-                if ( point_within_pixel(points[i], e->pos() ) ) {
-                    bTouchingPoint = true;
-                }
+        for (int i = 0; i < points.size(); i++) {
+            if ( point_within_pixel(points[i], e->pos() ) ) {
+                bTouchingPoint = true;
             }
         }
 
@@ -346,37 +334,39 @@ void QFunctionConfigurator::mouseReleaseEvent(QMouseEvent *e)
 {
     if (!_config)
         return;
+    
     QList<QPointF> points = _config->getPoints();
 
     if (e->button() == Qt::LeftButton) {
         timer.invalidate();
-        if (movingPoint >= 0 && movingPoint < points.size()) {
+        if (moving_control_point_idx >= 0 && moving_control_point_idx < points.size()) {
             if (_config) {
-                _config->movePoint(movingPoint, pixel_coord_to_point(e->pos()));
+                _config->movePoint(moving_control_point_idx, pixel_coord_to_point(e->pos()));
             }
         }
         setCursor(Qt::ArrowCursor);
-        movingPoint = -1;
+        moving_control_point_idx = -1;
     }
 
     _draw_function = true;
     update();
 }
 
-bool QFunctionConfigurator::point_within_pixel(QPointF pt, QPointF pixel) const
+bool QFunctionConfigurator::point_within_pixel(const QPointF &pt, const QPointF &pixel)
 {
-    QPointF pixel2(range.x() + pt.x() * c.x(), (range.y() + range.height() - pt.y() * c.y()));
+    QPointF pixel2(pixel_bounds.x() + pt.x() * c.x(),
+                   (pixel_bounds.y() + pixel_bounds.height() - pt.y() * c.y()));
     return pixel2.x() >= pixel.x() - pointSize && pixel2.x() < pixel.x() + pointSize &&
            pixel2.y() >= pixel.y() - pointSize && pixel2.y() < pixel.y() + pointSize;
 }
 
-QPointF QFunctionConfigurator::pixel_coord_to_point(QPointF point) const
+QPointF QFunctionConfigurator::pixel_coord_to_point(const QPointF& point)
 {
     if (!_config)
         return QPointF(-1, -1);
 
-    double x = (point.x() - range.x()) / c.x();
-    double y = (range.height() - point.y() + range.y()) / c.y();
+    double x = (point.x() - pixel_bounds.x()) / c.x();
+    double y = (pixel_bounds.height() - point.y() + pixel_bounds.y()) / c.y();
 
     if (x < 0)
         x = 0;
@@ -391,10 +381,10 @@ QPointF QFunctionConfigurator::pixel_coord_to_point(QPointF point) const
     return QPointF(x, y);
 }
 
-QPointF QFunctionConfigurator::point_to_pixel(QPointF point) const
+QPointF QFunctionConfigurator::point_to_pixel(const QPointF& point)
 {
-    return QPointF(range.x() + point.x() * c.x(),
-                   range.y() + range.height() - point.y() * c.y());
+    return QPointF(pixel_bounds.x() + point.x() * c.x(),
+                   pixel_bounds.y() + pixel_bounds.height() - point.y() * c.y());
 }
 
 void QFunctionConfigurator::resizeEvent(QResizeEvent *)