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	onExporterFinished ()
void	onExporterFinishedWithError (QString error)
void	onExporterProgressUpdated (int frameNo)
void	onExporterStarted ()
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 459 of file recorder_export.cpp.

    : QDialog(parent)
    , settings(s)
    , d(new Private(this))
{
    d->ui->setupUi(this);
 
#ifdef Q_OS_ANDROID
    d->ui->labelFfmpegLocation->hide();
    d->ui->editFfmpegPath->hide();
    d->ui->buttonBrowseFfmpeg->hide();
    d->ui->labelExportTo->hide();
    d->ui->editVideoFilePath->hide();
    d->ui->buttonBrowseExport->hide();
    d->ui->buttonShowInFolder->hide();
#else
    d->ui->buttonBrowseFfmpeg->setIcon(KisIconUtils::loadIcon("folder"));
    d->ui->buttonBrowseExport->setIcon(KisIconUtils::loadIcon("folder"));
    d->ui->buttonShowInFolder->setIcon(KisIconUtils::loadIcon("folder"));
#endif
 
    d->spinInputFPSMaxValue = d->ui->spinInputFps->minimum();
    d->spinInputFPSMaxValue = d->ui->spinInputFps->maximum();
    d->ui->buttonBrowseDirectory->setIcon(KisIconUtils::loadIcon("view-preview"));
    d->ui->buttonEditProfile->setIcon(KisIconUtils::loadIcon("document-edit"));
    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->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());
    d->ui->lblWarnFpsIcon->setPixmap(KisIconUtils::loadIcon("dialog-warning").pixmap(48, 48));
    d->ui->lblWarnSizeIcon->setPixmap(KisIconUtils::loadIcon("dialog-warning").pixmap(48, 48));
    d->ui->wdgWarnFps->hide();
    d->ui->wdgWarnSize->hide();
 
    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->comboProfile, SIGNAL(currentIndexChanged(int)), SLOT(onComboProfileIndexChanged(int)));
    connect(d->ui->buttonEditProfile, SIGNAL(clicked()), SLOT(onButtonEditProfileClicked()));
    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->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)));
 
#ifndef Q_OS_ANDROID
    connect(d->ui->buttonBrowseFfmpeg, SIGNAL(clicked()), SLOT(onButtonBrowseFfmpegClicked()));
    connect(d->ui->buttonBrowseExport, SIGNAL(clicked()), SLOT(onButtonBrowseExportClicked()));
    connect(d->ui->editVideoFilePath, SIGNAL(textChanged(QString)), SLOT(onEditVideoPathChanged(QString)));
    connect(d->ui->buttonShowInFolder, SIGNAL(clicked()), SLOT(onButtonShowInFolderClicked()));
#endif
 
    if (settings->realTimeCaptureMode)
        d->ui->buttonBox->button(QDialogButtonBox::Close)->setText("OK");
    d->ui->buttonBox->button(QDialogButtonBox::Save)->setText(i18n("Export"));
#ifndef Q_OS_ANDROID
    d->ui->editVideoFilePath->installEventFilter(this);
#endif
}

References 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 534 of file recorder_export.cpp.

{
}

Member Function Documentation

closeEvent()

void RecorderExport::closeEvent ( QCloseEvent * event )

overrideprotected

Definition at line 597 of file recorder_export.cpp.

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

References d.

eventFilter()

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

overrideprivate

Definition at line 918 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 609 of file recorder_export.cpp.

