Added a time ruler above the audio wave

Author: BenPyton

Signal.cpp

@@ -27,8 +27,8 @@
 #include "WAVFormat.h"
 #include "LoopableBuffer.h"
 
-Signal::Signal(QObject *parent)
-    : QObject(parent),
+Signal::Signal(QObject *_parent)
+    : QObject(_parent),
       m_duration(1.0),
       m_audio(nullptr),
       m_samples(nullptr),
@@ -93,11 +93,11 @@ Signal::~Signal()
     delete m_samples;
 }
 
-void Signal::setVolume(qreal volume)
+void Signal::setVolume(qreal _volume)
 {
     if(m_audio != nullptr)
     {
-        qreal linearVolume = QAudio::convertVolume(volume,
+        qreal linearVolume = QAudio::convertVolume(_volume,
                                                 QAudio::LogarithmicVolumeScale,
                                                 QAudio::LinearVolumeScale);
         m_audio->setVolume(linearVolume);
@@ -122,11 +122,11 @@ int Signal::sampleCount()
     return 0;
 }
 
-qint32 Signal::getSample(int index)
+qint32 Signal::getSample(int _index)
 {
-    if(m_samples != nullptr && index * 4 >= 0 && index * 4 <= m_samples->size() - 4)
+    if(m_samples != nullptr && _index * 4 >= 0 && _index * 4 <= m_samples->size() - 4)
     {
-        return qFromLittleEndian<qint32>(m_samples->constData() + (index * 4));
+        return qFromLittleEndian<qint32>(m_samples->constData() + (_index * 4));
     }
     return 0;
 }
@@ -160,15 +160,15 @@ void Signal::generate()
     emit signalChanged();
 }
 
-void Signal::exportWAV(QString fileName)
+void Signal::exportWAV(QString _fileName)
 {
     WAVFormat wav(1, 1, m_sampleRate, 32);
-    wav.writeToFile(fileName, m_samples);
+    wav.writeToFile(_fileName, m_samples);
 }
 
-void Signal::loop(bool enable)
+void Signal::loop(bool _enable)
 {
-    m_buffer->setLoop(enable);
+    m_buffer->setLoop(_enable);
 }
 
 void Signal::play()
@@ -213,9 +213,9 @@ void Signal::toEnd()
 }
 
 
