RecorderExport Class Reference

#include <recorder_export.h>

Inheritance diagram for RecorderExport:

Classes
class	Private

Public Member Functions
	RecorderExport (RecorderExportSettings *s, QWidget *parent=nullptr)
void	setup ()
	~RecorderExport ()

Protected Member Functions
void	closeEvent (QCloseEvent *event) override

Private Slots
void	onButtonBrowseDirectoryClicked ()
void	onButtonBrowseExportClicked ()
void	onButtonBrowseFfmpegClicked ()
void	onButtonCancelClicked ()
void	onButtonEditProfileClicked ()
void	onButtonExportClicked ()
void	onButtonLockFpsToggled (bool checked)
void	onButtonLockRatioToggled (bool checked)
void	onButtonRemoveSnapshotsClicked ()
void	onButtonRestartClicked ()
void	onButtonShowInFolderClicked ()
void	onButtonWatchItClicked ()
void	onCheckExtendResultToggled (bool checked)
void	onCheckResizeToggled (bool checked)
void	onCheckResultPreviewToggled (bool checked)
void	onCleanUpFinished ()
void	onComboProfileIndexChanged (int index)
void	onEditVideoPathChanged (const QString &videoFilePath)
void	onFFMpegFinished ()
void	onFFMpegFinishedWithError (QString error)
void	onFFMpegProgressUpdated (int frameNo)
void	onFFMpegStarted ()
void	onFirstFrameSecValueChanged (int value)
void	onLastFrameSecValueChanged (int value)
void	onSpinFpsValueChanged (int value)
void	onSpinInputFpsValueChanged (int value)
void	onSpinScaleHeightValueChanged (int value)
void	onSpinScaleWidthValueChanged (int value)
void	reject () override

Private Member Functions
bool	eventFilter (QObject *obj, QEvent *event) override

Private Attributes
QScopedPointer< Private >	d
RecorderExportSettings *	settings

Detailed Description

Definition at line 16 of file recorder_export.h.

Constructor & Destructor Documentation

RecorderExport()

RecorderExport::RecorderExport ( RecorderExportSettings * s, QWidget * parent = nullptr )

explicit

