timerulerwidget.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "timerulerwidget.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QContextMenuEvent>
#include <QPainter>
#include <QPaintEvent>
#include <QFontDatabase>
#include <QMenu>
#include <QtMath>
#include <cmath>
#include <limits>
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace DISPLIB;
 
//=============================================================================================================
// CONSTANTS
//=============================================================================================================
 
namespace
{
// Same nice-interval table used by the render grid — guarantees perfect alignment.
static const double kNiceIntervals[] = {0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0};
constexpr double kMinMajorPx = 80.0; // minimum px spacing between major ticks
constexpr int kMajorH = 10;          // tick mark height in px (downward from bottom border)
constexpr int kMinorH = 5;
constexpr int kLabelGap = 3; // gap between label bottom and tick top
} // namespace
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
TimeRulerWidget::TimeRulerWidget(QWidget* parent)
: QWidget(parent)
{
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    setFixedHeight(kTotalH);
}
 
//=============================================================================================================
 
void TimeRulerWidget::setSfreq(double sfreq)
{
    m_sfreq = (sfreq > 0.0) ? sfreq : 1.0;
    update();
}
 
//=============================================================================================================
 
void TimeRulerWidget::setFirstFileSample(int firstFileSample)
{
    m_firstFileSample = firstFileSample;
    update();
}
 
//=============================================================================================================
 
void TimeRulerWidget::setEvents(const QVector<TimeRulerEventMark>& events)
{
    m_events = events;
    update();
}
 
//=============================================================================================================
 
void TimeRulerWidget::setReferenceMarkers(const QVector<TimeRulerReferenceMark>& markers)
{
    m_referenceMarkers = markers;
    update();
}
 
//=============================================================================================================
 
void TimeRulerWidget::setScrollSample(float sample)
{
    // Exact: a relative fuzzy compare ignores steps below 1e-5 of the position (10 samples at 10^6)
    if (m_scrollSample == sample)
        return;
    m_scrollSample = sample;
    update();
}
 
//=============================================================================================================
 
void TimeRulerWidget::setSamplesPerPixel(float spp)
{
    if (qFuzzyCompare(m_spp, spp))
        return;
    m_spp = spp;
    update();
}
 
//=============================================================================================================
 
QString TimeRulerWidget::formatTime(double seconds)
{
    if (seconds < 0.0)
        seconds = 0.0;
 
    if (seconds >= 3600.0) {
        int h = static_cast<int>(seconds) / 3600;
        int m = (static_cast<int>(seconds) % 3600) / 60;
        int s = static_cast<int>(seconds) % 60;
        return QString("%1:%2:%3")
            .arg(h)
            .arg(m, 2, 10, QChar('0'))
            .arg(s, 2, 10, QChar('0'));
    } else if (seconds >= 60.0) {
        int m = static_cast<int>(seconds) / 60;
        double s = seconds - m * 60.0;
        return QString("%1:%2").arg(m).arg(s, 4, 'f', 1, QChar('0'));
    } else if (seconds >= 10.0) {
        return QString("%1 s").arg(static_cast<int>(std::round(seconds)));
    } else if (seconds >= 1.0) {
        return QString("%1 s").arg(seconds, 0, 'f', 1);
    } else if (seconds >= 0.1) {
        return QString("%1 s").arg(seconds, 0, 'f', 2);
    } else if (seconds >= 0.001) {
        return QString("%1 ms").arg(seconds * 1e3, 0, 'f', 1);
    } else {
        return QString("%1 ms").arg(seconds * 1e3, 0, 'f', 2);
    }
}
 
//=============================================================================================================
 
void TimeRulerWidget::toggleTimeFormat()
{
    m_useClockTime = !m_useClockTime;
    update();
}
 
//=============================================================================================================
 
void TimeRulerWidget::setClockTimeFormat(bool useClock)
{
    if (m_useClockTime == useClock)
        return;
    m_useClockTime = useClock;
    update();
}
 
//=============================================================================================================
 
int TimeRulerWidget::sampleAtX(int x) const
{
    const int clampedX = qBound(0, x, qMax(0, width() - 1));
    const double sample = static_cast<double>(m_scrollSample) + static_cast<double>(clampedX) * static_cast<double>(m_spp);
    return qRound(sample);
}
 
//=============================================================================================================
 
int TimeRulerWidget::nearestReferenceMarkerIndex(int sample, int tolerancePixels) const
{
    if (m_referenceMarkers.isEmpty() || m_spp <= 0.f) {
        return -1;
    }
 
    int nearestIndex = -1;
    double nearestDistance = std::numeric_limits<double>::max();
    const double toleranceSamples = static_cast<double>(tolerancePixels) * static_cast<double>(m_spp);
 
    for (int i = 0; i < m_referenceMarkers.size(); ++i) {
        const double distance = qAbs(static_cast<double>(m_referenceMarkers.at(i).sample - sample));
        if (distance <= toleranceSamples && distance < nearestDistance) {
            nearestDistance = distance;
            nearestIndex = i;
        }
    }
 
    return nearestIndex;
}
 
