+ if (current) {
+ if (current->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB)
+ emit abortProcess(current->text(1));
+ else {
+ delete current;
+ slotCheckJob();
+ checkRenderStatus();
+ }
+ }
+}
+
+void RenderWidget::slotStartCurrentJob()
+{
+ QTreeWidgetItem *current = m_view.running_jobs->currentItem();
+ if (current && current->data(1, Qt::UserRole + 2).toInt() == WAITINGJOB)
+ startRendering(current);
+ m_view.start_job->setEnabled(false);
+}
+
+void RenderWidget::slotCheckJob()
+{
+ bool activate = false;
+ QTreeWidgetItem *current = m_view.running_jobs->currentItem();
+ if (current) {
+ if (current->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB) {
+ m_view.abort_job->setText(i18n("Abort Job"));
+ m_view.start_job->setEnabled(false);
+ } else {
+ m_view.abort_job->setText(i18n("Remove Job"));
+ m_view.start_job->setEnabled(current->data(1, Qt::UserRole + 2).toInt() == WAITINGJOB);
+ }
+ activate = true;
+ }
+ m_view.abort_job->setEnabled(activate);
+ for (int i = 0; i < m_view.running_jobs->topLevelItemCount(); i++) {
+ current = m_view.running_jobs->topLevelItem(i);
+ if (current == m_view.running_jobs->currentItem()) {
+ current->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 3));
+ } else current->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
+ }
+}
+
+void RenderWidget::slotCLeanUpJobs()
+{
+ int ix = 0;
+ QTreeWidgetItem *current = m_view.running_jobs->topLevelItem(ix);
+ while (current) {
+ if (current->data(1, Qt::UserRole + 2).toInt() == FINISHEDJOB)
+ delete current;
+ else ix++;
+ current = m_view.running_jobs->topLevelItem(ix);
+ }
+ slotCheckJob();
+}
+
+void RenderWidget::parseScriptFiles()
+{
+ QStringList scriptsFilter;
+ scriptsFilter << "*.sh";
+ m_view.scripts_list->clear();
+
+ QTreeWidgetItem *item;
+ // List the project scripts
+ QStringList scriptFiles = QDir(m_projectFolder + "scripts").entryList(scriptsFilter, QDir::Files);
+ for (int i = 0; i < scriptFiles.size(); ++i) {
+ KUrl scriptpath(m_projectFolder + "scripts/" + scriptFiles.at(i));
+ QString target;
+ QString renderer;
+ QString melt;
+ QFile file(scriptpath.path());
+ if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+ while (!file.atEnd()) {
+ QByteArray line = file.readLine();
+ if (line.startsWith("TARGET=")) {
+ target = QString(line).section("TARGET=", 1).simplified();
+ target.remove(QChar('"'));
+ } else if (line.startsWith("RENDERER=")) {
+ renderer = QString(line).section("RENDERER=", 1).simplified();
+ renderer.remove(QChar('"'));
+ } else if (line.startsWith("MELT=")) {
+ melt = QString(line).section("MELT=", 1).simplified();
+ melt.remove(QChar('"'));
+ }
+ }
+ file.close();
+ }
+ if (target.isEmpty()) continue;
+ item = new QTreeWidgetItem(m_view.scripts_list, QStringList() << QString() << scriptpath.fileName());
+ if (!renderer.isEmpty() && renderer.contains('/') && !QFile::exists(renderer)) {
+ item->setIcon(0, KIcon("dialog-cancel"));
+ item->setToolTip(1, i18n("Script contains wrong command: %1", renderer));
+ item->setData(0, Qt::UserRole, '1');
+ } else if (!melt.isEmpty() && melt.contains('/') && !QFile::exists(melt)) {
+ item->setIcon(0, KIcon("dialog-cancel"));
+ item->setToolTip(1, i18n("Script contains wrong command: %1", melt));
+ item->setData(0, Qt::UserRole, '1');
+ } else item->setIcon(0, KIcon("application-x-executable-script"));
+ item->setSizeHint(0, QSize(m_view.scripts_list->columnWidth(0), fontMetrics().height() * 2));
+ item->setData(1, Qt::UserRole, target.simplified());
+ item->setData(1, Qt::UserRole + 1, scriptpath.path());
+ }
+ bool activate = false;
+ QTreeWidgetItem *script = m_view.scripts_list->topLevelItem(0);
+ if (script) {
+ script->setSelected(true);
+ m_view.scripts_list->setCurrentItem(script);
+ activate = true;
+ }
+// m_view.start_script->setEnabled(activate);
+// m_view.delete_script->setEnabled(activate);
+}
+
+void RenderWidget::slotCheckScript()
+{
+ QTreeWidgetItem *current = m_view.scripts_list->currentItem();
+ if (current == NULL) return;
+ m_view.start_script->setEnabled(current->data(0, Qt::UserRole).toString().isEmpty());
+ m_view.delete_script->setEnabled(true);
+ for (int i = 0; i < m_view.scripts_list->topLevelItemCount(); i++) {
+ current = m_view.scripts_list->topLevelItem(i);
+ if (current == m_view.scripts_list->currentItem()) {
+ current->setSizeHint(1, QSize(m_view.scripts_list->columnWidth(1), fontMetrics().height() * 3));
+ } else current->setSizeHint(1, QSize(m_view.scripts_list->columnWidth(1), fontMetrics().height() * 2));
+ }
+}
+
+void RenderWidget::slotStartScript()
+{
+ QTreeWidgetItem *item = m_view.scripts_list->currentItem();
+ if (item) {
+ QString destination = item->data(1, Qt::UserRole).toString();
+ QString path = item->data(1, Qt::UserRole + 1).toString();
+ // Insert new job in queue
+ QTreeWidgetItem *renderItem;
+ QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(destination, Qt::MatchExactly, 1);
+ kDebug() << "------ START SCRIPT";
+ if (!existing.isEmpty()) {
+ renderItem = existing.at(0);
+ if (renderItem->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB) {
+ KMessageBox::information(this, i18n("There is already a job writing file:<br /><b>%1</b><br />Abort the job if you want to overwrite it...", destination), i18n("Already running"));
+ return;
+ }
+ } else renderItem = new QTreeWidgetItem(m_view.running_jobs, QStringList() << QString() << destination << QString());
+ kDebug() << "------ START SCRIPT 2";
+ renderItem->setData(2, Qt::UserRole, 0);
+ renderItem->setData(1, Qt::UserRole + 2, WAITINGJOB);
+ renderItem->setIcon(0, KIcon("media-playback-pause"));
+ renderItem->setData(1, Qt::UserRole, i18n("Waiting..."));
+ renderItem->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
+ renderItem->setData(1, Qt::UserRole + 1, QTime::currentTime());
+ renderItem->setData(1, Qt::UserRole + 3, path);
+ renderItem->setData(1, Qt::UserRole + 4, '1');
+ checkRenderStatus();
+ m_view.tabWidget->setCurrentIndex(1);
+ }
+}
+
+void RenderWidget::slotDeleteScript()
+{
+ QTreeWidgetItem *item = m_view.scripts_list->currentItem();
+ if (item) {
+ QString path = item->data(1, Qt::UserRole + 1).toString();
+ KIO::NetAccess::del(path + ".mlt", this);
+ KIO::NetAccess::del(path, this);
+ parseScriptFiles();
+ }
+}
+
+void RenderWidget::slotGenerateScript()
+{
+ slotPrepareExport(true);
+}
+
+void RenderWidget::slotHideLog()
+{
+ m_view.error_box->setVisible(false);
+}
+
+void RenderWidget::setRenderProfile(QMap <QString, QString> props)
+{
+ m_view.destination_list->blockSignals(true);
+ m_view.format_list->blockSignals(true);
+ m_view.scanning_list->setCurrentIndex(props.value("renderscanning").toInt());
+ int exportAudio = props.value("renderexportaudio").toInt();
+ switch (exportAudio) {
+ case 1:
+ m_view.export_audio->setCheckState(Qt::Unchecked);
+ break;
+ case 2:
+ m_view.export_audio->setCheckState(Qt::Checked);
+ break;
+ default:
+ m_view.export_audio->setCheckState(Qt::PartiallyChecked);
+ }
+ if (props.contains("renderrescale")) m_view.rescale->setChecked(props.value("renderrescale").toInt());
+ if (props.contains("renderrescalewidth")) m_view.rescale_width->setValue(props.value("renderrescalewidth").toInt());
+ if (props.contains("renderrescaleheight")) m_view.rescale_height->setValue(props.value("renderrescaleheight").toInt());
+ if (props.contains("rendertcoverlay")) m_view.tc_overlay->setChecked(props.value("rendertcoverlay").toInt());
+ if (props.contains("renderratio")) m_view.rescale_keep->setChecked(props.value("renderratio").toInt());
+ if (props.contains("renderplay")) m_view.play_after->setChecked(props.value("renderplay").toInt());
+
+ if (props.value("renderzone") == "1") m_view.render_zone->setChecked(true);
+ else if (props.value("renderguide") == "1") {
+ m_view.render_guide->setChecked(true);
+ m_view.guide_start->setCurrentIndex(props.value("renderstartguide").toInt());
+ m_view.guide_end->setCurrentIndex(props.value("renderendguide").toInt());
+ } else m_view.render_full->setChecked(true);
+ slotUpdateGuideBox();
+
+ QString url = props.value("renderurl");
+ if (!url.isEmpty()) m_view.out_file->setUrl(KUrl(url));
+
+ // set destination
+ for (int i = 0; i < m_view.destination_list->count(); i++) {
+ if (m_view.destination_list->itemData(i, Qt::UserRole) == props.value("renderdestination")) {
+ m_view.destination_list->setCurrentIndex(i);
+ break;
+ }
+ }
+ refreshCategory();
+
+ // set category
+ QString group = props.value("rendercategory");
+ if (!group.isEmpty()) {
+ QList<QListWidgetItem *> childs = m_view.format_list->findItems(group, Qt::MatchExactly);
+ if (!childs.isEmpty()) {
+ m_view.format_list->setCurrentItem(childs.at(0));
+ m_view.format_list->scrollToItem(childs.at(0));
+ }
+ refreshView();
+ }
+
+ // set profile
+ QList<QListWidgetItem *> childs = m_view.size_list->findItems(props.value("renderprofile"), Qt::MatchExactly);
+ if (!childs.isEmpty()) {
+ m_view.size_list->setCurrentItem(childs.at(0));
+ m_view.size_list->scrollToItem(childs.at(0));
+ }
+ //refreshView();
+ m_view.destination_list->blockSignals(false);
+ m_view.format_list->blockSignals(false);
+
+}
+
+bool RenderWidget::startWaitingRenderJobs()
+{
+ m_blockProcessing = true;
+ QString autoscriptFile = getFreeScriptName("auto");
+ QFile file(autoscriptFile);
+ if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+ kWarning() << "////// ERROR writing to file: " << autoscriptFile;
+ KMessageBox::error(0, i18n("Cannot write to file %1", autoscriptFile));
+ return false;
+ }
+
+ QTextStream outStream(&file);
+ outStream << "#! /bin/sh" << "\n" << "\n";
+ QTreeWidgetItem *item = m_view.running_jobs->topLevelItem(0);
+ while (item) {
+ if (item->data(1, Qt::UserRole + 2).toInt() == WAITINGJOB) {
+ if (item->data(1, Qt::UserRole + 4).isNull()) {
+ // Add render process for item
+ const QString params = item->data(1, Qt::UserRole + 3).toStringList().join(" ");
+ outStream << m_renderer << " " << params << "\n";
+ } else {
+ // Script item
+ outStream << item->data(1, Qt::UserRole + 3).toString() << "\n";
+ }
+ }
+ item = m_view.running_jobs->itemBelow(item);
+ }
+ // erase itself when rendering is finished
+ outStream << "rm " << autoscriptFile << "\n" << "\n";
+ if (file.error() != QFile::NoError) {
+ KMessageBox::error(0, i18n("Cannot write to file %1", autoscriptFile));
+ file.close();
+ m_blockProcessing = false;
+ return false;
+ }
+ file.close();
+ QFile::setPermissions(autoscriptFile, file.permissions() | QFile::ExeUser);
+ QProcess::startDetached(autoscriptFile, QStringList());
+ return true;
+}
+
+QString RenderWidget::getFreeScriptName(const QString &prefix)
+{
+ int ix = 0;
+ QString scriptsFolder = m_projectFolder + "scripts/";
+ KStandardDirs::makeDir(scriptsFolder);
+ QString path;
+ while (path.isEmpty() || QFile::exists(path)) {
+ ix++;
+ path = scriptsFolder + prefix + i18n("script") + QString::number(ix).rightJustified(3, '0', false) + ".sh";
+ }
+ return path;
+}
+
+void RenderWidget::slotPlayRendering(QTreeWidgetItem *item, int)
+{
+ if (KdenliveSettings::defaultplayerapp().isEmpty() || item->data(1, Qt::UserRole + 2).toInt() != FINISHEDJOB) return;
+ const QByteArray startId = KStartupInfo::createNewStartupId();
+ const QString command = KdenliveSettings::defaultplayerapp() + ' ' + item->text(1);
+ KRun::runCommand(command, KdenliveSettings::defaultplayerapp(), KdenliveSettings::defaultplayerapp(), this, startId);
+}
+
+void RenderWidget::missingClips(bool hasMissing)
+{
+ if (hasMissing) {
+ m_view.errorLabel->setText(i18n("Check missing clips"));
+ m_view.errorLabel->setHidden(false);
+ } else m_view.errorLabel->setHidden(true);
+}
+
+void RenderWidget::slotUpdateRescaleWidth(int val)
+{
+ KdenliveSettings::setDefaultrescalewidth(val);
+ if (!m_view.rescale_keep->isChecked()) return;
+ m_view.rescale_height->blockSignals(true);
+ m_view.rescale_height->setValue(val * m_profile.height / m_profile.width + 0.5);
+ KdenliveSettings::setDefaultrescaleheight(m_view.rescale_height->value());
+ m_view.rescale_height->blockSignals(false);
+}
+
+void RenderWidget::slotUpdateRescaleHeight(int val)
+{
+ KdenliveSettings::setDefaultrescaleheight(val);
+ if (!m_view.rescale_keep->isChecked()) return;
+ m_view.rescale_width->blockSignals(true);
+ m_view.rescale_width->setValue(val * m_profile.width / m_profile.height + 0.5);
+ KdenliveSettings::setDefaultrescaleheight(m_view.rescale_width->value());
+ m_view.rescale_width->blockSignals(false);
+}
+
+void RenderWidget::slotSwitchAspectRatio()
+{
+ KdenliveSettings::setRescalekeepratio(m_view.rescale_keep->isChecked());
+ if (m_view.rescale_keep->isChecked()) slotUpdateRescaleWidth(m_view.rescale_width->value());
+}
+
+void RenderWidget::slotUpdateAudioLabel(int ix)
+{
+ if (ix == Qt::PartiallyChecked)
+ m_view.export_audio->setText(i18n("Export audio (automatic)"));
+ else
+ m_view.export_audio->setText(i18n("Export audio"));
+}
+
+bool RenderWidget::automaticAudioExport() const
+{
+ return (m_view.export_audio->checkState() == Qt::PartiallyChecked);
+}
+
+bool RenderWidget::selectedAudioExport() const
+{
+ return (m_view.export_audio->checkState() != Qt::Unchecked);