{
    if (settings->framesCount != 0) {
        Private::desktopServicesOpenPath(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 RecorderExport::Private::desktopServicesOpenPath(), RecorderExportSettings::framesCount, RecorderExportSettings::inputDirectory, and settings.

onButtonBrowseExportClicked

void RecorderExport::onButtonBrowseExportClicked ( )

privateslot

Definition at line 790 of file recorder_export.cpp.

{
    QString videoFileName = d->requestFile(settings->profiles[settings->profileIndex].extension, settings->videoDirectory);
    if (!videoFileName.isEmpty()) {
        QFileInfo fileInfo(videoFileName);
        settings->videoDirectory = fileInfo.absolutePath();
        settings->videoFileName = fileInfo.completeBaseName();
        RecorderExportConfig(false).setVideoDirectory(settings->videoDirectory);
        d->updateVideoFilePath();
    }
}

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

onButtonBrowseFfmpegClicked

void RecorderExport::onButtonBrowseFfmpegClicked ( )

privateslot

Definition at line 723 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->checkExporter();
    }
}

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

onButtonCancelClicked

void RecorderExport::onButtonCancelClicked ( )

privateslot

Definition at line 831 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 750 of file recorder_export.cpp.

{
#ifdef Q_OS_ANDROID
    QString key = settings->selectedFormat;
    KisMediaEncoderFormat *format = KisMediaEncoderWrapper::getFormatByKey(key);
    KIS_SAFE_ASSERT_RECOVER_RETURN(format);
 
    KisMediaEncoderPreferencesDialog dlg(format, settings->formatPreferences.value(key).toMap(), this);
    if (dlg.exec() == QDialog::Accepted) {
        settings->formatPreferences.insert(key, dlg.preferences());
        RecorderExportConfig(false).setFormatPreferences(settings->formatPreferences);
    }
#else
    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);
    }
#endif
}

References d, RecorderExportSettings::defaultProfiles, RecorderProfileSettings::editProfile(), RecorderExportSettings::ffmpegPath, KisMediaEncoderWrapper::getFormatByKey(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisMediaEncoderPreferencesDialog::preferences(), RecorderExportSettings::profileIndex, RecorderExportSettings::profiles, RecorderProfileSettings::requestPreview(), RecorderProfileSettings::setPreview(), RecorderExportConfig::setProfiles(), settings, and RecorderExportSettings::videoFilePath.

onButtonExportClicked

void RecorderExport::onButtonExportClicked ( )

privateslot

Definition at line 803 of file recorder_export.cpp.

{
    if (settings->framesCount == 0) {
        QMessageBox::warning(this, windowTitle(), i18n("No frames to export."));
        return;
    }
 
#ifdef Q_OS_ANDROID
    KisMediaEncoderFormat *format = KisMediaEncoderWrapper::getFormatByKey(settings->selectedFormat);
    KIS_SAFE_ASSERT_RECOVER_RETURN(format);
    settings->videoFilePath = d->requestFile(format->extension());
    if (settings->videoFilePath.isEmpty()) {
        return;
    }
#else
    if (QFile::exists(settings->videoFilePath)) {
        if (QMessageBox::question(this, windowTitle(),
                                  i18n("The video file already exists. Do you wish to overwrite it?"))
            != QMessageBox::Yes) {
            return;
        }
    }
#endif
 
    d->ui->stackedWidget->setCurrentIndex(ExportPageIndex::PageProgress);
    d->startExport();
}

References d, KisMediaEncoderFormat::extension(), RecorderExportSettings::framesCount, KisMediaEncoderWrapper::getFormatByKey(), KIS_SAFE_ASSERT_RECOVER_RETURN, settings, and RecorderExportSettings::videoFilePath.

onButtonLockFpsToggled

void RecorderExport::onButtonLockFpsToggled ( bool checked )

privateslot

Definition at line 704 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);
    }
    d->updateWarningVisibility();
}

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

onButtonLockRatioToggled

void RecorderExport::onButtonLockRatioToggled ( bool checked )

privateslot

Definition at line 691 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"));
    d->updateWarningVisibility();
}

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

onButtonRemoveSnapshotsClicked

void RecorderExport::onButtonRemoveSnapshotsClicked ( )

privateslot

Definition at line 884 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 d, and onCleanUpFinished().

onButtonRestartClicked