//=============================================================================================================
 
void TimeRulerWidget::paintEvent(QPaintEvent* /*event*/)
{
    const int W = width();
    const int H = height(); // == kTotalH == kStimZoneH + kTimeZoneH
    const double spp = static_cast<double>(m_spp);
 
    if (W <= 0 || spp <= 0.0 || m_sfreq <= 0.0)
        return;
 
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, false);
    p.setRenderHint(QPainter::TextAntialiasing, true);
 
    // Layout (top → bottom):
    //   [0 .. kTimeZoneH)  — time zone: tick marks + labels
    //   [kTimeZoneH .. kTotalH) — stim zone: event chips
 
    // ── Time zone background (top kTimeZoneH px) ──────────────────────
    p.fillRect(QRect(0, 0, W, kTimeZoneH), QColor(245, 245, 247));
 
    // ── Stim lane background (bottom kStimZoneH px) ───────────────────
    p.fillRect(QRect(0, kTimeZoneH, W, kStimZoneH), QColor(238, 238, 246));
 
    // Separator line between the two zones
    p.setPen(QPen(QColor(190, 190, 205), 1));
    p.drawLine(0, kTimeZoneH, W, kTimeZoneH);
 
    // Bottom border
    p.setPen(QPen(QColor(185, 185, 195), 1));
    p.drawLine(0, H - 1, W, H - 1);
 
    // ── Persistent sample markers ────────────────────────────────────
    if (!m_referenceMarkers.isEmpty()) {
        QFont markerFont = p.font();
        markerFont.setPixelSize(9);
        markerFont.setBold(true);
        p.setFont(markerFont);
 
        constexpr int kMarkerChipH = 12;
        constexpr int kMarkerPadX = 5;
        const int markerChipY = 2;
 
        for (const TimeRulerReferenceMark& marker : m_referenceMarkers) {
            const float xF = (static_cast<float>(marker.sample) - m_scrollSample) / static_cast<float>(spp);
            if (xF < -2.f || xF > W + 2.f) {
                continue;
            }
 
            const int xi = static_cast<int>(std::round(xF));
            QColor markerColor = marker.color;
            markerColor.setAlpha(210);
            p.setPen(QPen(markerColor, 1));
            p.drawLine(xi, 0, xi, H - 1);
 
            const QString label = marker.label.isEmpty()
                ? QString::number(marker.sample)
                : marker.label;
            const int chipW = qMax(20, p.fontMetrics().horizontalAdvance(label) + 2 * kMarkerPadX);
            QRect chipRect(xi - chipW / 2, markerChipY, chipW, kMarkerChipH);
            chipRect.moveLeft(qBound(2, chipRect.left(), qMax(2, W - chipRect.width() - 2)));
 
            QColor fillColor = marker.color;
            fillColor.setAlpha(220);
            p.fillRect(chipRect, fillColor);
            p.setPen(Qt::white);
            p.drawText(chipRect, Qt::AlignCenter, label);
        }
    }
 
    // ── Stim event chips ─────────────────────────────────────────────
    if (!m_events.isEmpty()) {
        QFont evFont;
        evFont.setPixelSize(9);
        evFont.setBold(true);
        p.setFont(evFont);
 
        constexpr int kChipW = 26;
        constexpr int kChipH = 11;
        // Chips sit centred vertically in the stim zone (bottom strip)
        constexpr int kChipY = kTimeZoneH + (kStimZoneH - kChipH) / 2;
 
        // Track the rightmost x edge drawn so far.  When a chip would overlap,
        // we skip it entirely (only the tick mark is kept).  Events must be
        // sorted by ascending sample for this to work correctly.
        int lastChipRight = -kChipW;
 
        for (const TimeRulerEventMark& ev : m_events) {
            float xF = (static_cast<float>(ev.sample) - m_scrollSample) / static_cast<float>(spp);
            if (xF < -2.f || xF > W + 2.f)
                continue;
            int ix = static_cast<int>(xF);
 
            // Tick mark at the top of the stim zone (bridging separator into stim area)
            QColor col = ev.color;
            col.setAlpha(200);
            p.setPen(QPen(col, 1));
            p.drawLine(ix, kTimeZoneH, ix, kTimeZoneH + 3);
 
            // Chip: only draw if it fits without overlapping the previous chip.
            // When events are too close, we drop the chip (keeping only the tick mark)
            // so labels never pile up at the right edge.
            int chipX = ix - kChipW / 2;
            chipX = qMax(0, chipX); // don't go off left edge
            if (chipX + kChipW > W)
                continue; // would spill off right edge — skip entirely
            if (chipX < lastChipRight + 2)
                continue; // would overlap previous chip — skip
 
            QRectF chip(chipX, kChipY, kChipW, kChipH);
            QColor fill = ev.color;
            fill.setAlpha(150);
            p.fillRect(chip, fill);
            p.setPen(Qt::white);
            QString lbl = ev.label.isEmpty() ? QStringLiteral("?") : ev.label;
            p.drawText(chip, Qt::AlignCenter, lbl);
 
            lastChipRight = chipX + kChipW;
        }
    }
 
    // ── Choose tick interval ──────────────────────────────────────────
    const double pxPerSec = m_sfreq / spp;
    double tickIntervalS = kNiceIntervals[0];
    for (double iv : kNiceIntervals) {
        tickIntervalS = iv;
        if (iv * pxPerSec >= kMinMajorPx)
            break;
    }
 
    const double tickSamples = tickIntervalS * m_sfreq;
    const double minorSamples = tickSamples / 5.0;
    const double origin = static_cast<double>(m_firstFileSample);
 
    // ── Font ─────────────────────────────────────────────────────────
    QFont font = QFontDatabase::systemFont(QFontDatabase::FixedFont);
    font.setPointSizeF(8.0);
    p.setFont(font);
    const QFontMetrics fm(font);
 
    // ── Minor ticks (bottom of time zone, pointing down) ─────────────
    {
        double firstMinorS = std::ceil((m_scrollSample - origin - minorSamples) / minorSamples) * minorSamples + origin;
        p.setPen(QPen(QColor(165, 165, 175), 1));
        for (double s = firstMinorS;; s += minorSamples) {
            double xPx = (s - m_scrollSample) / spp;
            if (xPx > W + 2)
                break;
            if (xPx < -2)
                continue;
            int xi = static_cast<int>(std::round(xPx));
            p.drawLine(xi, kTimeZoneH - 1 - kMinorH, xi, kTimeZoneH - 2);
        }
    }
 
    // ── Major ticks + labels ─────────────────────────────────────────
    {
        double firstMajorS = std::ceil((m_scrollSample - origin - tickSamples) / tickSamples) * tickSamples + origin;
        for (double s = firstMajorS;; s += tickSamples) {
            double xPx = (s - m_scrollSample) / spp;
            if (xPx > W + 2)
                break;
            if (xPx < -2)
                continue;
 
            int xi = static_cast<int>(std::round(xPx));
 
            p.setPen(QPen(QColor(100, 100, 115), 1));
            p.drawLine(xi, kTimeZoneH - 1 - kMajorH, xi, kTimeZoneH - 2);
 
            double elapsedSec = (s - origin) / m_sfreq;
            if (elapsedSec >= -tickIntervalS * 0.5) {
                QString label;
                if (m_useClockTime && elapsedSec >= 0.0) {
                    int totalMs = static_cast<int>(elapsedSec * 1000.0 + 0.5);
                    int m = totalMs / 60000;
                    int sec = (totalMs % 60000) / 1000;
                    int ms = totalMs % 1000;
                    label = QString("%1:%2.%3")
                                .arg(m, 2, 10, QChar('0'))
                                .arg(sec, 2, 10, QChar('0'))
                                .arg(ms, 3, 10, QChar('0'));
                } else {
                    label = formatTime(elapsedSec);
                }
                const int lw = fm.horizontalAdvance(label);
 
                int lx = xi - lw / 2;
                lx = qBound(2, lx, W - lw - 2);
                int ly = kTimeZoneH - 1 - kMajorH - kLabelGap;
 
                p.setPen(QColor(65, 65, 80));
                p.drawText(lx, ly, label);
            }
        }
    }
}
 