Definition at line 323 of file recorder_export.cpp.

    : QDialog(parent)
    , settings(s)
    , d(new Private(this))
{
    d->ui->setupUi(this);
    d->spinInputFPSMaxValue = d->ui->spinInputFps->minimum();
    d->spinInputFPSMaxValue = d->ui->spinInputFps->maximum();
    d->ui->buttonBrowseDirectory->setIcon(KisIconUtils::loadIcon("view-preview"));
    d->ui->buttonBrowseFfmpeg->setIcon(KisIconUtils::loadIcon("folder"));
    d->ui->buttonEditProfile->setIcon(KisIconUtils::loadIcon("document-edit"));
    d->ui->buttonBrowseExport->setIcon(KisIconUtils::loadIcon("folder"));
    d->ui->buttonLockRatio->setIcon(settings->lockRatio ? KisIconUtils::loadIcon("locked") : KisIconUtils::loadIcon("unlocked"));
    d->ui->buttonLockFps->setIcon(settings->lockFps ? KisIconUtils::loadIcon("locked") : KisIconUtils::loadIcon("unlocked"));
    d->ui->buttonWatchIt->setIcon(KisIconUtils::loadIcon("media-playback-start"));
    d->ui->buttonShowInFolder->setIcon(KisIconUtils::loadIcon("folder"));
    d->ui->buttonRemoveSnapshots->setIcon(KisIconUtils::loadIcon("edit-delete"));
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageSettings);
    d->ui->spinLastFrameSec->setEnabled(d->ui->extendResultCheckBox->isChecked());
    d->ui->spinFirstFrameSec->setEnabled(d->ui->resultPreviewCheckBox->isChecked());
 
    connect(d->ui->buttonBrowseDirectory, SIGNAL(clicked()), SLOT(onButtonBrowseDirectoryClicked()));
    connect(d->ui->spinInputFps, SIGNAL(valueChanged(int)), SLOT(onSpinInputFpsValueChanged(int)));
    connect(d->ui->spinFps, SIGNAL(valueChanged(int)), SLOT(onSpinFpsValueChanged(int)));
    connect(d->ui->resultPreviewCheckBox, SIGNAL(toggled(bool)), SLOT(onCheckResultPreviewToggled(bool)));
    connect(d->ui->spinFirstFrameSec, SIGNAL(valueChanged(int)), SLOT(onFirstFrameSecValueChanged(int)));
    connect(d->ui->extendResultCheckBox, SIGNAL(toggled(bool)), SLOT(onCheckExtendResultToggled(bool)));
    connect(d->ui->spinLastFrameSec, SIGNAL(valueChanged(int)), SLOT(onLastFrameSecValueChanged(int)));
    connect(d->ui->checkResize, SIGNAL(toggled(bool)), SLOT(onCheckResizeToggled(bool)));
    connect(d->ui->spinScaleWidth, SIGNAL(valueChanged(int)), SLOT(onSpinScaleWidthValueChanged(int)));
    connect(d->ui->spinScaleHeight, SIGNAL(valueChanged(int)), SLOT(onSpinScaleHeightValueChanged(int)));
    connect(d->ui->buttonLockRatio, SIGNAL(toggled(bool)), SLOT(onButtonLockRatioToggled(bool)));
    connect(d->ui->buttonLockFps, SIGNAL(toggled(bool)), SLOT(onButtonLockFpsToggled(bool)));
    connect(d->ui->buttonBrowseFfmpeg, SIGNAL(clicked()), SLOT(onButtonBrowseFfmpegClicked()));
    connect(d->ui->comboProfile, SIGNAL(currentIndexChanged(int)), SLOT(onComboProfileIndexChanged(int)));
    connect(d->ui->buttonEditProfile, SIGNAL(clicked()), SLOT(onButtonEditProfileClicked()));
    connect(d->ui->editVideoFilePath, SIGNAL(textChanged(QString)), SLOT(onEditVideoPathChanged(QString)));
    connect(d->ui->buttonBrowseExport, SIGNAL(clicked()), SLOT(onButtonBrowseExportClicked()));
    connect(d->ui->buttonBox->button(QDialogButtonBox::Save), SIGNAL(clicked()), this, SLOT(onButtonExportClicked()));
    connect(d->ui->buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
    connect(d->ui->buttonCancelExport, SIGNAL(clicked()), SLOT(onButtonCancelClicked()));
    connect(d->ui->buttonWatchIt, SIGNAL(clicked()), SLOT(onButtonWatchItClicked()));
    connect(d->ui->buttonShowInFolder, SIGNAL(clicked()), SLOT(onButtonShowInFolderClicked()));
    connect(d->ui->buttonRemoveSnapshots, SIGNAL(clicked()), SLOT(onButtonRemoveSnapshotsClicked()));
    connect(d->ui->buttonRestart, SIGNAL(clicked()), SLOT(onButtonRestartClicked()));
    connect(d->ui->resultPreviewCheckBox, SIGNAL(toggled(bool)), d->ui->spinFirstFrameSec, SLOT(setEnabled(bool)));
    connect(d->ui->extendResultCheckBox, SIGNAL(toggled(bool)), d->ui->spinLastFrameSec, SLOT(setEnabled(bool)));
 
    if (settings->realTimeCaptureMode)
        d->ui->buttonBox->button(QDialogButtonBox::Close)->setText("OK");
    d->ui->buttonBox->button(QDialogButtonBox::Save)->setText(i18n("Export"));
    d->ui->editVideoFilePath->installEventFilter(this);
}

