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

   1 /***************************************************************************
   2  *   Copyright (C) 2011 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 "archivewidget.h"
  22 #include "titlewidget.h"
  23
  24 #include <KLocale>
  25 #include <KDiskFreeSpaceInfo>
  26 #include <KUrlRequester>
  27 #include <KFileDialog>
  28 #include <KMessageBox>
  29 #include <KGuiItem>
  30 #include <KIO/NetAccess>
  31 #include <KTar>
  32 #include <KDebug>
  33 #include <KApplication>
  34 #include <kio/directorysizejob.h>
  35 #if KDE_IS_VERSION(4,7,0)
  36 #include <KMessageWidget>
  37 #endif
  38
  39 #include <QTreeWidget>
  40 #include <QtConcurrentRun>
  41 #include "projectsettings.h"
  42
  43
  44 ArchiveWidget::ArchiveWidget(const QString &projectName, const QDomDocument &doc, const QList <DocClipBase*> &list, const QStringList &luma_list, QWidget * parent) :
  45         QDialog(parent)
  46         , m_requestedSize(0)
  47         , m_copyJob(NULL)
  48         , m_name(projectName.section('.', 0, -2))
  49         , m_doc(doc)
  50         , m_temp(NULL)
  51         , m_abortArchive(false)
  52         , m_extractMode(false)
  53         , m_progressTimer(NULL)
  54         , m_extractArchive(NULL)
  55         , m_missingClips(0)
  56 {
  57     setAttribute(Qt::WA_DeleteOnClose);
  58     setupUi(this);
  59     setWindowTitle(i18n("Archive Project"));
  60     archive_url->setUrl(KUrl(QDir::homePath()));
  61     connect(archive_url, SIGNAL(textChanged(QString)), this, SLOT(slotCheckSpace()));
  62     connect(this, SIGNAL(archivingFinished(bool)), this, SLOT(slotArchivingFinished(bool)));
  63     connect(this, SIGNAL(archiveProgress(int)), this, SLOT(slotArchivingProgress(int)));
  64     connect(proxy_only, SIGNAL(stateChanged(int)), this, SLOT(slotProxyOnly(int)));
  65
  66     // Setup categories
  67     QTreeWidgetItem *videos = new QTreeWidgetItem(files_list, QStringList() << i18n("Video clips"));
  68     videos->setIcon(0, KIcon("video-x-generic"));
  69     videos->setData(0, Qt::UserRole, "videos");
  70     videos->setExpanded(false);
  71     QTreeWidgetItem *sounds = new QTreeWidgetItem(files_list, QStringList() << i18n("Audio clips"));
  72     sounds->setIcon(0, KIcon("audio-x-generic"));
  73     sounds->setData(0, Qt::UserRole, "sounds");
  74     sounds->setExpanded(false);
  75     QTreeWidgetItem *images = new QTreeWidgetItem(files_list, QStringList() << i18n("Image clips"));
  76     images->setIcon(0, KIcon("image-x-generic"));
  77     images->setData(0, Qt::UserRole, "images");
  78     images->setExpanded(false);
  79     QTreeWidgetItem *slideshows = new QTreeWidgetItem(files_list, QStringList() << i18n("Slideshow clips"));
  80     slideshows->setIcon(0, KIcon("image-x-generic"));
  81     slideshows->setData(0, Qt::UserRole, "slideshows");
  82     slideshows->setExpanded(false);
  83     QTreeWidgetItem *texts = new QTreeWidgetItem(files_list, QStringList() << i18n("Text clips"));
  84     texts->setIcon(0, KIcon("text-plain"));
  85     texts->setData(0, Qt::UserRole, "texts");
  86     texts->setExpanded(false);
  87     QTreeWidgetItem *playlists = new QTreeWidgetItem(files_list, QStringList() << i18n("Playlist clips"));
  88     playlists->setIcon(0, KIcon("video-mlt-playlist"));
  89     playlists->setData(0, Qt::UserRole, "playlist");
  90     playlists->setExpanded(false);
  91     QTreeWidgetItem *others = new QTreeWidgetItem(files_list, QStringList() << i18n("Other clips"));
  92     others->setIcon(0, KIcon("unknown"));
  93     others->setData(0, Qt::UserRole, "others");
  94     others->setExpanded(false);
  95     QTreeWidgetItem *lumas = new QTreeWidgetItem(files_list, QStringList() << i18n("Luma files"));
  96     lumas->setIcon(0, KIcon("image-x-generic"));
  97     lumas->setData(0, Qt::UserRole, "lumas");
  98     lumas->setExpanded(false);
  99
 100     QTreeWidgetItem *proxies = new QTreeWidgetItem(files_list, QStringList() << i18n("Proxy clips"));
 101     proxies->setIcon(0, KIcon("video-x-generic"));
 102     proxies->setData(0, Qt::UserRole, "proxy");
 103     proxies->setExpanded(false);
 104
 105     // process all files
 106     QStringList allFonts;
 107     KUrl::List fileUrls;
 108     QStringList fileNames;
 109     QStringList extraImageUrls;
 110     QStringList otherUrls;
 111     generateItems(lumas, luma_list);
 112
 113     QMap <QString, QString> slideUrls;
 114     QMap <QString, QString> audioUrls;
 115     QMap <QString, QString>videoUrls;
 116     QMap <QString, QString>imageUrls;
 117     QMap <QString, QString>playlistUrls;
 118     QMap <QString, QString>proxyUrls;
 119
 120     for (int i = 0; i < list.count(); ++i) {
 121         DocClipBase *clip = list.at(i);
 122         CLIPTYPE t = clip->clipType();
 123         QString id = clip->getId();
 124         if (t == SLIDESHOW) {
 125             KUrl slideUrl = clip->fileURL();
 126             //TODO: Slideshow files
 127             slideUrls.insert(id, slideUrl.path());
 128         }
 129         else if (t == IMAGE) imageUrls.insert(id, clip->fileURL().path());
 130         else if (t == TEXT) {
 131             QStringList imagefiles = TitleWidget::extractImageList(clip->getProperty("xmldata"));
 132             QStringList fonts = TitleWidget::extractFontList(clip->getProperty("xmldata"));
 133             extraImageUrls << imagefiles;
 134             allFonts << fonts;
 135         } else if (t == PLAYLIST) {
 136             playlistUrls.insert(id, clip->fileURL().path());
 137             QStringList files = ProjectSettings::extractPlaylistUrls(clip->fileURL().path());
 138             otherUrls << files;
 139         }
 140         else if (!clip->fileURL().isEmpty()) {
 141             if (t == AUDIO) audioUrls.insert(id, clip->fileURL().path());
 142             else {
 143                 videoUrls.insert(id, clip->fileURL().path());
 144                 // Check if we have a proxy
 145                 QString proxy = clip->getProperty("proxy");
 146                 if (!proxy.isEmpty() && proxy != "-" && QFile::exists(proxy)) proxyUrls.insert(id, proxy);
 147             }
 148         }
 149     }
 150
 151     generateItems(images, extraImageUrls);
 152     generateItems(sounds, audioUrls);
 153     generateItems(videos, videoUrls);
 154     generateItems(images, imageUrls);
 155     generateItems(slideshows, slideUrls);
 156     generateItems(playlists, playlistUrls);
 157     generateItems(others, otherUrls);
 158     generateItems(proxies, proxyUrls);
 159
 160     allFonts.removeDuplicates();
 161
 162 #if KDE_IS_VERSION(4,7,0)
 163         m_infoMessage = new KMessageWidget(this);
 164         QVBoxLayout *s =  static_cast <QVBoxLayout*> (layout());
 165         s->insertWidget(5, m_infoMessage);
 166         m_infoMessage->setCloseButtonVisible(false);
 167         m_infoMessage->setWordWrap(true);
 168         m_infoMessage->hide();
 169 #endif
 170
 171         // missing clips, warn user
 172     if (m_missingClips > 0) {
 173         QString infoText = i18np("You have %1 missing clip in your project.", "You have %1 missing clips in your project.", m_missingClips);
 174 #if KDE_IS_VERSION(4,7,0)
 175         m_infoMessage->setMessageType(KMessageWidget::Warning);
 176         m_infoMessage->setText(infoText);
 177         m_infoMessage->animatedShow();
 178 #else
 179         KMessageBox::sorry(this, infoText);
 180 #endif
 181     }
 182
 183     //TODO: fonts
 184
 185     // Hide unused categories, add item count
 186     int total = 0;
 187     for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 188         QTreeWidgetItem *parentItem = files_list->topLevelItem(i);
 189         int items = parentItem->childCount();
 190         if (items == 0) {
 191             files_list->topLevelItem(i)->setHidden(true);
 192         }
 193         else {
 194             if (parentItem->data(0, Qt::UserRole).toString() == "slideshows")
 195             {
 196                 // Special case: slideshows contain several files
 197                 for (int j = 0; j < items; j++) {
 198                     total += parentItem->child(j)->data(0, Qt::UserRole + 1).toStringList().count();
 199                 }
 200             }
 201             else total += items;
 202             parentItem->setText(0, files_list->topLevelItem(i)->text(0) + ' ' + i18np("(%1 item)", "(%1 items)", items));
 203         }
 204     }
 205     if (m_name.isEmpty()) m_name = i18n("Untitled");
 206     compressed_archive->setText(compressed_archive->text() + " (" + m_name + ".tar.gz)");
 207     project_files->setText(i18np("%1 file to archive, requires %2", "%1 files to archive, requires %2", total, KIO::convertSize(m_requestedSize)));
 208     buttonBox->button(QDialogButtonBox::Apply)->setText(i18n("Archive"));
 209     connect(buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()), this, SLOT(slotStartArchiving()));
 210     buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 211
 212     slotCheckSpace();
 213 }
 214
 215 // Constructor for extract widget
 216 ArchiveWidget::ArchiveWidget(const KUrl &url, QWidget * parent):
 217     QDialog(parent),
 218     m_extractMode(true),
 219     m_extractUrl(url)
 220 {
 221     //setAttribute(Qt::WA_DeleteOnClose);
 222
 223     setupUi(this);
 224     m_progressTimer = new QTimer;
 225     m_progressTimer->setInterval(800);
 226     m_progressTimer->setSingleShot(false);
 227     connect(m_progressTimer, SIGNAL(timeout()), this, SLOT(slotExtractProgress()));
 228     connect(this, SIGNAL(extractingFinished()), this, SLOT(slotExtractingFinished()));
 229     connect(this, SIGNAL(showMessage(QString,QString)), this, SLOT(slotDisplayMessage(QString,QString)));
 230
 231     compressed_archive->setHidden(true);
 232     proxy_only->setHidden(true);
 233     project_files->setHidden(true);
 234     files_list->setHidden(true);
 235     label->setText(i18n("Extract to"));
 236     setWindowTitle(i18n("Open Archived Project"));
 237     archive_url->setUrl(KUrl(QDir::homePath()));
 238     buttonBox->button(QDialogButtonBox::Apply)->setText(i18n("Extract"));
 239     connect(buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()), this, SLOT(slotStartExtracting()));
 240     buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 241     adjustSize();
 242     m_archiveThread = QtConcurrent::run(this, &ArchiveWidget::openArchiveForExtraction);
 243 }
 244
 245
 246 ArchiveWidget::~ArchiveWidget()
 247 {
 248     delete m_extractArchive;
 249     delete m_progressTimer;
 250 }
 251
 252 void ArchiveWidget::slotDisplayMessage(const QString &icon, const QString &text)
 253 {
 254     icon_info->setPixmap(KIcon(icon).pixmap(16, 16));
 255     text_info->setText(text);
 256 }
 257
 258 void ArchiveWidget::slotJobResult(bool success, const QString &text)
 259 {
 260 #if KDE_IS_VERSION(4,7,0)
 261     m_infoMessage->setMessageType(success ? KMessageWidget::Positive : KMessageWidget::Warning);
 262     m_infoMessage->setText(text);
 263     m_infoMessage->animatedShow();
 264 #else
 265     if (success) icon_info->setPixmap(KIcon("dialog-ok").pixmap(16, 16));
 266     else icon_info->setPixmap(KIcon("dialog-close").pixmap(16, 16));
 267     text_info->setText(text);
 268 #endif
 269 }
 270
 271 void ArchiveWidget::openArchiveForExtraction()
 272 {
 273     emit showMessage("system-run", i18n("Opening archive..."));
 274     m_extractArchive = new KTar(m_extractUrl.path());
 275     if (!m_extractArchive->isOpen() && !m_extractArchive->open( QIODevice::ReadOnly )) {
 276         emit showMessage("dialog-close", i18n("Cannot open archive file:\n %1", m_extractUrl.path()));
 277         groupBox->setEnabled(false);
 278         return;
 279     }
 280
 281     // Check that it is a kdenlive project archive
 282     bool isProjectArchive = false;
 283     QStringList files = m_extractArchive->directory()->entries();
 284     for (int i = 0; i < files.count(); ++i) {
 285         if (files.at(i).endsWith(".kdenlive")) {
 286             m_projectName = files.at(i);
 287             isProjectArchive = true;
 288             break;
 289         }
 290     }
 291
 292     if (!isProjectArchive) {
 293         emit showMessage("dialog-close", i18n("File %1\n is not an archived Kdenlive project", m_extractUrl.path()));
 294         groupBox->setEnabled(false);
 295         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 296         return;
 297     }
 298     buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 299     emit showMessage("dialog-ok", i18n("Ready"));
 300 }
 301
 302 void ArchiveWidget::done ( int r )
 303 {
 304     if (closeAccepted()) QDialog::done(r);
 305 }
 306
 307 void ArchiveWidget::closeEvent ( QCloseEvent * e )
 308 {
 309
 310     if (closeAccepted()) e->accept();
 311     else e->ignore();
 312 }
 313
 314
 315 bool ArchiveWidget::closeAccepted()
 316 {
 317     if (!m_extractMode && !archive_url->isEnabled()) {
 318         // Archiving in progress, should we stop?
 319         if (KMessageBox::warningContinueCancel(this, i18n("Archiving in progress, do you want to stop it?"), i18n("Stop Archiving"), KGuiItem(i18n("Stop Archiving"))) != KMessageBox::Continue) {
 320             return false;
 321         }
 322         if (m_copyJob) m_copyJob->kill();
 323     }
 324     return true;
 325 }
 326
 327
 328 void ArchiveWidget::generateItems(QTreeWidgetItem *parentItem, const QStringList& items)
 329 {
 330     QStringList filesList;
 331     QString fileName;
 332     int ix = 0;
 333     bool isSlideshow = parentItem->data(0, Qt::UserRole).toString() == "slideshows";
 334     foreach(const QString & file, items) {
 335         QTreeWidgetItem *item = new QTreeWidgetItem(parentItem, QStringList() << file);
 336         fileName = KUrl(file).fileName();
 337         if (isSlideshow) {
 338             // we store each slideshow in a separate subdirectory
 339             item->setData(0, Qt::UserRole, ix);
 340             ix++;
 341             KUrl slideUrl(file);
 342             QDir dir(slideUrl.directory(KUrl::AppendTrailingSlash));
 343             if (slideUrl.fileName().startsWith(".all.")) {
 344                 // mimetype slideshow (for example *.png)
 345                     QStringList filters;
 346                     // TODO: improve jpeg image detection with extension like jpeg, requires change in MLT image producers
 347                     filters << "*." + slideUrl.fileName().section('.', -1);
 348                     dir.setNameFilters(filters);
 349                     QFileInfoList resultList = dir.entryInfoList(QDir::Files);
 350                     QStringList slideImages;
 351                     qint64 totalSize = 0;
 352                     for (int i = 0; i < resultList.count(); ++i) {
 353                         totalSize += resultList.at(i).size();
 354                         slideImages << resultList.at(i).absoluteFilePath();
 355                     }
 356                     item->setData(0, Qt::UserRole + 1, slideImages);
 357                     item->setData(0, Qt::UserRole + 3, totalSize);
 358                     m_requestedSize += totalSize;
 359             }
 360             else {
 361                 // pattern url (like clip%.3d.png)
 362                 QStringList result = dir.entryList(QDir::Files);
 363                 QString filter = slideUrl.fileName();
 364                 QString ext = filter.section('.', -1);
 365                 filter = filter.section('%', 0, -2);
 366                 QString regexp = '^' + filter + "\\d+\\." + ext + '$';
 367                 QRegExp rx(regexp);
 368                 QStringList slideImages;
 369                 QString directory = dir.absolutePath();
 370                 if (!directory.endsWith('/')) directory.append('/');
 371                 qint64 totalSize = 0;
 372                 foreach(const QString & path, result) {
 373                     if (rx.exactMatch(path)) {
 374                         totalSize += QFileInfo(directory + path).size();
 375                         slideImages <<  directory + path;
 376                     }
 377                 }
 378                 item->setData(0, Qt::UserRole + 1, slideImages);
 379                 item->setData(0, Qt::UserRole + 3, totalSize);
 380                 m_requestedSize += totalSize;
 381             }
 382         }
 383         else if (filesList.contains(fileName)) {
 384             // we have 2 files with same name
 385             int ix = 0;
 386             QString newFileName = fileName.section('.', 0, -2) + '_' + QString::number(ix) + '.' + fileName.section('.', -1);
 387             while (filesList.contains(newFileName)) {
 388                 ix ++;
 389                 newFileName = fileName.section('.', 0, -2) + '_' + QString::number(ix) + '.' + fileName.section('.', -1);
 390             }
 391             fileName = newFileName;
 392             item->setData(0, Qt::UserRole, fileName);
 393         }
 394         if (!isSlideshow) {
 395             qint64 fileSize = QFileInfo(file).size();
 396             if (fileSize <= 0) {
 397                 item->setIcon(0, KIcon("edit-delete"));
 398                 m_missingClips++;
 399             }
 400             else {
 401                 m_requestedSize += fileSize;
 402                 item->setData(0, Qt::UserRole + 3, fileSize);
 403             }
 404             filesList << fileName;
 405         }
 406     }
 407 }
 408
 409 void ArchiveWidget::generateItems(QTreeWidgetItem *parentItem, const QMap <QString, QString>& items)
 410 {
 411     QStringList filesList;
 412     QString fileName;
 413     int ix = 0;
 414     bool isSlideshow = parentItem->data(0, Qt::UserRole).toString() == "slideshows";
 415     QMap<QString, QString>::const_iterator it = items.constBegin();
 416     while (it != items.constEnd()) {
 417         QString file = it.value();
 418         QTreeWidgetItem *item = new QTreeWidgetItem(parentItem, QStringList() << file);
 419         // Store the clip's id
 420         item->setData(0, Qt::UserRole + 2, it.key());
 421         fileName = KUrl(file).fileName();
 422         if (isSlideshow) {
 423             // we store each slideshow in a separate subdirectory
 424             item->setData(0, Qt::UserRole, ix);
 425             ix++;
 426             KUrl slideUrl(file);
 427             QDir dir(slideUrl.directory(KUrl::AppendTrailingSlash));
 428             if (slideUrl.fileName().startsWith(".all.")) {
 429                 // mimetype slideshow (for example *.png)
 430                     QStringList filters;
 431                     // TODO: improve jpeg image detection with extension like jpeg, requires change in MLT image producers
 432                     filters << "*." + slideUrl.fileName().section('.', -1);
 433                     dir.setNameFilters(filters);
 434                     QFileInfoList resultList = dir.entryInfoList(QDir::Files);
 435                     QStringList slideImages;
 436                     qint64 totalSize = 0;
 437                     for (int i = 0; i < resultList.count(); ++i) {
 438                         totalSize += resultList.at(i).size();
 439                         slideImages << resultList.at(i).absoluteFilePath();
 440                     }
 441                     item->setData(0, Qt::UserRole + 1, slideImages);
 442                     item->setData(0, Qt::UserRole + 3, totalSize);
 443                     m_requestedSize += totalSize;
 444             }
 445             else {
 446                 // pattern url (like clip%.3d.png)
 447                 QStringList result = dir.entryList(QDir::Files);
 448                 QString filter = slideUrl.fileName();
 449                 QString ext = filter.section('.', -1);
 450                 filter = filter.section('%', 0, -2);
 451                 QString regexp = '^' + filter + "\\d+\\." + ext + '$';
 452                 QRegExp rx(regexp);
 453                 QStringList slideImages;
 454                 qint64 totalSize = 0;
 455                 QString directory = dir.absolutePath();
 456                 if (!directory.endsWith('/')) directory.append('/');
 457                 foreach(const QString & path, result) {
 458                     if (rx.exactMatch(path)) {
 459                         totalSize += QFileInfo(directory + path).size();
 460                         slideImages <<  directory + path;
 461                     }
 462                 }
 463                 item->setData(0, Qt::UserRole + 1, slideImages);
 464                 item->setData(0, Qt::UserRole + 3, totalSize);
 465                 m_requestedSize += totalSize;
 466             }
 467         }
 468         else if (filesList.contains(fileName)) {
 469             // we have 2 files with same name
 470             int ix = 0;
 471             QString newFileName = fileName.section('.', 0, -2) + '_' + QString::number(ix) + '.' + fileName.section('.', -1);
 472             while (filesList.contains(newFileName)) {
 473                 ix ++;
 474                 newFileName = fileName.section('.', 0, -2) + "_" + QString::number(ix) + "." + fileName.section('.', -1);
 475             }
 476             fileName = newFileName;
 477             item->setData(0, Qt::UserRole, fileName);
 478         }
 479         if (!isSlideshow) {
 480             qint64 fileSize = QFileInfo(file).size();
 481             if (fileSize <= 0) {
 482                 item->setIcon(0, KIcon("edit-delete"));
 483                 m_missingClips++;
 484             }
 485             else {
 486                 m_requestedSize += fileSize;
 487                 item->setData(0, Qt::UserRole + 3, fileSize);
 488             }
 489             filesList << fileName;
 490         }
 491         ++it;
 492     }
 493 }
 494
 495 void ArchiveWidget::slotCheckSpace()
 496 {
 497     KDiskFreeSpaceInfo inf = KDiskFreeSpaceInfo::freeSpaceInfo( archive_url->url().path());
 498     KIO::filesize_t freeSize = inf.available();
 499     if (freeSize > m_requestedSize) {
 500         // everything is ok
 501         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 502         slotDisplayMessage("dialog-ok", i18n("Available space on drive: %1", KIO::convertSize(freeSize)));
 503     }
 504     else {
 505         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 506         slotDisplayMessage("dialog-close", i18n("Not enough space on drive, free space: %1", KIO::convertSize(freeSize)));
 507     }
 508 }
 509
 510 bool ArchiveWidget::slotStartArchiving(bool firstPass)
 511 {
 512     if (firstPass && (m_copyJob || m_archiveThread.isRunning())) {
 513         // archiving in progress, abort
 514         if (m_copyJob) m_copyJob->kill(KJob::EmitResult);
 515         m_abortArchive = true;
 516         return true;
 517     }
 518     bool isArchive = compressed_archive->isChecked();
 519     if (!firstPass) m_copyJob = NULL;
 520     else {
 521         //starting archiving
 522         m_abortArchive = false;
 523         m_duplicateFiles.clear();
 524         m_replacementList.clear();
 525         m_foldersList.clear();
 526         m_filesList.clear();
 527         slotDisplayMessage("system-run", i18n("Archiving..."));
 528         repaint();
 529         archive_url->setEnabled(false);
 530         proxy_only->setEnabled(false);
 531         compressed_archive->setEnabled(false);
 532     }
 533     KUrl::List files;
 534     KUrl destUrl;
 535     QString destPath;
 536     QTreeWidgetItem *parentItem;
 537     bool isSlideshow = false;
 538     int items = 0;
 539
 540     // We parse all files going into one folder, then start the copy job
 541     for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 542         parentItem = files_list->topLevelItem(i);
 543         if (parentItem->isDisabled()) {
 544             parentItem->setExpanded(false);
 545             continue;
 546         }
 547         if (parentItem->childCount() > 0) {
 548             if (parentItem->data(0, Qt::UserRole).toString() == "slideshows") {
 549                 KUrl slideFolder(archive_url->url().path(KUrl::AddTrailingSlash) + "slideshows");
 550                 if (isArchive) m_foldersList.append("slideshows");
 551                 else KIO::NetAccess::mkdir(slideFolder, this);
 552                 isSlideshow = true;
 553             }
 554             else isSlideshow = false;
 555             files_list->setCurrentItem(parentItem);
 556             parentItem->setExpanded(true);
 557             destPath = parentItem->data(0, Qt::UserRole).toString() + '/';
 558             destUrl = KUrl(archive_url->url().path(KUrl::AddTrailingSlash) + destPath);
 559             QTreeWidgetItem *item;
 560             for (int j = 0; j < parentItem->childCount(); j++) {
 561                 item = parentItem->child(j);
 562                 if (item->isDisabled()) continue;
 563                 // Special case: slideshows
 564                 items++;
 565                 if (isSlideshow) {
 566                     destPath += item->data(0, Qt::UserRole).toString() + '/';
 567                     destUrl = KUrl(archive_url->url().path(KUrl::AddTrailingSlash) + destPath);
 568                     QStringList srcFiles = item->data(0, Qt::UserRole + 1).toStringList();
 569                     for (int k = 0; k < srcFiles.count(); k++) {
 570                         files << KUrl(srcFiles.at(k));
 571                     }
 572                     item->setDisabled(true);
 573                     if (parentItem->indexOfChild(item) == parentItem->childCount() - 1) {
 574                         // We have processed all slideshows
 575                         parentItem->setDisabled(true);
 576                     }
 577                     break;
 578                 }
 579                 else if (item->data(0, Qt::UserRole).isNull()) {
 580                     files << KUrl(item->text(0));
 581                 }
 582                 else {
 583                     // We must rename the destination file, since another file with same name exists
 584                     //TODO: monitor progress
 585                     if (isArchive) {
 586                         m_filesList.insert(item->text(0), destPath + item->data(0, Qt::UserRole).toString());
 587                     }
 588                     else m_duplicateFiles.insert(KUrl(item->text(0)), KUrl(destUrl.path(KUrl::AddTrailingSlash) + item->data(0, Qt::UserRole).toString()));
 589                 }
 590             }
 591             if (!isSlideshow) parentItem->setDisabled(true);
 592             break;
 593         }
 594     }
 595
 596     if (items == 0) {
 597         // No clips to archive
 598         slotArchivingFinished(NULL, true);
 599         return true;
 600     }
 601
 602     if (destPath.isEmpty()) {
 603         if (m_duplicateFiles.isEmpty()) return false;
 604         QMapIterator<KUrl, KUrl> i(m_duplicateFiles);
 605         if (i.hasNext()) {
 606             i.next();
 607             KUrl startJobSrc = i.key();
 608             KUrl startJobDst = i.value();
 609             m_duplicateFiles.remove(startJobSrc);
 610             KIO::CopyJob *job = KIO::copyAs(startJobSrc, startJobDst, KIO::HideProgressInfo);
 611             connect(job, SIGNAL(result(KJob*)), this, SLOT(slotArchivingFinished(KJob*)));
 612             connect(job, SIGNAL(processedSize(KJob*,qulonglong)), this, SLOT(slotArchivingProgress(KJob*,qulonglong)));
 613         }
 614         return true;
 615     }
 616
 617     if (isArchive) {
 618         m_foldersList.append(destPath);
 619         for (int i = 0; i < files.count(); ++i) {
 620             m_filesList.insert(files.at(i).path(), destPath + files.at(i).fileName());
 621         }
 622         slotArchivingFinished();
 623     }
 624     else if (files.isEmpty()) {
 625         slotStartArchiving(false);
 626     }
 627     else {
 628         KIO::NetAccess::mkdir(destUrl, this);
 629         m_copyJob = KIO::copy (files, destUrl, KIO::HideProgressInfo);
 630         connect(m_copyJob, SIGNAL(result(KJob*)), this, SLOT(slotArchivingFinished(KJob*)));
 631         connect(m_copyJob, SIGNAL(processedSize(KJob*,qulonglong)), this, SLOT(slotArchivingProgress(KJob*,qulonglong)));
 632     }
 633     if (firstPass) {
 634         progressBar->setValue(0);
 635         buttonBox->button(QDialogButtonBox::Apply)->setText(i18n("Abort"));
 636     }
 637     return true;
 638 }
 639
 640 void ArchiveWidget::slotArchivingFinished(KJob *job, bool finished)
 641 {
 642     if (job == NULL || job->error() == 0) {
 643         if (!finished && slotStartArchiving(false)) {
 644             // We still have files to archive
 645             return;
 646         }
 647         else if (!compressed_archive->isChecked()) {
 648             // Archiving finished
 649             progressBar->setValue(100);
 650             if (processProjectFile()) {
 651                 slotJobResult(true, i18n("Project was successfully archived."));
 652             }
 653             else {
 654                 slotJobResult(false, i18n("There was an error processing project file"));
 655             }
 656         } else processProjectFile();
 657     }
 658     else {
 659         m_copyJob = NULL;
 660         slotJobResult(false, i18n("There was an error while copying the files: %1", job->errorString()));
 661     }
 662     if (!compressed_archive->isChecked()) {
 663         buttonBox->button(QDialogButtonBox::Apply)->setText(i18n("Archive"));
 664         archive_url->setEnabled(true);
 665         proxy_only->setEnabled(true);
 666         compressed_archive->setEnabled(true);
 667         for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 668             files_list->topLevelItem(i)->setDisabled(false);
 669             for (int j = 0; j < files_list->topLevelItem(i)->childCount(); j++)
 670                 files_list->topLevelItem(i)->child(j)->setDisabled(false);
 671         }
 672     }
 673 }
 674
 675 void ArchiveWidget::slotArchivingProgress(KJob *, qulonglong size)
 676 {
 677     progressBar->setValue((int) 100 * size / m_requestedSize);
 678 }
 679
 680
 681 bool ArchiveWidget::processProjectFile()
 682 {
 683     KUrl destUrl;
 684     QTreeWidgetItem *item;
 685     bool isArchive = compressed_archive->isChecked();
 686
 687     for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 688         QTreeWidgetItem *parentItem = files_list->topLevelItem(i);
 689         if (parentItem->childCount() > 0) {
 690             destUrl = KUrl(archive_url->url().path(KUrl::AddTrailingSlash) + parentItem->data(0, Qt::UserRole).toString());
 691             bool isSlideshow = parentItem->data(0, Qt::UserRole).toString() == "slideshows";
 692             for (int j = 0; j < parentItem->childCount(); j++) {
 693                 item = parentItem->child(j);
 694                 KUrl src(item->text(0));
 695                 KUrl dest = destUrl;
 696                 if (isSlideshow) {
 697                     dest = KUrl(destUrl.path(KUrl::AddTrailingSlash) + item->data(0, Qt::UserRole).toString() + '/' + src.fileName());
 698                 }
 699                 else if (item->data(0, Qt::UserRole).isNull()) {
 700                     dest.addPath(src.fileName());
 701                 }
 702                 else {
 703                     dest.addPath(item->data(0, Qt::UserRole).toString());
 704                 }
 705                 m_replacementList.insert(src, dest);
 706             }
 707         }
 708     }
 709
 710     QDomElement mlt = m_doc.documentElement();
 711     QString root = mlt.attribute("root") + '/';
 712
 713     // Adjust global settings
 714     QString basePath;
 715     if (isArchive) basePath = "$CURRENTPATH";
 716     else basePath = archive_url->url().path(KUrl::RemoveTrailingSlash);
 717     mlt.setAttribute("root", basePath);
 718     QDomElement project = mlt.firstChildElement("kdenlivedoc");
 719     project.setAttribute("projectfolder", basePath);
 720
 721     // process kdenlive producers
 722     QDomNodeList prods = mlt.elementsByTagName("kdenlive_producer");
 723     for (int i = 0; i < prods.count(); ++i) {
 724         QDomElement e = prods.item(i).toElement();
 725         if (e.isNull()) continue;
 726         if (e.hasAttribute("resource")) {
 727             KUrl src(e.attribute("resource"));
 728             KUrl dest = m_replacementList.value(src);
 729             if (!dest.isEmpty()) e.setAttribute("resource", dest.path());
 730         }
 731         if (e.hasAttribute("proxy") && e.attribute("proxy") != "-") {
 732             KUrl src(e.attribute("proxy"));
 733             KUrl dest = m_replacementList.value(src);
 734             if (!dest.isEmpty()) e.setAttribute("proxy", dest.path());
 735         }
 736     }
 737
 738     // process mlt producers
 739     prods = mlt.elementsByTagName("producer");
 740     for (int i = 0; i < prods.count(); ++i) {
 741         QDomElement e = prods.item(i).toElement();
 742         if (e.isNull()) continue;
 743         QString src = EffectsList::property(e, "resource");
 744         if (!src.isEmpty()) {
 745             if (!src.startsWith('/')) src.prepend(root);
 746             KUrl srcUrl(src);
 747             KUrl dest = m_replacementList.value(src);
 748             if (!dest.isEmpty()) EffectsList::setProperty(e, "resource", dest.path());
 749         }
 750     }
 751
 752     // process mlt transitions (for luma files)
 753     prods = mlt.elementsByTagName("transition");
 754     QString attribute;
 755     for (int i = 0; i < prods.count(); ++i) {
 756         QDomElement e = prods.item(i).toElement();
 757         if (e.isNull()) continue;
 758         attribute = "resource";
 759         QString src = EffectsList::property(e, attribute);
 760         if (src.isEmpty()) attribute = "luma";
 761         src = EffectsList::property(e, attribute);
 762         if (!src.isEmpty()) {
 763             if (!src.startsWith('/')) src.prepend(root);
 764             KUrl srcUrl(src);
 765             KUrl dest = m_replacementList.value(src);
 766             if (!dest.isEmpty()) EffectsList::setProperty(e, attribute, dest.path());
 767         }
 768     }
 769
 770     QString playList = m_doc.toString();
 771     if (isArchive) {
 772         QString startString("\"");
 773         startString.append(archive_url->url().path(KUrl::RemoveTrailingSlash));
 774         QString endString("\"");
 775         endString.append(basePath);
 776         playList.replace(startString, endString);
 777         startString = '>' + archive_url->url().path(KUrl::RemoveTrailingSlash);
 778         endString = '>' + basePath;
 779         playList.replace(startString, endString);
 780     }
 781
 782     if (isArchive) {
 783         m_temp = new KTemporaryFile;
 784         if (!m_temp->open()) KMessageBox::error(this, i18n("Cannot create temporary file"));
 785         m_temp->write(playList.toUtf8());
 786         m_temp->close();
 787         m_archiveThread = QtConcurrent::run(this, &ArchiveWidget::createArchive);
 788         return true;
 789     }
 790
 791     QString path = archive_url->url().path(KUrl::AddTrailingSlash) + m_name + ".kdenlive";
 792     QFile file(path);
 793     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 794         kWarning() << "//////  ERROR writing to file: " << path;
 795         KMessageBox::error(this, i18n("Cannot write to file %1", path));
 796         return false;
 797     }
 798
 799     file.write(m_doc.toString().toUtf8());
 800     if (file.error() != QFile::NoError) {
 801         KMessageBox::error(this, i18n("Cannot write to file %1", path));
 802         file.close();
 803         return false;
 804     }
 805     file.close();
 806     return true;
 807 }
 808
 809 void ArchiveWidget::createArchive()
 810 {
 811     QFileInfo dirInfo(archive_url->url().path());
 812     QString user = dirInfo.owner();
 813     QString group = dirInfo.group();
 814     KTar archive(archive_url->url().path(KUrl::AddTrailingSlash) + m_name + ".tar.gz", "application/x-gzip");
 815     archive.open( QIODevice::WriteOnly );
 816
 817     // Create folders
 818     foreach(const QString &path, m_foldersList) {
 819         archive.writeDir(path, user, group);
 820     }
 821
 822     // Add files
 823     int ix = 0;
 824     QMapIterator<QString, QString> i(m_filesList);
 825     while (i.hasNext()) {
 826         i.next();
 827         archive.addLocalFile(i.key(), i.value());
 828         emit archiveProgress((int) 100 * ix / m_filesList.count());
 829         ix++;
 830     }
 831
 832     // Add project file
 833     bool result = false;
 834     if (m_temp) {
 835         archive.addLocalFile(m_temp->fileName(), m_name + ".kdenlive");
 836         result = archive.close();
 837         delete m_temp;
 838         m_temp = 0;
 839     }
 840     emit archivingFinished(result);
 841 }
 842
 843 void ArchiveWidget::slotArchivingFinished(bool result)
 844 {
 845     if (result) {
 846         slotJobResult(true, i18n("Project was successfully archived."));
 847         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 848     }
 849     else {
 850         slotJobResult(false, i18n("There was an error processing project file"));
 851     }
 852     progressBar->setValue(100);
 853     buttonBox->button(QDialogButtonBox::Apply)->setText(i18n("Archive"));
 854     archive_url->setEnabled(true);
 855     proxy_only->setEnabled(true);
 856     compressed_archive->setEnabled(true);
 857     for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 858         files_list->topLevelItem(i)->setDisabled(false);
 859         for (int j = 0; j < files_list->topLevelItem(i)->childCount(); j++)
 860             files_list->topLevelItem(i)->child(j)->setDisabled(false);
 861     }
 862 }
 863
 864 void ArchiveWidget::slotArchivingProgress(int p)
 865 {
 866     progressBar->setValue(p);
 867 }
 868
 869 void ArchiveWidget::slotStartExtracting()
 870 {
 871     if (m_archiveThread.isRunning()) {
 872         //TODO: abort extracting
 873         return;
 874     }
 875     QFileInfo f(m_extractUrl.path());
 876     m_requestedSize = f.size();
 877     KIO::NetAccess::mkdir(archive_url->url().path(KUrl::RemoveTrailingSlash), this);
 878     slotDisplayMessage("system-run", i18n("Extracting..."));
 879     buttonBox->button(QDialogButtonBox::Apply)->setText(i18n("Abort"));
 880     m_archiveThread = QtConcurrent::run(this, &ArchiveWidget::doExtracting);
 881     m_progressTimer->start();
 882 }
 883
 884 void ArchiveWidget::slotExtractProgress()
 885 {
 886     KIO::DirectorySizeJob *job = KIO::directorySize(archive_url->url());
 887     connect(job, SIGNAL(result(KJob*)), this, SLOT(slotGotProgress(KJob*)));
 888 }
 889
 890 void ArchiveWidget::slotGotProgress(KJob* job)
 891 {
 892     if (!job->error()) {
 893         KIO::DirectorySizeJob *j = static_cast <KIO::DirectorySizeJob *>(job);
 894         progressBar->setValue((int) 100 * j->totalSize() / m_requestedSize);
 895     }
 896     job->deleteLater();
 897 }
 898
 899 void ArchiveWidget::doExtracting()
 900 {
 901     m_extractArchive->directory()->copyTo(archive_url->url().path(KUrl::AddTrailingSlash));
 902     m_extractArchive->close();
 903     emit extractingFinished();
 904 }
 905
 906 QString ArchiveWidget::extractedProjectFile() const
 907 {
 908     return archive_url->url().path(KUrl::AddTrailingSlash) + m_projectName;
 909 }
 910
 911 void ArchiveWidget::slotExtractingFinished()
 912 {
 913     m_progressTimer->stop();
 914     // Process project file
 915     QFile file(extractedProjectFile());
 916     bool error = false;
 917     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 918         error = true;
 919     }
 920     else {
 921         QString playList = QString::fromUtf8(file.readAll());
 922         file.close();
 923         if (playList.isEmpty()) {
 924             error = true;
 925         }
 926         else {
 927             playList.replace("$CURRENTPATH", archive_url->url().path(KUrl::RemoveTrailingSlash));
 928             if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
 929                 kWarning() << "//////  ERROR writing to file: ";
 930                 error = true;
 931             }
 932             else {
 933                 file.write(playList.toUtf8());
 934                 if (file.error() != QFile::NoError) {
 935                     error = true;
 936                 }
 937                 file.close();
 938             }
 939         }
 940     }
 941     if (error) {
 942         KMessageBox::sorry(kapp->activeWindow(), i18n("Cannot open project file %1", extractedProjectFile()), i18n("Cannot open file"));
 943         reject();
 944     }
 945     else accept();
 946 }
 947
 948 void ArchiveWidget::slotProxyOnly(int onlyProxy)
 949 {
 950     m_requestedSize = 0;
 951     if (onlyProxy == Qt::Checked) {
 952         // Archive proxy clips
 953         QStringList proxyIdList;
 954         QTreeWidgetItem *parentItem = NULL;
 955
 956         // Build list of existing proxy ids
 957         for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 958             parentItem = files_list->topLevelItem(i);
 959             if (parentItem->data(0, Qt::UserRole).toString() == "proxy") break;
 960         }
 961         if (!parentItem) return;
 962         int items = parentItem->childCount();
 963         for (int j = 0; j < items; j++) {
 964             proxyIdList << parentItem->child(j)->data(0, Qt::UserRole + 2).toString();
 965         }
 966
 967         // Parse all items to disable original clips for existing proxies
 968         for (int i = 0; i < proxyIdList.count(); ++i) {
 969             QString id = proxyIdList.at(i);
 970             if (id.isEmpty()) continue;
 971             for (int j = 0; j < files_list->topLevelItemCount(); j++) {
 972                 parentItem = files_list->topLevelItem(j);
 973                 if (parentItem->data(0, Qt::UserRole).toString() == "proxy") continue;
 974                 items = parentItem->childCount();
 975                 for (int k = 0; k < items; k++) {
 976                     if (parentItem->child(k)->data(0, Qt::UserRole + 2).toString() == id) {
 977                         // This item has a proxy, do not archive it
 978                         parentItem->child(k)->setFlags(Qt::ItemIsSelectable);
 979                         break;
 980                     }
 981                 }
 982             }
 983         }
 984     }
 985     else {
 986         // Archive all clips
 987         for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 988             QTreeWidgetItem *parentItem = files_list->topLevelItem(i);
 989             int items = parentItem->childCount();
 990             for (int j = 0; j < items; j++) {
 991                 parentItem->child(j)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
 992             }
 993         }
 994     }
 995
 996     // Calculate requested size
 997     int total = 0;
 998     for (int i = 0; i < files_list->topLevelItemCount(); ++i) {
 999         QTreeWidgetItem *parentItem = files_list->topLevelItem(i);
1000         int items = parentItem->childCount();
1001         int itemsCount = 0;
1002         bool isSlideshow = parentItem->data(0, Qt::UserRole).toString() == "slideshows";
1003
1004         for (int j = 0; j < items; j++) {
1005             if (!parentItem->child(j)->isDisabled()) {
1006                 m_requestedSize += parentItem->child(j)->data(0, Qt::UserRole + 3).toInt();
1007                 if (isSlideshow) total += parentItem->child(j)->data(0, Qt::UserRole + 1).toStringList().count();
1008                 else total ++;
1009                 itemsCount ++;
1010             }
1011         }
1012         parentItem->setText(0, parentItem->text(0).section('(', 0, 0) + i18np("(%1 item)", "(%1 items)", itemsCount));
1013     }
1014     project_files->setText(i18np("%1 file to archive, requires %2", "%1 files to archive, requires %2", total, KIO::convertSize(m_requestedSize)));
1015     slotCheckSpace();
1016 }
1017
1018
1019 #include "archivewidget.moc"