#include "renderwidget.h"
#include "renderer.h"
#include "audiosignal.h"
-#ifndef NO_JOGSHUTTLE
+#ifdef USE_JOGSHUTTLE
#include "jogshuttle.h"
#include "jogaction.h"
#include "jogshuttleconfig.h"
-#endif /* NO_JOGSHUTTLE */
+#endif
#include "clipproperties.h"
#include "wizard.h"
-#include "editclipcommand.h"
+#include "commands/editclipcommand.h"
#include "titlewidget.h"
#include "markerdialog.h"
#include "clipitem.h"
#include "interfaces.h"
-#include "kdenlive-config.h"
+#include "config-kdenlive.h"
#include "cliptranscode.h"
#include "ui_templateclip_ui.h"
#include "colorscopes/vectorscope.h"
#include "colorscopes/waveform.h"
#include "colorscopes/rgbparade.h"
#include "colorscopes/histogram.h"
-#include "audiospectrum.h"
-#include "spectrogram.h"
+#include "audioscopes/audiospectrum.h"
+#include "audioscopes/spectrogram.h"
+#include "archivewidget.h"
+#include "databackup/backupwidget.h"
+
#include <KApplication>
#include <KAction>
#include <KProcess>
#include <KActionMenu>
#include <KMenu>
-#include <locale.h>
#include <ktogglefullscreenaction.h>
#include <KFileItem>
#include <KNotification>
#include <knewstuff2/engine.h>
#include <knewstuff2/ui/knewstuffaction.h>
#define KNS3 KNS
-#endif /* KDE_IS_VERSION(4,3,80) */
+#endif
#include <KToolBar>
#include <KColorScheme>
#include <KProgressDialog>
Q_DECLARE_METATYPE(QVector<int16_t>)
+
EffectsList MainWindow::videoEffects;
EffectsList MainWindow::audioEffects;
EffectsList MainWindow::customEffects;
KXmlGuiWindow(parent),
m_activeDocument(NULL),
m_activeTimeline(NULL),
+ m_recMonitor(NULL),
m_renderWidget(NULL),
-#ifndef NO_JOGSHUTTLE
+#ifdef USE_JOGSHUTTLE
m_jogProcess(NULL),
m_jogShuttle(NULL),
-#endif /* NO_JOGSHUTTLE */
+#endif
m_findActivated(false),
m_stopmotion(NULL)
-{
+{
qRegisterMetaType<QVector<int16_t> > ();
+ qRegisterMetaType<stringMap> ("stringMap");
+ qRegisterMetaType<audioByteArray> ("audioByteArray");
+
+ // Init locale
+ QLocale systemLocale = QLocale();
+ systemLocale.setNumberOptions(QLocale::OmitGroupSeparator);
+ QLocale::setDefault(systemLocale);
+
// Create DBus interface
new MainWindowAdaptor(this);
QDBusConnection dbus = QDBusConnection::sessionBus();
dbus.registerObject("/MainWindow", this);
- setlocale(LC_NUMERIC, "POSIX");
if (!KdenliveSettings::colortheme().isEmpty()) slotChangePalette(NULL, KdenliveSettings::colortheme());
setFont(KGlobalSettings::toolBarFont());
parseProfiles(MltPath);
closeTabButton->adjustSize();
closeTabButton->setToolTip(i18n("Close the current tab"));
m_timelineArea->setCornerWidget(closeTabButton);
- connect(m_timelineArea, SIGNAL(currentChanged(int)), this, SLOT(activateDocument()));
+ //connect(m_timelineArea, SIGNAL(currentChanged(int)), this, SLOT(activateDocument()));
connect(&m_findTimer, SIGNAL(timeout()), this, SLOT(findTimeout()));
m_findTimer.setSingleShot(true);
m_clipMonitorDock->setObjectName("clip_monitor");
m_clipMonitor = new Monitor("clip", m_monitorManager, QString(), m_timelineArea);
m_clipMonitorDock->setWidget(m_clipMonitor);
+
+ // Connect the project list
+ connect(m_projectList, SIGNAL(clipSelected(DocClipBase *, QPoint)), m_clipMonitor, SLOT(slotSetClipProducer(DocClipBase *, QPoint)));
+ connect(m_projectList, SIGNAL(raiseClipMonitor()), m_clipMonitor, SLOT(activateMonitor()));
+ connect(m_projectList, SIGNAL(loadingIsOver()), this, SLOT(slotElapsedTime()));
+ connect(m_projectList, SIGNAL(displayMessage(const QString&, int)), this, SLOT(slotGotProgressInfo(const QString&, int)));
+ connect(m_projectList, SIGNAL(updateRenderStatus()), this, SLOT(slotCheckRenderStatus()));
+ connect(m_projectList, SIGNAL(clipNeedsReload(const QString&)),this, SLOT(slotUpdateClip(const QString &)));
+ connect(m_projectList, SIGNAL(updateProfile(const QString &)), this, SLOT(slotUpdateProjectProfile(const QString &)));
+ connect(m_projectList, SIGNAL(refreshClip(const QString &, bool)), m_monitorManager, SLOT(slotRefreshCurrentMonitor()));
+ connect(m_projectList, SIGNAL(findInTimeline(const QString&)), this, SLOT(slotClipInTimeline(const QString&)));
+ connect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), m_projectList, SLOT(slotUpdateClipCut(QPoint)));
m_projectMonitorDock = new QDockWidget(i18n("Project Monitor"), this);
m_projectMonitorDock->setObjectName("project_monitor");
#ifndef Q_WS_MAC
m_recMonitorDock = new QDockWidget(i18n("Record Monitor"), this);
m_recMonitorDock->setObjectName("record_monitor");
- m_recMonitor = new RecMonitor("record");
+ m_recMonitor = new RecMonitor("record", m_monitorManager);
m_recMonitorDock->setWidget(m_recMonitor);
connect(m_recMonitor, SIGNAL(addProjectClip(KUrl)), this, SLOT(slotAddProjectClip(KUrl)));
+ connect(m_recMonitor, SIGNAL(addProjectClipList(KUrl::List)), this, SLOT(slotAddProjectClipList(KUrl::List)));
connect(m_recMonitor, SIGNAL(showConfigDialog(int, int)), this, SLOT(slotPreferences(int, int)));
-#endif
+#endif /* ! Q_WS_MAC */
+ m_monitorManager->initMonitors(m_clipMonitor, m_projectMonitor, m_recMonitor);
m_notesDock = new QDockWidget(i18n("Project Notes"), this);
m_notesDock->setObjectName("notes_widget");
- m_notesWidget = new KTextEdit();
+ m_notesWidget = new NotesWidget();
+ connect(m_notesWidget, SIGNAL(insertNotesTimecode()), this, SLOT(slotInsertNotesTimecode()));
+ connect(m_notesWidget, SIGNAL(seekProject(int)), m_projectMonitor->render, SLOT(seekToFrame(int)));
+
m_notesWidget->setTabChangesFocus(true);
#if KDE_IS_VERSION(4,4,0)
m_notesWidget->setClickMessage(i18n("Enter your project notes here ..."));
m_effectListDock->setWidget(m_effectList);
addDockWidget(Qt::TopDockWidgetArea, m_effectListDock);
- m_vectorscope = new Vectorscope(m_projectMonitor, m_clipMonitor);
+ m_vectorscope = new Vectorscope(m_monitorManager);
m_vectorscopeDock = new QDockWidget(i18n("Vectorscope"), this);
m_vectorscopeDock->setObjectName(m_vectorscope->widgetName());
m_vectorscopeDock->setWidget(m_vectorscope);
connect(m_vectorscope, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
m_gfxScopesList.append(m_vectorscopeDock);
- m_waveform = new Waveform(m_projectMonitor, m_clipMonitor);
+ m_waveform = new Waveform(m_monitorManager);
m_waveformDock = new QDockWidget(i18n("Waveform"), this);
m_waveformDock->setObjectName(m_waveform->widgetName());
m_waveformDock->setWidget(m_waveform);
connect(m_waveform, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
m_gfxScopesList.append(m_waveformDock);
- m_RGBParade = new RGBParade(m_projectMonitor, m_clipMonitor);
+ m_RGBParade = new RGBParade(m_monitorManager);
m_RGBParadeDock = new QDockWidget(i18n("RGB Parade"), this);
m_RGBParadeDock->setObjectName(m_RGBParade->widgetName());
m_RGBParadeDock->setWidget(m_RGBParade);
connect(m_RGBParade, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
m_gfxScopesList.append(m_RGBParadeDock);
- m_histogram = new Histogram(m_projectMonitor, m_clipMonitor);
+ m_histogram = new Histogram(m_monitorManager);
m_histogramDock = new QDockWidget(i18n("Histogram"), this);
m_histogramDock->setObjectName(m_histogram->widgetName());
m_histogramDock->setWidget(m_histogram);
setupActions();
+ connect(m_commandStack, SIGNAL(cleanChanged(bool)), m_saveAction, SLOT(setDisabled(bool)));
// Close non-general docks for the initial layout
setupGUI();
-
// Find QDockWidget tab bars and show / hide widget title bars on right click
QList <QTabBar *> tabs = findChildren<QTabBar *>();
for (int i = 0; i < tabs.count(); i++) {
loadPlugins();
loadTranscoders();
- //kDebug() << factory() << " " << factory()->container("video_effects_menu", this);
m_projectMonitor->setupMenu(static_cast<QMenu*>(factory()->container("monitor_go", this)), m_playZone, m_loopZone, NULL, m_loopClip);
m_clipMonitor->setupMenu(static_cast<QMenu*>(factory()->container("monitor_go", this)), m_playZone, m_loopZone, static_cast<QMenu*>(factory()->container("marker_menu", this)));
QMenu *m = static_cast<QMenu*>(factory()->container("video_effects_menu", this));
- m = m_effectsMenu;
+ m->addActions(m_effectsMenu->actions());
m_transitionsMenu = new QMenu(i18n("Add Transition"), this);
for (int i = 0; i < transitions.count(); ++i)
m_transitionsMenu->addAction(m_transitions[i]);
+ connect(m, SIGNAL(triggered(QAction *)), this, SLOT(slotAddVideoEffect(QAction *)));
connect(m_effectsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddVideoEffect(QAction *)));
connect(m_transitionsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddTransition(QAction *)));
connect(m_projectMonitorDock, SIGNAL(visibilityChanged(bool)), m_projectMonitor, SLOT(refreshMonitor(bool)));
connect(m_clipMonitorDock, SIGNAL(visibilityChanged(bool)), m_clipMonitor, SLOT(refreshMonitor(bool)));
- //connect(m_monitorManager, SIGNAL(connectMonitors()), this, SLOT(slotConnectMonitors()));
- connect(m_monitorManager, SIGNAL(raiseClipMonitor(bool)), this, SLOT(slotRaiseMonitor(bool)));
connect(m_monitorManager, SIGNAL(checkColorScopes()), this, SLOT(slotUpdateColorScopes()));
+ connect(m_monitorManager, SIGNAL(clearScopes()), this, SLOT(slotClearColorScopes()));
connect(m_effectList, SIGNAL(addEffect(const QDomElement)), this, SLOT(slotAddEffect(const QDomElement)));
connect(m_effectList, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
- m_monitorManager->initMonitors(m_clipMonitor, m_projectMonitor);
slotConnectMonitors();
// Open or create a file. Command line argument passed in Url has
m_projectList->slotAddClip(urls);
}
-#ifndef NO_JOGSHUTTLE
+#ifdef USE_JOGSHUTTLE
activateShuttleDevice();
-#endif /* NO_JOGSHUTTLE */
+#endif
m_projectListDock->raise();
actionCollection()->addAssociatedWidget(m_clipMonitor->container());
actionCollection()->addAssociatedWidget(m_projectMonitor->container());
+
+ // Populate encoding profiles
+ KConfig conf("encodingprofiles.rc", KConfig::FullConfig, "appdata");
+ if (KdenliveSettings::proxyparams().isEmpty() || KdenliveSettings::proxyextension().isEmpty()) {
+ KConfigGroup group(&conf, "proxy");
+ QMap< QString, QString > values = group.entryMap();
+ QMapIterator<QString, QString> i(values);
+ if (i.hasNext()) {
+ i.next();
+ QString data = i.value();
+ KdenliveSettings::setProxyparams(data.section(';', 0, 0));
+ KdenliveSettings::setProxyextension(data.section(';', 1, 1));
+ }
+ }
+ if (KdenliveSettings::v4l_parameters().isEmpty() || KdenliveSettings::v4l_extension().isEmpty()) {
+ KConfigGroup group(&conf, "video4linux");
+ QMap< QString, QString > values = group.entryMap();
+ QMapIterator<QString, QString> i(values);
+ if (i.hasNext()) {
+ i.next();
+ QString data = i.value();
+ KdenliveSettings::setV4l_parameters(data.section(';', 0, 0));
+ KdenliveSettings::setV4l_extension(data.section(';', 1, 1));
+ }
+ }
+ if (KdenliveSettings::decklink_parameters().isEmpty() || KdenliveSettings::decklink_extension().isEmpty()) {
+ KConfigGroup group(&conf, "decklink");
+ QMap< QString, QString > values = group.entryMap();
+ QMapIterator<QString, QString> i(values);
+ if (i.hasNext()) {
+ i.next();
+ QString data = i.value();
+ KdenliveSettings::setDecklink_parameters(data.section(';', 0, 0));
+ KdenliveSettings::setDecklink_extension(data.section(';', 1, 1));
+ }
+ }
}
MainWindow::~MainWindow()
m_effectList->reloadEffectList(m_effectsMenu, m_effectActions);
}
-#ifndef NO_JOGSHUTTLE
+#ifdef USE_JOGSHUTTLE
void MainWindow::activateShuttleDevice()
{
delete m_jogShuttle;
connect(m_jogShuttle, SIGNAL(forward(double)), m_monitorManager, SLOT(slotForward(double)));
connect(m_jogShuttle, SIGNAL(action(const QString&)), this, SLOT(slotDoAction(const QString&)));
}
-#endif /* NO_JOGSHUTTLE */
+#endif /* USE_JOGSHUTTLE */
void MainWindow::slotDoAction(const QString& action_name)
{
else m_activeTimeline->projectView()->slotAddEffect(effectToAdd, GenTime(), -1);
}
-void MainWindow::slotRaiseMonitor(bool clipMonitor)
-{
- if (clipMonitor) m_clipMonitorDock->raise();
- else m_projectMonitorDock->raise();
-}
-
void MainWindow::slotUpdateClip(const QString &id)
{
if (!m_activeDocument) return;
- m_activeTimeline->projectView()->slotUpdateClip(id);
+ DocClipBase *clip = m_activeDocument->clipManager()->getClipById(id);
+ if (!clip) return;
+ if (clip->numReferences() > 0) m_activeTimeline->projectView()->slotUpdateClip(id);
+ if (m_clipMonitor->activeClip() && m_clipMonitor->activeClip()->getId() == id) {
+ Mlt::Producer *monitorProducer = clip->getCloneProducer();
+ m_clipMonitor->updateClipProducer(monitorProducer);
+ }
+ clip->cleanupProducers();
}
void MainWindow::slotConnectMonitors()
{
m_projectList->setRenderer(m_projectMonitor->render);
- //connect(m_projectList, SIGNAL(receivedClipDuration(const QString &)), this, SLOT(slotUpdateClip(const QString &)));
connect(m_projectList, SIGNAL(deleteProjectClips(QStringList, QMap<QString, QString>)), this, SLOT(slotDeleteProjectClips(QStringList, QMap<QString, QString>)));
connect(m_projectList, SIGNAL(showClipProperties(DocClipBase *)), this, SLOT(slotShowClipProperties(DocClipBase *)));
connect(m_projectList, SIGNAL(showClipProperties(QList <DocClipBase *>, QMap<QString, QString>)), this, SLOT(slotShowClipProperties(QList <DocClipBase *>, QMap<QString, QString>)));
- connect(m_projectList, SIGNAL(getFileProperties(const QDomElement, const QString &, int, bool, bool)), m_projectMonitor->render, SLOT(getFileProperties(const QDomElement, const QString &, int, bool, bool)));
- connect(m_projectMonitor->render, SIGNAL(replyGetImage(const QString &, const QPixmap &)), m_projectList, SLOT(slotReplyGetImage(const QString &, const QPixmap &)));
- connect(m_projectMonitor->render, SIGNAL(replyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &, bool, bool)), m_projectList, SLOT(slotReplyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &, bool, bool)));
+ connect(m_projectMonitor->render, SIGNAL(replyGetImage(const QString &, const QString &, int, int)), m_projectList, SLOT(slotReplyGetImage(const QString &, const QString &, int, int)));
+ connect(m_projectMonitor->render, SIGNAL(replyGetImage(const QString &, const QImage &)), m_projectList, SLOT(slotReplyGetImage(const QString &, const QImage &)));
+ connect(m_projectMonitor->render, SIGNAL(replyGetFileProperties(const QString &, Mlt::Producer*, const stringMap &, const stringMap &, bool)), m_projectList, SLOT(slotReplyGetFileProperties(const QString &, Mlt::Producer*, const stringMap &, const stringMap &, bool)));
connect(m_projectMonitor->render, SIGNAL(removeInvalidClip(const QString &, bool)), m_projectList, SLOT(slotRemoveInvalidClip(const QString &, bool)));
- connect(m_projectMonitor->render, SIGNAL(removeInvalidProxy(const QString &)), m_projectList, SLOT(slotRemoveInvalidProxy(const QString &)));
+
+ connect(m_projectMonitor->render, SIGNAL(removeInvalidProxy(const QString &, bool)), m_projectList, SLOT(slotRemoveInvalidProxy(const QString &, bool)));
connect(m_clipMonitor, SIGNAL(refreshClipThumbnail(const QString &, bool)), m_projectList, SLOT(slotRefreshClipThumbnail(const QString &, bool)));
connect(m_projectMonitor, SIGNAL(requestFrameForAnalysis(bool)), this, SLOT(slotMonitorRequestRenderFrame(bool)));
- connect(m_clipMonitor, SIGNAL(saveZone(Render *, QPoint)), this, SLOT(slotSaveZone(Render *, QPoint)));
- connect(m_projectMonitor, SIGNAL(saveZone(Render *, QPoint)), this, SLOT(slotSaveZone(Render *, QPoint)));
+ connect(m_clipMonitor, SIGNAL(saveZone(Render *, QPoint, DocClipBase *)), this, SLOT(slotSaveZone(Render *, QPoint, DocClipBase *)));
+ connect(m_projectMonitor, SIGNAL(saveZone(Render *, QPoint, DocClipBase *)), this, SLOT(slotSaveZone(Render *, QPoint, DocClipBase *)));
}
void MainWindow::slotAdjustClipMonitor()
collection.addAction("project_settings", projectAction);
connect(projectAction, SIGNAL(triggered(bool)), this, SLOT(slotEditProjectSettings()));
+ KAction* backupAction = new KAction(KIcon("edit-undo"), i18n("Open Backup File"), this);
+ collection.addAction("open_backup", backupAction);
+ connect(backupAction, SIGNAL(triggered(bool)), this, SLOT(slotOpenBackupDialog()));
+
KAction* projectRender = new KAction(KIcon("media-record"), i18n("Render"), this);
collection.addAction("project_render", projectRender);
projectRender->setShortcut(Qt::CTRL + Qt::Key_Return);
collection.addAction("transcode_clip", transcodeClip);
connect(transcodeClip, SIGNAL(triggered(bool)), this, SLOT(slotTranscodeClip()));
+ KAction *archiveProject = new KAction(KIcon("file-save"), i18n("Archive Project"), this);
+ collection.addAction("archive_project", archiveProject);
+ connect(archiveProject, SIGNAL(triggered(bool)), this, SLOT(slotArchiveProject()));
+
+
KAction *markIn = collection.addAction("mark_in");
markIn->setText(i18n("Set Zone In"));
markIn->setShortcut(Qt::Key_I);
showTitleBar->setChecked(KdenliveSettings::showtitlebars());
slotShowTitleBars(KdenliveSettings::showtitlebars());
-
- //const QByteArray state = layoutGroup.readEntry("layout1", QByteArray());
-
- /*QAction *maxCurrent = new KAction(i18n("Maximize Current Widget"), this);
- collection.addAction("maximize_current", maxCurrent);
- maxCurrent->setCheckable(true);
- maxCurrent->setChecked(false);
- connect(maxCurrent, SIGNAL(triggered(bool)), this, SLOT(slotMaximizeCurrent(bool)));*/
-
m_closeAction = KStandardAction::close(this, SLOT(closeCurrentDocument()), collection);
KStandardAction::quit(this, SLOT(close()), collection);
KStandardAction::open(this, SLOT(openFile()), collection);
connect(reloadClip , SIGNAL(triggered()), m_projectList, SLOT(slotReloadClip()));
reloadClip->setEnabled(false);
+ QAction *proxyClip = new KAction(i18n("Proxy Clip"), this);
+ collection.addAction("proxy_clip", proxyClip);
+ proxyClip->setData("proxy_clip");
+ proxyClip->setCheckable(true);
+ proxyClip->setChecked(false);
+ connect(proxyClip, SIGNAL(toggled(bool)), m_projectList, SLOT(slotProxyCurrentItem(bool)));
+
QAction *stopMotion = new KAction(KIcon("image-x-generic"), i18n("Stop Motion Capture"), this);
collection.addAction("stopmotion", stopMotion);
connect(stopMotion , SIGNAL(triggered()), this, SLOT(slotOpenStopmotion()));
addClips->addAction(addFolderButton);
addClips->addAction(reloadClip);
+ addClips->addAction(proxyClip);
addClips->addAction(clipProperties);
addClips->addAction(openClip);
addClips->addAction(deleteClip);
}
//m_effectsActionCollection->readSettings();
- //connect(collection, SIGNAL( clearStatusText() ),
- //statusBar(), SLOT( clear() ) );
}
void MainWindow::slotDisplayActionMessage(QAction *a)
if (layoutId.isEmpty()) return;
KSharedConfigPtr config = KGlobal::config();
KConfigGroup layouts(config, "Layouts");
- //QByteArray geom = QByteArray::fromBase64(layouts.readEntry(layoutId).toAscii());
QByteArray state = QByteArray::fromBase64(layouts.readEntry(layoutId).toAscii());
- //restoreGeometry(geom);
restoreState(state);
}
QMap <QString, QString> documentProperties;
QPoint projectTracks(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks());
if (!showProjectSettings) {
- // set up default properties
- documentProperties.insert("enableproxy", QString::number((int) KdenliveSettings::enableproxy()));
- documentProperties.insert("generateproxy", QString::number((int) KdenliveSettings::generateproxy()));
- documentProperties.insert("proxyminsize", QString::number(KdenliveSettings::proxyminsize()));
- documentProperties.insert("proxyparams", KdenliveSettings::proxyparams());
- documentProperties.insert("proxyextension", KdenliveSettings::proxyextension());
- documentProperties.insert("generateimageproxy", QString::number((int) KdenliveSettings::generateimageproxy()));
- documentProperties.insert("proxyimageminsize", QString::number(KdenliveSettings::proxyimageminsize()));
if (!KdenliveSettings::activatetabs())
if (!closeCurrentDocument())
return;
}
m_timelineArea->setEnabled(true);
m_projectList->setEnabled(true);
-
- KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, m_commandStack, profileName, documentProperties, projectTracks, m_projectMonitor->render, m_notesWidget, this);
+ bool openBackup;
+ KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, m_commandStack, profileName, documentProperties, projectTracks, m_projectMonitor->render, m_notesWidget, &openBackup, this);
doc->m_autosave = new KAutoSaveFile(KUrl(), doc);
bool ok;
TrackView *trackView = new TrackView(doc, &ok, this);
break;
}
}
- m_clipMonitor->slotSetXml(NULL);
+ m_clipMonitor->slotSetClipProducer(NULL);
+ m_projectList->slotResetProjectList();
m_timelineArea->removeTab(m_timelineArea->indexOf(w));
if (m_timelineArea->count() == 1) {
m_timelineArea->setTabBarHidden(true);
m_activeDocument->setModified(false);
m_fileOpenRecent->addUrl(KUrl(outputFileName));
m_fileRevert->setEnabled(true);
+ m_undoView->stack()->setClean();
return true;
}
bool MainWindow::saveFileAs()
{
- QString outputFile = KFileDialog::getSaveFileName(m_activeDocument->projectFolder(), getMimeType());
+ QString outputFile = KFileDialog::getSaveFileName(m_activeDocument->projectFolder(), getMimeType(false));
if (outputFile.isEmpty()) {
return false;
}
void MainWindow::openFile(const KUrl &url)
{
+ // Make sure the url is a Kdenlive project file
+ KMimeType::Ptr mime = KMimeType::findByUrl(url);
+ if (mime.data()->is("application/x-compressed-tar")) {
+ // Opening a compressed project file, we need to process it
+ kDebug()<<"Opening archive, processing";
+ ArchiveWidget *ar = new ArchiveWidget(url);
+ if (ar->exec() == QDialog::Accepted) openFile(KUrl(ar->extractedProjectFile()));
+ delete ar;
+ return;
+ }
+ if (!url.fileName().endsWith(".kdenlive")) {
+ // This is not a Kdenlive project file, abort loading
+ KMessageBox::sorry(this, i18n("File %1 is not a Kdenlive project file", url.path()));
+ return;
+ }
+
// Check if the document is already opened
const int ct = m_timelineArea->count();
bool isOpened = false;
delete m_stopmotion;
m_stopmotion = NULL;
}
-
+
+ m_timer.start();
KProgressDialog progressDialog(this, i18n("Loading project"), i18n("Loading project"));
progressDialog.setAllowCancel(false);
progressDialog.progressBar()->setMaximum(4);
progressDialog.progressBar()->setValue(0);
qApp->processEvents();
- KdenliveDoc *doc = new KdenliveDoc(url, KdenliveSettings::defaultprojectfolder(), m_commandStack, KdenliveSettings::default_profile(), QMap <QString, QString> (), QPoint(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks()), m_projectMonitor->render, m_notesWidget, this, &progressDialog);
+ bool openBackup;
+ KdenliveDoc *doc = new KdenliveDoc(url, KdenliveSettings::defaultprojectfolder(), m_commandStack, KdenliveSettings::default_profile(), QMap <QString, QString> (), QPoint(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks()), m_projectMonitor->render, m_notesWidget, &openBackup, this, &progressDialog);
progressDialog.progressBar()->setValue(1);
progressDialog.progressBar()->setMaximum(4);
bool ok;
TrackView *trackView = new TrackView(doc, &ok, this);
-
+ connectDocument(trackView, doc);
progressDialog.progressBar()->setValue(3);
qApp->processEvents();
slotGotProgressInfo(QString(), -1);
m_projectMonitor->adjustRulerSize(trackView->duration());
m_projectMonitor->slotZoneMoved(trackView->inPoint(), trackView->outPoint());
- m_clipMonitor->refreshMonitor(true);
-
progressDialog.progressBar()->setValue(4);
+ if (openBackup) slotOpenBackupDialog(url);
}
void MainWindow::recoverFiles(QList<KAutoSaveFile *> staleFiles)
{
QPoint p = m_activeDocument->getTracksCount();
ProjectSettings *w = new ProjectSettings(m_projectList, m_activeTimeline->projectView()->extractTransitionsLumas(), p.x(), p.y(), m_activeDocument->projectFolder().path(), true, !m_activeDocument->isModified(), this);
+ connect(w, SIGNAL(disableProxies()), this, SLOT(slotDisableProxies()));
if (w->exec() == QDialog::Accepted) {
QString profile = w->selectedProfile();
m_activeDocument->setProjectFolder(w->selectedFolder());
-#ifndef Q_WS_MAC
+#ifndef Q_WS_MAC
m_recMonitor->slotUpdateCaptureFolder(m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash));
#endif
if (m_renderWidget) m_renderWidget->setDocumentPath(m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash));
delete w;
}
-void MainWindow::slotUpdateProjectProfile(const QString &profile)
+void MainWindow::slotDisableProxies()
{
- double dar = m_activeDocument->dar();
+ m_activeDocument->setDocumentProperty("enableproxy", QString::number((int) false));
+ m_activeDocument->setModified();
+ slotUpdateProxySettings();
+}
+void MainWindow::slotUpdateProjectProfile(const QString &profile)
+{
// Recreate the stopmotion widget if profile changes
if (m_stopmotion) {
delete m_stopmotion;
// Deselect current effect / transition
m_effectStack->slotClipItemSelected(NULL, 0);
m_transitionConfig->slotTransitionItemSelected(NULL, 0, QPoint(), false);
- m_clipMonitor->slotSetXml(NULL);
+ m_clipMonitor->slotSetClipProducer(NULL);
bool updateFps = m_activeDocument->setProfilePath(profile);
KdenliveSettings::setCurrent_profile(profile);
KdenliveSettings::setProject_fps(m_activeDocument->fps());
m_projectList->updateProjectFormat(m_activeDocument->timecode());
if (m_renderWidget) m_renderWidget->setProfile(m_activeDocument->mltProfile());
m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
- //m_activeDocument->clipManager()->resetProducersList(m_projectMonitor->render->producersList());
- if (dar != m_activeDocument->dar()) m_projectList->reloadClipThumbnails();
if (updateFps) m_activeTimeline->updateProjectFps();
+ m_activeDocument->clipManager()->clearCache();
+ m_activeTimeline->updateProfile();
m_activeDocument->setModified(true);
m_commandStack->activeStack()->clear();
//Update the mouse position display so it will display in DF/NDF format by default based on the project setting.
{
if (!m_renderWidget) {
QString projectfolder = m_activeDocument ? m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash) : KdenliveSettings::defaultprojectfolder();
- m_renderWidget = new RenderWidget(projectfolder, m_projectList->useProxy(), this);
+ MltVideoProfile profile;
+ if (m_activeDocument) profile = m_activeDocument->mltProfile();
+ m_renderWidget = new RenderWidget(projectfolder, m_projectList->useProxy(), profile, this);
connect(m_renderWidget, SIGNAL(shutdown()), this, SLOT(slotShutdown()));
connect(m_renderWidget, SIGNAL(selectedRenderProfile(QMap <QString, QString>)), this, SLOT(slotSetDocumentRenderProfile(QMap <QString, QString>)));
connect(m_renderWidget, SIGNAL(prepareRenderingData(bool, bool, const QString&)), this, SLOT(slotPrepareRendering(bool, bool, const QString&)));
disconnect(m_notesWidget, SIGNAL(textChanged()), m_activeDocument, SLOT(setModified()));
disconnect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), m_activeDocument, SLOT(setModified()));
disconnect(m_projectList, SIGNAL(projectModified()), m_activeDocument, SLOT(setModified()));
- disconnect(m_projectList, SIGNAL(updateProfile(const QString &)), this, SLOT(slotUpdateProjectProfile(const QString &)));
- disconnect(m_projectMonitor->render, SIGNAL(refreshDocumentProducers()), m_activeDocument, SLOT(checkProjectClips()));
+ disconnect(m_projectMonitor->render, SIGNAL(refreshDocumentProducers(bool, bool)), m_activeDocument, SLOT(checkProjectClips(bool, bool)));
disconnect(m_activeDocument, SIGNAL(guidesUpdated()), this, SLOT(slotGuidesUpdated()));
disconnect(m_activeDocument, SIGNAL(addProjectClip(DocClipBase *, bool)), m_projectList, SLOT(slotAddClip(DocClipBase *, bool)));
disconnect(m_activeDocument, SIGNAL(signalDeleteProjectClip(const QString &)), this, SLOT(slotDeleteClip(const QString &)));
disconnect(m_activeDocument, SIGNAL(updateClipDisplay(const QString &)), m_projectList, SLOT(slotUpdateClip(const QString &)));
disconnect(m_activeDocument, SIGNAL(selectLastAddedClip(const QString &)), m_projectList, SLOT(slotSelectClip(const QString &)));
- disconnect(m_activeDocument, SIGNAL(deleteTimelineClip(const QString &)), m_activeTimeline, SLOT(slotDeleteClip(const QString &)));
disconnect(m_activeTimeline->projectView(), SIGNAL(clipItemSelected(ClipItem*, int, bool)), m_effectStack, SLOT(slotClipItemSelected(ClipItem*, int)));
disconnect(m_activeTimeline->projectView(), SIGNAL(clipItemSelected(ClipItem*, int, bool)), this, SLOT(slotActivateEffectStackView(ClipItem*, int, bool)));
disconnect(m_activeTimeline->projectView(), SIGNAL(clipItemSelected(ClipItem*, int, bool)), m_projectMonitor, SLOT(slotSetSelectedClip(ClipItem*)));
disconnect(m_activeTimeline->projectView(), SIGNAL(transitionItemSelected(Transition*, int, QPoint, bool)), m_projectMonitor, SLOT(slotSetSelectedClip(Transition*)));
disconnect(m_activeTimeline->projectView(), SIGNAL(playMonitor()), m_projectMonitor, SLOT(slotPlay()));
disconnect(m_activeTimeline->projectView(), SIGNAL(displayMessage(const QString&, MessageType)), m_messageLabel, SLOT(setMessage(const QString&, MessageType)));
- disconnect(m_activeTimeline->projectView(), SIGNAL(showClipFrame(DocClipBase *, QPoint, const int)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *, QPoint, const int)));
+ disconnect(m_activeTimeline->projectView(), SIGNAL(showClipFrame(DocClipBase *, QPoint, const int)), m_clipMonitor, SLOT(slotSetClipProducer(DocClipBase *, QPoint, const int)));
disconnect(m_activeTimeline, SIGNAL(cursorMoved()), m_projectMonitor, SLOT(activateMonitor()));
disconnect(m_activeTimeline, SIGNAL(insertTrack(int)), this, SLOT(slotInsertTrack(int)));
disconnect(m_activeTimeline, SIGNAL(deleteTrack(int)), this, SLOT(slotDeleteTrack(int)));
disconnect(m_activeTimeline->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(activateMonitor()));
disconnect(m_activeTimeline, SIGNAL(zoneMoved(int, int)), this, SLOT(slotZoneMoved(int, int)));
disconnect(m_projectList, SIGNAL(loadingIsOver()), m_activeTimeline->projectView(), SLOT(slotUpdateAllThumbs()));
- disconnect(m_projectList, SIGNAL(displayMessage(const QString&, int)), this, SLOT(slotGotProgressInfo(const QString&, int)));
- disconnect(m_projectList, SIGNAL(updateRenderStatus()), this, SLOT(slotCheckRenderStatus()));
- disconnect(m_projectList, SIGNAL(clipNeedsReload(const QString&, bool)), m_activeTimeline->projectView(), SLOT(slotUpdateClip(const QString &, bool)));
disconnect(m_projectList, SIGNAL(refreshClip(const QString &)), m_activeTimeline->projectView(), SLOT(slotRefreshThumbs(const QString &)));
m_effectStack->clear();
}
//m_activeDocument->setRenderer(NULL);
- disconnect(m_projectList, SIGNAL(clipSelected(DocClipBase *)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *)));
- disconnect(m_projectList, SIGNAL(refreshClip(const QString &, bool)), m_monitorManager, SLOT(slotRefreshCurrentMonitor()));
m_clipMonitor->stop();
}
KdenliveSettings::setCurrent_profile(doc->profilePath());
KdenliveSettings::setProject_fps(doc->fps());
m_monitorManager->resetProfiles(doc->timecode());
+ m_clipMonitorDock->raise();
m_projectList->setDocument(doc);
m_transitionConfig->updateProjectFormat(doc->mltProfile(), doc->timecode(), doc->tracksList());
m_effectStack->updateProjectFormat(doc->mltProfile(), doc->timecode());
- connect(m_projectList, SIGNAL(clipSelected(DocClipBase *, QPoint)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *, QPoint)));
- connect(m_projectList, SIGNAL(refreshClip(const QString &, bool)), m_monitorManager, SLOT(slotRefreshCurrentMonitor()));
connect(m_projectList, SIGNAL(refreshClip(const QString &, bool)), trackView->projectView(), SLOT(slotRefreshThumbs(const QString &, bool)));
- connect(m_projectList, SIGNAL(clipNeedsReload(const QString&, bool)), trackView->projectView(), SLOT(slotUpdateClip(const QString &, bool)));
connect(m_projectList, SIGNAL(projectModified()), doc, SLOT(setModified()));
- connect(m_projectList, SIGNAL(updateProfile(const QString &)), this, SLOT(slotUpdateProjectProfile(const QString &)));
connect(m_projectList, SIGNAL(clipNameChanged(const QString, const QString)), trackView->projectView(), SLOT(clipNameChanged(const QString, const QString)));
- connect(m_projectList, SIGNAL(findInTimeline(const QString&)), this, SLOT(slotClipInTimeline(const QString&)));
-
-
- connect(trackView, SIGNAL(cursorMoved()), m_projectMonitor, SLOT(activateMonitor()));
+ //connect(trackView, SIGNAL(cursorMoved()), m_projectMonitor, SLOT(activateMonitor()));
connect(trackView, SIGNAL(insertTrack(int)), this, SLOT(slotInsertTrack(int)));
connect(trackView, SIGNAL(deleteTrack(int)), this, SLOT(slotDeleteTrack(int)));
connect(trackView, SIGNAL(configTrack(int)), this, SLOT(slotConfigTrack(int)));
connect(trackView->projectView(), SIGNAL(forceClipProcessing(const QString &)), m_projectList, SLOT(slotForceProcessing(const QString &)));
connect(m_projectMonitor, SIGNAL(renderPosition(int)), trackView, SLOT(moveCursorPos(int)));
connect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), trackView, SLOT(slotSetZone(QPoint)));
- connect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), m_projectList, SLOT(slotUpdateClipCut(QPoint)));
connect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), doc, SLOT(setModified()));
connect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), doc, SLOT(setModified()));
connect(m_projectMonitor, SIGNAL(durationChanged(int)), trackView, SLOT(setDuration(int)));
- connect(m_projectMonitor->render, SIGNAL(refreshDocumentProducers()), doc, SLOT(checkProjectClips()));
+ connect(m_projectMonitor->render, SIGNAL(refreshDocumentProducers(bool, bool)), doc, SLOT(checkProjectClips(bool, bool)));
connect(doc, SIGNAL(addProjectClip(DocClipBase *, bool)), m_projectList, SLOT(slotAddClip(DocClipBase *, bool)));
connect(doc, SIGNAL(resetProjectList()), m_projectList, SLOT(slotResetProjectList()));
connect(doc, SIGNAL(updateClipDisplay(const QString &)), m_projectList, SLOT(slotUpdateClip(const QString &)));
connect(doc, SIGNAL(selectLastAddedClip(const QString &)), m_projectList, SLOT(slotSelectClip(const QString &)));
- connect(doc, SIGNAL(deleteTimelineClip(const QString &)), trackView, SLOT(slotDeleteClip(const QString &)));
connect(doc, SIGNAL(docModified(bool)), this, SLOT(slotUpdateDocumentState(bool)));
connect(doc, SIGNAL(guidesUpdated()), this, SLOT(slotGuidesUpdated()));
+ connect(doc, SIGNAL(saveTimelinePreview(const QString &)), trackView, SLOT(slotSaveTimelinePreview(const QString)));
+
connect(m_notesWidget, SIGNAL(textChanged()), doc, SLOT(setModified()));
connect(trackView->projectView(), SIGNAL(clipItemSelected(ClipItem*, int, bool)), m_effectStack, SLOT(slotClipItemSelected(ClipItem*, int)));
connect(trackView, SIGNAL(setZoom(int)), this, SLOT(slotSetZoom(int)));
connect(trackView->projectView(), SIGNAL(displayMessage(const QString&, MessageType)), m_messageLabel, SLOT(setMessage(const QString&, MessageType)));
- connect(trackView->projectView(), SIGNAL(showClipFrame(DocClipBase *, QPoint, const int)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *, QPoint, const int)));
+ connect(trackView->projectView(), SIGNAL(showClipFrame(DocClipBase *, QPoint, const int)), m_clipMonitor, SLOT(slotSetClipProducer(DocClipBase *, QPoint, const int)));
connect(trackView->projectView(), SIGNAL(playMonitor()), m_projectMonitor, SLOT(slotPlay()));
connect(trackView->projectView(), SIGNAL(clipItemSelected(ClipItem*, int, bool)), m_projectMonitor, SLOT(slotSetSelectedClip(ClipItem*)));
connect(trackView->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(activateMonitor()));
connect(trackView, SIGNAL(zoneMoved(int, int)), this, SLOT(slotZoneMoved(int, int)));
connect(m_projectList, SIGNAL(loadingIsOver()), trackView->projectView(), SLOT(slotUpdateAllThumbs()));
- connect(m_projectList, SIGNAL(displayMessage(const QString&, int)), this, SLOT(slotGotProgressInfo(const QString&, int)));
- connect(m_projectList, SIGNAL(updateRenderStatus()), this, SLOT(slotCheckRenderStatus()));
trackView->projectView()->setContextMenu(m_timelineContextMenu, m_timelineContextClipMenu, m_timelineContextTransitionMenu, m_clipTypeGroup, (QMenu*)(factory()->container("marker_menu", this)));
m_activeDocument = doc;
m_activeTimeline->updateProjectFps();
m_activeDocument->checkProjectClips();
-#ifndef Q_WS_MAC
+#ifndef Q_WS_MAC
m_recMonitor->slotUpdateCaptureFolder(m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash));
#endif
//Update the mouse position display so it will display in DF/NDF format by default based on the project setting.
slotUpdateMousePosition(0);
+ m_monitorManager->activateMonitor("clip");
// set tool to select tool
m_buttonSelectTool->setChecked(true);
}
void MainWindow::slotUpdateCaptureFolder()
{
-#ifndef Q_WS_MAC
+#ifndef Q_WS_MAC
if (m_activeDocument) m_recMonitor->slotUpdateCaptureFolder(m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash));
else m_recMonitor->slotUpdateCaptureFolder(KdenliveSettings::defaultprojectfolder());
#endif
if (m_activeTimeline) {
m_activeTimeline->refresh();
m_activeTimeline->projectView()->checkAutoScroll();
- m_activeTimeline->projectView()->checkTrackHeight();
+ m_activeTimeline->checkTrackHeight();
if (m_activeDocument)
m_activeDocument->clipManager()->checkAudioThumbs();
}
// Update list of transcoding profiles
loadTranscoders();
-#ifndef NO_JOGSHUTTLE
+#ifdef USE_JOGSHUTTLE
activateShuttleDevice();
-#endif /* NO_JOGSHUTTLE */
+#endif
}
m_activeDocument->slotAddClipFile(url, QString());
}
+void MainWindow::slotAddProjectClipList(KUrl::List urls)
+{
+ if (m_activeDocument)
+ m_activeDocument->slotAddClipList(urls, QString());
+}
+
void MainWindow::slotAddTransition(QAction *result)
{
if (!result) return;
else m_messageLabel->setMessage(i18n("Cannot find effect %1 / %2").arg(info.at(0)).arg(info.at(1)), ErrorMessage);
}
-void MainWindow::slotAddAudioEffect(QAction *result)
-{
- if (!result) return;
- QStringList info = result->data().toStringList();
- if (info.isEmpty()) return;
- QDomElement effect = audioEffects.getEffectByTag(info.at(1), info.at(2));
- slotAddEffect(effect);
-}
-
-void MainWindow::slotAddCustomEffect(QAction *result)
-{
- if (!result) return;
- QStringList info = result->data().toStringList();
- if (info.isEmpty()) return;
- QDomElement effect = customEffects.getEffectByTag(info.at(1), info.at(2));
- slotAddEffect(effect);
-}
void MainWindow::slotZoomIn()
{
// any type of clip but a title
ClipProperties *dia = new ClipProperties(clip, m_activeDocument->timecode(), m_activeDocument->fps(), this);
connect(dia, SIGNAL(addMarker(const QString &, GenTime, QString)), m_activeTimeline->projectView(), SLOT(slotAddClipMarker(const QString &, GenTime, QString)));
+ connect(dia, SIGNAL(deleteProxy(const QString)), m_projectList, SLOT(slotDeleteProxy(const QString)));
connect(dia, SIGNAL(applyNewClipProperties(const QString, QMap <QString, QString> , QMap <QString, QString> , bool, bool)), this, SLOT(slotApplyNewClipProperties(const QString, QMap <QString, QString> , QMap <QString, QString> , bool, bool)));
dia->show();
}
if (e->type() == QEvent::User)
m_messageLabel->setMessage(static_cast <MltErrorEvent *>(e)->message(), MltError);
}
-void MainWindow::slotActivateEffectStackView(ClipItem*, int, bool raise)
+void MainWindow::slotActivateEffectStackView(ClipItem* item, int ix, bool raise)
{
- if (raise) m_effectStack->raiseWindow(m_effectStackDock);
+ Q_UNUSED(item)
+ Q_UNUSED(ix)
+
+ if (raise)
+ m_effectStack->raiseWindow(m_effectStackDock);
}
void MainWindow::slotActivateTransitionView(Transition *t)
}
-void MainWindow::slotSaveZone(Render *render, QPoint zone)
+void MainWindow::slotSaveZone(Render *render, QPoint zone, DocClipBase *baseClip, KUrl path)
{
KDialog *dialog = new KDialog(this);
dialog->setCaption("Save clip zone");
QVBoxLayout *vbox = new QVBoxLayout(widget);
QLabel *label1 = new QLabel(i18n("Save clip zone as:"), this);
- QString path = m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash);
- path.append("untitled.mlt");
- KUrlRequester *url = new KUrlRequester(KUrl(path), this);
+ if (path.isEmpty()) {
+ QString tmppath = m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash);
+ if (baseClip == NULL) tmppath.append("untitled.mlt");
+ else {
+ tmppath.append((baseClip->name().isEmpty() ? baseClip->fileURL().fileName() : baseClip->name()) + "-" + QString::number(zone.x()).rightJustified(4, '0') + ".mlt");
+ }
+ path = KUrl(tmppath);
+ }
+ KUrlRequester *url = new KUrlRequester(path, this);
url->setFilter("video/mlt-playlist");
QLabel *label2 = new QLabel(i18n("Description:"), this);
KLineEdit *edit = new KLineEdit(this);
vbox->addWidget(url);
vbox->addWidget(label2);
vbox->addWidget(edit);
- if (dialog->exec() == QDialog::Accepted)
- render->saveZone(url->url(), edit->text(), zone);
+ if (dialog->exec() == QDialog::Accepted) {
+ if (QFile::exists(url->url().path())) {
+ if (KMessageBox::questionYesNo(this, i18n("File %1 already exists.\nDo you want to overwrite it?", url->url().path())) == KMessageBox::No) {
+ slotSaveZone(render, zone, baseClip, url->url());
+ return;
+ }
+ }
+ if (baseClip && !baseClip->fileURL().isEmpty()) {
+ // create zone from clip url, so that we don't have problems with proxy clips
+ QProcess p;
+#if QT_VERSION >= 0x040600
+ QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+ env.remove("MLT_PROFILE");
+ p.setProcessEnvironment(env);
+#else
+ QStringList env = QProcess::systemEnvironment();
+ env << "MLT_PROFILE='\0'";
+ p.setEnvironment(env);
+#endif
+ p.start(KdenliveSettings::rendererpath(), QStringList() << baseClip->fileURL().path() << "in=" + QString::number(zone.x()) << "out=" + QString::number(zone.y()) << "-consumer" << "xml:" + url->url().path());
+ if (!p.waitForStarted(3000)) {
+ KMessageBox::sorry(this, i18n("Cannot start MLT's renderer:\n%1", KdenliveSettings::rendererpath()));
+ }
+ else if (!p.waitForFinished(5000)) {
+ KMessageBox::sorry(this, i18n("Timeout while creating xml output"));
+ }
+ }
+ else render->saveZone(url->url(), edit->text(), zone);
+ }
}
void MainWindow::slotSetInPoint()
{
- if (m_clipMonitor->isActive())
+ if (m_clipMonitor->isActive()) {
m_clipMonitor->slotSetZoneStart();
- else
+ } else {
m_projectMonitor->slotSetZoneStart();
- //else m_activeTimeline->projectView()->setInPoint();
+ }
}
void MainWindow::slotSetOutPoint()
{
- if (m_clipMonitor->isActive())
+ if (m_clipMonitor->isActive()) {
m_clipMonitor->slotSetZoneEnd();
- else
+ } else {
m_projectMonitor->slotSetZoneEnd();
- // else m_activeTimeline->projectView()->setOutPoint();
+ }
}
void MainWindow::slotResizeItemStart()
if (entry->status() == KNS::Entry::Installed)
kDebug() << "// Installed files: " << entry->installedFiles();
}
-#endif /* KDE_IS_VERSION(4,3,80) */
+#endif
return entries.size();
}
}
}
-void MainWindow::slotMaximizeCurrent(bool /*show*/)
+void MainWindow::slotMaximizeCurrent(bool)
{
//TODO: is there a way to maximize current widget?
- //if (show == true)
- {
- m_timelineState = saveState();
- QWidget *par = focusWidget()->parentWidget();
- while (par->parentWidget() && par->parentWidget() != this)
- par = par->parentWidget();
- kDebug() << "CURRENT WIDGET: " << par->objectName();
- }
- /*else {
- //centralWidget()->setHidden(false);
- //restoreState(m_timelineState);
- }*/
+
+ m_timelineState = saveState();
+ QWidget *par = focusWidget()->parentWidget();
+ while (par->parentWidget() && par->parentWidget() != this)
+ par = par->parentWidget();
+ kDebug() << "CURRENT WIDGET: " << par->objectName();
}
void MainWindow::loadTranscoders()
if (m_renderWidget->automaticAudioExport()) {
exportAudio = m_activeTimeline->checkProjectAudio();
} else exportAudio = m_renderWidget->selectedAudioExport();
+
+ // Set playlist audio volume to 100%
+ QDomDocument doc;
+ doc.setContent(playlistContent);
+ QDomElement tractor = doc.documentElement().firstChildElement("tractor");
+ if (!tractor.isNull()) {
+ QDomNodeList props = tractor.elementsByTagName("property");
+ for (int i = 0; i < props.count(); i++) {
+ if (props.at(i).toElement().attribute("name") == "meta.volume") {
+ props.at(i).firstChild().setNodeValue("1");
+ break;
+ }
+ }
+ }
// Do we want proxy rendering
if (m_projectList->useProxy() && !m_renderWidget->proxyRendering()) {
- QDomDocument doc;
- doc.setContent(playlistContent);
QString root = doc.documentElement().attribute("root");
// replace proxy clips with originals
QMap <QString, QString> proxies = m_projectList->getProxies();
- QMapIterator<QString, QString> i(proxies);
+
+ QDomNodeList producers = doc.elementsByTagName("producer");
+ QString producerResource;
+ QString suffix;
+ for (uint n = 0; n < producers.length(); n++) {
+ QDomElement e = producers.item(n).toElement();
+ producerResource = EffectsList::property(e, "resource");
+ if (producerResource.isEmpty()) continue;
+ if (!producerResource.startsWith("/")) {
+ producerResource.prepend(root + "/");
+ }
+ if (producerResource.contains('?')) {
+ // slowmotion producer
+ suffix = "?" + producerResource.section('?', 1);
+ producerResource = producerResource.section('?', 0, 0);
+ }
+ else suffix.clear();
+ if (!producerResource.isEmpty()) {
+ if (proxies.contains(producerResource)) {
+ EffectsList::setProperty(e, "resource", proxies.value(producerResource) + suffix);
+ // We need to delete the "aspect_ratio" property because proxy clips
+ // sometimes have different ratio than original clips
+ EffectsList::removeProperty(e, "aspect_ratio");
+ EffectsList::removeMetaProperties(e);
+ }
+ }
+ }
+
+ /*QMapIterator<QString, QString> i(proxies);
while (i.hasNext()) {
i.next();
// Replace all keys with their values (proxy path with original path)
QString key = i.key();
playlistContent.replace(key, i.value());
if (!root.isEmpty() && key.startsWith(root)) {
- // in case ther resource path in MLT playlist is relative
+ // in case the resource path in MLT playlist is relative
key.remove(0, root.count() + 1);
playlistContent.replace(key, i.value());
}
- }
+ }*/
}
+ playlistContent = doc.toString();
// Do save scenelist
QFile file(playlistPath);
else theme = action->data().toString();
KdenliveSettings::setColortheme(theme);
// Make palette for all widgets.
- QPalette plt;
+ QPalette plt = kapp->palette();
if (theme.isEmpty()) {
plt = QApplication::desktop()->palette();
} else {
KSharedConfigPtr config = KSharedConfig::openConfig(theme);
- plt = KGlobalSettings::createApplicationPalette(config);
+
+#if KDE_IS_VERSION(4,6,3)
+ plt = KGlobalSettings::createNewApplicationPalette(config);
+#else
+ // Since there was a bug in createApplicationPalette in KDE < 4.6.3 we need
+ // to do the palette loading stuff ourselves. (https://bugs.kde.org/show_bug.cgi?id=263497)
+ QPalette::ColorGroup states[3] = { QPalette::Active, QPalette::Inactive,
+ QPalette::Disabled };
+ // TT thinks tooltips shouldn't use active, so we use our active colors for all states
+ KColorScheme schemeTooltip(QPalette::Active, KColorScheme::Tooltip, config);
+
+ for ( int i = 0; i < 3 ; i++ ) {
+ QPalette::ColorGroup state = states[i];
+ KColorScheme schemeView(state, KColorScheme::View, config);
+ KColorScheme schemeWindow(state, KColorScheme::Window, config);
+ KColorScheme schemeButton(state, KColorScheme::Button, config);
+ KColorScheme schemeSelection(state, KColorScheme::Selection, config);
+
+ plt.setBrush( state, QPalette::WindowText, schemeWindow.foreground() );
+ plt.setBrush( state, QPalette::Window, schemeWindow.background() );
+ plt.setBrush( state, QPalette::Base, schemeView.background() );
+ plt.setBrush( state, QPalette::Text, schemeView.foreground() );
+ plt.setBrush( state, QPalette::Button, schemeButton.background() );
+ plt.setBrush( state, QPalette::ButtonText, schemeButton.foreground() );
+ plt.setBrush( state, QPalette::Highlight, schemeSelection.background() );
+ plt.setBrush( state, QPalette::HighlightedText, schemeSelection.foreground() );
+ plt.setBrush( state, QPalette::ToolTipBase, schemeTooltip.background() );
+ plt.setBrush( state, QPalette::ToolTipText, schemeTooltip.foreground() );
+
+ plt.setColor( state, QPalette::Light, schemeWindow.shade( KColorScheme::LightShade ) );
+ plt.setColor( state, QPalette::Midlight, schemeWindow.shade( KColorScheme::MidlightShade ) );
+ plt.setColor( state, QPalette::Mid, schemeWindow.shade( KColorScheme::MidShade ) );
+ plt.setColor( state, QPalette::Dark, schemeWindow.shade( KColorScheme::DarkShade ) );
+ plt.setColor( state, QPalette::Shadow, schemeWindow.shade( KColorScheme::ShadowShade ) );
+
+ plt.setBrush( state, QPalette::AlternateBase, schemeView.background( KColorScheme::AlternateBackground) );
+ plt.setBrush( state, QPalette::Link, schemeView.foreground( KColorScheme::LinkText ) );
+ plt.setBrush( state, QPalette::LinkVisited, schemeView.foreground( KColorScheme::VisitedText ) );
+ }
+#endif
}
kapp->setPalette(plt);
slotShowTitleBars(!KdenliveSettings::showtitlebars());
}
-QString MainWindow::getMimeType()
+QString MainWindow::getMimeType(bool open)
{
QString mimetype = "application/x-kdenlive";
KMimeType::Ptr mime = KMimeType::mimeType(mimetype);
- if (!mime) mimetype = "*.kdenlive";
+ if (!mime) {
+ mimetype = "*.kdenlive";
+ if (open) mimetype.append(" *.tar.gz");
+ }
+ else if (open) mimetype.append(" application/x-compressed-tar");
return mimetype;
}
m_projectMonitor->render->sendFrameForAnalysis = false;
}
m_clipMonitor->render->sendFrameForAnalysis = false;
+ if (m_recMonitor)
+ m_recMonitor->analyseFrames(false);
} else {
m_projectMonitor->render->sendFrameForAnalysis = true;
m_clipMonitor->render->sendFrameForAnalysis = true;
+ if (m_recMonitor)
+ m_recMonitor->analyseFrames(true);
}
}
void MainWindow::slotUpdateColorScopes()
{
bool request = false;
+ kDebug()<<"// UPDATE SCOPES";
for (int i = 0; i < m_gfxScopesList.count(); i++) {
// Check if we need the renderer to send a new frame for update
if (!m_gfxScopesList.at(i)->widget()->visibleRegion().isEmpty() && !(static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->autoRefreshEnabled())) request = true;
- static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->slotActiveMonitorChanged(m_clipMonitor->isActive());
+ static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->slotActiveMonitorChanged();
}
- if (request) {
- if (m_clipMonitor->isActive()) m_clipMonitor->render->sendFrameUpdate();
- else m_projectMonitor->render->sendFrameUpdate();
+ if (request && m_monitorManager->activeRenderer()) {
+ m_monitorManager->activeRenderer()->sendFrameUpdate();
+ }
+}
+
+void MainWindow::slotClearColorScopes()
+{
+ for (int i = 0; i < m_gfxScopesList.count(); i++) {
+ static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->slotClearMonitor();
}
}
void MainWindow::slotOpenStopmotion()
{
if (m_stopmotion == NULL) {
- m_stopmotion = new StopmotionWidget(m_activeDocument->projectFolder(), m_stopmotion_actions->actions(), this);
- connect(m_stopmotion, SIGNAL(addOrUpdateSequence(const QString)), m_projectList, SLOT(slotAddOrUpdateSequence(const QString)));
- for (int i = 0; i < m_gfxScopesList.count(); i++) {
+ m_stopmotion = new StopmotionWidget(m_monitorManager, m_activeDocument->projectFolder(), m_stopmotion_actions->actions(), this);
+ connect(m_stopmotion, SIGNAL(addOrUpdateSequence(const QString &)), m_projectList, SLOT(slotAddOrUpdateSequence(const QString)));
+ //for (int i = 0; i < m_gfxScopesList.count(); i++) {
// Check if we need the renderer to send a new frame for update
/*if (!m_scopesList.at(i)->widget()->visibleRegion().isEmpty() && !(static_cast<AbstractScopeWidget *>(m_scopesList.at(i)->widget())->autoRefreshEnabled())) request = true;*/
- connect(m_stopmotion, SIGNAL(gotFrame(QImage)), static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget()), SLOT(slotRenderZoneUpdated(QImage)));
+ //connect(m_stopmotion, SIGNAL(gotFrame(QImage)), static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget()), SLOT(slotRenderZoneUpdated(QImage)));
//static_cast<AbstractScopeWidget *>(m_scopesList.at(i)->widget())->slotMonitorCapture();
- }
+ //}
}
m_stopmotion->show();
}
m_projectList->updateProxyConfig();
}
+void MainWindow::slotInsertNotesTimecode()
+{
+ int frames = m_projectMonitor->render->seekPosition().frames(m_activeDocument->fps());
+ QString position = m_activeDocument->timecode().getTimecodeFromFrames(frames);
+ m_notesWidget->insertHtml("<a href=\"" + QString::number(frames) + "\">" + position + "</a> ");
+}
+
+void MainWindow::slotArchiveProject()
+{
+ QList <DocClipBase*> list = m_projectList->documentClipList();
+ QDomDocument doc = m_activeDocument->xmlSceneList(m_projectMonitor->sceneList(), m_projectList->expandedFolders());
+ ArchiveWidget *d = new ArchiveWidget(m_activeDocument->url().fileName(), doc, list, m_activeTimeline->projectView()->extractTransitionsLumas(), this);
+ d->exec();
+}
+
+
+void MainWindow::slotOpenBackupDialog(const KUrl url)
+{
+ KUrl projectFile;
+ KUrl projectFolder;
+ QString projectId;
+ kDebug()<<"// BACKUP URL: "<<url.path();
+ if (!url.isEmpty()) {
+ // we could not open the project file, guess where the backups are
+ projectFolder = KUrl(KdenliveSettings::defaultprojectfolder());
+ projectFile = url;
+ }
+ else {
+ projectFolder = m_activeDocument->projectFolder();
+ projectFile = m_activeDocument->url();
+ projectId = m_activeDocument->getDocumentProperty("documentid");
+ }
+
+ BackupWidget *dia = new BackupWidget(projectFile, projectFolder, projectId, this);
+ if (dia->exec() == QDialog::Accepted) {
+ QString requestedBackup = dia->selectedFile();
+ m_activeDocument->backupLastSavedVersion(projectFile.path());
+ closeCurrentDocument(false);
+ doOpenFile(KUrl(requestedBackup), NULL);
+ m_activeDocument->setUrl(projectFile);
+ m_activeDocument->setModified(true);
+ setCaption(m_activeDocument->description());
+ }
+ delete dia;
+}
+
+void MainWindow::slotElapsedTime()
+{
+ kDebug()<<"-----------------------------------------\n"<<"Time elapsed: "<<m_timer.elapsed()<<"\n-------------------------";
+}
+
#include "mainwindow.moc"
#ifdef DEBUG_MAINW