//=============================================================================================================
 
void TimeRulerWidget::contextMenuEvent(QContextMenuEvent* event)
{
    if (m_sfreq <= 0.0 || m_spp <= 0.0f) {
        QWidget::contextMenuEvent(event);
        return;
    }
 
    const int sample = sampleAtX(event->pos().x());
    const int nearbyMarkerIndex = nearestReferenceMarkerIndex(sample);
 
    QMenu menu(this);
    QAction* addMarkerAction = menu.addAction(tr("Add Marker Here"));
    QAction* removeMarkerAction = nullptr;
    QAction* clearMarkersAction = nullptr;
 
    if (nearbyMarkerIndex >= 0) {
        removeMarkerAction = menu.addAction(tr("Remove Nearest Marker"));
    }
 
    if (!m_referenceMarkers.isEmpty()) {
        menu.addSeparator();
        clearMarkersAction = menu.addAction(tr("Clear All Markers"));
    }
 
    QAction* selectedAction = menu.exec(event->globalPos());
    if (!selectedAction) {
        return;
    }
 
    if (selectedAction == addMarkerAction) {
        emit addReferenceMarkerRequested(sample);
    } else if (selectedAction == removeMarkerAction) {
        emit removeReferenceMarkerRequested(sample);
    } else if (selectedAction == clearMarkersAction) {
        emit clearReferenceMarkersRequested();
    }
}