void RecorderExport::onButtonRestartClicked ( )

privateslot

Definition at line 902 of file recorder_export.cpp.

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

References d.

onButtonShowInFolderClicked

void RecorderExport::onButtonShowInFolderClicked ( )

privateslot

Definition at line 878 of file recorder_export.cpp.

{
    Private::desktopServicesOpenPath(settings->videoDirectory);
}

References RecorderExport::Private::desktopServicesOpenPath(), settings, and RecorderExportSettings::videoDirectory.

onButtonWatchItClicked

void RecorderExport::onButtonWatchItClicked ( )

privateslot

Definition at line 872 of file recorder_export.cpp.

{
    Private::desktopServicesOpenPath(settings->videoFilePath);
}

References RecorderExport::Private::desktopServicesOpenPath(), settings, and RecorderExportSettings::videoFilePath.

onCheckExtendResultToggled

void RecorderExport::onCheckExtendResultToggled ( bool checked )

privateslot

Definition at line 652 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 666 of file recorder_export.cpp.

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

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

onCheckResultPreviewToggled

void RecorderExport::onCheckResultPreviewToggled ( bool checked )

privateslot

Definition at line 638 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 907 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 737 of file recorder_export.cpp.

{
#ifdef Q_OS_ANDROID
    QString format = d->ui->comboProfile->itemData(index).toString();
    d->settings->selectedFormat = format;
    RecorderExportConfig(false).setSelectedFormat(format);
#else
    settings->profileIndex = index;
    d->updateVideoFilePath();
    RecorderExportConfig(false).setProfileIndex(index);
#endif
}

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

onEditVideoPathChanged

void RecorderExport::onEditVideoPathChanged ( const QString & videoFilePath )

privateslot

Definition at line 780 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.

onExporterFinished

void RecorderExport::onExporterFinished ( )

privateslot

Definition at line 851 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->cleanupExporter();
}

References d, settings, and RecorderExportSettings::videoFilePath.

onExporterFinishedWithError

void RecorderExport::onExporterFinishedWithError ( QString error )

privateslot

Definition at line 860 of file recorder_export.cpp.

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

References d.

onExporterProgressUpdated

void RecorderExport::onExporterProgressUpdated ( int frameNo )

privateslot

Definition at line 867 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.

onExporterStarted

void RecorderExport::onExporterStarted ( )

privateslot

Definition at line 845 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 645 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 659 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 628 of file recorder_export.cpp.

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

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

onSpinInputFpsValueChanged

void RecorderExport::onSpinInputFpsValueChanged ( int value )

privateslot

Definition at line 619 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 682 of file recorder_export.cpp.

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

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

onSpinScaleWidthValueChanged

void RecorderExport::onSpinScaleWidthValueChanged ( int value )

privateslot

Definition at line 673 of file recorder_export.cpp.

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

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

reject

void RecorderExport::reject ( )

overrideprivateslot

Definition at line 603 of file recorder_export.cpp.

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

References d.

setup()

void RecorderExport::setup

(

)

Definition at line 538 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;
 
    // Video dimensions are much more restrictive than image dimensions.
    // Clobber them with sensible defaults instead of letting the user run into
    // the trap of trying to export video well beyond what most encoders,
    // devices and websites support.
    d->initDimensions();
 
    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);
    {
        // Need to block signals or else a locked ratio will mess these up.
        QSignalBlocker spinScaleWidthBlocker(d->ui->spinScaleWidth);
        QSignalBlocker spinScaleHeightBlocker(d->ui->spinScaleHeight);
        QSignalBlocker buttonLockRatioBlocker(d->ui->buttonLockRatio);
        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();
#ifndef Q_OS_ANDROID
    d->checkExporter();
    d->updateVideoFilePath();
#endif
    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 80 of file recorder_export.h.

settings

RecorderExportSettings* RecorderExport::settings

private

Definition at line 79 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