References connect(), d, KisIconUtils::loadIcon(), RecorderExportSettings::lockFps, RecorderExportSettings::lockRatio, onButtonBrowseDirectoryClicked(), onButtonBrowseExportClicked(), onButtonBrowseFfmpegClicked(), onButtonCancelClicked(), onButtonEditProfileClicked(), onButtonExportClicked(), onButtonLockFpsToggled(), onButtonLockRatioToggled(), onButtonRemoveSnapshotsClicked(), onButtonRestartClicked(), onButtonShowInFolderClicked(), onButtonWatchItClicked(), onCheckExtendResultToggled(), onCheckResizeToggled(), onCheckResultPreviewToggled(), onComboProfileIndexChanged(), onEditVideoPathChanged(), onFirstFrameSecValueChanged(), onLastFrameSecValueChanged(), onSpinFpsValueChanged(), onSpinInputFpsValueChanged(), onSpinScaleHeightValueChanged(), onSpinScaleWidthValueChanged(), RecorderExportSettings::realTimeCaptureMode, and settings.

~RecorderExport()

RecorderExport::~RecorderExport

(

)

Definition at line 377 of file recorder_export.cpp.

{
}

Member Function Documentation

closeEvent()

void RecorderExport::closeEvent ( QCloseEvent * event )

overrideprotected

Definition at line 426 of file recorder_export.cpp.

{
    if (!d->tryAbortExport())
        event->ignore();
}

References d.

eventFilter()

bool RecorderExport::eventFilter ( QObject * obj, QEvent * event )

overrideprivate

Definition at line 712 of file recorder_export.cpp.

{
    if (obj == d->ui->editVideoFilePath && event->type() == QEvent::FocusOut)
        d->updateVideoFilePath();
 
    return QDialog::eventFilter(obj, event);
}

References d.

onButtonBrowseDirectoryClicked

void RecorderExport::onButtonBrowseDirectoryClicked ( )

privateslot

Definition at line 438 of file recorder_export.cpp.

{
    if (settings->framesCount != 0) {
        QDesktopServices::openUrl(QUrl::fromLocalFile(settings->inputDirectory));
    } else {
        QMessageBox::warning(this, windowTitle(), i18nc("Can't browse frames of recording because no frames have been recorded", "No frames to browse."));
        return;
    }
}

References RecorderExportSettings::framesCount, RecorderExportSettings::inputDirectory, and settings.

onButtonBrowseExportClicked

void RecorderExport::onButtonBrowseExportClicked ( )

privateslot

Definition at line 591 of file recorder_export.cpp.

{
    KoFileDialog dialog(this, KoFileDialog::SaveFile, "ExportTimelapse");
    dialog.setCaption(i18n("Export Timelapse Video As"));
    dialog.setDefaultDir(settings->videoDirectory);
    const QString &extension = settings->profiles[settings->profileIndex].extension;
    dialog.setMimeTypeFilters(QStringList(KisMimeDatabase::mimeTypeForSuffix(extension)));
    QString videoFileName = dialog.filename();
    if (!videoFileName.isEmpty()) {
        QFileInfo fileInfo(videoFileName);
        settings->videoDirectory = fileInfo.absolutePath();
        settings->videoFileName = fileInfo.completeBaseName();
        d->updateVideoFilePath();
        RecorderExportConfig(false).setVideoDirectory(settings->videoDirectory);
    }
}

References d, KisMimeDatabase::mimeTypeForSuffix(), RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, KoFileDialog::SaveFile, settings, RecorderExportConfig::setVideoDirectory(), RecorderExportSettings::videoDirectory, and RecorderExportSettings::videoFileName.

onButtonBrowseFfmpegClicked

void RecorderExport::onButtonBrowseFfmpegClicked ( )

privateslot

Definition at line 546 of file recorder_export.cpp.

{
    KoFileDialog dialog(this, KoFileDialog::OpenFile, "SelectFFmpeg");
    dialog.setCaption(i18n("Select FFmpeg Executable File"));
    dialog.setDefaultDir(settings->ffmpegPath);
    QString file = dialog.filename();
    if (!file.isEmpty()) {
        settings->ffmpegPath = file;
        RecorderExportConfig(false).setFfmpegPath(file);
        d->checkFfmpeg();
    }
}

References d, RecorderExportSettings::ffmpegPath, KoFileDialog::OpenFile, RecorderExportConfig::setFfmpegPath(), and settings.

onButtonCancelClicked

void RecorderExport::onButtonCancelClicked ( )

privateslot

Definition at line 628 of file recorder_export.cpp.

