mainwindow.cpp

#include "mainwindow.hpp"
#include "loghighlighter.hpp"
#include "logmediator.hpp"
#include "ui_mainwindow.h"

#include <QFileDialog>
#include <QStandardPaths>
#include <ctime>
#include <sstream>
#include <QMessageBox>
#include <QMetaEnum>
#include <QVideoWidget>
#include <QMimeType>
#include <QLabel>
#include <QTextBrowser>

static QString _strftimeNowPath(const QString &fmt)
{
    std::time_t time = std::time(nullptr);
    std::tm tm = *std::localtime(&time);

    std::wostringstream oss;
    oss << std::put_time(&tm, fmt.toStdWString().c_str());

    QString result(oss.str());
    return result;
}

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , m_ui(std::make_unique<Ui::MainWindow>())
    , m_lblRecordingStatus(new QLabel("Ready", this))
{
    m_ui->setupUi(this);
    connect(m_ui->btnCapture, &QPushButton::toggled, this, &MainWindow::onCaptureToggled);
    connect(m_ui->btnPreferences, &QPushButton::clicked, this, &MainWindow::onPreferencesClicked);
    connect(m_ui->btnLogs, &QPushButton::clicked, this, &MainWindow::onLogsClicked);

    connect(&m_recorder, &QMediaRecorder::errorOccurred, this, &MainWindow::onRecorderError);
    connect(
        &m_recorder, &QMediaRecorder::recorderStateChanged,
        this, &MainWindow::onRecorderStateChanged
    );

    m_screenCapture.start();
    m_captureSession.setScreenCapture(&m_screenCapture);
    m_captureSession.setRecorder(&m_recorder);
    m_captureSession.setVideoOutput(m_ui->video);

    QSettings settings;
    m_prefs.load(settings);

    m_lblRecordingStatus->setContentsMargins(5, 0, 5, 0);
    m_ui->statusBar->addPermanentWidget(m_lblRecordingStatus);
}

MainWindow::~MainWindow()
{}

void MainWindow::onCaptureToggled(bool status)
{
    m_ui->btnPreferences->setDisabled(status);
    if(m_prefsForm)
        m_prefsForm->close();

    if(status)
    {
        QString fn = _strftimeNowPath(m_prefs.fileFmt)
            + "."
            + m_prefs.mediaFmt.mimeType().preferredSuffix();

        m_recorder.setOutputLocation(m_prefs.dir.absoluteFilePath(fn));
        m_recorder.setMediaFormat(m_prefs.mediaFmt);
        m_recorder.setVideoBitRate(m_prefs.videoBitrateBPS);
        m_recorder.setVideoResolution(m_prefs.resolution);
        m_recorder.setVideoFrameRate(m_prefs.framerate);
        m_recorder.setQuality(m_prefs.quality);
        m_recorder.setEncodingMode(m_prefs.encodingMode);

        m_screenCapture.setScreen(QApplication::primaryScreen());
        m_recorder.record();
    }
    else
    {
        m_lblRecordingStatus->setText("Finalizing File...");
        m_recorder.stop();
    }
}

void MainWindow::onPreferencesClicked()
{
    if(m_prefsForm)
    {
        m_prefsForm->raise();
        m_prefsForm->activateWindow();
    }
    else
    {
        m_prefsForm = new PreferencesForm(m_prefs, this);
        m_prefsForm->setAttribute(Qt::WA_DeleteOnClose);
        m_prefsForm->show();
        connect(
            m_prefsForm, &PreferencesForm::preferencesChanged, 
            this, &MainWindow::onPreferencesChanged
        );
    }
}

void MainWindow::onRecorderError(QMediaRecorder::Error error, const QString &errorStr)
{
    // Calls our slot onCaptureToggled, so we don't have to clean up resources here
    m_ui->btnCapture->setChecked(false);

    // Get enum item name
    auto mo = m_recorder.metaObject();
    int idx = mo->indexOfEnumerator("Error");
    auto metaEnum = mo->enumerator(idx);
    const char *name = metaEnum.valueToKey(error);

    auto text = tr("Code: %1\nDescription: %2").arg(name).arg(errorStr);
    QMessageBox::critical(this, tr("Recorder Error"), text);
}

void MainWindow::onPreferencesChanged(const Preferences &preferences)
{
    QSettings settings;
    m_prefs.store(settings);
    settings.sync();
}

void MainWindow::onRecorderStateChanged(QMediaRecorder::RecorderState state)
{
    if(state == QMediaRecorder::RecordingState)
    {
        m_lblRecordingStatus->setText("Recording");
    }
    if(state == QMediaRecorder::PausedState)
    {
        m_lblRecordingStatus->setText("Paused");
    }
    if(state == QMediaRecorder::StoppedState)
    {
        m_lblRecordingStatus->setText("Ready");
    }
}

void MainWindow::onLogsClicked()
{
    auto *dialog = new QDialog(this);
    dialog->setWindowTitle("Logs");

    auto *browser = new QTextBrowser(dialog);
    LogMediator::instance().setupTextEdit(*browser);
    browser->setWordWrapMode(QTextOption::NoWrap);
    browser->setStyleSheet(QStringLiteral(R"(
        font-family: 'Monaco', 'Consolas', 'Lucida Console', 'Liberation Mono',
            'Courier New', 'Droid Sans Mono', 'Ubuntu Mono', 'Unifont', monospace;
    )"));
    new LogHighlighter(browser->document());

    auto layout = new QVBoxLayout;
    layout->addWidget(browser);
    dialog->setLayout(layout);
    dialog->resize({720, 576});
    dialog->show();
}