git.sesse.net Git - kdenlive/blob - src/renderwidget.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Jean-Baptiste Mardelle (jb@kdenlive.org)        *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  18  ***************************************************************************/
  19
  20
  21 #include "renderwidget.h"
  22 #include "kdenlivesettings.h"
  23 #include "ui_saveprofile_ui.h"
  24 #include "timecode.h"
  25
  26 #include <KStandardDirs>
  27 #include <KDebug>
  28 #include <KMessageBox>
  29 #include <KComboBox>
  30 #include <KRun>
  31 #include <KIO/NetAccess>
  32 #include <KColorScheme>
  33 #include <KNotification>
  34 #include <KStartupInfo>
  35 // #include <knewstuff2/engine.h>
  36
  37 #include <QDomDocument>
  38 #include <QItemDelegate>
  39 #include <QTreeWidgetItem>
  40 #include <QListWidgetItem>
  41 #include <QHeaderView>
  42 #include <QMenu>
  43 #include <QInputDialog>
  44 #include <QProcess>
  45
  46 const int GroupRole = Qt::UserRole;
  47 const int ExtensionRole = GroupRole + 1;
  48 const int StandardRole = GroupRole + 2;
  49 const int RenderRole = GroupRole + 3;
  50 const int ParamsRole = GroupRole + 4;
  51 const int EditableRole = GroupRole + 5;
  52 const int MetaGroupRole = GroupRole + 6;
  53 const int ExtraRole = GroupRole + 7;
  54
  55 // Running job status
  56 const int WAITINGJOB = 0;
  57 const int RUNNINGJOB = 1;
  58 const int FINISHEDJOB = 2;
  59
  60
  61 RenderWidget::RenderWidget(const QString &projectfolder, QWidget * parent) :
  62         QDialog(parent),
  63         m_projectFolder(projectfolder),
  64         m_blockProcessing(false)
  65 {
  66     m_view.setupUi(this);
  67     setWindowTitle(i18n("Rendering"));
  68     m_view.buttonDelete->setIcon(KIcon("trash-empty"));
  69     m_view.buttonDelete->setToolTip(i18n("Delete profile"));
  70     m_view.buttonDelete->setEnabled(false);
  71
  72     m_view.buttonEdit->setIcon(KIcon("document-properties"));
  73     m_view.buttonEdit->setToolTip(i18n("Edit profile"));
  74     m_view.buttonEdit->setEnabled(false);
  75
  76     m_view.buttonSave->setIcon(KIcon("document-new"));
  77     m_view.buttonSave->setToolTip(i18n("Create new profile"));
  78
  79     m_view.buttonInfo->setIcon(KIcon("help-about"));
  80     m_view.hide_log->setIcon(KIcon("go-down"));
  81
  82     if (KdenliveSettings::showrenderparams()) {
  83         m_view.buttonInfo->setDown(true);
  84     } else m_view.advanced_params->hide();
  85
  86     m_view.rescale_size->setInputMask("0099\\x0099");
  87     m_view.rescale_size->setText("320x240");
  88
  89
  90     QMenu *renderMenu = new QMenu(i18n("Start Rendering"), this);
  91     QAction *renderAction = renderMenu->addAction(KIcon("video-x-generic"), i18n("Render to File"));
  92     connect(renderAction, SIGNAL(triggered()), this, SLOT(slotPrepareExport()));
  93     QAction *scriptAction = renderMenu->addAction(KIcon("application-x-shellscript"), i18n("Generate Script"));
  94     connect(scriptAction, SIGNAL(triggered()), this, SLOT(slotGenerateScript()));
  95
  96     m_view.buttonStart->setMenu(renderMenu);
  97     m_view.buttonStart->setPopupMode(QToolButton::MenuButtonPopup);
  98     m_view.buttonStart->setDefaultAction(renderAction);
  99     m_view.buttonStart->setToolButtonStyle(Qt::ToolButtonTextOnly);
 100     m_view.abort_job->setEnabled(false);
 101     m_view.start_script->setEnabled(false);
 102     m_view.delete_script->setEnabled(false);
 103
 104     m_view.format_list->setAlternatingRowColors(true);
 105     m_view.size_list->setAlternatingRowColors(true);
 106
 107     parseProfiles();
 108     parseScriptFiles();
 109
 110     connect(m_view.start_script, SIGNAL(clicked()), this, SLOT(slotStartScript()));
 111     connect(m_view.delete_script, SIGNAL(clicked()), this, SLOT(slotDeleteScript()));
 112     connect(m_view.scripts_list, SIGNAL(itemSelectionChanged()), this, SLOT(slotCheckScript()));
 113     connect(m_view.running_jobs, SIGNAL(itemSelectionChanged()), this, SLOT(slotCheckJob()));
 114     connect(m_view.running_jobs, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)), this, SLOT(slotPlayRendering(QTreeWidgetItem *, int)));
 115
 116     connect(m_view.buttonInfo, SIGNAL(clicked()), this, SLOT(showInfoPanel()));
 117
 118     connect(m_view.buttonSave, SIGNAL(clicked()), this, SLOT(slotSaveProfile()));
 119     connect(m_view.buttonEdit, SIGNAL(clicked()), this, SLOT(slotEditProfile()));
 120     connect(m_view.buttonDelete, SIGNAL(clicked()), this, SLOT(slotDeleteProfile()));
 121     connect(m_view.abort_job, SIGNAL(clicked()), this, SLOT(slotAbortCurrentJob()));
 122     connect(m_view.clean_up, SIGNAL(clicked()), this, SLOT(slotCLeanUpJobs()));
 123     connect(m_view.hide_log, SIGNAL(clicked()), this, SLOT(slotHideLog()));
 124
 125     connect(m_view.buttonClose, SIGNAL(clicked()), this, SLOT(hide()));
 126     connect(m_view.buttonClose2, SIGNAL(clicked()), this, SLOT(hide()));
 127     connect(m_view.buttonClose3, SIGNAL(clicked()), this, SLOT(hide()));
 128     connect(m_view.rescale, SIGNAL(toggled(bool)), m_view.rescale_size, SLOT(setEnabled(bool)));
 129     connect(m_view.destination_list, SIGNAL(activated(int)), this, SLOT(refreshView()));
 130     connect(m_view.out_file, SIGNAL(textChanged(const QString &)), this, SLOT(slotUpdateButtons()));
 131     connect(m_view.out_file, SIGNAL(urlSelected(const KUrl &)), this, SLOT(slotUpdateButtons(const KUrl &)));
 132     connect(m_view.format_list, SIGNAL(currentRowChanged(int)), this, SLOT(refreshView()));
 133     connect(m_view.size_list, SIGNAL(currentRowChanged(int)), this, SLOT(refreshParams()));
 134
 135     connect(m_view.size_list, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(slotEditItem(QListWidgetItem *)));
 136
 137     connect(m_view.render_guide, SIGNAL(clicked(bool)), this, SLOT(slotUpdateGuideBox()));
 138     connect(m_view.render_zone, SIGNAL(clicked(bool)), this, SLOT(slotUpdateGuideBox()));
 139     connect(m_view.render_full, SIGNAL(clicked(bool)), this, SLOT(slotUpdateGuideBox()));
 140
 141     connect(m_view.guide_end, SIGNAL(activated(int)), this, SLOT(slotCheckStartGuidePosition()));
 142     connect(m_view.guide_start, SIGNAL(activated(int)), this, SLOT(slotCheckEndGuidePosition()));
 143
 144     connect(m_view.format_selection, SIGNAL(activated(int)), this, SLOT(refreshView()));
 145
 146     m_view.buttonStart->setEnabled(false);
 147     m_view.rescale_size->setEnabled(false);
 148     m_view.guides_box->setVisible(false);
 149     m_view.open_dvd->setVisible(false);
 150     m_view.create_chapter->setVisible(false);
 151     m_view.open_browser->setVisible(false);
 152     m_view.error_box->setVisible(false);
 153
 154     m_view.splitter->setStretchFactor(1, 5);
 155     m_view.splitter->setStretchFactor(0, 2);
 156
 157     m_view.out_file->setMode(KFile::File);
 158
 159     m_view.running_jobs->setHeaderLabels(QStringList() << QString() << i18n("File") << i18n("Progress"));
 160     m_jobsDelegate = new RenderViewDelegate(this);
 161     m_view.running_jobs->setItemDelegate(m_jobsDelegate);
 162
 163     QHeaderView *header = m_view.running_jobs->header();
 164     QFontMetrics fm = fontMetrics();
 165     header->setResizeMode(0, QHeaderView::Fixed);
 166     header->resizeSection(0, 30);
 167     header->setResizeMode(1, QHeaderView::Interactive);
 168     header->setResizeMode(2, QHeaderView::Fixed);
 169     header->resizeSection(1, width() * 2 / 3 - 15);
 170     header->setResizeMode(2, QHeaderView::Interactive);
 171     //header->setResizeMode(1, QHeaderView::Fixed);
 172
 173
 174     m_view.scripts_list->setHeaderLabels(QStringList() << QString() << i18n("Script Files"));
 175     m_scriptsDelegate = new RenderViewDelegate(this);
 176     m_view.scripts_list->setItemDelegate(m_scriptsDelegate);
 177     header = m_view.scripts_list->header();
 178     header->setResizeMode(0, QHeaderView::Fixed);
 179     header->resizeSection(0, 30);
 180
 181     // Find path for Kdenlive renderer
 182     m_renderer = QCoreApplication::applicationDirPath() + QString("/kdenlive_render");
 183     if (!QFile::exists(m_renderer)) {
 184         m_renderer = KStandardDirs::findExe("kdenlive_render");
 185         if (m_renderer.isEmpty()) m_renderer = KStandardDirs::locate("exe", "kdenlive_render");
 186         if (m_renderer.isEmpty()) m_renderer = "kdenlive_render";
 187     }
 188
 189     focusFirstVisibleItem();
 190 }
 191
 192 RenderWidget::~RenderWidget()
 193 {
 194     m_view.running_jobs->blockSignals(true);
 195     m_view.scripts_list->blockSignals(true);
 196     m_view.running_jobs->clear();
 197     m_view.scripts_list->clear();
 198     delete m_jobsDelegate;
 199     delete m_scriptsDelegate;
 200 }
 201
 202 void RenderWidget::slotEditItem(QListWidgetItem *item)
 203 {
 204     QString edit = item->data(EditableRole).toString();
 205     if (edit.isEmpty() || !edit.endsWith("customprofiles.xml")) slotSaveProfile();
 206     else slotEditProfile();
 207 }
 208
 209 void RenderWidget::showInfoPanel()
 210 {
 211     if (m_view.advanced_params->isVisible()) {
 212         m_view.advanced_params->setVisible(false);
 213         m_view.buttonInfo->setDown(false);
 214         KdenliveSettings::setShowrenderparams(false);
 215     } else {
 216         m_view.advanced_params->setVisible(true);
 217         m_view.buttonInfo->setDown(true);
 218         KdenliveSettings::setShowrenderparams(true);
 219     }
 220 }
 221
 222 void RenderWidget::setDocumentPath(const QString path)
 223 {
 224     if (m_view.out_file->url().directory() == KUrl(m_projectFolder).directory()) {
 225         const QString fileName = m_view.out_file->url().fileName();
 226         m_view.out_file->setUrl(KUrl(path + fileName));
 227     }
 228     m_projectFolder = path;
 229     parseScriptFiles();
 230
 231 }
 232
 233 void RenderWidget::slotUpdateGuideBox()
 234 {
 235     m_view.guides_box->setVisible(m_view.render_guide->isChecked());
 236 }
 237
 238 void RenderWidget::slotCheckStartGuidePosition()
 239 {
 240     if (m_view.guide_start->currentIndex() > m_view.guide_end->currentIndex())
 241         m_view.guide_start->setCurrentIndex(m_view.guide_end->currentIndex());
 242 }
 243
 244 void RenderWidget::slotCheckEndGuidePosition()
 245 {
 246     if (m_view.guide_end->currentIndex() < m_view.guide_start->currentIndex())
 247         m_view.guide_end->setCurrentIndex(m_view.guide_start->currentIndex());
 248 }
 249
 250 void RenderWidget::setGuides(QDomElement guidesxml, double duration)
 251 {
 252     m_view.guide_start->clear();
 253     m_view.guide_end->clear();
 254     QDomNodeList nodes = guidesxml.elementsByTagName("guide");
 255     if (nodes.count() > 0) {
 256         m_view.guide_start->addItem(i18n("Beginning"), "0");
 257         m_view.render_guide->setEnabled(true);
 258         m_view.create_chapter->setEnabled(true);
 259     } else {
 260         m_view.render_guide->setEnabled(false);
 261         m_view.create_chapter->setEnabled(false);
 262     }
 263     double fps = (double) m_profile.frame_rate_num / m_profile.frame_rate_den;
 264     for (int i = 0; i < nodes.count(); i++) {
 265         QDomElement e = nodes.item(i).toElement();
 266         if (!e.isNull()) {
 267             GenTime pos = GenTime(e.attribute("time").toDouble());
 268             const QString guidePos = Timecode::getStringTimecode(pos.frames(fps), fps);
 269             m_view.guide_start->addItem(e.attribute("comment") + '/' + guidePos, e.attribute("time").toDouble());
 270             m_view.guide_end->addItem(e.attribute("comment") + '/' + guidePos, e.attribute("time").toDouble());
 271         }
 272     }
 273     if (nodes.count() > 0)
 274         m_view.guide_end->addItem(i18n("End"), QString::number(duration));
 275 }
 276
 277 /**
 278  * Will be called when the user selects an output file via the file dialog.
 279  * File extension will be added automatically.
 280  */
 281 void RenderWidget::slotUpdateButtons(KUrl url)
 282 {
 283     if (m_view.out_file->url().isEmpty()) m_view.buttonStart->setEnabled(false);
 284     else {
 285         updateButtons(); // This also checks whether the selected format is available
 286         //m_view.buttonStart->setEnabled(true);
 287     }
 288     if (url != 0) {
 289         QListWidgetItem *item = m_view.size_list->currentItem();
 290         QString extension = item->data(ExtensionRole).toString();
 291         url = filenameWithExtension(url, extension);
 292         m_view.out_file->setUrl(url);
 293     }
 294 }
 295
 296 /**
 297  * Will be called when the user changes the output file path in the text line.
 298  * File extension must NOT be added, would make editing impossible!
 299  */
 300 void RenderWidget::slotUpdateButtons()
 301 {
 302     if (m_view.out_file->url().isEmpty()) m_view.buttonStart->setEnabled(false);
 303     else updateButtons(); // This also checks whether the selected format is available
 304     //else m_view.buttonStart->setEnabled(true);
 305 }
 306
 307 void RenderWidget::slotSaveProfile()
 308 {
 309     //TODO: update to correctly use metagroups
 310     Ui::SaveProfile_UI ui;
 311     QDialog *d = new QDialog(this);
 312     ui.setupUi(d);
 313
 314     for (int i = 0; i < m_view.destination_list->count(); i++)
 315         ui.destination_list->addItem(m_view.destination_list->itemIcon(i), m_view.destination_list->itemText(i), m_view.destination_list->itemData(i, Qt::UserRole));
 316
 317     ui.destination_list->setCurrentIndex(m_view.destination_list->currentIndex());
 318     QString dest = ui.destination_list->itemData(ui.destination_list->currentIndex(), Qt::UserRole).toString();
 319
 320     QString customGroup = m_view.format_list->currentItem()->text();
 321     if (customGroup.isEmpty()) customGroup = i18n("Custom");
 322     ui.group_name->setText(customGroup);
 323
 324     ui.parameters->setText(m_view.advanced_params->toPlainText());
 325     ui.extension->setText(m_view.size_list->currentItem()->data(ExtensionRole).toString());
 326     ui.profile_name->setFocus();
 327
 328     if (d->exec() == QDialog::Accepted && !ui.profile_name->text().simplified().isEmpty()) {
 329         QString exportFile = KStandardDirs::locateLocal("appdata", "export/customprofiles.xml");
 330         QDomDocument doc;
 331         QFile file(exportFile);
 332         doc.setContent(&file, false);
 333         file.close();
 334         QDomElement documentElement;
 335         QDomElement profiles = doc.documentElement();
 336         if (profiles.isNull() || profiles.tagName() != "profiles") {
 337             doc.clear();
 338             profiles = doc.createElement("profiles");
 339             profiles.setAttribute("version", 1);
 340             doc.appendChild(profiles);
 341         }
 342         int version = profiles.attribute("version", 0).toInt();
 343         if (version < 1) {
 344             kDebug() << "// OLD profile version";
 345             doc.clear();
 346             profiles = doc.createElement("profiles");
 347             profiles.setAttribute("version", 1);
 348             doc.appendChild(profiles);
 349         }
 350
 351         QString newProfileName = ui.profile_name->text().simplified();
 352         QString newGroupName = ui.group_name->text().simplified();
 353         if (newGroupName.isEmpty()) newGroupName = i18n("Custom");
 354         QString newMetaGroupId = ui.destination_list->itemData(ui.destination_list->currentIndex(), Qt::UserRole).toString();
 355         QDomNodeList profilelist = doc.elementsByTagName("profile");
 356         int i = 0;
 357         while (!profilelist.item(i).isNull()) {
 358             // make sure a profile with same name doesn't exist
 359             documentElement = profilelist.item(i).toElement();
 360             QString profileName = documentElement.attribute("name");
 361             if (profileName == newProfileName) {
 362                 // a profile with that same name already exists
 363                 bool ok;
 364                 newProfileName = QInputDialog::getText(this, i18n("Profile already exists"), i18n("This profile name already exists. Change the name if you don't want to overwrite it."), QLineEdit::Normal, newProfileName, &ok);
 365                 if (!ok) return;
 366                 if (profileName == newProfileName) {
 367                     profiles.removeChild(profilelist.item(i));
 368                     break;
 369                 }
 370             }
 371             i++;
 372         }
 373
 374         QDomElement profileElement = doc.createElement("profile");
 375         profileElement.setAttribute("name", newProfileName);
 376         profileElement.setAttribute("category", newGroupName);
 377         profileElement.setAttribute("destinationid", newMetaGroupId);
 378         profileElement.setAttribute("extension", ui.extension->text().simplified());
 379         profileElement.setAttribute("args", ui.parameters->toPlainText().simplified());
 380         profiles.appendChild(profileElement);
 381
 382         //QCString save = doc.toString().utf8();
 383
 384         if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 385             KMessageBox::sorry(this, i18n("Unable to write to file %1", exportFile));
 386             delete d;
 387             return;
 388         }
 389         QTextStream out(&file);
 390         out << doc.toString();
 391         if (file.error() != QFile::NoError) {
 392             KMessageBox::error(this, i18n("Cannot write to file %1", exportFile));
 393             file.close();
 394             delete d;
 395             return;
 396         }
 397         file.close();
 398         parseProfiles(newMetaGroupId, newGroupName, newProfileName);
 399     }
 400     delete d;
 401 }
 402
 403 void RenderWidget::slotEditProfile()
 404 {
 405     QListWidgetItem *item = m_view.size_list->currentItem();
 406     if (!item) return;
 407     QString currentGroup = m_view.format_list->currentItem()->text();
 408
 409     QString params = item->data(ParamsRole).toString();
 410     QString extension = item->data(ExtensionRole).toString();
 411     QString currentProfile = item->text();
 412
 413     Ui::SaveProfile_UI ui;
 414     QDialog *d = new QDialog(this);
 415     ui.setupUi(d);
 416
 417     for (int i = 0; i < m_view.destination_list->count(); i++)
 418         ui.destination_list->addItem(m_view.destination_list->itemIcon(i), m_view.destination_list->itemText(i), m_view.destination_list->itemData(i, Qt::UserRole));
 419
 420     ui.destination_list->setCurrentIndex(m_view.destination_list->currentIndex());
 421     QString dest = ui.destination_list->itemData(ui.destination_list->currentIndex(), Qt::UserRole).toString();
 422
 423     QString customGroup = m_view.format_list->currentItem()->text();
 424     if (customGroup.isEmpty()) customGroup = i18n("Custom");
 425     ui.group_name->setText(customGroup);
 426
 427     ui.profile_name->setText(currentProfile);
 428     ui.extension->setText(extension);
 429     ui.parameters->setText(params);
 430     ui.profile_name->setFocus();
 431     d->setWindowTitle(i18n("Edit Profile"));
 432     if (d->exec() == QDialog::Accepted) {
 433         slotDeleteProfile(false);
 434         QString exportFile = KStandardDirs::locateLocal("appdata", "export/customprofiles.xml");
 435         QDomDocument doc;
 436         QFile file(exportFile);
 437         doc.setContent(&file, false);
 438         file.close();
 439         QDomElement documentElement;
 440         QDomElement profiles = doc.documentElement();
 441
 442         if (profiles.isNull() || profiles.tagName() != "profiles") {
 443             doc.clear();
 444             profiles = doc.createElement("profiles");
 445             profiles.setAttribute("version", 1);
 446             doc.appendChild(profiles);
 447         }
 448
 449         int version = profiles.attribute("version", 0).toInt();
 450         if (version < 1) {
 451             kDebug() << "// OLD profile version";
 452             doc.clear();
 453             profiles = doc.createElement("profiles");
 454             profiles.setAttribute("version", 1);
 455             doc.appendChild(profiles);
 456         }
 457
 458         QString newProfileName = ui.profile_name->text().simplified();
 459         QString newGroupName = ui.group_name->text().simplified();
 460         if (newGroupName.isEmpty()) newGroupName = i18n("Custom");
 461         QString newMetaGroupId = ui.destination_list->itemData(ui.destination_list->currentIndex(), Qt::UserRole).toString();
 462         QDomNodeList profilelist = doc.elementsByTagName("profile");
 463         int i = 0;
 464         while (!profilelist.item(i).isNull()) {
 465             // make sure a profile with same name doesn't exist
 466             documentElement = profilelist.item(i).toElement();
 467             QString profileName = documentElement.attribute("name");
 468             if (profileName == newProfileName) {
 469                 // a profile with that same name already exists
 470                 bool ok;
 471                 newProfileName = QInputDialog::getText(this, i18n("Profile already exists"), i18n("This profile name already exists. Change the name if you don't want to overwrite it."), QLineEdit::Normal, newProfileName, &ok);
 472                 if (!ok) return;
 473                 if (profileName == newProfileName) {
 474                     profiles.removeChild(profilelist.item(i));
 475                     break;
 476                 }
 477             }
 478             i++;
 479         }
 480
 481         QDomElement profileElement = doc.createElement("profile");
 482         profileElement.setAttribute("name", newProfileName);
 483         profileElement.setAttribute("category", newGroupName);
 484         profileElement.setAttribute("destinationid", newMetaGroupId);
 485         profileElement.setAttribute("extension", ui.extension->text().simplified());
 486         profileElement.setAttribute("args", ui.parameters->toPlainText().simplified());
 487         profiles.appendChild(profileElement);
 488
 489         //QCString save = doc.toString().utf8();
 490         delete d;
 491         if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 492             KMessageBox::error(this, i18n("Cannot write to file %1", exportFile));
 493             return;
 494         }
 495         QTextStream out(&file);
 496         out << doc.toString();
 497         if (file.error() != QFile::NoError) {
 498             KMessageBox::error(this, i18n("Cannot write to file %1", exportFile));
 499             file.close();
 500             return;
 501         }
 502         file.close();
 503         parseProfiles(newMetaGroupId, newGroupName, newProfileName);
 504     } else delete d;
 505 }
 506
 507 void RenderWidget::slotDeleteProfile(bool refresh)
 508 {
 509     //TODO: delete a profile installed by KNewStuff the easy way
 510     /*
 511     QString edit = m_view.size_list->currentItem()->data(EditableRole).toString();
 512     if (!edit.endsWith("customprofiles.xml")) {
 513         // This is a KNewStuff installed file, process through KNS
 514         KNS::Engine engine(0);
 515         if (engine.init("kdenlive_render.knsrc")) {
 516             KNS::Entry::List entries;
 517         }
 518         return;
 519     }*/
 520     QString currentGroup = m_view.format_list->currentItem()->text();
 521     QString currentProfile = m_view.size_list->currentItem()->text();
 522     QString metaGroupId = m_view.destination_list->itemData(m_view.destination_list->currentIndex(), Qt::UserRole).toString();
 523
 524     QString exportFile = KStandardDirs::locateLocal("appdata", "export/customprofiles.xml");
 525     QDomDocument doc;
 526     QFile file(exportFile);
 527     doc.setContent(&file, false);
 528     file.close();
 529
 530     QDomElement documentElement;
 531     QDomNodeList profiles = doc.elementsByTagName("profile");
 532     int i = 0;
 533     QString groupName;
 534     QString profileName;
 535     QString destination;
 536
 537     while (!profiles.item(i).isNull()) {
 538         documentElement = profiles.item(i).toElement();
 539         profileName = documentElement.attribute("name");
 540         groupName = documentElement.attribute("category");
 541         destination = documentElement.attribute("destinationid");
 542
 543         if (profileName == currentProfile && groupName == currentGroup && destination == metaGroupId) {
 544             kDebug() << "// GOT it: " << profileName;
 545             doc.documentElement().removeChild(profiles.item(i));
 546             break;
 547         }
 548         i++;
 549     }
 550
 551     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 552         KMessageBox::sorry(this, i18n("Unable to write to file %1", exportFile));
 553         return;
 554     }
 555     QTextStream out(&file);
 556     out << doc.toString();
 557     if (file.error() != QFile::NoError) {
 558         KMessageBox::error(this, i18n("Cannot write to file %1", exportFile));
 559         file.close();
 560         return;
 561     }
 562     file.close();
 563     if (refresh) {
 564         parseProfiles(metaGroupId, currentGroup);
 565         focusFirstVisibleItem();
 566     }
 567 }
 568
 569 void RenderWidget::updateButtons()
 570 {
 571     if (!m_view.size_list->currentItem() || m_view.size_list->currentItem()->isHidden()) {
 572         m_view.buttonSave->setEnabled(false);
 573         m_view.buttonDelete->setEnabled(false);
 574         m_view.buttonEdit->setEnabled(false);
 575         m_view.buttonStart->setEnabled(false);
 576     } else {
 577         m_view.buttonSave->setEnabled(true);
 578         m_view.buttonStart->setEnabled(m_view.size_list->currentItem()->toolTip().isEmpty());
 579         QString edit = m_view.size_list->currentItem()->data(EditableRole).toString();
 580         if (edit.isEmpty() || !edit.endsWith("customprofiles.xml")) {
 581             m_view.buttonDelete->setEnabled(false);
 582             m_view.buttonEdit->setEnabled(false);
 583         } else {
 584             m_view.buttonDelete->setEnabled(true);
 585             m_view.buttonEdit->setEnabled(true);
 586         }
 587     }
 588 }
 589
 590
 591 void RenderWidget::focusFirstVisibleItem()
 592 {
 593     if (m_view.size_list->currentItem() && !m_view.size_list->currentItem()->isHidden()) {
 594         updateButtons();
 595         return;
 596     }
 597     for (int ix = 0; ix < m_view.size_list->count(); ix++) {
 598         QListWidgetItem *item = m_view.size_list->item(ix);
 599         if (item && !item->isHidden()) {
 600             m_view.size_list->setCurrentRow(ix);
 601             break;
 602         }
 603     }
 604     if (!m_view.size_list->currentItem()) m_view.size_list->setCurrentRow(0);
 605     updateButtons();
 606 }
 607
 608 void RenderWidget::slotPrepareExport(bool scriptExport)
 609 {
 610     if (!QFile::exists(KdenliveSettings::rendererpath())) {
 611         KMessageBox::sorry(this, i18n("Cannot find the melt program required for rendering (part of Mlt)"));
 612         return;
 613     }
 614     if (m_view.play_after->isChecked() && KdenliveSettings::defaultplayerapp().isEmpty())
 615         KMessageBox::sorry(this, i18n("Cannot play video after rendering because the default video player application is not set.\nPlease define it in Kdenlive settings dialog."));
 616     QString chapterFile;
 617     if (m_view.create_chapter->isChecked()) chapterFile = m_view.out_file->url().path() + ".dvdchapter";
 618
 619     // mantisbt 1051
 620     KStandardDirs::makeDir(m_view.out_file->url().directory());
 621
 622     emit prepareRenderingData(scriptExport, m_view.render_zone->isChecked(), chapterFile);
 623 }
 624
 625
 626 void RenderWidget::slotExport(bool scriptExport, int zoneIn, int zoneOut, const QString &playlistPath, const QString &scriptPath)
 627 {
 628     QListWidgetItem *item = m_view.size_list->currentItem();
 629     if (!item) return;
 630
 631     QString dest = m_view.out_file->url().path();
 632     if (dest.isEmpty()) return;
 633
 634     // Check whether target file has an extension.
 635     // If not, ask whether extension should be added or not.
 636     QString extension = item->data(ExtensionRole).toString();
 637     if (!dest.endsWith(extension, Qt::CaseInsensitive)) {
 638         if (KMessageBox::questionYesNo(this, i18n("File has no extension. Add extension (%1)?", extension)) == KMessageBox::Yes) {
 639             dest.append("." + extension);
 640         }
 641     }
 642
 643     QFile f(dest);
 644     if (f.exists()) {
 645         if (KMessageBox::warningYesNo(this, i18n("Output file already exists. Do you want to overwrite it?")) != KMessageBox::Yes)
 646             return;
 647     }
 648
 649     QStringList overlayargs;
 650     if (m_view.tc_overlay->isChecked()) {
 651         QString filterFile = KStandardDirs::locate("appdata", "metadata.properties");
 652         overlayargs << "meta.attr.timecode=1" << "meta.attr.timecode.markup=#timecode";
 653         overlayargs << "-attach" << "data_feed:attr_check" << "-attach";
 654         overlayargs << "data_show:" + filterFile << "_loader=1" << "dynamic=1";
 655     }
 656
 657     QStringList render_process_args;
 658
 659     if (!scriptExport) render_process_args << "-erase";
 660     if (KdenliveSettings::usekuiserver()) render_process_args << "-kuiserver";
 661
 662     double guideStart = 0;
 663     double guideEnd = 0;
 664
 665     if (m_view.render_zone->isChecked()) render_process_args << "in=" + QString::number(zoneIn) << "out=" + QString::number(zoneOut);
 666     else if (m_view.render_guide->isChecked()) {
 667         double fps = (double) m_profile.frame_rate_num / m_profile.frame_rate_den;
 668         guideStart = m_view.guide_start->itemData(m_view.guide_start->currentIndex()).toDouble();
 669         guideEnd = m_view.guide_end->itemData(m_view.guide_end->currentIndex()).toDouble();
 670         render_process_args << "in=" + QString::number(GenTime(guideStart).frames(fps)) << "out=" + QString::number(GenTime(guideEnd).frames(fps));
 671     }
 672
 673     if (!overlayargs.isEmpty()) render_process_args << "preargs=" + overlayargs.join(" ");
 674
 675     render_process_args << KdenliveSettings::rendererpath() << m_profile.path << item->data(RenderRole).toString();
 676     if (m_view.play_after->isChecked()) render_process_args << KdenliveSettings::KdenliveSettings::defaultplayerapp();
 677     else render_process_args << "-";
 678
 679     QString renderArgs = m_view.advanced_params->toPlainText().simplified();
 680
 681     // Adjust frame scale
 682     int width;
 683     int height;
 684     if (m_view.rescale->isChecked() && m_view.rescale->isEnabled()) {
 685         width = m_view.rescale_size->text().section('x', 0, 0).toInt();
 686         height = m_view.rescale_size->text().section('x', 1, 1).toInt();
 687     } else {
 688         width = m_profile.width;
 689         height = m_profile.height;
 690     }
 691     renderArgs.replace("%dar", '@' + QString::number(m_profile.display_aspect_num) + '/' + QString::number(m_profile.display_aspect_den));
 692
 693     // Adjust scanning
 694     if (m_view.scanning_list->currentIndex() == 1) renderArgs.append(" progressive=1");
 695     else if (m_view.scanning_list->currentIndex() == 2) renderArgs.append(" progressive=0");
 696
 697     // disable audio if requested
 698     if (!m_view.export_audio->isChecked())
 699         renderArgs.append(" an=1 ");
 700
 701     // Check if the rendering profile is different from project profile,
 702     // in which case we need to use the producer_comsumer from MLT
 703     QString std = renderArgs;
 704     QString destination = m_view.destination_list->itemData(m_view.destination_list->currentIndex()).toString();
 705     const QString currentSize = QString::number(width) + 'x' + QString::number(height);
 706     QString subsize = currentSize;
 707     if (std.startsWith("s=")) {
 708         subsize = std.section(' ', 0, 0).toLower();
 709         subsize = subsize.section("=", 1, 1);
 710     } else if (std.contains(" s=")) {
 711         subsize = std.section(" s=", 1, 1);
 712         subsize = subsize.section(' ', 0, 0).toLower();
 713     } else if (destination != "audioonly" && m_view.rescale->isChecked() && m_view.rescale->isEnabled()) {
 714         subsize = QString(" s=%1x%2").arg(width).arg(height);
 715         // Add current size parameter
 716         renderArgs.append(subsize);
 717     }
 718     bool resizeProfile = (subsize != currentSize);
 719     QStringList paramsList = renderArgs.split(" ", QString::SkipEmptyParts);
 720     for (int i = 0; i < paramsList.count(); i++) {
 721         if (paramsList.at(i).startsWith("profile=")) {
 722             if (paramsList.at(i).section('=', 1) != m_profile.path) resizeProfile = true;
 723             break;
 724         }
 725     }
 726
 727     if (resizeProfile) render_process_args << "consumer:" + playlistPath;
 728     else render_process_args << playlistPath;
 729     render_process_args << dest;
 730     render_process_args << paramsList;
 731
 732     QString group = m_view.size_list->currentItem()->data(MetaGroupRole).toString();
 733
 734     QStringList renderParameters;
 735     renderParameters << dest << item->data(RenderRole).toString() << renderArgs.simplified();
 736     renderParameters << QString::number(zoneIn) << QString::number(zoneOut) << QString::number(m_view.play_after->isChecked());
 737     renderParameters << QString::number(guideStart) << QString::number(guideEnd) << QString::number(resizeProfile);
 738
 739     QString scriptName;
 740     if (scriptExport) {
 741         // Generate script file
 742         QFile file(scriptPath);
 743         if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 744             KMessageBox::error(this, i18n("Cannot write to file %1", scriptPath));
 745             return;
 746         }
 747         QTextStream outStream(&file);
 748         outStream << "#! /bin/sh" << "\n" << "\n";
 749         outStream << "SOURCE=" << "\"" + playlistPath + "\"" << "\n";
 750         outStream << "TARGET=" << "\"" + dest + "\"" << "\n";
 751         outStream << "RENDERER=" << "\"" + m_renderer + "\"" << "\n";
 752         outStream << "MELT=" << "\"" + render_process_args.takeFirst() + "\"" << "\n";
 753         outStream << "PARAMETERS=" << "\"" + render_process_args.join(" ") + "\"" << "\n";
 754         outStream << "$RENDERER $MELT $PARAMETERS" << "\n" << "\n";
 755         if (file.error() != QFile::NoError) {
 756             KMessageBox::error(this, i18n("Cannot write to file %1", scriptPath));
 757             file.close();
 758             return;
 759         }
 760         file.close();
 761         QFile::setPermissions(scriptPath, file.permissions() | QFile::ExeUser);
 762
 763         QTimer::singleShot(400, this, SLOT(parseScriptFiles()));
 764         m_view.tabWidget->setCurrentIndex(2);
 765         return;
 766     }
 767     renderParameters << scriptName;
 768     m_view.tabWidget->setCurrentIndex(1);
 769
 770     // Save rendering profile to document
 771     emit selectedRenderProfile(m_view.size_list->currentItem()->data(MetaGroupRole).toString(), m_view.size_list->currentItem()->text(), dest);
 772
 773     // insert item in running jobs list
 774     QTreeWidgetItem *renderItem;
 775     QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(dest, Qt::MatchExactly, 1);
 776     if (!existing.isEmpty()) {
 777         renderItem = existing.at(0);
 778         if (renderItem->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB) {
 779             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...", dest), i18n("Already running"));
 780             return;
 781         }
 782         renderItem->setData(1, Qt::UserRole + 4, QString());
 783     } else {
 784         renderItem = new QTreeWidgetItem(m_view.running_jobs, QStringList() << QString() << dest << QString());
 785     }
 786     renderItem->setData(1, Qt::UserRole + 2, WAITINGJOB);
 787     renderItem->setIcon(0, KIcon("media-playback-pause"));
 788     renderItem->setData(1, Qt::UserRole, i18n("Waiting..."));
 789     renderItem->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
 790     renderItem->setData(1, Qt::UserRole + 1, QTime::currentTime());
 791
 792     // Set rendering type
 793     if (group == "dvd") {
 794         if (m_view.open_dvd->isChecked()) {
 795             renderItem->setData(0, Qt::UserRole, group);
 796             if (renderArgs.contains("profile=")) {
 797                 // rendering profile contains an MLT profile, so pass it to the running jog item, useful for dvd
 798                 QString prof = renderArgs.section("profile=", 1, 1);
 799                 prof = prof.section(' ', 0, 0);
 800                 kDebug() << "// render profile: " << prof;
 801                 renderItem->setData(0, Qt::UserRole + 1, prof);
 802             }
 803         }
 804     } else {
 805         if (group == "websites" && m_view.open_browser->isChecked()) {
 806             renderItem->setData(0, Qt::UserRole, group);
 807             // pass the url
 808             QString url = m_view.size_list->currentItem()->data(ExtraRole).toString();
 809             renderItem->setData(0, Qt::UserRole + 1, url);
 810         }
 811     }
 812     renderItem->setData(1, Qt::UserRole + 3, render_process_args);
 813     checkRenderStatus();
 814 }
 815
 816 void RenderWidget::checkRenderStatus()
 817 {
 818     if (m_blockProcessing) return;
 819     QTreeWidgetItem *item = m_view.running_jobs->topLevelItem(0);
 820     while (item) {
 821         if (item->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB) return;
 822         item = m_view.running_jobs->itemBelow(item);
 823     }
 824     item = m_view.running_jobs->topLevelItem(0);
 825     while (item) {
 826         if (item->data(1, Qt::UserRole + 2).toInt() == WAITINGJOB) {
 827             item->setData(1, Qt::UserRole + 1, QTime::currentTime());
 828             if (item->data(1, Qt::UserRole + 4).isNull()) {
 829                 // Normal render process
 830                 if (QProcess::startDetached(m_renderer, item->data(1, Qt::UserRole + 3).toStringList()) == false) {
 831                     item->setData(1, Qt::UserRole + 2, FINISHEDJOB);
 832                     item->setData(1, Qt::UserRole, i18n("Rendering crashed"));
 833                     item->setIcon(0, KIcon("dialog-close"));
 834                     item->setData(2, Qt::UserRole, 100);
 835                 } else KNotification::event("RenderStarted", i18n("Rendering <i>%1</i> started", item->text(1)), QPixmap(), this);
 836             } else {
 837                 // Script item
 838                 if (QProcess::startDetached(item->data(1, Qt::UserRole + 3).toString()) == false) {
 839                     item->setData(1, Qt::UserRole + 2, FINISHEDJOB);
 840                     item->setData(1, Qt::UserRole, i18n("Rendering crashed"));
 841                     item->setIcon(0, KIcon("dialog-close"));
 842                     item->setData(2, Qt::UserRole, 100);
 843                 }
 844             }
 845             break;
 846         }
 847         item = m_view.running_jobs->itemBelow(item);
 848     }
 849 }
 850
 851 int RenderWidget::waitingJobsCount() const
 852 {
 853     int count = 0;
 854     QTreeWidgetItem *item = m_view.running_jobs->topLevelItem(0);
 855     while (item) {
 856         if (item->data(1, Qt::UserRole + 2).toInt() == WAITINGJOB) count++;
 857         item = m_view.running_jobs->itemBelow(item);
 858     }
 859     return count;
 860 }
 861
 862 void RenderWidget::setProfile(MltVideoProfile profile)
 863 {
 864     m_profile = profile;
 865     //WARNING: this way to tell the video standard is a bit hackish...
 866     if (m_profile.description.contains("pal", Qt::CaseInsensitive) || m_profile.description.contains("25", Qt::CaseInsensitive) || m_profile.description.contains("50", Qt::CaseInsensitive)) m_view.format_selection->setCurrentIndex(0);
 867     else m_view.format_selection->setCurrentIndex(1);
 868     m_view.scanning_list->setCurrentIndex(0);
 869     refreshView();
 870 }
 871
 872 void RenderWidget::refreshView()
 873 {
 874     m_view.size_list->blockSignals(true);
 875     QListWidgetItem *sizeItem;
 876
 877     QString destination;
 878     KIcon brokenIcon("dialog-close");
 879     if (m_view.destination_list->currentIndex() > 0)
 880         destination = m_view.destination_list->itemData(m_view.destination_list->currentIndex()).toString();
 881
 882
 883     if (destination == "dvd") {
 884         m_view.open_dvd->setVisible(true);
 885         m_view.create_chapter->setVisible(true);
 886     } else {
 887         m_view.open_dvd->setVisible(false);
 888         m_view.create_chapter->setVisible(false);
 889     }
 890     if (destination == "websites") m_view.open_browser->setVisible(true);
 891     else m_view.open_browser->setVisible(false);
 892     if (!destination.isEmpty() && QString("dvd websites audioonly").contains(destination))
 893         m_view.rescale->setEnabled(false);
 894     else m_view.rescale->setEnabled(true);
 895     // hide groups that are not in the correct destination
 896     for (int i = 0; i < m_view.format_list->count(); i++) {
 897         sizeItem = m_view.format_list->item(i);
 898         if (sizeItem->data(MetaGroupRole).toString() == destination) {
 899             sizeItem->setHidden(false);
 900             //kDebug() << "// SET GRP:: " << sizeItem->text() << ", METY:" << sizeItem->data(MetaGroupRole).toString();
 901         } else sizeItem->setHidden(true);
 902     }
 903
 904     // activate first visible item
 905     QListWidgetItem * item = m_view.format_list->currentItem();
 906     if (!item || item->isHidden()) {
 907         for (int i = 0; i < m_view.format_list->count(); i++) {
 908             if (!m_view.format_list->item(i)->isHidden()) {
 909                 m_view.format_list->setCurrentRow(i);
 910                 break;
 911             }
 912         }
 913         item = m_view.format_list->currentItem();
 914     }
 915     if (!item || item->isHidden()) {
 916         m_view.format_list->setEnabled(false);
 917         m_view.size_list->setEnabled(false);
 918         return;
 919     } else {
 920         m_view.format_list->setEnabled(true);
 921         m_view.size_list->setEnabled(true);
 922     }
 923     int count = 0;
 924     for (int i = 0; i < m_view.format_list->count() && count < 2; i++) {
 925         if (!m_view.format_list->isRowHidden(i)) count++;
 926     }
 927     if (count > 1) m_view.format_list->setVisible(true);
 928     else m_view.format_list->setVisible(false);
 929     QString std;
 930     QString group = item->text();
 931     bool firstSelected = false;
 932     const QStringList formatsList = KdenliveSettings::supportedformats();
 933     const QStringList vcodecsList = KdenliveSettings::videocodecs();
 934     const QStringList acodecsList = KdenliveSettings::audiocodecs();
 935
 936     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
 937     const QColor disabled = scheme.foreground(KColorScheme::InactiveText).color();
 938     const QColor disabledbg = scheme.background(KColorScheme::NegativeBackground).color();
 939
 940     for (int i = 0; i < m_view.size_list->count(); i++) {
 941         sizeItem = m_view.size_list->item(i);
 942         if ((sizeItem->data(GroupRole).toString() == group || sizeItem->data(GroupRole).toString().isEmpty()) && sizeItem->data(MetaGroupRole).toString() == destination) {
 943             std = sizeItem->data(StandardRole).toString();
 944             if (!std.isEmpty()) {
 945                 if (std.contains("PAL", Qt::CaseInsensitive)) sizeItem->setHidden(m_view.format_selection->currentIndex() != 0);
 946                 else if (std.contains("NTSC", Qt::CaseInsensitive)) sizeItem->setHidden(m_view.format_selection->currentIndex() != 1);
 947             } else {
 948                 sizeItem->setHidden(false);
 949                 if (!firstSelected) m_view.size_list->setCurrentItem(sizeItem);
 950                 firstSelected = true;
 951             }
 952
 953             if (!sizeItem->isHidden()) {
 954                 // Make sure the selected profile uses an installed avformat codec / format
 955                 std = sizeItem->data(ParamsRole).toString();
 956                 if (!formatsList.isEmpty()) {
 957                     QString format;
 958                     if (std.startsWith("f=")) format = std.section("f=", 1, 1);
 959                     else if (std.contains(" f=")) format = std.section(" f=", 1, 1);
 960                     if (!format.isEmpty()) {
 961                         format = format.section(' ', 0, 0).toLower();
 962                         if (!formatsList.contains(format)) {
 963                             kDebug() << "***** UNSUPPORTED F: " << format;
 964                             //sizeItem->setHidden(true);
 965                             //sizeItem->setFlags(Qt::ItemIsSelectable);
 966                             sizeItem->setToolTip(i18n("Unsupported video format: %1", format));
 967                             sizeItem->setIcon(brokenIcon);
 968                             sizeItem->setForeground(disabled);
 969                         }
 970                     }
 971                 }
 972                 if (!acodecsList.isEmpty() && !sizeItem->isHidden()) {
 973                     QString format;
 974                     if (std.startsWith("acodec=")) format = std.section("acodec=", 1, 1);
 975                     else if (std.contains(" acodec=")) format = std.section(" acodec=", 1, 1);
 976                     if (!format.isEmpty()) {
 977                         format = format.section(' ', 0, 0).toLower();
 978                         if (!acodecsList.contains(format)) {
 979                             kDebug() << "*****  UNSUPPORTED ACODEC: " << format;
 980                             //sizeItem->setHidden(true);
 981                             //sizeItem->setFlags(Qt::ItemIsSelectable);
 982                             sizeItem->setToolTip(i18n("Unsupported audio codec: %1", format));
 983                             sizeItem->setIcon(brokenIcon);
 984                             sizeItem->setForeground(disabled);
 985                             sizeItem->setBackground(disabledbg);
 986                         }
 987                     }
 988                 }
 989                 if (!vcodecsList.isEmpty() && !sizeItem->isHidden()) {
 990                     QString format;
 991                     if (std.startsWith("vcodec=")) format = std.section("vcodec=", 1, 1);
 992                     else if (std.contains(" vcodec=")) format = std.section(" vcodec=", 1, 1);
 993                     if (!format.isEmpty()) {
 994                         format = format.section(' ', 0, 0).toLower();
 995                         if (!vcodecsList.contains(format)) {
 996                             kDebug() << "*****  UNSUPPORTED VCODEC: " << format;
 997                             //sizeItem->setHidden(true);
 998                             //sizeItem->setFlags(Qt::ItemIsSelectable);
 999                             sizeItem->setToolTip(i18n("Unsupported video codec: %1", format));
1000                             sizeItem->setIcon(brokenIcon);
1001                             sizeItem->setForeground(disabled);
1002                         }
1003                     }
1004                 }
1005             }
1006         } else sizeItem->setHidden(true);
1007     }
1008     focusFirstVisibleItem();
1009     m_view.size_list->blockSignals(false);
1010     refreshParams();
1011 }
1012
1013 KUrl RenderWidget::filenameWithExtension(KUrl url, QString extension)
1014 {
1015     if (url.isEmpty()) url = KUrl(m_projectFolder);
1016     QString directory = url.directory(KUrl::AppendTrailingSlash | KUrl::ObeyTrailingSlash);
1017     QString filename = url.fileName(KUrl::ObeyTrailingSlash);
1018     QString ext;
1019
1020     if (extension.at(0) == '.') ext = extension;
1021     else ext = '.' + extension;
1022
1023     if (filename.isEmpty()) filename = i18n("untitled");
1024
1025     int pos = filename.lastIndexOf('.');
1026     if (pos == 0) filename.append(ext);
1027     else {
1028         if (!filename.endsWith(ext, Qt::CaseInsensitive)) {
1029             filename = filename.left(pos) + ext;
1030         }
1031     }
1032
1033     return KUrl(directory + filename);
1034 }
1035
1036
1037 /**
1038  * Called when a new format or size has been selected.
1039  */
1040 void RenderWidget::refreshParams()
1041 {
1042     // Format not available (e.g. codec not installed); Disable start button
1043     QListWidgetItem *item = m_view.size_list->currentItem();
1044     if (!item || item->isHidden()) {
1045         m_view.advanced_params->clear();
1046         m_view.buttonStart->setEnabled(false);
1047         return;
1048     }
1049     QString params = item->data(ParamsRole).toString();
1050     QString extension = item->data(ExtensionRole).toString();
1051     m_view.advanced_params->setPlainText(params);
1052     QString destination = m_view.destination_list->itemData(m_view.destination_list->currentIndex()).toString();
1053     if (params.contains(" s=") || destination == "audioonly") {
1054         // profile has a fixed size, do not allow resize
1055         m_view.rescale->setEnabled(false);
1056         m_view.rescale_size->setEnabled(false);
1057     } else {
1058         m_view.rescale->setEnabled(true);
1059         m_view.rescale_size->setEnabled(true);
1060     }
1061     KUrl url = filenameWithExtension(m_view.out_file->url(), extension);
1062     m_view.out_file->setUrl(url);
1063 //     if (!url.isEmpty()) {
1064 //         QString path = url.path();
1065 //         int pos = path.lastIndexOf('.') + 1;
1066 //  if (pos == 0) path.append('.' + extension);
1067 //         else path = path.left(pos) + extension;
1068 //         m_view.out_file->setUrl(KUrl(path));
1069 //     } else {
1070 //         m_view.out_file->setUrl(KUrl(QDir::homePath() + "/untitled." + extension));
1071 //     }
1072     m_view.out_file->setFilter("*." + extension);
1073     QString edit = item->data(EditableRole).toString();
1074     if (edit.isEmpty() || !edit.endsWith("customprofiles.xml")) {
1075         m_view.buttonDelete->setEnabled(false);
1076         m_view.buttonEdit->setEnabled(false);
1077     } else {
1078         m_view.buttonDelete->setEnabled(true);
1079         m_view.buttonEdit->setEnabled(true);
1080     }
1081
1082     m_view.buttonStart->setEnabled(m_view.size_list->currentItem()->toolTip().isEmpty());
1083 }
1084
1085 void RenderWidget::reloadProfiles()
1086 {
1087     parseProfiles();
1088 }
1089
1090 void RenderWidget::parseProfiles(QString meta, QString group, QString profile)
1091 {
1092     m_view.size_list->clear();
1093     m_view.format_list->clear();
1094     m_view.destination_list->clear();
1095     m_view.destination_list->addItem(KIcon("video-x-generic"), i18n("File rendering"));
1096     m_view.destination_list->addItem(KIcon("media-optical"), i18n("DVD"), "dvd");
1097     m_view.destination_list->addItem(KIcon("audio-x-generic"), i18n("Audio only"), "audioonly");
1098     m_view.destination_list->addItem(KIcon("applications-internet"), i18n("Web sites"), "websites");
1099     m_view.destination_list->addItem(KIcon("applications-multimedia"), i18n("Media players"), "mediaplayers");
1100     m_view.destination_list->addItem(KIcon("drive-harddisk"), i18n("Lossless / HQ"), "lossless");
1101     m_view.destination_list->addItem(KIcon("pda"), i18n("Mobile devices"), "mobile");
1102
1103     QString exportFile = KStandardDirs::locate("appdata", "export/profiles.xml");
1104     parseFile(exportFile, false);
1105
1106
1107     QString exportFolder = KStandardDirs::locateLocal("appdata", "export/");
1108     QDir directory = QDir(exportFolder);
1109     QStringList filter;
1110     filter << "*.xml";
1111     QStringList fileList = directory.entryList(filter, QDir::Files);
1112     // We should parse customprofiles.xml in last position, so that user profiles
1113     // can also override profiles installed by KNewStuff
1114     fileList.removeAll("customprofiles.xml");
1115     foreach(const QString &filename, fileList)
1116     parseFile(exportFolder + filename, true);
1117     if (QFile::exists(exportFolder + "customprofiles.xml")) parseFile(exportFolder + "customprofiles.xml", true);
1118
1119     if (!meta.isEmpty()) {
1120         m_view.destination_list->blockSignals(true);
1121         m_view.destination_list->setCurrentIndex(m_view.destination_list->findData(meta));
1122         m_view.destination_list->blockSignals(false);
1123     }
1124     refreshView();
1125     QList<QListWidgetItem *> child;
1126     if (!group.isEmpty()) child = m_view.format_list->findItems(group, Qt::MatchExactly);
1127     if (!child.isEmpty()) {
1128         for (int i = 0; i < child.count(); i++) {
1129             if (child.at(i)->data(MetaGroupRole).toString() == meta) {
1130                 m_view.format_list->setCurrentItem(child.at(i));
1131                 break;
1132             }
1133         }
1134     }
1135     child.clear();
1136     if (!profile.isEmpty()) child = m_view.size_list->findItems(profile, Qt::MatchExactly);
1137     if (!child.isEmpty()) m_view.size_list->setCurrentItem(child.at(0));
1138 }
1139
1140 void RenderWidget::parseFile(QString exportFile, bool editable)
1141 {
1142     kDebug() << "// Parsing file: " << exportFile;
1143     kDebug() << "------------------------------";
1144     QDomDocument doc;
1145     QFile file(exportFile);
1146     doc.setContent(&file, false);
1147     file.close();
1148     QDomElement documentElement;
1149     QDomElement profileElement;
1150     QString extension;
1151     QListWidgetItem *item;
1152     QDomNodeList groups = doc.elementsByTagName("group");
1153
1154     const QStringList acodecsList = KdenliveSettings::audiocodecs();
1155     bool replaceVorbisCodec = false;
1156     if (!acodecsList.contains("vorbis") && acodecsList.contains("libvorbis")) replaceVorbisCodec = true;
1157     bool replaceLibfaacCodec = false;
1158     if (!acodecsList.contains("libfaac") && acodecsList.contains("aac")) replaceLibfaacCodec = true;
1159
1160
1161     if (editable || groups.count() == 0) {
1162         QDomElement profiles = doc.documentElement();
1163         if (editable && profiles.attribute("version", 0).toInt() < 1) {
1164             kDebug() << "// OLD profile version";
1165             // this is an old profile version, update it
1166             QDomDocument newdoc;
1167             QDomElement newprofiles = newdoc.createElement("profiles");
1168             newprofiles.setAttribute("version", 1);
1169             newdoc.appendChild(newprofiles);
1170             QDomNodeList profilelist = doc.elementsByTagName("profile");
1171             for (int i = 0; i < profilelist.count(); i++) {
1172                 QString category = i18n("Custom");
1173                 QString extension;
1174                 QDomNode parent = profilelist.at(i).parentNode();
1175                 if (!parent.isNull()) {
1176                     QDomElement parentNode = parent.toElement();
1177                     if (parentNode.hasAttribute("name")) category = parentNode.attribute("name");
1178                     extension = parentNode.attribute("extension");
1179                 }
1180                 profilelist.at(i).toElement().setAttribute("category", category);
1181                 if (!extension.isEmpty()) profilelist.at(i).toElement().setAttribute("extension", extension);
1182                 QDomNode n = profilelist.at(i).cloneNode();
1183                 newprofiles.appendChild(newdoc.importNode(n, true));
1184             }
1185             if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
1186                 KMessageBox::sorry(this, i18n("Unable to write to file %1", exportFile));
1187                 return;
1188             }
1189             QTextStream out(&file);
1190             out << newdoc.toString();
1191             file.close();
1192             parseFile(exportFile, editable);
1193             return;
1194         }
1195
1196         QDomNode node = doc.elementsByTagName("profile").at(0);
1197         if (node.isNull()) {
1198             kDebug() << "// Export file: " << exportFile << " IS BROKEN";
1199             return;
1200         }
1201         int count = 1;
1202         while (!node.isNull()) {
1203             QDomElement profile = node.toElement();
1204             QString profileName = profile.attribute("name");
1205             QString standard = profile.attribute("standard");
1206             QString params = profile.attribute("args");
1207
1208             if (replaceVorbisCodec && params.contains("acodec=vorbis")) {
1209                 // replace vorbis with libvorbis
1210                 params = params.replace("vorbis", "libvorbis");
1211             }
1212             if (replaceLibfaacCodec && params.contains("acodec=libfaac")) {
1213                 // replace libfaac with aac
1214                 params = params.replace("libfaac", "aac");
1215             }
1216
1217             QString category = profile.attribute("category", i18n("Custom"));
1218             QString dest = profile.attribute("destinationid");
1219             QString prof_extension = profile.attribute("extension");
1220             if (!prof_extension.isEmpty()) extension = prof_extension;
1221
1222             QList <QListWidgetItem *> list = m_view.format_list->findItems(category, Qt::MatchExactly);
1223             bool exists = false;
1224             for (int j = 0; j < list.count(); j++) {
1225                 if (list.at(j)->data(MetaGroupRole) == dest) {
1226                     exists = true;
1227                     break;
1228                 }
1229             }
1230             if (!exists) {
1231                 item = new QListWidgetItem(category, m_view.format_list);
1232                 item->setData(MetaGroupRole, dest);
1233             }
1234
1235             // Check if item with same name already exists and replace it,
1236             // allowing to override default profiles
1237
1238             list = m_view.size_list->findItems(profileName, Qt::MatchExactly);
1239
1240             for (int j = 0; j < list.count(); j++) {
1241                 if (list.at(j)->data(MetaGroupRole) == dest) {
1242                     QListWidgetItem *duplicate = list.takeAt(j);
1243                     delete duplicate;
1244                     j--;
1245                 }
1246             }
1247
1248             item = new QListWidgetItem(profileName, m_view.size_list);
1249             //kDebug() << "// ADDINg item with name: " << profileName << ", GRP" << category << ", DEST:" << dest ;
1250             item->setData(GroupRole, category);
1251             item->setData(MetaGroupRole, dest);
1252             item->setData(ExtensionRole, extension);
1253             item->setData(RenderRole, "avformat");
1254             item->setData(StandardRole, standard);
1255             item->setData(ParamsRole, params);
1256             if (profile.hasAttribute("url")) item->setData(ExtraRole, profile.attribute("url"));
1257             if (editable) {
1258                 item->setData(EditableRole, exportFile);
1259                 if (exportFile.endsWith("customprofiles.xml")) item->setIcon(KIcon("emblem-favorite"));
1260                 else item->setIcon(KIcon("applications-internet"));
1261             }
1262             node = doc.elementsByTagName("profile").at(count);
1263             count++;
1264         }
1265         return;
1266     }
1267
1268     int i = 0;
1269     QString groupName;
1270     QString profileName;
1271
1272     QString prof_extension;
1273     QString renderer;
1274     QString params;
1275     QString standard;
1276     KIcon icon;
1277
1278     while (!groups.item(i).isNull()) {
1279         documentElement = groups.item(i).toElement();
1280         QDomNode gname = documentElement.elementsByTagName("groupname").at(0);
1281         QString metagroupName;
1282         QString metagroupId;
1283         if (!gname.isNull()) {
1284             metagroupName = gname.firstChild().nodeValue();
1285             metagroupId = gname.toElement().attribute("id");
1286
1287             if (!metagroupName.isEmpty() && m_view.destination_list->findData(metagroupId) == -1) {
1288                 if (metagroupId == "dvd") icon = KIcon("media-optical");
1289                 else if (metagroupId == "audioonly") icon = KIcon("audio-x-generic");
1290                 else if (metagroupId == "websites") icon = KIcon("applications-internet");
1291                 else if (metagroupId == "mediaplayers") icon = KIcon("applications-multimedia");
1292                 else if (metagroupId == "lossless") icon = KIcon("drive-harddisk");
1293                 else if (metagroupId == "mobile") icon = KIcon("pda");
1294                 m_view.destination_list->addItem(icon, i18n(metagroupName.toUtf8().data()), metagroupId);
1295             }
1296         }
1297         groupName = documentElement.attribute("name", i18n("Custom"));
1298         extension = documentElement.attribute("extension", QString());
1299         renderer = documentElement.attribute("renderer", QString());
1300         QList <QListWidgetItem *> list = m_view.format_list->findItems(groupName, Qt::MatchExactly);
1301         bool exists = false;
1302         for (int j = 0; j < list.count(); j++) {
1303             if (list.at(j)->data(MetaGroupRole) == metagroupId) {
1304                 exists = true;
1305                 break;
1306             }
1307         }
1308         if (!exists) {
1309             item = new QListWidgetItem(groupName, m_view.format_list);
1310             item->setData(MetaGroupRole, metagroupId);
1311         }
1312
1313         QDomNode n = groups.item(i).firstChild();
1314         while (!n.isNull()) {
1315             if (n.toElement().tagName() != "profile") {
1316                 n = n.nextSibling();
1317                 continue;
1318             }
1319             profileElement = n.toElement();
1320             profileName = profileElement.attribute("name");
1321             standard = profileElement.attribute("standard");
1322             params = profileElement.attribute("args");
1323
1324             if (replaceVorbisCodec && params.contains("acodec=vorbis")) {
1325                 // replace vorbis with libvorbis
1326                 params = params.replace("vorbis", "libvorbis");
1327             }
1328             if (replaceLibfaacCodec && params.contains("acodec=libfaac")) {
1329                 // replace libfaac with aac
1330                 params = params.replace("libfaac", "aac");
1331             }
1332
1333             prof_extension = profileElement.attribute("extension");
1334             if (!prof_extension.isEmpty()) extension = prof_extension;
1335             item = new QListWidgetItem(profileName, m_view.size_list);
1336             item->setData(GroupRole, groupName);
1337             item->setData(MetaGroupRole, metagroupId);
1338             item->setData(ExtensionRole, extension);
1339             item->setData(RenderRole, renderer);
1340             item->setData(StandardRole, standard);
1341             item->setData(ParamsRole, params);
1342             if (profileElement.hasAttribute("url")) item->setData(ExtraRole, profileElement.attribute("url"));
1343             if (editable) item->setData(EditableRole, exportFile);
1344             n = n.nextSibling();
1345         }
1346
1347         i++;
1348     }
1349 }
1350
1351 void RenderWidget::setRenderJob(const QString &dest, int progress)
1352 {
1353     QTreeWidgetItem *item;
1354     QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(dest, Qt::MatchExactly, 1);
1355     if (!existing.isEmpty()) item = existing.at(0);
1356     else {
1357         item = new QTreeWidgetItem(m_view.running_jobs, QStringList() << QString() << dest << QString());
1358         item->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
1359         if (progress == 0) {
1360             item->setData(1, Qt::UserRole + 2, WAITINGJOB);
1361             item->setIcon(0, KIcon("media-playback-pause"));
1362             item->setData(1, Qt::UserRole, i18n("Waiting..."));
1363         }
1364     }
1365     item->setData(2, Qt::UserRole, progress);
1366     item->setData(1, Qt::UserRole + 2, RUNNINGJOB);
1367     if (progress == 0) {
1368         item->setIcon(0, KIcon("system-run"));
1369         item->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
1370         item->setData(1, Qt::UserRole + 1, QTime::currentTime());
1371         slotCheckJob();
1372     } else {
1373         QTime startTime = item->data(1, Qt::UserRole + 1).toTime();
1374         int seconds = startTime.secsTo(QTime::currentTime());;
1375         const QString t = i18n("Estimated time %1", QTime().addSecs(seconds * (100 - progress) / progress).toString("hh:mm:ss"));
1376         item->setData(1, Qt::UserRole, t);
1377     }
1378 }
1379
1380 void RenderWidget::setRenderStatus(const QString &dest, int status, const QString &error)
1381 {
1382     QTreeWidgetItem *item;
1383     QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(dest, Qt::MatchExactly, 1);
1384     if (!existing.isEmpty()) item = existing.at(0);
1385     else {
1386         item = new QTreeWidgetItem(m_view.running_jobs, QStringList() << QString() << dest << QString());
1387         item->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
1388     }
1389     item->setData(1, Qt::UserRole + 2, FINISHEDJOB);
1390     if (status == -1) {
1391         // Job finished successfully
1392         item->setIcon(0, KIcon("dialog-ok"));
1393         item->setData(2, Qt::UserRole, 100);
1394         QTime startTime = item->data(1, Qt::UserRole + 1).toTime();
1395         int seconds = startTime.secsTo(QTime::currentTime());
1396         const QTime tm = QTime().addSecs(seconds);
1397         const QString t = i18n("Rendering finished in %1", tm.toString("hh:mm:ss"));
1398         item->setData(1, Qt::UserRole, t);
1399         QString itemGroup = item->data(0, Qt::UserRole).toString();
1400         if (itemGroup == "dvd") {
1401             emit openDvdWizard(item->text(1), item->data(0, Qt::UserRole + 1).toString());
1402         } else if (itemGroup == "websites") {
1403             QString url = item->data(0, Qt::UserRole + 1).toString();
1404             if (!url.isEmpty()) new KRun(url, this);
1405         }
1406     } else if (status == -2) {
1407         // Rendering crashed
1408         item->setData(1, Qt::UserRole, i18n("Rendering crashed"));
1409         item->setIcon(0, KIcon("dialog-close"));
1410         item->setData(2, Qt::UserRole, 100);
1411         m_view.error_log->append(i18n("<strong>Rendering of %1 crashed</strong><br />", dest));
1412         m_view.error_log->append(error);
1413         m_view.error_log->append("<hr />");
1414         m_view.error_box->setVisible(true);
1415     } else if (status == -3) {
1416         // User aborted job
1417         item->setData(1, Qt::UserRole, i18n("Rendering aborted"));
1418         item->setIcon(0, KIcon("dialog-cancel"));
1419         item->setData(2, Qt::UserRole, 100);
1420     }
1421     slotCheckJob();
1422     checkRenderStatus();
1423 }
1424
1425 void RenderWidget::slotAbortCurrentJob()
1426 {
1427     QTreeWidgetItem *current = m_view.running_jobs->currentItem();
1428     if (current) {
1429         if (current->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB)
1430             emit abortProcess(current->text(1));
1431         else {
1432             delete current;
1433             slotCheckJob();
1434             checkRenderStatus();
1435         }
1436     }
1437 }
1438
1439 void RenderWidget::slotCheckJob()
1440 {
1441     bool activate = false;
1442     QTreeWidgetItem *current = m_view.running_jobs->currentItem();
1443     if (current) {
1444         if (current->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB)
1445             m_view.abort_job->setText(i18n("Abort Job"));
1446         else m_view.abort_job->setText(i18n("Remove Job"));
1447         activate = true;
1448     }
1449     m_view.abort_job->setEnabled(activate);
1450 }
1451
1452 void RenderWidget::slotCLeanUpJobs()
1453 {
1454     int ix = 0;
1455     QTreeWidgetItem *current = m_view.running_jobs->topLevelItem(ix);
1456     while (current) {
1457         if (current->data(1, Qt::UserRole + 2).toInt() == FINISHEDJOB)
1458             delete current;
1459         else ix++;
1460         current = m_view.running_jobs->topLevelItem(ix);
1461     }
1462     slotCheckJob();
1463 }
1464
1465 void RenderWidget::parseScriptFiles()
1466 {
1467     QStringList scriptsFilter;
1468     scriptsFilter << "*.sh";
1469     m_view.scripts_list->clear();
1470
1471     QTreeWidgetItem *item;
1472     // List the project scripts
1473     QStringList scriptFiles = QDir(m_projectFolder + "scripts").entryList(scriptsFilter, QDir::Files);
1474     for (int i = 0; i < scriptFiles.size(); ++i) {
1475         KUrl scriptpath(m_projectFolder + "scripts/" + scriptFiles.at(i));
1476         QString target;
1477         QString renderer;
1478         QString melt;
1479         QFile file(scriptpath.path());
1480         if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
1481             while (!file.atEnd()) {
1482                 QByteArray line = file.readLine();
1483                 if (line.startsWith("TARGET=")) {
1484                     target = QString(line).section("TARGET=", 1).simplified();
1485                     target.remove(QChar('"'));
1486                 } else if (line.startsWith("RENDERER=")) {
1487                     renderer = QString(line).section("RENDERER=", 1).simplified();
1488                     renderer.remove(QChar('"'));
1489                 } else if (line.startsWith("MELT=")) {
1490                     melt = QString(line).section("MELT=", 1).simplified();
1491                     melt.remove(QChar('"'));
1492                 }
1493             }
1494             file.close();
1495         }
1496         if (target.isEmpty()) continue;
1497         item = new QTreeWidgetItem(m_view.scripts_list, QStringList() << QString() << scriptpath.fileName());
1498         if (!renderer.isEmpty() && renderer.contains('/') && !QFile::exists(renderer)) {
1499             item->setIcon(0, KIcon("dialog-cancel"));
1500             item->setToolTip(1, i18n("Script contains wrong command: %1", renderer));
1501             item->setData(0, Qt::UserRole, '1');
1502         } else if (!melt.isEmpty() && melt.contains('/') && !QFile::exists(melt)) {
1503             item->setIcon(0, KIcon("dialog-cancel"));
1504             item->setToolTip(1, i18n("Script contains wrong command: %1", melt));
1505             item->setData(0, Qt::UserRole, '1');
1506         } else item->setIcon(0, KIcon("application-x-executable-script"));
1507         item->setSizeHint(0, QSize(m_view.scripts_list->columnWidth(0), fontMetrics().height() * 2));
1508         item->setData(1, Qt::UserRole, target.simplified());
1509         item->setData(1, Qt::UserRole + 1, scriptpath.path());
1510     }
1511     bool activate = false;
1512     QTreeWidgetItem *script = m_view.scripts_list->topLevelItem(0);
1513     if (script) {
1514         script->setSelected(true);
1515         m_view.scripts_list->setCurrentItem(script);
1516         activate = true;
1517     }
1518 //    m_view.start_script->setEnabled(activate);
1519 //    m_view.delete_script->setEnabled(activate);
1520 }
1521
1522 void RenderWidget::slotCheckScript()
1523 {
1524     QTreeWidgetItem *item = m_view.scripts_list->currentItem();
1525     if (item == NULL) return;
1526     m_view.start_script->setEnabled(item->data(0, Qt::UserRole).toString().isEmpty());
1527     m_view.delete_script->setEnabled(true);
1528 }
1529
1530 void RenderWidget::slotStartScript()
1531 {
1532     QTreeWidgetItem *item = m_view.scripts_list->currentItem();
1533     if (item) {
1534         QString destination = item->data(1, Qt::UserRole).toString();
1535         QString path = item->data(1, Qt::UserRole + 1).toString();
1536         // Insert new job in queue
1537         QTreeWidgetItem *renderItem;
1538         QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(destination, Qt::MatchExactly, 1);
1539         kDebug() << "------  START SCRIPT";
1540         if (!existing.isEmpty()) {
1541             renderItem = existing.at(0);
1542             if (renderItem->data(1, Qt::UserRole + 2).toInt() == RUNNINGJOB) {
1543                 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"));
1544                 return;
1545             }
1546         } else renderItem = new QTreeWidgetItem(m_view.running_jobs, QStringList() << QString() << destination << QString());
1547         kDebug() << "------  START SCRIPT 2";
1548         renderItem->setData(2, Qt::UserRole, 0);
1549         renderItem->setData(1, Qt::UserRole + 2, WAITINGJOB);
1550         renderItem->setIcon(0, KIcon("media-playback-pause"));
1551         renderItem->setData(1, Qt::UserRole, i18n("Waiting..."));
1552         renderItem->setSizeHint(1, QSize(m_view.running_jobs->columnWidth(1), fontMetrics().height() * 2));
1553         renderItem->setData(1, Qt::UserRole + 1, QTime::currentTime());
1554         renderItem->setData(1, Qt::UserRole + 3, path);
1555         renderItem->setData(1, Qt::UserRole + 4, '1');
1556         checkRenderStatus();
1557         m_view.tabWidget->setCurrentIndex(1);
1558     }
1559 }
1560
1561 void RenderWidget::slotDeleteScript()
1562 {
1563     QTreeWidgetItem *item = m_view.scripts_list->currentItem();
1564     if (item) {
1565         QString path = item->data(1, Qt::UserRole + 1).toString();
1566         KIO::NetAccess::del(path + ".mlt", this);
1567         KIO::NetAccess::del(path, this);
1568         parseScriptFiles();
1569     }
1570 }
1571
1572 void RenderWidget::slotGenerateScript()
1573 {
1574     slotPrepareExport(true);
1575 }
1576
1577 void RenderWidget::slotHideLog()
1578 {
1579     m_view.error_box->setVisible(false);
1580 }
1581
1582 void RenderWidget::setRenderProfile(const QString &dest, const QString &name, const QString &url)
1583 {
1584     m_view.destination_list->blockSignals(true);
1585     m_view.format_list->blockSignals(true);
1586     m_view.size_list->blockSignals(true);
1587
1588     if (!url.isEmpty()) m_view.out_file->setUrl(KUrl(url));
1589
1590     for (int i = 0; i < m_view.destination_list->count(); i++) {
1591         if (m_view.destination_list->itemData(i, Qt::UserRole) == dest) {
1592             m_view.destination_list->setCurrentIndex(i);
1593             break;
1594         }
1595     }
1596     QList<QListWidgetItem *> childs = m_view.size_list->findItems(name, Qt::MatchExactly);
1597     if (!childs.isEmpty()) {
1598         QListWidgetItem *profile = childs.at(0);
1599         if (profile->isHidden()) {
1600             QString group = profile->data(GroupRole).toString();
1601             childs = m_view.format_list->findItems(group, Qt::MatchExactly);
1602             if (!childs.isEmpty()) {
1603                 m_view.format_list->setCurrentItem(childs.at(0));
1604             }
1605         }
1606         refreshView();
1607         m_view.size_list->blockSignals(false);
1608         m_view.size_list->setCurrentItem(profile);
1609     } else m_view.size_list->blockSignals(false);
1610     m_view.destination_list->blockSignals(false);
1611     m_view.format_list->blockSignals(false);
1612
1613 }
1614
1615 bool RenderWidget::startWaitingRenderJobs()
1616 {
1617     m_blockProcessing = true;
1618     QString autoscriptFile = getFreeScriptName("auto");
1619     QFile file(autoscriptFile);
1620     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
1621         kWarning() << "//////  ERROR writing to file: " << autoscriptFile;
1622         KMessageBox::error(0, i18n("Cannot write to file %1", autoscriptFile));
1623         return false;
1624     }
1625
1626     QTextStream outStream(&file);
1627     outStream << "#! /bin/sh" << "\n" << "\n";
1628     QTreeWidgetItem *item = m_view.running_jobs->topLevelItem(0);
1629     while (item) {
1630         if (item->data(1, Qt::UserRole + 2).toInt() == WAITINGJOB) {
1631             if (item->data(1, Qt::UserRole + 4).isNull()) {
1632                 // Add render process for item
1633                 const QString params = item->data(1, Qt::UserRole + 3).toStringList().join(" ");
1634                 outStream << m_renderer << " " << params << "\n";
1635             } else {
1636                 // Script item
1637                 outStream << item->data(1, Qt::UserRole + 3).toString() << "\n";
1638             }
1639         }
1640         item = m_view.running_jobs->itemBelow(item);
1641     }
1642     // erase itself when rendering is finished
1643     outStream << "rm " << autoscriptFile << "\n" << "\n";
1644     if (file.error() != QFile::NoError) {
1645         KMessageBox::error(0, i18n("Cannot write to file %1", autoscriptFile));
1646         file.close();
1647         m_blockProcessing = false;
1648         return false;
1649     }
1650     file.close();
1651     QFile::setPermissions(autoscriptFile, file.permissions() | QFile::ExeUser);
1652     QProcess::startDetached(autoscriptFile, QStringList());
1653     return true;
1654 }
1655
1656 QString RenderWidget::getFreeScriptName(const QString &prefix)
1657 {
1658     int ix = 0;
1659     QString scriptsFolder = m_projectFolder + "scripts/";
1660     KStandardDirs::makeDir(scriptsFolder);
1661     QString path;
1662     while (path.isEmpty() || QFile::exists(path)) {
1663         ix++;
1664         path = scriptsFolder + prefix + i18n("script") + QString::number(ix).rightJustified(3, '0', false) + ".sh";
1665     }
1666     return path;
1667 }
1668
1669 void RenderWidget::slotPlayRendering(QTreeWidgetItem *item, int)
1670 {
1671     if (KdenliveSettings::defaultplayerapp().isEmpty() || item->data(1, Qt::UserRole + 2).toInt() != FINISHEDJOB) return;
1672     const QByteArray startId = KStartupInfo::createNewStartupId();
1673     const QString command = KdenliveSettings::defaultplayerapp() + ' ' + item->text(1);
1674     KRun::runCommand(command, KdenliveSettings::defaultplayerapp(), KdenliveSettings::defaultplayerapp(), this, startId);
1675 }
1676
1677
1678