{
    if (d->cleaner) {
        d->cleaner->stop();
        d->cleaner->deleteLater();
        d->cleaner = nullptr;
        return;
    }
 
    if (d->tryAbortExport())
        d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageSettings);
}

References d.

onButtonEditProfileClicked

void RecorderExport::onButtonEditProfileClicked ( )

privateslot

Definition at line 566 of file recorder_export.cpp.

{
    RecorderProfileSettings settingsDialog(this);
 
    connect(&settingsDialog, &RecorderProfileSettings::requestPreview, [&](const QString & arguments) {
        settingsDialog.setPreview(settings->ffmpegPath % " -y " % d->applyVariables(arguments).replace("\n", " ")
                                  % " \"" % settings->videoFilePath % "\"");
    });
 
    if (settingsDialog.editProfile(
            &settings->profiles[settings->profileIndex], settings->defaultProfiles[settings->profileIndex])) {
        d->fillComboProfiles();
        d->updateVideoFilePath();
        RecorderExportConfig(false).setProfiles(settings->profiles);
    }
}

References connect(), d, RecorderExportSettings::defaultProfiles, RecorderProfileSettings::editProfile(), RecorderExportSettings::ffmpegPath, RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, RecorderProfileSettings::requestPreview(), RecorderProfileSettings::setPreview(), RecorderExportConfig::setProfiles(), settings, and RecorderExportSettings::videoFilePath.

onButtonExportClicked

void RecorderExport::onButtonExportClicked ( )

privateslot

Definition at line 608 of file recorder_export.cpp.

{
    if (QFile::exists(settings->videoFilePath)) {
        if (settings->framesCount != 0) {
            if (QMessageBox::question(this, windowTitle(),
                                      i18n("The video file already exists. Do you wish to overwrite it?"))
                != QMessageBox::Yes) {
                return;
            }
        } else {
            QMessageBox::warning(this, windowTitle(), i18n("No frames to export."));
            return;
        }
    }
 
 
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageProgress);
    d->startExport();
}

References d, RecorderExportSettings::framesCount, settings, and RecorderExportSettings::videoFilePath.

onButtonLockFpsToggled

void RecorderExport::onButtonLockFpsToggled ( bool checked )

privateslot

Definition at line 528 of file recorder_export.cpp.

{
    settings->lockFps = checked;
    RecorderExportConfig config(false);
    config.setLockFps(checked);
    d->updateFps(config);
    if (settings->lockFps) {
        d->ui->buttonLockFps->setIcon(KisIconUtils::loadIcon("locked"));
        d->ui->spinInputFps->setMinimum(d->ui->spinFps->minimum());
        d->ui->spinInputFps->setMaximum(d->ui->spinFps->maximum());
    } else {
        d->ui->buttonLockFps->setIcon(KisIconUtils::loadIcon("unlocked"));
        d->ui->spinInputFps->setMinimum(d->spinInputFPSMinValue);
        d->ui->spinInputFps->setMaximum(d->spinInputFPSMaxValue);
    }
 
}

References d, KisIconUtils::loadIcon(), RecorderExportSettings::lockFps, RecorderExportConfig::setLockFps(), and settings.

onButtonLockRatioToggled

void RecorderExport::onButtonLockRatioToggled ( bool checked )

privateslot

Definition at line 516 of file recorder_export.cpp.

{
    settings->lockRatio = checked;
    RecorderExportConfig config(false);
    config.setLockRatio(checked);
    if (settings->lockRatio) {
        d->updateRatio(true);
        config.setSize(settings->size);
    }
    d->ui->buttonLockRatio->setIcon(settings->lockRatio ? KisIconUtils::loadIcon("locked") : KisIconUtils::loadIcon("unlocked"));
}

References d, KisIconUtils::loadIcon(), RecorderExportSettings::lockRatio, RecorderExportConfig::setLockRatio(), RecorderExportConfig::setSize(), settings, and RecorderExportSettings::size.

onButtonRemoveSnapshotsClicked

void RecorderExport::onButtonRemoveSnapshotsClicked ( )

privateslot

Definition at line 679 of file recorder_export.cpp.

