animatedsplash.cpp

/**
 * @file animatedsplash.cpp
 * @brief Full-screen overlay with a centered circular splash.
 */

#include "animatedsplash.h"

#include <QCursor>
#include <QGuiApplication>
#include <QPainter>
#include <QPainterPath>
#include <QScreen>
#include <QShowEvent>
#include <QTimer>
#include <QtMath>

namespace {

const QColor kBrandGreen(0x8F, 0xCB, 0x57);
const QColor kInk(0x11, 0x11, 0x11);
const QColor kMuted(0x6B, 0x72, 0x80);

} // namespace

AnimatedSplash::AnimatedSplash(QWidget *parent)
    : QWidget(parent,
              Qt::Window | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint)
{
    setAttribute(Qt::WA_TranslucentBackground, true);
    setAttribute(Qt::WA_OpaquePaintEvent, false);
    setWindowTitle(QStringLiteral("Spectrum Analyzer"));

    m_timer = new QTimer(this);
    m_timer->setInterval(16);
    connect(m_timer, &QTimer::timeout, this, &AnimatedSplash::onTick);
    m_timer->start();
}

AnimatedSplash::~AnimatedSplash() = default;

void AnimatedSplash::applyScreenCover()
{
    QScreen *screen = QGuiApplication::screenAt(QCursor::pos());
    if (!screen) {
        screen = QGuiApplication::primaryScreen();
    }
    if (!screen) {
        return;
    }

    setGeometry(screen->geometry());
}

void AnimatedSplash::showCoveringScreen()
{
    applyScreenCover();
    showFullScreen();
    applyScreenCover();
    raise();
}

void AnimatedSplash::showEvent(QShowEvent *event)
{
    QWidget::showEvent(event);
    applyScreenCover();
    if (!isFullScreen()) {
        showFullScreen();
    }
    QTimer::singleShot(0, this, [this]() {
        applyScreenCover();
        if (!isFullScreen()) {
            showFullScreen();
        }
    });
}

void AnimatedSplash::onTick()
{
    m_phase += 0.14;
    m_sweep += 0.045;
    if (m_sweep > M_PI * 2.0) {
        m_sweep -= M_PI * 2.0;
    }
    update();
}

void AnimatedSplash::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);

    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);

    // Window fills the monitor; the badge is drawn at the geometric center.
    const QPointF c(width() * 0.5, height() * 0.5);
    const qreal diameter = qMin<qreal>(kCircleDiameter,
                                       qMin(width(), height()) - 80.0);
    const qreal r = diameter * 0.5;

    // Soft drop shadow so the circle lifts off the desktop.
    p.setPen(Qt::NoPen);
    p.setBrush(QColor(0, 0, 0, 55));
    p.drawEllipse(c + QPointF(0.0, 6.0), r, r);

    // Breathing halo in brand green.
    const qreal halo = 10.0 + 6.0 * (0.5 + 0.5 * qSin(m_phase * 0.85));
    QColor haloColor = kBrandGreen;
    haloColor.setAlpha(70);
    p.setBrush(haloColor);
    p.drawEllipse(c, r + halo, r + halo);

    QPainterPath disc;
    disc.addEllipse(c, r, r);
    p.fillPath(disc, QColor(QStringLiteral("#FAFBFA")));

    p.setPen(QPen(kBrandGreen, 4.0));
    p.setBrush(Qt::NoBrush);
    p.drawEllipse(c, r, r);

    // Rotating spectrum sweep along the rim.
    p.save();
    p.setClipPath(disc);
    QPen sweepPen(QColor(0x8F, 0xCB, 0x57, 180), 10.0, Qt::SolidLine, Qt::RoundCap);
    p.setPen(sweepPen);
    const int start = static_cast<int>(qRadiansToDegrees(-m_sweep) * 16.0);
    p.drawArc(QRectF(c.x() - r + 8.0, c.y() - r + 8.0,
                     (r - 8.0) * 2.0, (r - 8.0) * 2.0),
              start, 50 * 16);
    p.restore();

    p.setPen(kInk);
    QFont title = font();
    title.setFamily(QStringLiteral("Georgia"));
    title.setPointSize(16);
    title.setBold(true);
    p.setFont(title);
    p.drawText(QRectF(c.x() - r + 28.0, c.y() - r + 52.0, r * 2.0 - 56.0, 36.0),
               Qt::AlignHCenter | Qt::AlignVCenter,
               QStringLiteral("Spectrum Analyzer"));

    const qreal barTop = c.y() - 28.0;
    const qreal barBottom = c.y() + 78.0;
    const qreal barAreaH = barBottom - barTop;
    const qreal barLeft = c.x() - r * 0.55;
    const qreal barWidthTotal = r * 1.10;
    const qreal gap = 5.0;
    const qreal barW = (barWidthTotal - gap * (kBarCount - 1)) / kBarCount;

    p.save();
    p.setClipPath(disc);
    for (int i = 0; i < kBarCount; ++i) {
        const qreal envelope = qSin((i - (kBarCount - 1) * 0.5) * 0.28);
        const qreal wave = 0.28 + 0.55 * (0.5 + 0.5 * qSin(m_phase + i * 0.38));
        const qreal bounce = 0.12 * qSin(m_phase * 1.6 + i * 0.85);
        const qreal level = qBound(0.14, wave + bounce + 0.12 * envelope * envelope, 1.0);
        const qreal h = barAreaH * level;
        const qreal bx = barLeft + i * (barW + gap);
        const qreal by = barBottom - h;

        const bool accent = (i == kBarCount / 2) || (i % 5 == 0);
        QColor fill = accent ? kBrandGreen : kInk;
        QPainterPath bar;
        bar.addRoundedRect(QRectF(bx, by, barW, h), barW * 0.45, barW * 0.45);
        p.fillPath(bar, fill);
    }
    p.restore();

    p.setPen(kMuted);
    QFont nameFont = font();
    nameFont.setFamily(QStringLiteral("Georgia"));
    nameFont.setPointSize(11);
    nameFont.setItalic(true);
    p.setFont(nameFont);
    p.drawText(QRectF(c.x() - r + 24.0, c.y() + r - 78.0, r * 2.0 - 48.0, 28.0),
               Qt::AlignHCenter | Qt::AlignVCenter,
               QStringLiteral("Mohammad Haghpanah"));
}