-void Signal::handleStateChanged(QAudio::State newState)
+void Signal::handleStateChanged(QAudio::State _newState)
 {
-    switch (newState) {
+    switch (_newState) {
         case QAudio::IdleState:
             // Finished playing (no more data)
             m_audio->stop();

Signal.h

@@ -37,16 +37,17 @@ class Signal : public QObject
     Signal(QObject* parent = nullptr);
     virtual ~Signal() override;
 
-    void setComponent(Component* component) { m_component = component; }
-    Component* component() { return m_component; }
+    inline void setComponent(Component* _component) { m_component = _component; }
+    inline Component* component() { return m_component; }
 
-    void setVolume(qreal volume);
+    void setVolume(qreal _volume);
     qreal volume();
 
-    void setDuration(qreal duration) { m_duration = duration; }
-    qreal duration() { return m_duration; }
+    inline void setDuration(qreal _duration) { m_duration = _duration; }
+    inline qreal duration() { return m_duration; }
     int sampleCount();
-    qint32 getSample(int index);
+    qint32 getSample(int _index);
+    inline int getSampleRate() { return m_sampleRate; }
 
 signals:
     void signalChanged();
@@ -59,11 +60,11 @@ public slots:
     void toStart();
     void toEnd();
     void generate();
-    void exportWAV(QString fileName);
-    void loop(bool enable);
+    void exportWAV(QString _fileName);
+    void loop(bool _enable);
 
 private slots:
-    void handleStateChanged(QAudio::State newState);
+    void handleStateChanged(QAudio::State _newState);
 
 private:
     int m_sampleRate;

SoundGenerator.pro

@@ -66,7 +66,8 @@ SOURCES += \
     UI/WaveFormChunk.cpp \
     UI/WaveFormView.cpp \
     LoopableBuffer.cpp \
-    ActionCycle.cpp
+    ActionCycle.cpp \
+    UI/TimeRuler.cpp
 
 HEADERS += \
     Components/AddComponent.h \
@@ -108,7 +109,8 @@ HEADERS += \
     UI/WaveFormChunk.h \
     UI/WaveFormView.h \
     LoopableBuffer.h \
-    ActionCycle.h
+    ActionCycle.h \
+    UI/TimeRuler.h
 
 FORMS += \
     UI/mainwindow.ui

UI/MainWindow.cpp

@@ -57,8 +57,9 @@ MainWindow::MainWindow(QWidget* _parent)
 
 
     ui->buttonLayout->setAlignment(Qt::Alignment(Qt::AlignTop | Qt::AlignHCenter));
-    ui->waveFormView->setScrollBar(ui->waveFormScrollBar);
     ui->waveFormView->setSignal(&m_signal);
+    connect(ui->waveFormView, &WaveFormView::zoomChanged, this, &MainWindow::onWaveFormViewZoomChanged);
+    connect(ui->waveFormScrollBar, &QScrollBar::valueChanged, this, &MainWindow::onScrollbarValueChanged);
 
     m_scene = new NodalScene(ui->nodalView);
     m_scene->setBackgroundBrush(Qt::black);
@@ -540,6 +541,36 @@ void MainWindow::onOutputChanged()
     }
 }
 
+void MainWindow::onWaveFormViewZoomChanged()
+{
+    int total = ui->waveFormView->getNbTotalSample();
+    int offset = ui->waveFormView->getSampleOffset();
+    int viewSize = ui->waveFormView->getNbSampleViewed();
+
+    // update scrollbar
+    ui->waveFormScrollBar->setMinimum(0);
+    ui->waveFormScrollBar->setMaximum(qMax(0, total - viewSize));
+    ui->waveFormScrollBar->setPageStep(viewSize);
+    ui->waveFormScrollBar->setValue((viewSize < total) ? offset : 0);
+
+    // update time ruler
+    qreal sampleDuration = 1.0 / static_cast<qreal>(m_signal.getSampleRate());
+    ui->timeRuler->setTimeWindow(offset * sampleDuration, (offset + viewSize) * sampleDuration);
+}
+
+void MainWindow::onScrollbarValueChanged()
+{
+    int offset = ui->waveFormScrollBar->value();
+    int viewSize = ui->waveFormScrollBar->pageStep();
+
+    // update wave form view
+    ui->waveFormView->setSampleOffset(offset);
+
+    // update time ruler
+    qreal sampleDuration = 1.0 / static_cast<qreal>(m_signal.getSampleRate());
+    ui->timeRuler->setTimeWindow(offset * sampleDuration, (offset + viewSize) * sampleDuration);
+}
+
 void MainWindow::createActions()
 {
 

UI/MainWindow.h

@@ -77,6 +77,9 @@ public slots:
     void changeAutoGenerate(QAction* _action);
     void onOutputChanged();
 
+    void onWaveFormViewZoomChanged();
+    void onScrollbarValueChanged();
+
 private:
     void createActions();
     void createMenus();

UI/TimeRuler.cpp

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2020 Benoit Pelletier
+ *
+ * This file is part of Sound Generator.
+ *
+ * Sound Generator is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Sound Generator is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Sound Generator.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "TimeRuler.h"
+#include <QPainter>
+#include <qmath.h>
+#include "Utils.h"
+#include <math.h>
+
+TimeRuler::TimeRuler(QWidget *_parent)
+    : QWidget(_parent)
+{
+    m_startTime = 0.0;
+    m_endTime = 1.0;
+}
+
+void TimeRuler::setTimeWindow(qreal _startTime, qreal _endTime)
+{
+    m_startTime = _startTime;
+    m_endTime = _endTime;
+
+    update();
+}
+
+void TimeRuler::paintEvent(QPaintEvent *_event)
+{
+    Q_UNUSED(_event);
+
+    QPen pen;
+    pen.setColor(QColor(200, 200, 200));
+    pen.setStyle(Qt::PenStyle::SolidLine);
+
+    QPainter painter(this);
+    painter.setPen(pen);
+
+    qreal pixelPerSecond = size().width() / (m_endTime - m_startTime);
+    qreal minDistBetweenTimecodes = 200.0;
+    qreal timeInterval = 1.0 / qPow(2, qFloor(log2(pixelPerSecond / minDistBetweenTimecodes)));
+    qreal pixelInterval = timeInterval * pixelPerSecond;
+    qreal firstTimeCode = qFloor(m_startTime / timeInterval) * timeInterval;
+    int pixelOffset = qRound((firstTimeCode - m_startTime) * pixelPerSecond);
+    int nbLine = qCeil(size().width() / pixelInterval) + 1;
+    int nbSubdiv = 10;
+
+    QVector<QLineF> lines(nbLine * nbSubdiv);
+    QRectF textRect;
+    QPointF pos;
+    qreal minY = 15.0;
+    qreal maxY = static_cast<qreal>(size().height());
+
+    // main divisions with timecodes
+    for(int i = 0; i < nbLine; ++i)
+    {
+        pos.setX(static_cast<qreal>(qRound(i * pixelInterval + pixelOffset)));
+        textRect.moveCenter(pos);
+        painter.drawText(textRect, Qt::AlignHCenter | Qt::AlignTop | Qt::TextDontClip
+                         , Utils::FormatTimeCode(firstTimeCode + i * timeInterval));
+
+        lines[i * nbSubdiv].setLine(pos.x(), minY, pos.x(), maxY);
+    }
+
+    // sub division (N subdivisions, so N-1 lines in each division)
+    for(int i = 0; i < nbLine * nbSubdiv; ++i)
+    {
+        if(i % nbSubdiv != 0)
+        {
+            qreal x = static_cast<qreal>(qRound(i * pixelInterval / static_cast<qreal>(nbSubdiv) + pixelOffset));
+            lines[i].setLine(x, minY + 5, x, maxY);
+        }
+    }
+
+    painter.drawLines(lines);
+}

UI/TimeRuler.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020 Benoit Pelletier
+ *
+ * This file is part of Sound Generator.
+ *
+ * Sound Generator is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Sound Generator is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Sound Generator.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TIMERULER_H
+#define TIMERULER_H
+
+#include <QWidget>
+
+class TimeRuler : public QWidget
+{
+    Q_OBJECT
+
+public:
+    TimeRuler(QWidget* _parent = nullptr);
+
+    void setTimeWindow(qreal _startTime, qreal _endTime);
+    inline qreal getStartTime() { return m_startTime; }
+    inline qreal getEndTime() { return m_endTime; }
+
+public slots:
+    virtual void paintEvent(QPaintEvent* _event) override;
+
+signals:
+    void onTimeSelected(qreal _time);
+
+private:
+    qreal m_startTime = 0.0;
+    qreal m_endTime = 0.0;
+};
+
+#endif // TIMERULER_H