{
    const QString confirmation(i18n("The recordings for this document will be deleted"
                                    " and you will not be able to export a timelapse for it again"
                                    ". Note that already exported timelapses will still be preserved."
                                    "\n\nDo you wish to continue?"));
    if (QMessageBox::question(this, windowTitle(), confirmation) != QMessageBox::Yes)
        return;
 
    d->ui->labelStatus->setText(i18nc("Label title, Snapshot directory deleting is in progress", "Cleaning up..."));
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageProgress);
 
    Q_ASSERT(d->cleaner == nullptr);
    d->cleaner = new RecorderDirectoryCleaner({d->settings->inputDirectory});
    connect(d->cleaner, SIGNAL(finished()), this, SLOT(onCleanUpFinished()));
    d->cleaner->start();
}

References connect(), d, and onCleanUpFinished().

onButtonRestartClicked

void RecorderExport::onButtonRestartClicked ( )

privateslot

Definition at line 697 of file recorder_export.cpp.

{
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageSettings);
}

References d.

onButtonShowInFolderClicked

void RecorderExport::onButtonShowInFolderClicked ( )

privateslot

Definition at line 674 of file recorder_export.cpp.

{
    QDesktopServices::openUrl(QUrl::fromLocalFile(settings->videoDirectory));
}

References settings, and RecorderExportSettings::videoDirectory.

onButtonWatchItClicked

void RecorderExport::onButtonWatchItClicked ( )

privateslot

Definition at line 669 of file recorder_export.cpp.

{
    QDesktopServices::openUrl(QUrl::fromLocalFile(settings->videoFilePath));
}

References settings, and RecorderExportSettings::videoFilePath.

onCheckExtendResultToggled

void RecorderExport::onCheckExtendResultToggled ( bool checked )

privateslot

Definition at line 480 of file recorder_export.cpp.

{
    settings->extendResult = checked;
    RecorderExportConfig(false).setExtendResult(checked);
    d->updateVideoDuration();
}

References d, RecorderExportSettings::extendResult, RecorderExportConfig::setExtendResult(), and settings.

onCheckResizeToggled

void RecorderExport::onCheckResizeToggled ( bool checked )

privateslot

Definition at line 494 of file recorder_export.cpp.

{
    settings->resize = checked;
    RecorderExportConfig(false).setResize(checked);
}

References RecorderExportSettings::resize, RecorderExportConfig::setResize(), and settings.

onCheckResultPreviewToggled

void RecorderExport::onCheckResultPreviewToggled ( bool checked )

privateslot

Definition at line 466 of file recorder_export.cpp.

{
    settings->resultPreview = checked;
    RecorderExportConfig(false).setResultPreview(checked);
    d->updateVideoDuration();
}

References d, RecorderExportSettings::resultPreview, RecorderExportConfig::setResultPreview(), and settings.

onCleanUpFinished

void RecorderExport::onCleanUpFinished ( )

privateslot

Definition at line 702 of file recorder_export.cpp.

{
    d->cleaner->deleteLater();
    d->cleaner = nullptr;
 
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageDone);
    d->ui->buttonRestart->hide();
    d->ui->buttonRemoveSnapshots->hide();
}

References d.

onComboProfileIndexChanged

void RecorderExport::onComboProfileIndexChanged ( int index )

privateslot

Definition at line 559 of file recorder_export.cpp.

{
    settings->profileIndex = index;
    d->updateVideoFilePath();
    RecorderExportConfig(false).setProfileIndex(index);
}

References d, RecorderExportSettings::profileIndex, RecorderExportConfig::setProfileIndex(), and settings.

onEditVideoPathChanged

void RecorderExport::onEditVideoPathChanged ( const QString & videoFilePath )

privateslot

Definition at line 583 of file recorder_export.cpp.

{
    QFileInfo fileInfo(videoFilePath);
    if (!fileInfo.isRelative())
        settings->videoDirectory = fileInfo.absolutePath();
    settings->videoFileName = fileInfo.completeBaseName();
}

References settings, RecorderExportSettings::videoDirectory, and RecorderExportSettings::videoFileName.

