|
|
#include "nmWxPebiResultAnimationExportDlg.h"
|
|
|
|
|
|
#include "nmFFmpegVideoWriter.h"
|
|
|
#include "ZxBaseUtil.h"
|
|
|
|
|
|
#include <QButtonGroup>
|
|
|
#include <QComboBox>
|
|
|
#include <QCoreApplication>
|
|
|
#include <QDialogButtonBox>
|
|
|
#include <QDir>
|
|
|
#include <QFileDialog>
|
|
|
#include <QFileInfo>
|
|
|
#include <QGridLayout>
|
|
|
#include <QGroupBox>
|
|
|
#include <QIcon>
|
|
|
#include <QLabel>
|
|
|
#include <QLineEdit>
|
|
|
#include <QMessageBox>
|
|
|
#include <QPushButton>
|
|
|
#include <QRadioButton>
|
|
|
#include <QSizePolicy>
|
|
|
#include <QSpinBox>
|
|
|
#include <QVBoxLayout>
|
|
|
#include <QVariant>
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
QString exportDialogIconPath(const QString& sFileName)
|
|
|
{
|
|
|
const QString sApplicationDir = QCoreApplication::applicationDirPath();
|
|
|
return sApplicationDir.section('/', 0, -2) +
|
|
|
"/Res/Icon/" + sFileName;
|
|
|
}
|
|
|
|
|
|
QLabel* createRightAlignedLabel(const QString& sText, QWidget* pParent)
|
|
|
{
|
|
|
QLabel* pLabel = new QLabel(sText, pParent);
|
|
|
pLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
|
|
|
return pLabel;
|
|
|
}
|
|
|
|
|
|
QString formatPixelSize(int nWidth, int nHeight)
|
|
|
{
|
|
|
QString sText = QString::number(nWidth);
|
|
|
sText.append(' ');
|
|
|
sText.append(QChar(0x00D7));
|
|
|
sText.append(QString::fromLatin1(" %1 px").arg(nHeight));
|
|
|
return sText;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
nmWxPebiResultAnimationExportDlg::nmWxPebiResultAnimationExportDlg(
|
|
|
const QVector<double>& vecFrameTimesHours,
|
|
|
const QSize& oCurrentViewportSize,
|
|
|
QWidget* pParent)
|
|
|
: iDlgBase(pParent),
|
|
|
m_vecFrameTimesHours(vecFrameTimesHours),
|
|
|
m_pFpsSpinBox(nullptr),
|
|
|
m_pStartFrameCombo(nullptr),
|
|
|
m_pEndFrameCombo(nullptr),
|
|
|
m_pSamplingIntervalSpinBox(nullptr),
|
|
|
m_pResolutionButtonGroup(nullptr),
|
|
|
m_pCurrentSizeRadioButton(nullptr),
|
|
|
m_p720pRadioButton(nullptr),
|
|
|
m_p1080pRadioButton(nullptr),
|
|
|
m_pCustomSizeRadioButton(nullptr),
|
|
|
m_pWidthSpinBox(nullptr),
|
|
|
m_pHeightSpinBox(nullptr),
|
|
|
m_pVideoFormatCombo(nullptr),
|
|
|
m_pTargetPathEdit(nullptr),
|
|
|
m_pOutputFrameCountLabel(nullptr),
|
|
|
m_pEstimatedDurationLabel(nullptr),
|
|
|
m_pErrorLabel(nullptr)
|
|
|
{
|
|
|
int nCurrentWidth = oCurrentViewportSize.width();
|
|
|
int nCurrentHeight = oCurrentViewportSize.height();
|
|
|
if(nCurrentWidth <= 0 || nCurrentHeight <= 0) {
|
|
|
nCurrentWidth = 1280;
|
|
|
nCurrentHeight = 720;
|
|
|
}
|
|
|
m_oEffectiveCurrentViewportSize = QSize(
|
|
|
normalizeEvenDimension(nCurrentWidth),
|
|
|
normalizeEvenDimension(nCurrentHeight));
|
|
|
|
|
|
createUi();
|
|
|
populateFrameItems();
|
|
|
populateVideoFormats();
|
|
|
setTargetFilePath(getSuggestedTargetFilePath());
|
|
|
onResolutionPresetChanged(Resolution_CurrentView);
|
|
|
onFrameRangeChanged();
|
|
|
}
|
|
|
|
|
|
nmPebiResultAnimationExportSettings
|
|
|
nmWxPebiResultAnimationExportDlg::getSettings() const
|
|
|
{
|
|
|
return m_oAcceptedSettings;
|
|
|
}
|
|
|
|
|
|
QString nmWxPebiResultAnimationExportDlg::getTargetFilePath() const
|
|
|
{
|
|
|
return m_sAcceptedTargetFilePath;
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::onFrameRangeChanged()
|
|
|
{
|
|
|
const int nStartIndex = m_pStartFrameCombo->currentIndex();
|
|
|
if(nStartIndex >= 0 &&
|
|
|
m_pEndFrameCombo->currentIndex() < nStartIndex) {
|
|
|
const bool bBlocked = m_pEndFrameCombo->blockSignals(true);
|
|
|
m_pEndFrameCombo->setCurrentIndex(nStartIndex);
|
|
|
m_pEndFrameCombo->blockSignals(bBlocked);
|
|
|
}
|
|
|
|
|
|
const int nRangeLength = qMax(1,
|
|
|
m_pEndFrameCombo->currentIndex() -
|
|
|
m_pStartFrameCombo->currentIndex());
|
|
|
m_pSamplingIntervalSpinBox->setMaximum(nRangeLength);
|
|
|
updateSummary();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::onResolutionPresetChanged(
|
|
|
int nPresetId)
|
|
|
{
|
|
|
const bool bCustom = nPresetId == Resolution_Custom;
|
|
|
m_pWidthSpinBox->setEnabled(bCustom);
|
|
|
m_pHeightSpinBox->setEnabled(bCustom);
|
|
|
updateSummary();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::normalizeCustomDimensions()
|
|
|
{
|
|
|
// editingFinished后再回写，避免valueChanged期间干扰用户键盘输入。
|
|
|
m_pWidthSpinBox->setValue(
|
|
|
normalizeEvenDimension(m_pWidthSpinBox->value()));
|
|
|
m_pHeightSpinBox->setValue(
|
|
|
normalizeEvenDimension(m_pHeightSpinBox->value()));
|
|
|
updateSummary();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::updateSummary()
|
|
|
{
|
|
|
const nmPebiResultAnimationExportSettings oSettings =
|
|
|
collectSettings();
|
|
|
const int nOutputFrameCount = oSettings.getOutputFrameCount();
|
|
|
m_pOutputFrameCountLabel->setText(
|
|
|
tr("%1 frames").arg(nOutputFrameCount));
|
|
|
const double dDuration = oSettings.m_nFramesPerSecond > 0
|
|
|
? static_cast<double>(nOutputFrameCount) /
|
|
|
static_cast<double>(oSettings.m_nFramesPerSecond)
|
|
|
: 0.0;
|
|
|
m_pEstimatedDurationLabel->setText(
|
|
|
tr("%1 s").arg(QString::number(dDuration, 'g', 4)));
|
|
|
clearError();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::onVideoFormatChanged(int nIndex)
|
|
|
{
|
|
|
Q_UNUSED(nIndex);
|
|
|
if(m_pTargetPathEdit != nullptr &&
|
|
|
!m_pTargetPathEdit->text().isEmpty()) {
|
|
|
setTargetFilePath(normalizeTargetFilePath(
|
|
|
m_pTargetPathEdit->text()));
|
|
|
}
|
|
|
clearError();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::browseTargetFile()
|
|
|
{
|
|
|
const QString sExtension = getSelectedVideoExtension();
|
|
|
if(sExtension.isEmpty()) {
|
|
|
showError(tr("The selected video format is unsupported."));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const QString sInitialPath = m_pTargetPathEdit->text().isEmpty()
|
|
|
? getSuggestedTargetFilePath() : m_pTargetPathEdit->text();
|
|
|
const QFileInfo oInitialFileInfo(sInitialPath);
|
|
|
|
|
|
QFileDialog oFileDialog(this, tr("Save Result Animation"));
|
|
|
oFileDialog.setAcceptMode(QFileDialog::AcceptSave);
|
|
|
oFileDialog.setFileMode(QFileDialog::AnyFile);
|
|
|
oFileDialog.setNameFilter(getSelectedVideoFilter());
|
|
|
oFileDialog.setDefaultSuffix(sExtension);
|
|
|
oFileDialog.setOption(QFileDialog::DontConfirmOverwrite, true);
|
|
|
oFileDialog.setDirectory(oInitialFileInfo.absolutePath());
|
|
|
oFileDialog.selectFile(oInitialFileInfo.fileName());
|
|
|
if(oFileDialog.exec() != QDialog::Accepted ||
|
|
|
oFileDialog.selectedFiles().isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const QString sTargetPath = normalizeTargetFilePath(
|
|
|
oFileDialog.selectedFiles().first());
|
|
|
const QFileInfo oTargetFileInfo(sTargetPath);
|
|
|
setTargetFilePath(oTargetFileInfo.absoluteFilePath());
|
|
|
ZxBaseUtil::setLastDir(oTargetFileInfo.absolutePath());
|
|
|
clearError();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::acceptSettings()
|
|
|
{
|
|
|
// 只有自定义模式需要把编辑值回写为编码器最终使用的偶数尺寸。
|
|
|
if(m_pCustomSizeRadioButton->isChecked()) {
|
|
|
normalizeCustomDimensions();
|
|
|
}
|
|
|
const nmPebiResultAnimationExportSettings oSettings =
|
|
|
collectSettings();
|
|
|
if(!oSettings.isValid(m_vecFrameTimesHours.size())) {
|
|
|
showError(tr("The animation export settings are invalid."));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if(m_pTargetPathEdit->text().isEmpty()) {
|
|
|
showError(tr("Please select an output file."));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const QString sExtension = getSelectedVideoExtension();
|
|
|
if(sExtension.isEmpty()) {
|
|
|
showError(tr("The selected video format is unsupported."));
|
|
|
return;
|
|
|
}
|
|
|
const QString sTargetPath = QFileInfo(normalizeTargetFilePath(
|
|
|
m_pTargetPathEdit->text())).absoluteFilePath();
|
|
|
const QFileInfo oTargetFileInfo(sTargetPath);
|
|
|
if(oTargetFileInfo.suffix().compare(
|
|
|
sExtension, Qt::CaseInsensitive) != 0) {
|
|
|
showError(tr("The selected video file extension does not match "
|
|
|
"the selected format."));
|
|
|
return;
|
|
|
}
|
|
|
if(oTargetFileInfo.isDir()) {
|
|
|
showError(tr("The selected output path is a directory."));
|
|
|
return;
|
|
|
}
|
|
|
if(!QDir(oTargetFileInfo.absolutePath()).exists()) {
|
|
|
showError(tr("The selected output directory does not exist."));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
setTargetFilePath(sTargetPath);
|
|
|
if(oTargetFileInfo.exists() &&
|
|
|
QMessageBox::question(
|
|
|
this, tr("Export Animation"),
|
|
|
tr("The selected file already exists. Replace it?"),
|
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
|
QMessageBox::No) != QMessageBox::Yes) {
|
|
|
return;
|
|
|
}
|
|
|
m_oAcceptedSettings = oSettings;
|
|
|
m_sAcceptedTargetFilePath = sTargetPath;
|
|
|
accept();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::createUi()
|
|
|
{
|
|
|
setWindowTitle(tr("Export Animation"));
|
|
|
setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
|
|
|
setMinimumWidth(460);
|
|
|
|
|
|
QVBoxLayout* pMainLayout = new QVBoxLayout(this);
|
|
|
pMainLayout->setContentsMargins(12, 10, 12, 10);
|
|
|
pMainLayout->setSpacing(8);
|
|
|
|
|
|
QGroupBox* pFrameGroup = new QGroupBox(tr("Frame Settings"), this);
|
|
|
QGridLayout* pFrameGrid = new QGridLayout(pFrameGroup);
|
|
|
pFrameGrid->setHorizontalSpacing(8);
|
|
|
pFrameGrid->setVerticalSpacing(6);
|
|
|
pFrameGrid->setColumnStretch(1, 1);
|
|
|
const QSizePolicy oFieldSizePolicy(
|
|
|
QSizePolicy::Expanding, QSizePolicy::Fixed);
|
|
|
|
|
|
m_pFpsSpinBox = new QSpinBox(pFrameGroup);
|
|
|
m_pFpsSpinBox->setRange(1, 5000);
|
|
|
m_pFpsSpinBox->setValue(15);
|
|
|
m_pFpsSpinBox->setSuffix(tr(" FPS"));
|
|
|
m_pFpsSpinBox->setSizePolicy(oFieldSizePolicy);
|
|
|
pFrameGrid->addWidget(
|
|
|
createRightAlignedLabel(tr("Frame rate"), pFrameGroup), 0, 0);
|
|
|
pFrameGrid->addWidget(m_pFpsSpinBox, 0, 1);
|
|
|
|
|
|
m_pStartFrameCombo = new QComboBox(pFrameGroup);
|
|
|
m_pStartFrameCombo->setSizePolicy(oFieldSizePolicy);
|
|
|
pFrameGrid->addWidget(
|
|
|
createRightAlignedLabel(tr("Start time"), pFrameGroup), 1, 0);
|
|
|
pFrameGrid->addWidget(m_pStartFrameCombo, 1, 1);
|
|
|
|
|
|
m_pEndFrameCombo = new QComboBox(pFrameGroup);
|
|
|
m_pEndFrameCombo->setSizePolicy(oFieldSizePolicy);
|
|
|
pFrameGrid->addWidget(
|
|
|
createRightAlignedLabel(tr("End time"), pFrameGroup), 2, 0);
|
|
|
pFrameGrid->addWidget(m_pEndFrameCombo, 2, 1);
|
|
|
|
|
|
m_pSamplingIntervalSpinBox = new QSpinBox(pFrameGroup);
|
|
|
m_pSamplingIntervalSpinBox->setRange(1, 1);
|
|
|
m_pSamplingIntervalSpinBox->setSizePolicy(oFieldSizePolicy);
|
|
|
pFrameGrid->addWidget(
|
|
|
createRightAlignedLabel(tr("Frame step"), pFrameGroup), 3, 0);
|
|
|
pFrameGrid->addWidget(m_pSamplingIntervalSpinBox, 3, 1);
|
|
|
pMainLayout->addWidget(pFrameGroup);
|
|
|
|
|
|
QGroupBox* pOutputSizeGroup = new QGroupBox(tr("Output Size"), this);
|
|
|
QGridLayout* pOutputSizeGrid = new QGridLayout(pOutputSizeGroup);
|
|
|
pOutputSizeGrid->setHorizontalSpacing(6);
|
|
|
pOutputSizeGrid->setVerticalSpacing(6);
|
|
|
|
|
|
m_pResolutionButtonGroup = new QButtonGroup(this);
|
|
|
m_pCurrentSizeRadioButton = new QRadioButton(
|
|
|
tr("Current image size") + QString::fromLatin1(" ") +
|
|
|
formatPixelSize(m_oEffectiveCurrentViewportSize.width(),
|
|
|
m_oEffectiveCurrentViewportSize.height()),
|
|
|
pOutputSizeGroup);
|
|
|
m_p720pRadioButton = new QRadioButton(
|
|
|
formatPixelSize(1280, 720), pOutputSizeGroup);
|
|
|
m_p1080pRadioButton = new QRadioButton(
|
|
|
formatPixelSize(1920, 1080), pOutputSizeGroup);
|
|
|
m_pCustomSizeRadioButton = new QRadioButton(
|
|
|
tr("Custom size"), pOutputSizeGroup);
|
|
|
m_pResolutionButtonGroup->addButton(
|
|
|
m_pCurrentSizeRadioButton, Resolution_CurrentView);
|
|
|
m_pResolutionButtonGroup->addButton(
|
|
|
m_p720pRadioButton, Resolution_720p);
|
|
|
m_pResolutionButtonGroup->addButton(
|
|
|
m_p1080pRadioButton, Resolution_1080p);
|
|
|
m_pResolutionButtonGroup->addButton(
|
|
|
m_pCustomSizeRadioButton, Resolution_Custom);
|
|
|
m_pCurrentSizeRadioButton->setChecked(true);
|
|
|
|
|
|
pOutputSizeGrid->addWidget(
|
|
|
m_pCurrentSizeRadioButton, 0, 1, 1, 5, Qt::AlignLeft);
|
|
|
pOutputSizeGrid->addWidget(
|
|
|
m_p720pRadioButton, 1, 1, 1, 5, Qt::AlignLeft);
|
|
|
pOutputSizeGrid->addWidget(
|
|
|
m_p1080pRadioButton, 2, 1, 1, 5, Qt::AlignLeft);
|
|
|
pOutputSizeGrid->addWidget(m_pCustomSizeRadioButton, 3, 1, Qt::AlignLeft);
|
|
|
|
|
|
m_pWidthSpinBox = new QSpinBox(pOutputSizeGroup);
|
|
|
m_pHeightSpinBox = new QSpinBox(pOutputSizeGroup);
|
|
|
m_pWidthSpinBox->setRange(2, 8192);
|
|
|
m_pHeightSpinBox->setRange(2, 8192);
|
|
|
m_pWidthSpinBox->setSingleStep(2);
|
|
|
m_pHeightSpinBox->setSingleStep(2);
|
|
|
m_pWidthSpinBox->setMinimumWidth(90);
|
|
|
m_pWidthSpinBox->setMaximumWidth(110);
|
|
|
m_pHeightSpinBox->setMinimumWidth(90);
|
|
|
m_pHeightSpinBox->setMaximumWidth(110);
|
|
|
m_pWidthSpinBox->setValue(m_oEffectiveCurrentViewportSize.width());
|
|
|
m_pHeightSpinBox->setValue(m_oEffectiveCurrentViewportSize.height());
|
|
|
QLabel* pMultiplyLabel = new QLabel(
|
|
|
QString(QChar(0x00D7)), pOutputSizeGroup);
|
|
|
pMultiplyLabel->setAlignment(Qt::AlignCenter);
|
|
|
QLabel* pPixelLabel = new QLabel(
|
|
|
QString::fromLatin1("px"), pOutputSizeGroup);
|
|
|
pOutputSizeGrid->addWidget(m_pWidthSpinBox, 3, 2);
|
|
|
pOutputSizeGrid->addWidget(pMultiplyLabel, 3, 3, Qt::AlignCenter);
|
|
|
pOutputSizeGrid->addWidget(m_pHeightSpinBox, 3, 4);
|
|
|
pOutputSizeGrid->addWidget(pPixelLabel, 3, 5, Qt::AlignLeft);
|
|
|
// 两侧等权留白使完整尺寸选项块居中，块内控件仍保持左对齐。
|
|
|
pOutputSizeGrid->setColumnStretch(0, 1);
|
|
|
pOutputSizeGrid->setColumnStretch(6, 1);
|
|
|
pMainLayout->addWidget(pOutputSizeGroup);
|
|
|
|
|
|
QGroupBox* pOutputFileGroup = new QGroupBox(
|
|
|
tr("Output File"), this);
|
|
|
QGridLayout* pOutputFileGrid = new QGridLayout(pOutputFileGroup);
|
|
|
pOutputFileGrid->setHorizontalSpacing(8);
|
|
|
pOutputFileGrid->setVerticalSpacing(6);
|
|
|
pOutputFileGrid->setColumnStretch(1, 1);
|
|
|
|
|
|
m_pVideoFormatCombo = new QComboBox(pOutputFileGroup);
|
|
|
m_pVideoFormatCombo->setSizePolicy(oFieldSizePolicy);
|
|
|
pOutputFileGrid->addWidget(
|
|
|
createRightAlignedLabel(
|
|
|
tr("File format"), pOutputFileGroup), 0, 0);
|
|
|
pOutputFileGrid->addWidget(m_pVideoFormatCombo, 0, 1, 1, 2);
|
|
|
|
|
|
m_pTargetPathEdit = new QLineEdit(pOutputFileGroup);
|
|
|
m_pTargetPathEdit->setReadOnly(true);
|
|
|
m_pTargetPathEdit->setSizePolicy(oFieldSizePolicy);
|
|
|
QPushButton* pBrowseButton = new QPushButton(
|
|
|
tr("Browse..."), pOutputFileGroup);
|
|
|
pBrowseButton->setMinimumWidth(72);
|
|
|
pOutputFileGrid->addWidget(
|
|
|
createRightAlignedLabel(
|
|
|
tr("Save location"), pOutputFileGroup), 1, 0);
|
|
|
pOutputFileGrid->addWidget(m_pTargetPathEdit, 1, 1);
|
|
|
pOutputFileGrid->addWidget(pBrowseButton, 1, 2);
|
|
|
pMainLayout->addWidget(pOutputFileGroup);
|
|
|
|
|
|
QGroupBox* pInformationGroup = new QGroupBox(
|
|
|
tr("Export Information"), this);
|
|
|
QGridLayout* pInformationGrid = new QGridLayout(pInformationGroup);
|
|
|
pInformationGrid->setHorizontalSpacing(8);
|
|
|
pInformationGrid->setVerticalSpacing(6);
|
|
|
m_pOutputFrameCountLabel = new QLabel(pInformationGroup);
|
|
|
m_pEstimatedDurationLabel = new QLabel(pInformationGroup);
|
|
|
m_pOutputFrameCountLabel->setTextInteractionFlags(
|
|
|
Qt::TextSelectableByMouse);
|
|
|
m_pEstimatedDurationLabel->setTextInteractionFlags(
|
|
|
Qt::TextSelectableByMouse);
|
|
|
pInformationGrid->addWidget(
|
|
|
createRightAlignedLabel(
|
|
|
tr("Output frames"), pInformationGroup), 0, 1);
|
|
|
pInformationGrid->addWidget(
|
|
|
m_pOutputFrameCountLabel, 0, 2, Qt::AlignLeft);
|
|
|
pInformationGrid->addWidget(
|
|
|
createRightAlignedLabel(
|
|
|
tr("Estimated duration"), pInformationGroup), 1, 1);
|
|
|
pInformationGrid->addWidget(
|
|
|
m_pEstimatedDurationLabel, 1, 2, Qt::AlignLeft);
|
|
|
// 标签列和数值列作为一个整体居中，保留内部左右对齐关系。
|
|
|
pInformationGrid->setColumnStretch(0, 1);
|
|
|
pInformationGrid->setColumnStretch(3, 1);
|
|
|
pMainLayout->addWidget(pInformationGroup);
|
|
|
|
|
|
m_pErrorLabel = new QLabel(this);
|
|
|
m_pErrorLabel->setStyleSheet("QLabel { color: #a32626; }");
|
|
|
m_pErrorLabel->setWordWrap(true);
|
|
|
m_pErrorLabel->hide();
|
|
|
pMainLayout->addWidget(m_pErrorLabel);
|
|
|
|
|
|
QDialogButtonBox* pButtonBox = new QDialogButtonBox(
|
|
|
QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
|
|
|
Qt::Horizontal, this);
|
|
|
QPushButton* pOkButton = pButtonBox->button(QDialogButtonBox::Ok);
|
|
|
QPushButton* pCancelButton = pButtonBox->button(QDialogButtonBox::Cancel);
|
|
|
pOkButton->setIcon(QIcon(exportDialogIconPath("OK.png")));
|
|
|
pCancelButton->setIcon(QIcon(exportDialogIconPath("Cancel.png")));
|
|
|
pOkButton->setIconSize(QSize(16, 16));
|
|
|
pCancelButton->setIconSize(QSize(16, 16));
|
|
|
pOkButton->setMinimumWidth(72);
|
|
|
pCancelButton->setMinimumWidth(72);
|
|
|
pMainLayout->addWidget(pButtonBox, 0, Qt::AlignRight);
|
|
|
|
|
|
connect(m_pStartFrameCombo, SIGNAL(currentIndexChanged(int)),
|
|
|
this, SLOT(onFrameRangeChanged()));
|
|
|
connect(m_pEndFrameCombo, SIGNAL(currentIndexChanged(int)),
|
|
|
this, SLOT(onFrameRangeChanged()));
|
|
|
connect(m_pSamplingIntervalSpinBox, SIGNAL(valueChanged(int)),
|
|
|
this, SLOT(updateSummary()));
|
|
|
connect(m_pFpsSpinBox, SIGNAL(valueChanged(int)),
|
|
|
this, SLOT(updateSummary()));
|
|
|
connect(m_pResolutionButtonGroup, SIGNAL(buttonClicked(int)),
|
|
|
this, SLOT(onResolutionPresetChanged(int)));
|
|
|
connect(m_pVideoFormatCombo, SIGNAL(currentIndexChanged(int)),
|
|
|
this, SLOT(onVideoFormatChanged(int)));
|
|
|
connect(pBrowseButton, SIGNAL(clicked()),
|
|
|
this, SLOT(browseTargetFile()));
|
|
|
connect(m_pWidthSpinBox, SIGNAL(valueChanged(int)),
|
|
|
this, SLOT(updateSummary()));
|
|
|
connect(m_pHeightSpinBox, SIGNAL(valueChanged(int)),
|
|
|
this, SLOT(updateSummary()));
|
|
|
connect(m_pWidthSpinBox, SIGNAL(editingFinished()),
|
|
|
this, SLOT(normalizeCustomDimensions()));
|
|
|
connect(m_pHeightSpinBox, SIGNAL(editingFinished()),
|
|
|
this, SLOT(normalizeCustomDimensions()));
|
|
|
connect(pButtonBox, SIGNAL(accepted()),
|
|
|
this, SLOT(acceptSettings()));
|
|
|
connect(pButtonBox, SIGNAL(rejected()),
|
|
|
this, SLOT(reject()));
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::populateFrameItems()
|
|
|
{
|
|
|
for(int nFrameIndex = 0;
|
|
|
nFrameIndex < m_vecFrameTimesHours.size(); ++nFrameIndex) {
|
|
|
const QString sText = tr("%1 h").arg(QString::number(
|
|
|
m_vecFrameTimesHours[nFrameIndex], 'g', 8));
|
|
|
m_pStartFrameCombo->addItem(sText, nFrameIndex);
|
|
|
m_pEndFrameCombo->addItem(sText, nFrameIndex);
|
|
|
}
|
|
|
if(!m_vecFrameTimesHours.isEmpty()) {
|
|
|
m_pStartFrameCombo->setCurrentIndex(0);
|
|
|
m_pEndFrameCombo->setCurrentIndex(
|
|
|
m_vecFrameTimesHours.size() - 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::populateVideoFormats()
|
|
|
{
|
|
|
// itemData只保存稳定扩展名，界面翻译不会参与格式识别。
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("MP4 Video (*.mp4)"), QString::fromLatin1("mp4"));
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("AVI Video (*.avi)"), QString::fromLatin1("avi"));
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("QuickTime Video (*.mov)"), QString::fromLatin1("mov"));
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("MPEG Video (*.mpg)"), QString::fromLatin1("mpg"));
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("WebM Video (*.webm)"), QString::fromLatin1("webm"));
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("Matroska Video (*.mkv)"), QString::fromLatin1("mkv"));
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("Windows Media Video (*.wmv)"), QString::fromLatin1("wmv"));
|
|
|
m_pVideoFormatCombo->addItem(
|
|
|
tr("Flash Video (*.flv)"), QString::fromLatin1("flv"));
|
|
|
m_pVideoFormatCombo->setCurrentIndex(0);
|
|
|
}
|
|
|
|
|
|
nmPebiResultAnimationExportSettings
|
|
|
nmWxPebiResultAnimationExportDlg::collectSettings() const
|
|
|
{
|
|
|
nmPebiResultAnimationExportSettings oSettings;
|
|
|
oSettings.m_nFramesPerSecond = m_pFpsSpinBox->value();
|
|
|
oSettings.m_nStartFrameIndex =
|
|
|
m_pStartFrameCombo->itemData(
|
|
|
m_pStartFrameCombo->currentIndex()).toInt();
|
|
|
oSettings.m_nEndFrameIndex =
|
|
|
m_pEndFrameCombo->itemData(
|
|
|
m_pEndFrameCombo->currentIndex()).toInt();
|
|
|
oSettings.m_nSamplingInterval =
|
|
|
m_pSamplingIntervalSpinBox->value();
|
|
|
const QSize oOutputSize = getSelectedOutputSize();
|
|
|
oSettings.m_nOutputWidth = oOutputSize.width();
|
|
|
oSettings.m_nOutputHeight = oOutputSize.height();
|
|
|
return oSettings;
|
|
|
}
|
|
|
|
|
|
QSize nmWxPebiResultAnimationExportDlg::getSelectedOutputSize() const
|
|
|
{
|
|
|
const int nPresetId = m_pResolutionButtonGroup == nullptr
|
|
|
? Resolution_CurrentView :
|
|
|
m_pResolutionButtonGroup->checkedId();
|
|
|
if(nPresetId == Resolution_720p) {
|
|
|
return QSize(1280, 720);
|
|
|
}
|
|
|
if(nPresetId == Resolution_1080p) {
|
|
|
return QSize(1920, 1080);
|
|
|
}
|
|
|
if(nPresetId == Resolution_Custom) {
|
|
|
return QSize(
|
|
|
normalizeEvenDimension(m_pWidthSpinBox->value()),
|
|
|
normalizeEvenDimension(m_pHeightSpinBox->value()));
|
|
|
}
|
|
|
return m_oEffectiveCurrentViewportSize;
|
|
|
}
|
|
|
|
|
|
QString nmWxPebiResultAnimationExportDlg::getSelectedVideoExtension() const
|
|
|
{
|
|
|
if(m_pVideoFormatCombo == nullptr ||
|
|
|
m_pVideoFormatCombo->currentIndex() < 0) {
|
|
|
return QString();
|
|
|
}
|
|
|
const QString sExtension = m_pVideoFormatCombo->itemData(
|
|
|
m_pVideoFormatCombo->currentIndex()).toString().toLower();
|
|
|
return nmFFmpegVideoWriter::isSupportedExtension(sExtension)
|
|
|
? sExtension : QString();
|
|
|
}
|
|
|
|
|
|
QString nmWxPebiResultAnimationExportDlg::getSelectedVideoFilter() const
|
|
|
{
|
|
|
return m_pVideoFormatCombo == nullptr
|
|
|
? QString() : m_pVideoFormatCombo->currentText();
|
|
|
}
|
|
|
|
|
|
QString nmWxPebiResultAnimationExportDlg::normalizeTargetFilePath(
|
|
|
const QString& sPath) const
|
|
|
{
|
|
|
const QString sExtension = getSelectedVideoExtension();
|
|
|
if(sPath.isEmpty() || sExtension.isEmpty()) {
|
|
|
return QString();
|
|
|
}
|
|
|
|
|
|
QString sNormalizedPath = QDir::fromNativeSeparators(sPath);
|
|
|
const QString sExistingExtension =
|
|
|
QFileInfo(sNormalizedPath).suffix().toLower();
|
|
|
if(sExistingExtension.isEmpty()) {
|
|
|
if(!sNormalizedPath.endsWith('.')) {
|
|
|
sNormalizedPath.append('.');
|
|
|
}
|
|
|
sNormalizedPath.append(sExtension);
|
|
|
} else if(nmFFmpegVideoWriter::isSupportedExtension(
|
|
|
sExistingExtension)) {
|
|
|
sNormalizedPath.chop(sExistingExtension.length());
|
|
|
sNormalizedPath.append(sExtension);
|
|
|
} else {
|
|
|
sNormalizedPath.append(
|
|
|
QString::fromLatin1(".%1").arg(sExtension));
|
|
|
}
|
|
|
return QDir::cleanPath(sNormalizedPath);
|
|
|
}
|
|
|
|
|
|
QString nmWxPebiResultAnimationExportDlg::getSuggestedTargetFilePath() const
|
|
|
{
|
|
|
QString sDirectory = ZxBaseUtil::getLastDir();
|
|
|
if(sDirectory.isEmpty() || !QDir(sDirectory).exists()) {
|
|
|
sDirectory = QDir::homePath();
|
|
|
}
|
|
|
return QDir(sDirectory).absoluteFilePath(
|
|
|
QString::fromLatin1("PEBI-result.%1").arg(
|
|
|
getSelectedVideoExtension()));
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::setTargetFilePath(
|
|
|
const QString& sPath)
|
|
|
{
|
|
|
const QString sDisplayPath = QDir::toNativeSeparators(sPath);
|
|
|
m_pTargetPathEdit->setText(sDisplayPath);
|
|
|
m_pTargetPathEdit->setToolTip(sDisplayPath);
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::showError(const QString& sError)
|
|
|
{
|
|
|
m_pErrorLabel->setText(sError);
|
|
|
m_pErrorLabel->show();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultAnimationExportDlg::clearError()
|
|
|
{
|
|
|
m_pErrorLabel->clear();
|
|
|
m_pErrorLabel->hide();
|
|
|
}
|
|
|
|
|
|
int nmWxPebiResultAnimationExportDlg::normalizeEvenDimension(int nValue)
|
|
|
{
|
|
|
nValue = qBound(2, nValue, 8192);
|
|
|
if((nValue % 2) != 0) {
|
|
|
++nValue;
|
|
|
}
|
|
|
return qMin(nValue, 8192);
|
|
|
}
|