(w);
if (pw) {
pw->setProducer(producer);
} else {
LOG_ERROR() << "Widget is not a producer widget.";
return w;
}
if (-1 != w->metaObject()->indexOfSignal("producerChanged(Mlt::Producer*)")) {
connect(w, SIGNAL(producerChanged(Mlt::Producer *)), SLOT(onProducerChanged()));
connect(w,
SIGNAL(producerChanged(Mlt::Producer *)),
m_filterController,
SLOT(setProducer(Mlt::Producer *)));
connect(w,
SIGNAL(producerChanged(Mlt::Producer *)),
m_playlistDock,
SLOT(onProducerChanged(Mlt::Producer *)));
if (producer->get(kMultitrackItemProperty))
connect(w,
SIGNAL(producerChanged(Mlt::Producer *)),
m_timelineDock,
SLOT(onProducerChanged(Mlt::Producer *)));
}
if (-1 != w->metaObject()->indexOfSignal("modified()")) {
connect(w, SIGNAL(modified()), SLOT(onProducerModified()));
connect(w, SIGNAL(modified()), m_playlistDock, SLOT(onProducerModified()));
connect(w, SIGNAL(modified()), m_timelineDock, SLOT(onProducerModified()));
connect(w, SIGNAL(modified()), m_keyframesDock, SLOT(onProducerModified()));
connect(w, SIGNAL(modified()), m_filterController, SLOT(onProducerChanged()));
}
if (-1 != w->metaObject()->indexOfSignal("showInFiles(QString)")) {
connect(w, SIGNAL(showInFiles(QString)), this, SLOT(onFilesDockTriggered()));
connect(w, SIGNAL(showInFiles(QString)), m_filesDock, SLOT(changeDirectory(QString)));
}
if (-1 != w->metaObject()->indexOfSlot("updateDuration()")) {
connect(m_timelineDock, SIGNAL(durationChanged()), w, SLOT(updateDuration()));
}
if (-1 != w->metaObject()->indexOfSlot("rename()")) {
connect(this, SIGNAL(renameRequested()), w, SLOT(rename()));
}
if (-1 != w->metaObject()->indexOfSlot("offerConvert(QString)")) {
connect(m_filterController->attachedModel(),
SIGNAL(requestConvert(QString, bool, bool)),
w,
SLOT(offerConvert(QString, bool)),
Qt::QueuedConnection);
}
scrollArea->setWidget(w);
onProducerChanged();
} else if (scrollArea->widget()) {
scrollArea->widget()->deleteLater();
}
return w;
}
*/
void MainWindow::on_actionEnterFullScreen_triggered()
{
bool isFull = isFullScreen();
if (isFull) {
showNormal();
ui->actionEnterFullScreen->setText(tr("Enter Full Screen"));
} else {
showFullScreen();
ui->actionEnterFullScreen->setText(tr("Exit Full Screen"));
}
}
void MainWindow::onGpuNotSupported()
{
// DISABLED: MLT GPU processing
// if (Settings.processingMode() == ShotcutSettings::Linear10GpuCpu) {
// Settings.setProcessingMode(ShotcutSettings::Native8Cpu);
// }
// ui->actionLinear10bitGpuCpu->setChecked(false);
// ui->actionLinear10bitGpuCpu->setDisabled(true);
LOG_WARNING() << "GPU not supported (disabled for mail client)";
// QMessageBox::critical(this, qApp->applicationName(), tr("GPU processing is not supported"));
}
void MainWindow::onShuttle(float x)
{
// DISABLED: MLT player shuttle
// if (x == 0) {
// m_player->pause();
// } else if (x > 0) {
// m_player->play(10.0 * x);
// } else {
// m_player->play(20.0 * x);
// }
}
void MainWindow::showUpgradePrompt()
{
if (Settings.checkUpgradeAutomatic()) {
showStatusMessage("Checking for upgrade...");
m_network.get(QNetworkRequest(QUrl("https://check.shotcut.org/version.json")));
} else {
QAction *action = new QAction(tr("Click here to check for a new version of Shotcut."), 0);
connect(action, SIGNAL(triggered(bool)), SLOT(on_actionUpgrade_triggered()));
showStatusMessage(action, 15 /* seconds */);
}
}
void MainWindow::on_actionRealtime_triggered(bool checked)
{
Settings.setPlayerRealtime(checked);
if (Settings.playerGPU())
MLT.pause();
if (MLT.consumer()) {
MLT.consumerChanged();
}
}
void MainWindow::on_actionProgressive_triggered(bool checked)
{
MLT.videoWidget()->setProperty("progressive", checked);
if (Settings.playerGPU())
MLT.pause();
if (MLT.consumer()) {
MLT.profile().set_progressive(checked);
MLT.updatePreviewProfile();
MLT.consumerChanged();
}
Settings.setPlayerProgressive(checked);
}
void MainWindow::changeAudioChannels(bool checked, int channels)
{
if (checked) {
Settings.setPlayerAudioChannels(channels);
setAudioChannels(Settings.playerAudioChannels());
}
}
void MainWindow::on_actionChannels1_triggered(bool checked)
{
changeAudioChannels(checked, 1);
}
void MainWindow::on_actionChannels2_triggered(bool checked)
{
changeAudioChannels(checked, 2);
}
void MainWindow::on_actionChannels4_triggered(bool checked)
{
changeAudioChannels(checked, 4);
}
void MainWindow::on_actionChannels6_triggered(bool checked)
{
changeAudioChannels(checked, 6);
}
void MainWindow::changeDeinterlacer(bool checked, const char *method)
{
if (checked) {
MLT.videoWidget()->setProperty("deinterlacer", method);
if (MLT.consumer()) {
MLT.consumer()->set("deinterlacer", method);
MLT.refreshConsumer();
}
}
Settings.setPlayerDeinterlacer(method);
}
void MainWindow::on_actionOneField_triggered(bool checked)
{
changeDeinterlacer(checked, "onefield");
}
void MainWindow::on_actionLinearBlend_triggered(bool checked)
{
changeDeinterlacer(checked, "linearblend");
}
void MainWindow::on_actionYadifTemporal_triggered(bool checked)
{
changeDeinterlacer(checked, "yadif-nospatial");
}
void MainWindow::on_actionYadifSpatial_triggered(bool checked)
{
changeDeinterlacer(checked, "yadif");
}
void MainWindow::on_actionBwdif_triggered(bool checked)
{
changeDeinterlacer(checked, "bwdif");
}
void MainWindow::changeInterpolation(bool checked, const char *method)
{
if (checked) {
MLT.videoWidget()->setProperty("rescale", method);
if (MLT.consumer()) {
MLT.consumer()->set("rescale", method);
MLT.refreshConsumer();
}
}
Settings.setPlayerInterpolation(method);
}
void MainWindow::processMultipleFiles()
{
if (m_multipleFiles.length() <= 0)
return;
QStringList multipleFiles = m_multipleFiles;
m_multipleFiles.clear();
int count = multipleFiles.length();
if (count > 1) {
m_multipleFilesLoading = true;
LongUiTask longTask(tr("Open Files"));
m_playlistDock->show();
m_playlistDock->raise();
ResourceDialog dialog(this);
for (int i = 0; i < count; i++) {
QString filename = multipleFiles.takeFirst();
LOG_DEBUG() << filename;
longTask.reportProgress(QFileInfo(filename).fileName(), i, count);
Mlt::Producer p(MLT.profile(), filename.toUtf8().constData());
if (p.is_valid()) {
if (QDir::toNativeSeparators(filename)
== QDir::toNativeSeparators(MAIN.fileName())) {
MAIN.showStatusMessage(QObject::tr("You cannot add a project to itself!"));
continue;
}
Util::getHash(p);
Mlt::Producer *producer = MLT.setupNewProducer(&p);
ProxyManager::generateIfNotExists(*producer);
producer->set(kShotcutSkipConvertProperty, true);
undoStack()->push(
new Playlist::AppendCommand(*m_playlistDock->model(), MLT.XML(producer), false));
m_recentDock->add(filename.toUtf8().constData());
dialog.add(producer);
delete producer;
}
}
emit m_playlistDock->model()->modified();
if (Settings.showConvertClipDialog() && dialog.hasTroubleClips()) {
dialog.selectTroubleClips();
dialog.setWindowTitle(tr("Opened Files"));
dialog.exec();
}
m_multipleFilesLoading = false;
}
if (m_isPlaylistLoaded && Settings.playerGPU()) {
updateThumbnails();
m_isPlaylistLoaded = false;
}
}
void MainWindow::processSingleFile()
{
if (!m_multipleFilesLoading && Settings.showConvertClipDialog()
&& !MLT.producer()->get_int(kShotcutSkipConvertProperty)) {
QString convertAdvice = Util::getConversionAdvice(MLT.producer());
if (!convertAdvice.isEmpty()) {
MLT.producer()->set(kShotcutSkipConvertProperty, true);
LongUiTask::cancel();
MLT.pause();
Util::offerSingleFileConversion(convertAdvice, MLT.producer(), this);
}
}
}
void MainWindow::onLanguageTriggered(QAction *action)
{
Settings.setLanguage(action->data().toString());
QMessageBox dialog(QMessageBox::Information,
qApp->applicationName(),
tr("You must restart Shotcut to switch to the new language.\n"
"Do you want to restart now?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() == QMessageBox::Yes) {
m_exitCode = EXIT_RESTART;
QApplication::closeAllWindows();
}
}
void MainWindow::on_actionNearest_triggered(bool checked)
{
changeInterpolation(checked, "nearest");
}
void MainWindow::on_actionBilinear_triggered(bool checked)
{
changeInterpolation(checked, "bilinear");
}
void MainWindow::on_actionBicubic_triggered(bool checked)
{
changeInterpolation(checked, "bicubic");
}
void MainWindow::on_actionHyper_triggered(bool checked)
{
changeInterpolation(checked, "hyper");
}
void MainWindow::on_actionJack_triggered(bool checked)
{
Settings.setPlayerJACK(checked);
if (!MLT.enableJack(checked)) {
if (ui->actionJack)
ui->actionJack->setChecked(false);
Settings.setPlayerJACK(false);
QMessageBox::warning(
this,
qApp->applicationName(),
tr("Failed to connect to JACK.\nPlease verify that JACK is installed and running."));
}
}
void MainWindow::onExternalTriggered(QAction *action)
{
// DISABLED: MLT external monitor output
LOG_DEBUG() << action->data().toString();
// bool isExternal = !action->data().toString().isEmpty();
// QString profile = Settings.playerProfile();
// if (Settings.playerGPU() && MLT.producer() && Settings.playerExternal() != action->data()) {
// if (confirmRestartExternalMonitor()) {
// Settings.setPlayerExternal(action->data().toString());
// if (isExternal && profile.isEmpty()) {
// profile = "atsc_720p_50";
// Settings.setPlayerProfile(profile);
// }
// m_exitCode = EXIT_RESTART;
// QApplication::closeAllWindows();
// } else {
// for (auto a : m_externalGroup->actions()) {
// if (a->data() == Settings.playerExternal()) {
// a->setChecked(true);
// if (a->data().toString().startsWith("decklink")) {
// if (m_decklinkGammaMenu)
// m_decklinkGammaMenu->setEnabled(true);
// if (m_keyerMenu)
// m_keyerMenu->setEnabled(true);
// }
// break;
// }
// }
// }
// return;
// }
// Settings.setPlayerExternal(action->data().toString());
// MLT.stop();
// bool ok = false;
// int screen = action->data().toInt(&ok);
// if (ok || action->data().toString().isEmpty()) {
// m_player->moveVideoToScreen(ok ? screen : -2);
// isExternal = false;
// MLT.videoWidget()->setProperty("mlt_service", QVariant());
// } else {
// m_player->moveVideoToScreen(-2);
// MLT.videoWidget()->setProperty("mlt_service", action->data());
// }
// // Automatic not permitted for SDI/HDMI
// if (isExternal && profile.isEmpty()) {
// auto xml = MLT.XML();
// profile = "atsc_720p_50";
// Settings.setPlayerProfile(profile);
// setProfile(profile);
// MLT.reload(xml);
// foreach (QAction *a, m_profileGroup->actions()) {
// if (a->data() == profile) {
// a->setChecked(true);
// break;
// }
// }
// } else {
// MLT.consumerChanged();
// }
// // Automatic not permitted for SDI/HDMI
// m_profileGroup->actions().at(0)->setEnabled(!isExternal);
// // Disable progressive option when SDI/HDMI
// ui->actionProgressive->setEnabled(!isExternal);
// bool isProgressive = isExternal ? MLT.profile().progressive()
// : ui->actionProgressive->isChecked();
// MLT.videoWidget()->setProperty("progressive", isProgressive);
// if (MLT.consumer()) {
// MLT.consumer()->set("progressive", isProgressive);
// MLT.consumerChanged();
// }
// if (action->data().toString().startsWith("decklink")) {
// if (m_decklinkGammaMenu)
// m_decklinkGammaMenu->setEnabled(true);
// if (m_keyerMenu)
// m_keyerMenu->setEnabled(true);
// }
// // Preview scaling not permitted for SDI/HDMI
// if (isExternal) {
// ui->actionPreview360->setEnabled(false);
// ui->actionPreview540->setEnabled(false);
// } else {
// ui->actionPreview360->setEnabled(true);
// ui->actionPreview540->setEnabled(true);
// }
// setPreviewScale(Settings.playerPreviewScale());
Q_UNUSED(action)
}
void MainWindow::onDecklinkGammaTriggered(QAction *action)
{
LOG_DEBUG() << action->data().toString();
MLT.videoWidget()->setProperty("decklinkGamma", action->data());
if (Settings.playerGPU() && MLT.producer()) {
if (confirmRestartExternalMonitor()) {
Settings.setPlayerDecklinkGamma(action->data().toInt());
m_exitCode = EXIT_RESTART;
QApplication::closeAllWindows();
} else {
auto gamma = Settings.playerDecklinkGamma();
for (auto a : m_decklinkGammaGroup->actions()) {
if (a->data() == gamma) {
a->setChecked(true);
break;
}
}
}
return;
}
MLT.consumerChanged();
Settings.setPlayerDecklinkGamma(action->data().toInt());
}
void MainWindow::onKeyerTriggered(QAction *action)
{
LOG_DEBUG() << action->data().toString();
MLT.videoWidget()->setProperty("keyer", action->data());
if (Settings.playerGPU() && MLT.producer()) {
if (confirmRestartExternalMonitor()) {
Settings.setPlayerKeyerMode(action->data().toInt());
m_exitCode = EXIT_RESTART;
QApplication::closeAllWindows();
} else {
auto keyer = Settings.playerKeyerMode();
for (auto a : m_keyerGroup->actions()) {
if (a->data() == keyer) {
a->setChecked(true);
break;
}
}
}
return;
}
MLT.consumerChanged();
Settings.setPlayerKeyerMode(action->data().toInt());
}
void MainWindow::onProfileTriggered(QAction *action)
{
if (MLT.producer() && MLT.producer()->is_valid()) {
if (!confirmProfileChange())
return;
Settings.setPlayerProfile(action->data().toString());
// Figure out the top-level project producer
auto producer = MLT.producer();
if (m_timelineDock->model()->rowCount() > 0) {
producer = multitrack();
} else if (m_playlistDock->model()->rowCount() > 0) {
producer = playlist();
} else if (MLT.isMultitrack() || MLT.isPlaylist()) {
producer = MLT.savedProducer();
}
MLT.fixLengthProperties(*producer);
// Save the XML to get correct in/out points before profile is changed.
QString xml = MLT.XML(producer);
setProfile(action->data().toString());
MLT.reload(xml);
emit producerOpened(false);
} else {
Settings.setPlayerProfile(action->data().toString());
setProfile(action->data().toString());
}
}
void MainWindow::onProfileChanged()
{
if (multitrack() && MLT.isMultitrack()
&& (m_timelineDock->selection().isEmpty() || m_timelineDock->currentTrack() == -1)) {
emit m_timelineDock->selected(multitrack());
}
updateWindowTitle();
}
void MainWindow::on_actionAddCustomProfile_triggered()
{
QString xml;
if (MLT.producer() && MLT.producer()->is_valid()) {
if (!confirmProfileChange())
return;
// Save the XML to get correct in/out points before profile is changed.
xml = MLT.XML();
}
CustomProfileDialog dialog(this);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() == QDialog::Accepted) {
QString name = dialog.profileName();
if (!name.isEmpty()) {
addCustomProfile(name, customProfileMenu(), actionProfileRemove(), profileGroup());
} else if (m_profileGroup->checkedAction()) {
m_profileGroup->checkedAction()->setChecked(false);
}
// Use the new profile.
emit profileChanged();
if (!xml.isEmpty()) {
MLT.reload(xml);
emit producerOpened(false);
}
}
}
void MainWindow::restartAfterChangeTheme()
{
QMessageBox dialog(QMessageBox::Information,
qApp->applicationName(),
tr("You must restart %1 to switch to the new theme.\n"
"Do you want to restart now?")
.arg(qApp->applicationName()),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() == QMessageBox::Yes) {
m_exitCode = EXIT_RESTART;
QApplication::closeAllWindows();
}
}
void MainWindow::backup()
{
QFileInfo info(m_currentFile);
auto dateTime = info.lastModified().toString(Qt::ISODate);
dateTime.replace(':', '-');
auto filename = QStringLiteral("%1/%2 %3.mlt")
.arg(info.canonicalPath(), info.completeBaseName(), dateTime);
if (!QFile::exists(filename) && !Util::warnIfNotWritable(filename, this, tr("Save XML"))
&& QFile::copy(m_currentFile, filename)) {
showStatusMessage(tr("Saved backup %1").arg(filename));
}
}
void MainWindow::backupPeriodically()
{
auto dateTime = QFileInfo(m_currentFile).lastModified();
if (Settings.backupPeriod() > 0 && !kBackupFileRegex.match(m_currentFile).hasMatch()
&& dateTime.secsTo(QDateTime::currentDateTime()) / 60 > Settings.backupPeriod()) {
backup();
}
}
bool MainWindow::confirmProfileChange()
{
if (MLT.isClip() || !Settings.askChangeVideoMode())
return true;
QMessageBox dialog(QMessageBox::Warning,
QCoreApplication::applicationName(),
tr("Please review your entire project after making this change.
"
"Shotcut does not automatically adjust things that are sensitive to "
"size and position if you change resolution or aspect ratio.The timing of edits and keyframes may be slightly different if you "
"change frame rate.
"
"It is a good idea to use File > Backup and Save before or "
"after this operation.
"
"Do you want to change the Video Mode now?
"),
QMessageBox::No | QMessageBox::Yes,
&MAIN);
dialog.setWindowModality(QmlApplication::dialogModality());
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setCheckBox(
new QCheckBox(tr("Do not show this anymore.", "Change video mode warning dialog")));
auto result = QMessageBox::Yes == dialog.exec();
if (dialog.checkBox()->isChecked())
Settings.setAskChangeVideoMode(false);
return result;
}
bool MainWindow::confirmRestartExternalMonitor()
{
QMessageBox dialog(QMessageBox::Information,
qApp->applicationName(),
tr("Shotcut must restart to change external monitoring.\n"
"Do you want to restart now?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
return dialog.exec() == QMessageBox::Yes;
}
void MainWindow::resetFilterMenuIfNeeded()
{
// Reset to Favorites if currently set to Color or Audio
if (filterController()->metadataModel()->search() == "#color"
|| filterController()->metadataModel()->filter() == MetadataModel::AudioFilter) {
filterController()->metadataModel()->setFilter(MetadataModel::FavoritesFilter);
filterController()->metadataModel()->setSearch("");
}
}
void MainWindow::on_actionSystemTheme_triggered()
{
Settings.setTheme("system");
restartAfterChangeTheme();
}
void MainWindow::on_actionSystemFusion_triggered()
{
Settings.setTheme("system-fusion");
restartAfterChangeTheme();
}
void MainWindow::on_actionFusionDark_triggered()
{
Settings.setTheme("dark");
restartAfterChangeTheme();
}
void MainWindow::on_actionFusionLight_triggered()
{
Settings.setTheme("light");
restartAfterChangeTheme();
}
void MainWindow::on_actionJobPriorityLow_triggered()
{
Settings.setJobPriority("low");
}
void MainWindow::on_actionJobPriorityNormal_triggered()
{
Settings.setJobPriority("normal");
}
void MainWindow::on_actionTutorials_triggered()
{
Util::openUrl(QUrl("https://www.shotcut.org/tutorials/"));
}
void MainWindow::on_actionRestoreLayout_triggered()
{
auto mode = Settings.layoutMode();
if (mode != LayoutMode::Custom) {
// Clear the saved layout for this mode
Settings.setLayout(QString(kReservedLayoutPrefix).arg(mode), QByteArray(), QByteArray());
// Reset the layout mode so the current layout is saved as custom when trigger action
Settings.setLayoutMode();
}
switch (mode) {
case LayoutMode::Custom:
ui->actionLayoutEditing->setChecked(true);
Q_FALLTHROUGH();
case LayoutMode::Editing:
on_actionLayoutEditing_triggered();
break;
case LayoutMode::Logging:
on_actionLayoutLogging_triggered();
break;
case LayoutMode::Effects:
on_actionLayoutEffects_triggered();
break;
case LayoutMode::Color:
on_actionLayoutColor_triggered();
break;
case LayoutMode::Audio:
on_actionLayoutAudio_triggered();
break;
case LayoutMode::PlayerOnly:
on_actionLayoutPlayer_triggered();
break;
}
}
void MainWindow::on_actionShowTitleBars_triggered(bool checked)
{
QList docks = findChildren();
for (int i = 0; i < docks.count(); i++) {
QDockWidget *dock = docks.at(i);
if (checked) {
dock->setTitleBarWidget(0);
} else {
if (!dock->isFloating()) {
dock->setTitleBarWidget(new QWidget);
}
}
}
Settings.setShowTitleBars(checked);
}
void MainWindow::on_actionShowToolbar_triggered(bool checked)
{
ui->mainToolBar->setVisible(checked);
}
void MainWindow::onToolbarVisibilityChanged(bool visible)
{
ui->actionShowToolbar->setChecked(visible);
Settings.setShowToolBar(visible);
}
void MainWindow::on_menuExternal_aboutToShow()
{
#ifdef USE_SCREENS_FOR_EXTERNAL_MONITORING
foreach (QAction *action, m_externalGroup->actions()) {
bool ok = false;
int i = action->data().toInt(&ok);
if (ok && i < QGuiApplication::screens().count()) {
if (QGuiApplication::screens().at(i) == screen()) {
if (action->isChecked()) {
m_externalGroup->actions().first()->setChecked(true);
Settings.setPlayerExternal(QString());
}
action->setDisabled(true);
} else {
action->setEnabled(true);
}
}
}
#endif
}
void MainWindow::on_actionUpgrade_triggered()
{
if (Settings.askUpgradeAutomatic()) {
QMessageBox dialog(QMessageBox::Question,
qApp->applicationName(),
tr("Do you want to automatically check for updates in the future?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setWindowModality(QmlApplication::dialogModality());
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setCheckBox(
new QCheckBox(tr("Do not show this anymore.", "Automatic upgrade check dialog")));
Settings.setCheckUpgradeAutomatic(dialog.exec() == QMessageBox::Yes);
if (dialog.checkBox()->isChecked())
Settings.setAskUpgradeAutomatic(false);
}
showStatusMessage("Checking for upgrade...");
m_network.get(QNetworkRequest(QUrl("https://check.shotcut.org/version.json")));
}
void MainWindow::on_actionOpenXML_triggered()
{
QString path = Settings.openPath();
#ifdef Q_OS_MAC
path.append("/*");
#endif
QStringList filenames = QFileDialog::getOpenFileNames(this,
tr("Open File"),
path,
tr("MLT XML (*.mlt);;All Files (*)"),
nullptr,
Util::getFileDialogOptions());
if (filenames.length() > 0) {
QString url = filenames.first();
MltXmlChecker checker;
if (checker.check(url) == QXmlStreamReader::NoError) {
if (!isCompatibleWithGpuMode(checker, url))
return;
isXmlRepaired(checker, url);
} else {
showStatusMessage(tr("Failed to open ").append(url));
showIncompatibleProjectMessage(checker.shotcutVersion());
return;
}
Settings.setOpenPath(QFileInfo(url).path());
activateWindow();
if (filenames.length() > 1)
m_multipleFiles = filenames;
if (!MLT.openXML(url)) {
open(MLT.producer());
m_recentDock->add(url);
LOG_INFO() << url;
} else {
showStatusMessage(tr("Failed to open ") + url);
emit openFailed(url);
}
}
}
void MainWindow::on_actionShowProjectFolder_triggered()
{
Util::showInFolder(m_currentFile);
}
void MainWindow::onFocusChanged(QWidget *, QWidget *) const
{
LOG_DEBUG() << "Focuswidget changed";
LOG_DEBUG() << "Current focusWidget:" << QApplication::focusWidget();
LOG_DEBUG() << "Current focusObject:" << QApplication::focusObject();
LOG_DEBUG() << "Current focusWindow:" << QApplication::focusWindow();
}
void MainWindow::on_actionScrubAudio_triggered(bool checked)
{
Settings.setPlayerScrubAudio(checked);
}
#if !defined(Q_OS_MAC)
void MainWindow::onDrawingMethodTriggered(QAction *action)
{
Settings.setDrawMethod(action->data().toInt());
QMessageBox dialog(QMessageBox::Information,
qApp->applicationName(),
tr("You must restart Shotcut to change the display method.\n"
"Do you want to restart now?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() == QMessageBox::Yes) {
m_exitCode = EXIT_RESTART;
QApplication::closeAllWindows();
}
}
#endif
void MainWindow::on_actionResources_triggered()
{
ResourceDialog dialog(this);
dialog.search(multitrack());
dialog.search(playlist());
dialog.exec();
}
void MainWindow::on_actionApplicationLog_triggered()
{
TextViewerDialog dialog(this);
QDir dir = Settings.appDataLocation();
QFile logFile(dir.filePath("shotcut-log.txt"));
logFile.open(QIODevice::ReadOnly | QIODevice::Text);
dialog.setText(logFile.readAll());
logFile.close();
dialog.setWindowTitle(tr("Application Log"));
const auto previousLogName = dir.filePath("shotcut-log.bak");
if (QFile::exists(previousLogName)) {
auto button = dialog.buttonBox()->addButton(tr("Previous"), QDialogButtonBox::ActionRole);
connect(button, &QAbstractButton::clicked, this, [&]() {
QFile logFile(previousLogName);
logFile.open(QIODevice::ReadOnly | QIODevice::Text);
dialog.setText(logFile.readAll());
logFile.close();
button->setEnabled(false);
});
}
dialog.exec();
}
void MainWindow::on_actionClose_triggered()
{
m_timelineDock->stopRecording();
if (continueModified()) {
LOG_DEBUG() << "";
QMutexLocker locker(&m_autosaveMutex);
m_autosaveFile.reset();
locker.unlock();
setCurrentFile("");
MLT.resetURL();
MLT.setProjectFolder(QString());
ui->actionSave->setEnabled(false);
MLT.stop();
if (MLT.consumer() && MLT.consumer()->is_valid())
MLT.consumer()->purge();
QCoreApplication::processEvents();
if (multitrack())
m_timelineDock->model()->close();
if (playlist())
m_playlistDock->model()->close();
else
onMultitrackClosed();
closeProducer();
m_notesDock->setText("");
m_player->enableTab(Player::SourceTabIndex, false);
MLT.purgeMemoryPool();
}
}
void MainWindow::onPlayerTabIndexChanged(int index)
{
if (Player::SourceTabIndex == index)
m_timelineDock->saveAndClearSelection();
else
m_timelineDock->restoreSelection();
}
void MainWindow::onUpgradeCheckFinished(QNetworkReply *reply)
{
if (!reply->error()) {
QByteArray response = reply->readAll();
LOG_DEBUG() << "response: " << response;
QJsonDocument json = QJsonDocument::fromJson(response);
QString current = qApp->applicationVersion();
if (!json.isNull() && json.object().value("version_string").type() == QJsonValue::String) {
QString latest = json.object().value("version_string").toString();
if (current != "adhoc"
&& QVersionNumber::fromString(current) < QVersionNumber::fromString(latest)) {
QAction *action = new QAction(
tr("Shotcut version %1 is available! Click here to get it.").arg(latest), 0);
connect(action, SIGNAL(triggered(bool)), SLOT(onUpgradeTriggered()));
if (!json.object().value("url").isUndefined())
m_upgradeUrl = json.object().value("url").toString();
showStatusMessage(action, 15 /* seconds */);
} else {
showStatusMessage(tr("You are running the latest version of Shotcut."));
}
reply->deleteLater();
return;
} else {
LOG_WARNING() << "failed to parse version.json";
}
} else {
LOG_WARNING() << reply->errorString();
if (reply->error() == QNetworkReply::UnknownNetworkError) {
m_network.get(QNetworkRequest(QUrl("http://check.shotcut.org/version.json")));
}
}
QAction *action = new QAction(
tr("Failed to read version.json when checking. Click here to go to the Web site."), 0);
connect(action, SIGNAL(triggered(bool)), SLOT(onUpgradeTriggered()));
showStatusMessage(action);
reply->deleteLater();
}
void MainWindow::onUpgradeTriggered()
{
Util::openUrl(QUrl(m_upgradeUrl));
}
void MainWindow::onClipCopied()
{
// DISABLED: MLT player tab enabling
// m_player->enableTab(Player::SourceTabIndex);
}
void MainWindow::on_actionExportEDL_triggered()
{
// Dialog to get export file name.
QString path = Settings.savePath();
QString caption = tr("Export EDL");
QString saveFileName = QFileDialog::getSaveFileName(this,
caption,
path,
tr("EDL (*.edl);;All Files (*)"),
nullptr,
Util::getFileDialogOptions());
if (!saveFileName.isEmpty()) {
QFileInfo fi(saveFileName);
if (fi.suffix() != "edl")
saveFileName += ".edl";
if (Util::warnIfNotWritable(saveFileName, this, caption))
return;
// Locate the JavaScript file in the filesystem.
QDir qmlDir = QmlUtilities::qmlDir();
qmlDir.cd("export-edl");
QString jsFileName = qmlDir.absoluteFilePath("export-edl.js");
QFile scriptFile(jsFileName);
if (scriptFile.open(QIODevice::ReadOnly)) {
// Read JavaScript into a string.
QTextStream stream(&scriptFile);
stream.setEncoding(QStringConverter::Utf8);
stream.setAutoDetectUnicode(true);
QString contents = stream.readAll();
scriptFile.close();
// Evaluate JavaScript.
QJSEngine jsEngine;
QJSValue result = jsEngine.evaluate(contents, jsFileName);
if (!result.isError()) {
// Call the JavaScript main function.
QJSValue options = jsEngine.newObject();
options.setProperty("useBaseNameForReelName", true);
options.setProperty("useBaseNameForClipComment", true);
options.setProperty("channelsAV", "AA/V");
QJSValueList args;
args << MLT.XML(0, true, true) << options;
result = result.call(args);
if (!result.isError()) {
// Save the result with the export file name.
QFile f(saveFileName);
f.open(QIODevice::WriteOnly | QIODevice::Text);
f.write(result.toString().toUtf8());
f.close();
}
}
if (result.isError()) {
LOG_ERROR() << "Uncaught exception at line" << result.property("lineNumber").toInt()
<< ":" << result.toString();
showStatusMessage(tr("A JavaScript error occurred during export."));
}
} else {
showStatusMessage(tr("Failed to open export-edl.js"));
}
}
}
void MainWindow::on_actionExportFrame_triggered()
{
if (!MLT.producer() || !MLT.producer()->is_valid())
return;
filterController()->setCurrentFilter(QmlFilter::DeselectCurrentFilter);
auto *videoWidget = qobject_cast(MLT.videoWidget());
connect(videoWidget, &Mlt::VideoWidget::imageReady, this, &MainWindow::onVideoWidgetImageReady);
MLT.setPreviewScale(0);
videoWidget->requestImage();
MLT.refreshConsumer();
}
void MainWindow::onVideoWidgetImageReady()
{
auto *videoWidget = qobject_cast(MLT.videoWidget());
QImage image = videoWidget->image();
disconnect(videoWidget, SIGNAL(imageReady()), this, nullptr);
if (Settings.playerGPU() || Settings.playerPreviewScale()) {
MLT.setPreviewScale(Settings.playerPreviewScale());
}
if (!image.isNull()
&& (videoWidget->imageIsProxy() || (MLT.isMultitrack() && Settings.proxyEnabled()))
) {
QMessageBox dialog(
QMessageBox::Question,
tr("Export frame from proxy?"),
tr("This frame may be from a lower resolution proxy instead of the original source.\n\n"
"Do you still want to continue?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() != QMessageBox::Yes) {
return;
}
}
if (!image.isNull()) {
SaveImageDialog dialog(this, tr("Export Frame"), image);
dialog.exec();
if (!dialog.saveFile().isEmpty()) {
m_recentDock->add(dialog.saveFile());
}
} else {
showStatusMessage(tr("Unable to export frame."));
}
}
void MainWindow::on_actionAppDataSet_triggered()
{
QMessageBox dialog(QMessageBox::Information,
qApp->applicationName(),
tr("You must restart Shotcut to change the data directory.\n"
"Do you want to continue?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() != QMessageBox::Yes)
return;
QString dirName = QFileDialog::getExistingDirectory(this,
tr("Data Directory"),
Settings.appDataLocation(),
Util::getFileDialogOptions());
if (!dirName.isEmpty()) {
// Move the data files.
QDirIterator it(Settings.appDataLocation());
while (it.hasNext()) {
if (!it.filePath().isEmpty() && it.fileName() != "." && it.fileName() != "..") {
if (!QFile::exists(dirName + "/" + it.fileName())) {
if (it.fileInfo().isDir()) {
if (!QFile::rename(it.filePath(), dirName + "/" + it.fileName()))
LOG_WARNING() << "Failed to move" << it.filePath() << "to"
<< dirName + "/" + it.fileName();
} else {
if (!QFile::copy(it.filePath(), dirName + "/" + it.fileName()))
LOG_WARNING() << "Failed to copy" << it.filePath() << "to"
<< dirName + "/" + it.fileName();
}
}
}
it.next();
}
writeSettings();
Settings.setAppDataLocally(dirName);
m_exitCode = EXIT_RESTART;
QApplication::closeAllWindows();
}
}
void MainWindow::on_actionAppDataShow_triggered()
{
// Make the transitions sub-folder if it does not exist
QmlApplication::wipes();
Util::showInFolder(Settings.appDataLocation());
}
void MainWindow::on_actionNew_triggered()
{
on_actionClose_triggered();
}
void MainWindow::on_actionScreenSnapshot_triggered()
{
auto fileName = QmlApplication::getNextProjectFile("screenshot-.png");
if (fileName.isEmpty()) {
fileName = Settings.savePath() + "/%1.png";
fileName = QFileDialog::getSaveFileName(this,
tr("Screen Snapshot"),
fileName.arg(tr("screenshot")),
tr("PNG Files (*.png)"));
if (fileName.isEmpty())
return;
// Ensure the filename ends with .png
if (!fileName.endsWith(".png", Qt::CaseInsensitive)) {
fileName += ".png";
}
}
const bool maximized = windowState() & Qt::WindowMaximized;
const auto mode = ScreenCapture::isWayland() ? ScreenCapture::Fullscreen
: ScreenCapture::Interactive;
m_screenCapture = new ScreenCapture(fileName, mode, this);
connect(m_screenCapture, &ScreenCapture::minimizeShotcut, this, [this]() { showMinimized(); });
connect(m_screenCapture, &ScreenCapture::finished, this, [=](bool success) {
if (success)
// Automatically open the captured file
QTimer::singleShot(500, this, [this, fileName]() { open(fileName); });
if (maximized)
showMaximized();
else
showNormal();
});
m_screenCapture->startSnapshot();
}
void MainWindow::on_actionScreenRecording_triggered()
{
QString filenameExtension;
auto mode = ScreenCapture::Interactive;
#ifdef Q_OS_WIN
Util::openUrl({"ms-screenclip:?type=recording", QUrl::TolerantMode});
return;
#elif defined(Q_OS_MAC)
filenameExtension = ".mov";
#else
bool isGNOMEorKDEonWayland = false;
// GNOME and KDE have built-in screen recording compatible with Wayland
if (ScreenCapture::isWayland()) {
const auto desktop = qEnvironmentVariable("XDG_CURRENT_DESKTOP").toLower();
isGNOMEorKDEonWayland = desktop.contains("gnome") || desktop.contains("kde")
|| desktop.contains("plasma");
if (isGNOMEorKDEonWayland) {
filenameExtension = ".webm";
mode = ScreenCapture::Fullscreen;
}
} else {
filenameExtension = ".mp4";
}
#endif
QString fileName;
if (!filenameExtension.isEmpty()) {
fileName = QmlApplication::getNextProjectFile("screen-" + filenameExtension);
if (fileName.isEmpty()) {
fileName = Settings.savePath() + "/%1" + filenameExtension;
fileName = QFileDialog::getSaveFileName(this,
tr("Screen Recording"),
fileName.arg(tr("screen")),
QString("%1 %2 (*%3)")
.arg(filenameExtension.toUpper(),
tr("Files"),
filenameExtension));
if (fileName.isEmpty())
return;
// Ensure the filename ends with extension
if (!fileName.endsWith(filenameExtension, Qt::CaseInsensitive)) {
fileName += filenameExtension;
}
}
}
#ifdef Q_OS_MAC
ScreenCaptureJob *job = new ScreenCaptureJob(tr("Screen Recording"), fileName, QRect(), true);
JOBS.add(job);
return;
#elif defined(Q_OS_UNIX) && !defined(Q_OS_MAC)
// On Linux with Wayland and not GNOME or KDE
if (ScreenCapture::isWayland() && !isGNOMEorKDEonWayland) {
// Let user pick a program to use on Wayland and not GNOME or KDE.
// OBS Studio (default) supports Wayland.
QString exePath = Settings.screenRecorderPath();
// Check if saved path is still valid
if (!exePath.isEmpty() && !QFile::exists(exePath)) {
exePath.clear();
}
// If not found, prompt user
if (exePath.isEmpty()) {
exePath = Util::getExecutable(this);
if (exePath.isEmpty()) {
return; // User cancelled
}
Settings.setScreenRecorderPath(exePath);
}
// Launch the screen recorder
if (Util::startDetached(exePath, QStringList())) {
showStatusMessage(tr("Screen recorder launched"));
} else {
showStatusMessage(tr("Failed to launch screen recorder"));
}
return;
}
#endif
m_screenCapture = new ScreenCapture(fileName, mode, this);
connect(m_screenCapture, &ScreenCapture::minimizeShotcut, this, [this]() { showMinimized(); });
connect(m_screenCapture,
&ScreenCapture::beginRecording,
this,
[=](const QRect &rect, bool recordAudio) {
ScreenCaptureJob *job
= new ScreenCaptureJob(tr("Screen Recording"), fileName, rect, recordAudio);
JOBS.add(job);
});
m_screenCapture->startRecording();
}
void MainWindow::on_actionKeyboardShortcuts_triggered()
{
auto name = QString::fromLatin1("actionsDialog");
auto dialog = QObject::findChild(name, Qt::FindDirectChildrenOnly);
if (!dialog) {
dialog = new ActionsDialog(this);
dialog->setObjectName(name);
}
dialog->show();
dialog->activateWindow();
dialog->raise();
}
void MainWindow::on_actionLayoutLogging_triggered()
{
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Logging);
auto state = Settings.layoutState(QString(kReservedLayoutPrefix).arg(LayoutMode::Logging));
if (state.isEmpty()) {
restoreState(kLayoutLoggingDefault);
// setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
// setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
// setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
// setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
// resizeDocks({m_playlistDock, m_propertiesDock},
// {qFloor(width() * 0.25), qFloor(width() * 0.25)}, Qt::Horizontal);
} else {
// LOG_DEBUG() << state.toBase64();
restoreState(state);
}
Settings.setWindowState(saveState());
resetFilterMenuIfNeeded();
}
void MainWindow::on_actionLayoutEditing_triggered()
{
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Editing);
auto state = Settings.layoutState(QString(kReservedLayoutPrefix).arg(LayoutMode::Editing));
if (state.isEmpty()) {
restoreState(kLayoutEditingDefault);
// resetDockCorners();
} else {
// LOG_DEBUG() << state.toBase64();
restoreState(state);
}
Settings.setWindowState(saveState());
resetFilterMenuIfNeeded();
}
void MainWindow::on_actionLayoutEffects_triggered()
{
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Effects);
auto state = Settings.layoutState(QString(kReservedLayoutPrefix).arg(LayoutMode::Effects));
if (state.isEmpty()) {
restoreState(kLayoutEffectsDefault);
// resetDockCorners();
} else {
// LOG_DEBUG() << state.toBase64();
restoreState(state);
}
Settings.setWindowState(saveState());
resetFilterMenuIfNeeded();
}
void MainWindow::on_actionLayoutColor_triggered()
{
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Color);
auto state = Settings.layoutState(QString(kReservedLayoutPrefix).arg(LayoutMode::Color));
if (state.isEmpty()) {
restoreState(kLayoutColorDefault);
// setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
// setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
// setCorner(Qt::BottomLeftCorner, Qt::BottomDockWidgetArea);
// setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
} else {
// LOG_DEBUG() << state.toBase64();
restoreState(state);
}
Settings.setWindowState(saveState());
// Set filter menu to Video filters for Color layout
filterController()->metadataModel()->setFilter(MetadataModel::VideoFilter);
filterController()->metadataModel()->setSearch("#color");
}
void MainWindow::on_actionLayoutAudio_triggered()
{
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Audio);
auto state = Settings.layoutState(QString(kReservedLayoutPrefix).arg(LayoutMode::Audio));
if (state.isEmpty()) {
restoreState(kLayoutAudioDefault);
// setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
// setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
// setCorner(Qt::BottomLeftCorner, Qt::BottomDockWidgetArea);
// setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
} else {
// LOG_DEBUG() << state.toBase64();
restoreState(state);
}
Settings.setWindowState(saveState());
// Set filter menu to Audio filters for Audio layout
filterController()->metadataModel()->setFilter(MetadataModel::AudioFilter);
filterController()->metadataModel()->setSearch("");
}
void MainWindow::on_actionLayoutPlayer_triggered()
{
if (isMultitrackValid()) {
// Clearing selection causes Filters to clear, which prevents showing a filter's VUI
m_timelineDock->setSelection();
}
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::PlayerOnly);
auto state = Settings.layoutState(QString(kReservedLayoutPrefix).arg(LayoutMode::PlayerOnly));
if (state.isEmpty()) {
restoreState(kLayoutPlayerDefault);
// resetDockCorners();
} else {
// LOG_DEBUG() << state.toBase64();
restoreState(state);
}
Settings.setWindowState(saveState());
resetFilterMenuIfNeeded();
}
void MainWindow::on_actionLayoutPlaylist_triggered()
{
if (Settings.layoutMode() != LayoutMode::Custom) {
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Custom);
}
clearCurrentLayout();
restoreState(Settings.windowStateDefault());
m_recentDock->show();
m_recentDock->raise();
m_playlistDock->show();
m_playlistDock->raise();
Settings.setWindowState(saveState());
}
void MainWindow::on_actionLayoutClip_triggered()
{
if (Settings.layoutMode() != LayoutMode::Custom) {
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Custom);
}
clearCurrentLayout();
restoreState(Settings.windowStateDefault());
m_recentDock->show();
m_recentDock->raise();
m_filtersDock->show();
m_filtersDock->raise();
Settings.setWindowState(saveState());
resetFilterMenuIfNeeded();
}
void MainWindow::on_actionLayoutAdd_triggered()
{
QInputDialog dialog(this);
dialog.setInputMode(QInputDialog::TextInput);
dialog.setWindowTitle(tr("Add Custom Layout"));
dialog.setLabelText(tr("Name"));
dialog.setWindowModality(QmlApplication::dialogModality());
auto result = dialog.exec();
auto name = dialog.textValue();
if (result == QDialog::Accepted && !name.isEmpty()) {
if (Settings.setLayout(name, saveGeometry(), saveState())) {
Settings.setLayoutMode();
clearCurrentLayout();
Settings.sync();
if (Settings.layouts().size() == 1) {
ui->menuLayout->addAction(ui->actionLayoutRemove);
ui->menuLayout->addSeparator();
}
ui->menuLayout->addAction(addLayout(m_layoutGroup, name));
}
}
}
void MainWindow::onLayoutTriggered(QAction *action)
{
if (Settings.layoutMode() != LayoutMode::Custom) {
Settings.setLayout(QString(kReservedLayoutPrefix).arg(Settings.layoutMode()),
QByteArray(),
saveState());
Settings.setLayoutMode(LayoutMode::Custom);
}
clearCurrentLayout();
restoreState(Settings.layoutState(action->text()));
Settings.setWindowState(saveState());
resetFilterMenuIfNeeded();
}
void MainWindow::on_actionProfileRemove_triggered()
{
QDir dir(Settings.appDataLocation());
if (dir.cd("profiles")) {
// Setup the dialog.
QStringList profiles = dir.entryList(QDir::Files | QDir::NoDotAndDotDot | QDir::Readable);
ListSelectionDialog dialog(profiles, this);
dialog.setWindowModality(QmlApplication::dialogModality());
dialog.setWindowTitle(tr("Remove Video Mode"));
// Show the dialog.
if (dialog.exec() == QDialog::Accepted) {
removeCustomProfiles(dialog.selection(),
dir,
customProfileMenu(),
actionProfileRemove());
}
}
}
void MainWindow::on_actionLayoutRemove_triggered()
{
// Setup the dialog.
ListSelectionDialog dialog(Settings.layouts(), this);
dialog.setWindowModality(QmlApplication::dialogModality());
dialog.setWindowTitle(tr("Remove Layout"));
// Show the dialog.
if (dialog.exec() == QDialog::Accepted) {
foreach (const QString &layout, dialog.selection()) {
// Update the configuration.
if (Settings.removeLayout(layout))
Settings.sync();
// Locate the menu item.
foreach (QAction *action, ui->menuLayout->actions()) {
if (action->text() == layout) {
// Remove the menu item.
delete action;
break;
}
}
}
// If no more custom layouts.
if (Settings.layouts().size() == 0) {
// Remove the Remove action and separator.
ui->menuLayout->removeAction(ui->actionLayoutRemove);
bool isSecondSeparator = false;
foreach (QAction *action, ui->menuLayout->actions()) {
if (action->isSeparator()) {
if (isSecondSeparator) {
delete action;
break;
} else {
isSecondSeparator = true;
}
}
}
}
}
}
void MainWindow::on_actionOpenOther2_triggered()
{
const auto widget = ui->mainToolBar->widgetForAction(ui->actionOpenOther2);
ui->actionOpenOther2->menu()->popup(widget->mapToGlobal(QPoint(0, widget->height())));
}
void MainWindow::onOpenOtherTriggered(QWidget *widget)
{
m_producerWidget.reset(widget);
auto dialog = new QDialog(this);
dialog->resize(426, 288);
dialog->setWindowModality(QmlApplication::dialogModality());
auto vlayout = new QVBoxLayout(dialog);
vlayout->addWidget(widget);
auto buttonBox = new QDialogButtonBox(dialog);
buttonBox->setOrientation(Qt::Horizontal);
buttonBox->setStandardButtons(QDialogButtonBox::Cancel | QDialogButtonBox::Open);
if (!AbstractProducerWidget::isDevice(widget)) {
auto button = buttonBox->addButton(tr("Add To Timeline"), QDialogButtonBox::ApplyRole);
connect(button, &QPushButton::clicked, this, [=]() { dialog->done(-1); });
}
vlayout->addWidget(buttonBox);
connect(buttonBox, &QDialogButtonBox::accepted, dialog, &QDialog::accept);
connect(buttonBox, &QDialogButtonBox::rejected, dialog, &QDialog::reject);
connect(dialog, &QDialog::finished, this, &MainWindow::onOpenOtherFinished);
dialog->show();
}
void MainWindow::onOpenOtherFinished(int result)
{
// Handle screen capture custom result codes
if (result == 42) { // Screen Snapshot
on_actionScreenSnapshot_triggered();
return;
} else if (result == 43) { // Screen Recording
on_actionScreenRecording_triggered();
return;
}
if (QDialog::Rejected == result || !m_producerWidget)
return;
if (AbstractProducerWidget::isDevice(m_producerWidget.get()) && !Settings.playerGPU())
closeProducer();
const auto name = m_producerWidget->objectName();
auto dialog = dynamic_cast(m_producerWidget.get());
if (QLatin1String("GlaxnimateProducerWidget") == name) {
auto glax = qobject_cast(m_producerWidget.get());
glax->setLaunchOnNew(false);
}
auto &profile = MLT.profile();
auto producer = dialog->newProducer(profile);
if (!(producer && producer->is_valid())) {
delete producer;
m_producerWidget.reset();
return;
}
if (!profile.is_explicit()) {
profile.from_producer(*producer);
profile.set_width(Util::coerceMultiple(profile.width()));
profile.set_height(Util::coerceMultiple(profile.height()));
}
MLT.updatePreviewProfile();
setPreviewScale(Settings.playerPreviewScale());
if (QDialog::Accepted == result) {
// open in the source player
open(producer);
// Mlt::Controller owns the producer now
} else {
m_player->switchToTab(Player::ProjectTabIndex);
auto trackType = (QLatin1String("ToneProducerWidget") == name) ? AudioTrackType
: VideoTrackType;
auto trackIndex = m_timelineDock->addTrackIfNeeded(trackType);
m_timelineDock->overwrite(trackIndex, -1, MLT.XML(producer), false);
delete producer;
}
if (QLatin1String("TextProducerWidget") == name) {
m_filtersDock->show();
m_filtersDock->raise();
} else {
m_propertiesDock->show();
m_propertiesDock->raise();
}
m_producerWidget.reset();
}
void MainWindow::onOpenOtherTriggered()
{
if (sender()->objectName() == "color")
onOpenOtherTriggered(new ColorProducerWidget(this));
else if (sender()->objectName() == "text")
onOpenOtherTriggered(new TextProducerWidget(this));
else if (sender()->objectName() == "glaxnimate")
onOpenOtherTriggered(new GlaxnimateProducerWidget(this));
else if (sender()->objectName() == "noise")
onOpenOtherTriggered(new NoiseWidget(this));
else if (sender()->objectName() == "ising0r")
onOpenOtherTriggered(new IsingWidget(this));
else if (sender()->objectName() == "lissajous0r")
onOpenOtherTriggered(new LissajousWidget(this));
else if (sender()->objectName() == "plasma")
onOpenOtherTriggered(new PlasmaWidget(this));
else if (sender()->objectName() == "test_pat_B")
onOpenOtherTriggered(new ColorBarsWidget(this));
else if (sender()->objectName() == "tone")
onOpenOtherTriggered(new ToneProducerWidget(this));
else if (sender()->objectName() == "count")
onOpenOtherTriggered(new CountProducerWidget(this));
else if (sender()->objectName() == "blipflash")
onOpenOtherTriggered(new BlipProducerWidget(this));
}
void MainWindow::onHtmlGeneratorTriggered()
{
if (!Util::isChromiumAvailable()) {
QMessageBox
dialog(QMessageBox::Warning,
QApplication::applicationName(),
this->tr(
"This feature requires Google Chrome or a Chromium-based browser.
"
"If you already installed one it could not be "
"found at the expected location: %1
Click OK to "
"continue and locate the program on your system.
")
.arg(Settings.chromiumPath()),
QMessageBox::Cancel | QMessageBox::Ok,
this);
dialog.setWindowModality(QmlApplication::dialogModality());
dialog.setDefaultButton(QMessageBox::Ok);
dialog.setEscapeButton(QMessageBox::Cancel);
if (QMessageBox::Cancel == dialog.exec())
return;
const auto executable = Util::getExecutable(this);
if (executable.isEmpty())
return;
Settings.setChromiumPath(executable);
}
// Create a color producer with special property and open it
auto producer = new Mlt::Producer(MLT.profile(), "color", "#00000000");
producer->set(kPrivateProducerProperty, "htmlGenerator");
open(producer, false);
m_propertiesDock->show();
m_propertiesDock->raise();
m_producerWidget.reset();
}
void MainWindow::on_actionClearRecentOnExit_toggled(bool arg1)
{
Settings.setClearRecent(arg1);
if (arg1) {
Settings.setRecent(QStringList());
Settings.setProjects(QStringList());
}
}
void MainWindow::onSceneGraphInitialized()
{
if (Settings.playerGPU() && Settings.playerWarnGPU()) {
QMessageBox
dialog(QMessageBox::Warning,
qApp->applicationName(),
tr("GPU processing is EXPERIMENTAL, UNSTABLE and UNSUPPORTED! Unsupported "
"means do not report bugs about it.\n\n"
"Do you want to disable GPU processing and restart Shotcut?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() == QMessageBox::Yes) {
Settings.setProcessingMode(ShotcutSettings::Native8Cpu);
m_exitCode = EXIT_RESTART;
QApplication::closeAllWindows();
}
}
auto videoWidget = (Mlt::VideoWidget *) &(MLT);
videoWidget->setBlankScene();
}
void MainWindow::on_actionShowTextUnderIcons_toggled(bool b)
{
ui->mainToolBar->setToolButtonStyle(b ? Qt::ToolButtonTextUnderIcon : Qt::ToolButtonIconOnly);
Settings.setTextUnderIcons(b);
updateLayoutSwitcher();
if (b && this->width() < 1800) {
ui->mainToolBar->removeAction(ui->actionOpenOther2);
ui->mainToolBar->removeAction(ui->actionFiles);
ui->mainToolBar->removeAction(ui->actionMarkers);
ui->mainToolBar->removeAction(ui->actionNotes);
}
}
void MainWindow::on_actionShowSmallIcons_toggled(bool b)
{
ui->mainToolBar->setIconSize(b ? QSize(16, 16) : QSize());
Settings.setSmallIcons(b);
updateLayoutSwitcher();
}
void MainWindow::onPlaylistInChanged(int in)
{
// DISABLED: MLT player in point setting
// m_player->blockSignals(true);
// m_player->setIn(in);
// m_player->blockSignals(false);
Q_UNUSED(in)
}
void MainWindow::onPlaylistOutChanged(int out)
{
// DISABLED: MLT player out point setting
// m_player->blockSignals(true);
// m_player->setOut(out);
// m_player->blockSignals(false);
Q_UNUSED(out)
}
void MainWindow::on_actionPreviewNone_triggered(bool checked)
{
if (checked) {
Settings.setPlayerPreviewScale(0);
setPreviewScale(0);
m_player->showIdleStatus();
}
}
void MainWindow::on_actionPreview360_triggered(bool checked)
{
// DISABLED: MLT player preview scaling
// if (checked) {
// Settings.setPlayerPreviewScale(360);
// setPreviewScale(360);
// m_player->showIdleStatus();
// }
Q_UNUSED(checked)
}
void MainWindow::on_actionPreview540_triggered(bool checked)
{
// DISABLED: MLT player preview scaling
// if (checked) {
// Settings.setPlayerPreviewScale(540);
// setPreviewScale(540);
// m_player->showIdleStatus();
// }
Q_UNUSED(checked)
}
void MainWindow::on_actionPreview720_triggered(bool checked)
{
if (checked) {
Settings.setPlayerPreviewScale(720);
setPreviewScale(720);
m_player->showIdleStatus();
}
}
void MainWindow::on_actionPreview1080_triggered(bool checked)
{
if (checked) {
Settings.setPlayerPreviewScale(1080);
setPreviewScale(1080);
m_player->showIdleStatus();
}
}
void MainWindow::on_actionPreviewHardwareDecoder_triggered(bool checked)
{
Settings.setPlayerPreviewHardwareDecoder(checked);
MLT.configureHardwareDecoder(checked);
MLT.reload(QString());
emit producerOpened(false);
}
QUuid MainWindow::timelineClipUuid(int trackIndex, int clipIndex)
{
auto info = m_timelineDock->model()->getClipInfo(trackIndex, clipIndex);
if (info && info->producer && info->producer->is_valid())
return MLT.ensureHasUuid(*info->producer);
return QUuid();
}
void MainWindow::replaceInTimeline(const QUuid &uuid, Mlt::Producer &producer)
{
int trackIndex = -1;
int clipIndex = -1;
// lookup the current track and clip index by UUID
auto info = m_timelineDock->model()->findClipByUuid(uuid, trackIndex, clipIndex);
if (info && trackIndex >= 0 && clipIndex >= 0) {
Util::getHash(producer);
Util::applyCustomProperties(producer,
*info->producer,
producer.get_in(),
producer.get_out());
m_timelineDock->replace(trackIndex, clipIndex, MLT.XML(&producer));
}
}
void MainWindow::replaceAllByHash(const QString &hash, Mlt::Producer &producer, bool isProxy)
{
Util::getHash(producer);
if (!isProxy)
m_recentDock->add(producer.get("resource"));
if (MLT.isClip() && Util::getHash(*MLT.producer()) == hash) {
Util::applyCustomProperties(producer,
*MLT.producer(),
MLT.producer()->get_in(),
MLT.producer()->get_out());
MLT.copyFilters(*MLT.producer(), producer);
MLT.close();
m_player->setPauseAfterOpen(true);
open(
new Mlt::Producer(MLT.profile(), "xml-string", MLT.XML(&producer).toUtf8().constData()));
} else if (MLT.savedProducer() && Util::getHash(*MLT.savedProducer()) == hash) {
Util::applyCustomProperties(producer,
*MLT.savedProducer(),
MLT.savedProducer()->get_in(),
MLT.savedProducer()->get_out());
MLT.copyFilters(*MLT.savedProducer(), producer);
MLT.setSavedProducer(&producer);
}
if (playlist()) {
if (isProxy) {
m_playlistDock->replaceClipsWithHash(hash, producer);
} else {
// Append to playlist
producer.set(kPlaylistIndexProperty, playlist()->count());
MAIN.undoStack()->push(
new Playlist::AppendCommand(*m_playlistDock->model(), MLT.XML(&producer)));
}
}
if (isMultitrackValid()) {
m_timelineDock->replaceClipsWithHash(hash, producer);
}
}
int MainWindow::mltIndexForTrack(int trackIndex) const
{
return m_timelineDock->model()->mltIndexForTrack(trackIndex);
}
int MainWindow::bottomVideoTrackIndex() const
{
return m_timelineDock->model()->bottomVideoTrackIndex();
}
void MainWindow::on_actionTopics_triggered()
{
Util::openUrl(QUrl("https://www.shotcut.org/howtos/"));
}
void MainWindow::on_actionWhatsThis_triggered()
{
QWhatsThis::enterWhatsThisMode();
}
void MainWindow::on_actionSync_triggered()
{
auto dialog = new SystemSyncDialog(this);
dialog->show();
dialog->raise();
dialog->activateWindow();
}
void MainWindow::on_actionUseProxy_triggered(bool checked)
{
// DISABLED: MLT proxy handling
// if (MLT.producer()) {
// QDir dir(m_currentFile.isEmpty() ? QDir::tempPath() : QFileInfo(m_currentFile).dir());
// QScopedPointer tmp(new QTemporaryFile(dir.filePath("shotcut-XXXXXX.mlt")));
// tmp->open();
// tmp->close();
// QString fileName = tmp->fileName();
// tmp->remove();
// tmp.reset();
// LOG_DEBUG() << fileName;
// if (saveXML(fileName)) {
// MltXmlChecker checker;
// Settings.setProxyEnabled(checked);
// checker.check(fileName);
// if (!isXmlRepaired(checker, fileName)) {
// QFile::remove(fileName);
// return;
// }
// if (checker.isUpdated()) {
// QFile::remove(fileName);
// fileName = checker.tempFile().fileName();
// }
// // Open the temporary file
// int result = 0;
// {
// LongUiTask longTask(checked ? tr("Turn Proxy On") : tr("Turn Proxy Off"));
// QFuture future = QtConcurrent::run([=]() {
// return MLT.open(QDir::fromNativeSeparators(fileName),
// QDir::fromNativeSeparators(m_currentFile));
// });
// result = longTask.wait(tr("Converting"), future);
// }
// if (!result) {
// auto position = m_player->position();
// m_undoStack->clear();
// m_player->stop();
// m_player->setPauseAfterOpen(true);
// open(MLT.producer());
// MLT.seek(m_player->position());
// m_player->seek(position);
// if (checked && (isPlaylistValid() || isMultitrackValid())) {
// // Prompt user if they want to create missing proxies
// QMessageBox dialog(
// QMessageBox::Question,
// qApp->applicationName(),
// tr("Do you want to create missing proxies for every file in this project?"),
// QMessageBox::No | QMessageBox::Yes,
// this);
// dialog.setWindowModality(QmlApplication::dialogModality());
// dialog.setDefaultButton(QMessageBox::Yes);
// dialog.setEscapeButton(QMessageBox::No);
// if (dialog.exec() == QMessageBox::Yes) {
// Mlt::Producer producer(playlist());
// if (producer.is_valid()) {
// ProxyManager::generateIfNotExistsAll(producer);
// }
// producer = multitrack();
// if (producer.is_valid()) {
// ProxyManager::generateIfNotExistsAll(producer);
// }
// }
// }
// } else if (fileName != untitledFileName()) {
// showStatusMessage(tr("Failed to open ") + fileName);
// emit openFailed(fileName);
// }
// } else {
// ui->actionUseProxy->setChecked(!checked);
// showSaveError();
// }
// QFile::remove(fileName);
// } else {
// Settings.setProxyEnabled(checked);
// }
// m_player->showIdleStatus();
Q_UNUSED(checked)
}
void MainWindow::on_actionProxyStorageSet_triggered()
{
// Present folder dialog just like App Data Directory
QString dirName = QFileDialog::getExistingDirectory(this,
tr("Proxy Folder"),
Settings.proxyFolder(),
Util::getFileDialogOptions());
if (!dirName.isEmpty() && dirName != Settings.proxyFolder()) {
auto oldFolder = Settings.proxyFolder();
Settings.setProxyFolder(dirName);
Settings.sync();
// Get a count for the progress dialog
auto oldDir = QDir(oldFolder);
auto dirList = oldDir.entryList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
auto count = dirList.size();
if (count > 0) {
// Prompt user if they want to create missing proxies
QMessageBox
dialog(QMessageBox::Question,
qApp->applicationName(),
tr("Do you want to move all files from the old folder to the new folder?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setWindowModality(QmlApplication::dialogModality());
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
if (dialog.exec() == QMessageBox::Yes) {
// Move the existing files
LongUiTask longTask(tr("Moving Files"));
int i = 0;
for (const auto &fileName : dirList) {
if (!fileName.isEmpty() && !QFile::exists(dirName + "/" + fileName)) {
LOG_DEBUG() << "moving" << oldDir.filePath(fileName) << "to"
<< dirName + "/" + fileName;
longTask.reportProgress(fileName, i++, count);
if (!QFile::rename(oldDir.filePath(fileName), dirName + "/" + fileName))
LOG_WARNING() << "Failed to move" << oldDir.filePath(fileName);
}
}
}
}
}
}
void MainWindow::on_actionProxyStorageShow_triggered()
{
Util::showInFolder(ProxyManager::dir().path());
}
void MainWindow::on_actionProxyUseProjectFolder_triggered(bool checked)
{
Settings.setProxyUseProjectFolder(checked);
}
void MainWindow::on_actionProxyUseHardware_triggered(bool checked)
{
if (checked && Settings.encodeHardware().isEmpty()) {
if (!m_encodeDock->detectHardwareEncoders())
ui->actionProxyUseHardware->setChecked(false);
}
Settings.setProxyUseHardware(ui->actionProxyUseHardware->isChecked());
}
void MainWindow::on_actionProxyConfigureHardware_triggered()
{
m_encodeDock->on_hwencodeButton_clicked();
if (Settings.encodeHardware().isEmpty()) {
ui->actionProxyUseHardware->setChecked(false);
Settings.setProxyUseHardware(false);
}
}
void MainWindow::updateLayoutSwitcher()
{
if (Settings.textUnderIcons() && !Settings.smallIcons()) {
auto layoutSwitcher = findChild(kLayoutSwitcherName);
if (layoutSwitcher) {
layoutSwitcher->show();
for (const auto &child : layoutSwitcher->findChildren()) {
child->show();
}
} else {
layoutSwitcher = new QWidget;
layoutSwitcher->setObjectName(kLayoutSwitcherName);
auto layoutGrid = new QGridLayout(layoutSwitcher);
layoutGrid->setContentsMargins(0, 0, 0, 0);
ui->mainToolBar->insertWidget(ui->dummyAction, layoutSwitcher);
auto button = new QToolButton;
button->setAutoRaise(true);
button->setDefaultAction(ui->actionLayoutLogging);
layoutGrid->addWidget(button, 0, 0, Qt::AlignCenter);
button = new QToolButton;
button->setAutoRaise(true);
button->setDefaultAction(ui->actionLayoutEditing);
layoutGrid->addWidget(button, 0, 1, Qt::AlignCenter);
button = new QToolButton;
button->setAutoRaise(true);
button->setDefaultAction(ui->actionLayoutEffects);
layoutGrid->addWidget(button, 0, 2, Qt::AlignCenter);
button = new QToolButton;
button->setAutoRaise(true);
button->setDefaultAction(ui->actionLayoutColor);
layoutGrid->addWidget(button, 1, 0, Qt::AlignCenter);
button = new QToolButton;
button->setAutoRaise(true);
button->setDefaultAction(ui->actionLayoutAudio);
layoutGrid->addWidget(button, 1, 1, Qt::AlignCenter);
button = new QToolButton;
button->setAutoRaise(true);
button->setDefaultAction(ui->actionLayoutPlayer);
layoutGrid->addWidget(button, 1, 2, Qt::AlignCenter);
}
ui->mainToolBar->removeAction(ui->actionLayoutLogging);
ui->mainToolBar->removeAction(ui->actionLayoutEditing);
ui->mainToolBar->removeAction(ui->actionLayoutEffects);
ui->mainToolBar->removeAction(ui->actionLayoutColor);
ui->mainToolBar->removeAction(ui->actionLayoutAudio);
ui->mainToolBar->removeAction(ui->actionLayoutPlayer);
} else {
auto layoutSwitcher = findChild(kLayoutSwitcherName);
if (layoutSwitcher) {
layoutSwitcher->hide();
for (const auto &child : layoutSwitcher->findChildren()) {
child->hide();
}
ui->mainToolBar->insertAction(ui->dummyAction, ui->actionLayoutLogging);
ui->mainToolBar->insertAction(ui->dummyAction, ui->actionLayoutEditing);
ui->mainToolBar->insertAction(ui->dummyAction, ui->actionLayoutEffects);
ui->mainToolBar->insertAction(ui->dummyAction, ui->actionLayoutColor);
ui->mainToolBar->insertAction(ui->dummyAction, ui->actionLayoutAudio);
ui->mainToolBar->insertAction(ui->dummyAction, ui->actionLayoutPlayer);
}
}
}
void MainWindow::clearCurrentLayout()
{
auto currentLayout = ui->actionLayoutLogging->actionGroup()->checkedAction();
if (currentLayout) {
currentLayout->setChecked(false);
}
}
void MainWindow::onClipboardChanged()
{
auto s = QGuiApplication::clipboard()->text();
if (MLT.isMltXml(s) && !s.contains(kShotcutFiltersClipboard)) {
m_clipboardUpdatedAt = QDateTime::currentDateTime();
LOG_DEBUG() << m_clipboardUpdatedAt;
}
}
void MainWindow::sourceUpdated()
{
if (MLT.isClip()) {
m_sourceUpdatedAt = QDateTime::currentDateTime();
}
}
void MainWindow::resetSourceUpdated()
{
m_sourceUpdatedAt.setSecsSinceEpoch(0);
}
void MainWindow::on_actionExportChapters_triggered()
{
// Options dialog
auto uniqueColors = m_timelineDock->markersModel()->allColors();
if (uniqueColors.isEmpty()) {
return;
}
std::sort(uniqueColors.begin(), uniqueColors.end(), [=](const QColor &a, const QColor &b) {
if (a.hue() == b.hue()) {
if (a.saturation() == b.saturation()) {
return a.value() <= b.value();
}
return a.saturation() <= b.saturation();
}
return a.hue() <= b.hue();
});
QStringList colors;
for (auto &color : uniqueColors) {
colors << color.name();
}
const auto rangesOption = tr("Include ranges (Duration > 1 frame)?");
QStringList initialOptions;
for (auto &m : m_timelineDock->markersModel()->getMarkers()) {
if (m.end != m.start) {
initialOptions << rangesOption;
break;
}
}
ListSelectionDialog dialog(initialOptions, this);
dialog.setWindowModality(QmlApplication::dialogModality());
dialog.setWindowTitle(tr("Choose Markers"));
if (Settings.exportRangeMarkers()) {
dialog.setSelection({rangesOption});
}
dialog.setColors(colors);
if (dialog.exec() != QDialog::Accepted) {
return;
}
auto selection = dialog.selection();
Settings.setExportRangeMarkers(selection.contains(rangesOption));
// Dialog to get export file name
QString path = Settings.savePath();
QString caption = tr("Export Chapters");
QString saveFileName = QFileDialog::getSaveFileName(this,
caption,
path,
tr("Text (*.txt);;All Files (*)"),
nullptr,
Util::getFileDialogOptions());
if (!saveFileName.isEmpty()) {
QFileInfo fi(saveFileName);
if (fi.suffix() != "txt")
saveFileName += ".txt";
if (Util::warnIfNotWritable(saveFileName, this, caption))
return;
// Locate the JavaScript file in the filesystem.
QDir qmlDir = QmlUtilities::qmlDir();
qmlDir.cd("export-chapters");
QString jsFileName = qmlDir.absoluteFilePath("export-chapters.js");
QFile scriptFile(jsFileName);
if (scriptFile.open(QIODevice::ReadOnly)) {
// Read JavaScript into a string.
QTextStream stream(&scriptFile);
stream.setEncoding(QStringConverter::Utf8);
stream.setAutoDetectUnicode(true);
QString contents = stream.readAll();
scriptFile.close();
// Evaluate JavaScript.
QJSEngine jsEngine;
QJSValue result = jsEngine.evaluate(contents, jsFileName);
if (!result.isError()) {
// Call the JavaScript main function.
QJSValue options = jsEngine.newObject();
if (selection.contains(rangesOption)) {
options.setProperty("includeRanges", true);
selection.removeOne(rangesOption);
}
QJSValue array = jsEngine.newArray(selection.size());
for (int i = 0; i < selection.size(); ++i)
array.setProperty(i, selection[i].toUpper());
options.setProperty("colors", array);
QJSValueList args;
args << MLT.XML(0, true, true) << options;
result = result.call(args);
if (!result.isError()) {
// Save the result with the export file name.
QFile f(saveFileName);
f.open(QIODevice::WriteOnly | QIODevice::Text);
f.write(result.toString().toUtf8());
f.close();
}
}
if (result.isError()) {
LOG_ERROR() << "Uncaught exception at line" << result.property("lineNumber").toInt()
<< ":" << result.toString();
showStatusMessage(tr("A JavaScript error occurred during export."));
}
} else {
showStatusMessage(tr("Failed to open export-chapters.js"));
}
}
}
void MainWindow::on_actionAudioVideoDevice_triggered()
{
QDialog dialog(this);
dialog.setWindowModality(QmlApplication::dialogModality());
auto layout = new QVBoxLayout(&dialog);
QWidget *widget = nullptr;
#if defined(Q_OS_LINUX)
widget = new Video4LinuxWidget;
dialog.resize(500, 400);
dialog.setSizeGripEnabled(true);
#elif defined(Q_OS_MAC)
widget = new AvfoundationProducerWidget;
dialog.resize(1, 1);
#elif defined(Q_OS_WIN)
widget = new DirectShowVideoWidget;
dialog.resize(1, 1);
#endif
layout->addWidget(widget);
auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
connect(buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
connect(buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
layout->addWidget(buttonBox);
if (dialog.exec() == QDialog::Accepted) {
Mlt::Profile profile;
profile.set_explicit(1);
delete dynamic_cast(widget)->newProducer(profile);
}
}
void MainWindow::on_actionReset_triggered()
{
QMessageBox
dialog(QMessageBox::Question,
qApp->applicationName(),
tr("This will reset all settings, and Shotcut must restart afterwards.\n"
"Do you want to reset and restart now?"),
QMessageBox::No | QMessageBox::Yes,
this);
dialog.setDefaultButton(QMessageBox::Yes);
dialog.setEscapeButton(QMessageBox::No);
dialog.setWindowModality(QmlApplication::dialogModality());
if (dialog.exec() == QMessageBox::Yes) {
Settings.reset();
m_exitCode = EXIT_RESET;
QApplication::closeAllWindows();
}
}
void MainWindow::onCreateOrEditFilterOnOutput(Mlt::Filter *filter, const QStringList &key_properties)
{
m_timelineDock->selectMultitrack();
onFiltersDockTriggered();
m_timelineDock->emitSelectedFromSelection();
m_filterController->addOrEditFilter(filter, key_properties);
}
void MainWindow::showSettingsMenu() const
{
QPoint point(140 * devicePixelRatioF(), ui->menuBar->height());
#if !defined(Q_OS_MAC)
point = ui->menuBar->mapToGlobal(point);
#endif
ui->menuSettings->popup(point, ui->menuSettings->defaultAction());
}