onFFMpegFinished

void RecorderExport::onFFMpegFinished ( )

privateslot

Definition at line 648 of file recorder_export.cpp.

{
    quint64 elapsed = d->elapsedTimer.elapsed();
    d->ui->labelRenderTime->setText(d->formatDuration(elapsed));
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageDone);
    d->ui->labelVideoPathDone->setText(settings->videoFilePath);
    d->cleanupFFMpeg();
}

References d, settings, and RecorderExportSettings::videoFilePath.

onFFMpegFinishedWithError

void RecorderExport::onFFMpegFinishedWithError ( QString error )

privateslot

Definition at line 657 of file recorder_export.cpp.

{
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageSettings);
    QMessageBox::critical(this, windowTitle(), i18n("Export failed. FFmpeg message:") % "\n\n" % error);
    d->cleanupFFMpeg();
}

References d.

onFFMpegProgressUpdated

void RecorderExport::onFFMpegProgressUpdated ( int frameNo )

privateslot

Definition at line 664 of file recorder_export.cpp.

{
    d->ui->progressExport->setValue(frameNo * 100 / (settings->framesCount * settings->fps / static_cast<float>(settings->inputFps)));
}

References d, RecorderExportSettings::fps, RecorderExportSettings::framesCount, RecorderExportSettings::inputFps, and settings.

onFFMpegStarted

void RecorderExport::onFFMpegStarted ( )

privateslot

Definition at line 642 of file recorder_export.cpp.

{
    d->ui->buttonCancelExport->setEnabled(true);
    d->ui->labelStatus->setText(i18n("The timelapse video is being encoded..."));
}

References d.

onFirstFrameSecValueChanged

void RecorderExport::onFirstFrameSecValueChanged ( int value )

privateslot

Definition at line 473 of file recorder_export.cpp.

{
    settings->firstFrameSec = value;
    RecorderExportConfig(false).setFirstFrameSec(value);
    d->updateVideoDuration();
}

References d, RecorderExportSettings::firstFrameSec, RecorderExportConfig::setFirstFrameSec(), settings, and value().

onLastFrameSecValueChanged

void RecorderExport::onLastFrameSecValueChanged ( int value )

privateslot

Definition at line 487 of file recorder_export.cpp.

{
    settings->lastFrameSec = value;
    RecorderExportConfig(false).setLastFrameSec(value);
    d->updateVideoDuration();
}

References d, RecorderExportSettings::lastFrameSec, RecorderExportConfig::setLastFrameSec(), settings, and value().

onSpinFpsValueChanged

void RecorderExport::onSpinFpsValueChanged ( int value )

privateslot

Definition at line 457 of file recorder_export.cpp.

{
    settings->fps = value;
    RecorderExportConfig config(false);
    config.setFps(value);
    d->updateFps(config, false);
    d->updateVideoDuration();
}

References d, RecorderExportSettings::fps, RecorderExportConfig::setFps(), settings, and value().

onSpinInputFpsValueChanged

void RecorderExport::onSpinInputFpsValueChanged ( int value )

privateslot

Definition at line 448 of file recorder_export.cpp.

{
    settings->inputFps = value;
    RecorderExportConfig config(false);
    config.setInputFps(value);
    d->updateFps(config, true);
    d->updateVideoDuration();
}

References d, RecorderExportSettings::inputFps, RecorderExportConfig::setInputFps(), settings, and value().

onSpinScaleHeightValueChanged

void RecorderExport::onSpinScaleHeightValueChanged ( int value )

privateslot

Definition at line 508 of file recorder_export.cpp.

{
    settings->size.setHeight(value);
    if (settings->lockRatio)
        d->updateRatio(false);
    RecorderExportConfig(false).setSize(settings->size);
}

References d, RecorderExportSettings::lockRatio, RecorderExportConfig::setSize(), settings, RecorderExportSettings::size, and value().

onSpinScaleWidthValueChanged

void RecorderExport::onSpinScaleWidthValueChanged ( int value )

privateslot

Definition at line 500 of file recorder_export.cpp.

{
    settings->size.setWidth(value);
    if (settings->lockRatio)
        d->updateRatio(true);
    RecorderExportConfig(false).setSize(settings->size);
}

References d, RecorderExportSettings::lockRatio, RecorderExportConfig::setSize(), settings, RecorderExportSettings::size, and value().

reject

void RecorderExport::reject ( )

overrideprivateslot

Definition at line 432 of file recorder_export.cpp.

{
    if (d->tryAbortExport())
        QDialog::reject();
}

References d.

setup()

void RecorderExport::setup

(

)

Definition at line 381 of file recorder_export.cpp.

{
    RecorderExportConfig config(true);
    d->updateFps(config);
    d->updateFrameInfo();
 
    if (settings->framesCount == 0) {
        d->ui->labelRecordInfo->setText(i18nc("Can't export recording because nothing to export", "No frames to export"));
        d->ui->buttonBox->button(QDialogButtonBox::Save)->setEnabled(false);
    } else {
        d->ui->labelRecordInfo->setText(QString("%1: %2x%3 %4, %5 %6")
                                        .arg(i18nc("General information about recording", "Recording info"))
                                        .arg(settings->imageSize.width())
                                        .arg(settings->imageSize.height())
                                        .arg(i18nc("Pixel dimension suffix", "px"))
                                        .arg(settings->framesCount)
                                        .arg(i18nc("The suffix after number of frames", "frame(s)"))
                                       );
    }
 
 
    // Don't load lockFps flag from config, if liveCaptureMode was just set by the user
    config.loadConfiguration(settings, !settings->realTimeCaptureModeWasSet);
    settings->realTimeCaptureModeWasSet = false;
 
    d->ui->spinInputFps->setValue(settings->inputFps);
    d->ui->spinFps->setValue(settings->fps);
    d->ui->resultPreviewCheckBox->setChecked(settings->resultPreview);
    d->ui->spinFirstFrameSec->setValue(settings->firstFrameSec);
    d->ui->extendResultCheckBox->setChecked(settings->extendResult);
    d->ui->spinLastFrameSec->setValue(settings->lastFrameSec);
    d->ui->checkResize->setChecked(settings->resize);
    d->ui->spinScaleWidth->setValue(settings->size.width());
    d->ui->spinScaleHeight->setValue(settings->size.height());
    d->ui->buttonLockRatio->setChecked(settings->lockRatio);
    d->ui->buttonLockRatio->setIcon(settings->lockRatio ? KisIconUtils::loadIcon("locked") : KisIconUtils::loadIcon("unlocked"));
    d->ui->labelRealTimeCaptureNotion->setVisible(settings->realTimeCaptureMode);
    d->ui->buttonLockFps->setChecked(settings->lockFps);
    d->ui->buttonLockFps->setIcon(settings->lockFps ? KisIconUtils::loadIcon("locked") : KisIconUtils::loadIcon("unlocked"));
    d->fillComboProfiles();
    d->checkFfmpeg();
    d->updateVideoFilePath();
    d->updateVideoDuration();
}

References d, RecorderExportSettings::extendResult, RecorderExportSettings::firstFrameSec, RecorderExportSettings::fps, RecorderExportSettings::framesCount, RecorderExportSettings::imageSize, RecorderExportSettings::inputFps, RecorderExportSettings::lastFrameSec, RecorderExportConfig::loadConfiguration(), KisIconUtils::loadIcon(), RecorderExportSettings::lockFps, RecorderExportSettings::lockRatio, RecorderExportSettings::realTimeCaptureMode, RecorderExportSettings::realTimeCaptureModeWasSet, RecorderExportSettings::resize, RecorderExportSettings::resultPreview, settings, and RecorderExportSettings::size.

Member Data Documentation

d

QScopedPointer<Private> RecorderExport::d

private

Definition at line 72 of file recorder_export.h.

settings

RecorderExportSettings* RecorderExport::settings

private

Definition at line 71 of file recorder_export.h.

---

The documentation for this class was generated from the following files:

• plugins/dockers/recorder/recorder_export.h
• plugins/dockers/recorder/recorder_export.cpp