#include "trackview.h"
#include "customtrackview.h"
#include "effectslistview.h"
-#include "effectstackview.h"
+#include "effectstack/effectstackview2.h"
#include "transitionsettings.h"
-#include "renderwidget.h"
+#include "widgets/renderwidget.h"
#include "renderer.h"
-#include "audiosignal.h"
#ifdef USE_JOGSHUTTLE
#include "jogshuttle.h"
#include "jogaction.h"
#include "clipproperties.h"
#include "wizard.h"
#include "commands/editclipcommand.h"
-#include "titlewidget.h"
+#include "widgets/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 "audioscopes/audiospectrum.h"
-#include "audioscopes/spectrogram.h"
-#include "archivewidget.h"
+#include "scopes/scopemanager.h"
+#include "scopes/colorscopes/vectorscope.h"
+#include "scopes/colorscopes/waveform.h"
+#include "scopes/colorscopes/rgbparade.h"
+#include "scopes/colorscopes/histogram.h"
+#include "scopes/audioscopes/audiosignal.h"
+#include "scopes/audioscopes/audiospectrum.h"
+#include "scopes/audioscopes/spectrogram.h"
+#include "widgets/archivewidget.h"
#include "databackup/backupwidget.h"
+#include "utils/resourcewidget.h"
#include <KApplication>
#include <KAction>
-#include <KLocale>
+#include <KLocalizedString>
#include <KGlobal>
#include <KActionCollection>
#include <KActionCategory>
#include <QInputDialog>
#include <QDesktopWidget>
#include <QBitmap>
+#include <QUndoGroup>
+#include <QGLWidget>
#include <stdlib.h>
+#include <locale.h>
// Uncomment for deeper debugging
//#define DEBUG_MAINW
static const char version[] = VERSION;
-static const int ID_TIMELINE_POS = 0;
namespace Mlt
{
class Producer;
EffectsList MainWindow::customEffects;
EffectsList MainWindow::transitions;
+QMap <QString,QImage> MainWindow::m_lumacache;
+
+static bool sortByNames(const QPair<QString, KAction*> &a, const QPair<QString, KAction*> &b)
+{
+ return a.first < b.first;
+}
+
MainWindow::MainWindow(const QString &MltPath, const KUrl & Url, const QString & clipsToLoad, QWidget *parent) :
KXmlGuiWindow(parent),
+ m_glContext(NULL),
m_activeDocument(NULL),
m_activeTimeline(NULL),
+ m_projectList(NULL),
+ m_effectList(NULL),
+ m_effectStack(NULL),
+ m_clipMonitor(NULL),
+ m_projectMonitor(NULL),
m_recMonitor(NULL),
m_renderWidget(NULL),
-#ifdef USE_JOGSHUTTLE
+ #ifdef USE_JOGSHUTTLE
m_jogProcess(NULL),
m_jogShuttle(NULL),
-#endif
+ #endif
m_findActivated(false),
- m_stopmotion(NULL)
-{
+ m_stopmotion(NULL),
+ m_mainClip(NULL)
+{
qRegisterMetaType<QVector<int16_t> > ();
qRegisterMetaType<stringMap> ("stringMap");
qRegisterMetaType<audioByteArray> ("audioByteArray");
// Init locale
QLocale systemLocale = QLocale();
+ setlocale(LC_NUMERIC, NULL);
+ char *separator = localeconv()->decimal_point;
+ if (separator != systemLocale.decimalPoint()) {
+ kDebug()<<"------\n!!! system locale is not similar to Qt's locale... be prepared for bugs!!!\n------";
+ // HACK: There is a locale conflict, so set locale to C
+ // Make sure to override exported values or it won't work
+ setenv("LANG", "C", 1);
+ setlocale(LC_NUMERIC, "C");
+ systemLocale = QLocale::c();
+ }
+
systemLocale.setNumberOptions(QLocale::OmitGroupSeparator);
QLocale::setDefault(systemLocale);
setFont(KGlobalSettings::toolBarFont());
parseProfiles(MltPath);
KdenliveSettings::setCurrent_profile(KdenliveSettings::default_profile());
+
+ // Create OpenGL context, to have a common context all the other contexts
+ // can share with.
+ m_glContext = new QGLWidget(this);
+ m_glContext->resize(0, 0);
+
m_commandStack = new QUndoGroup;
setDockNestingEnabled(true);
m_timelineArea = new KTabWidget(this);
// FIXME: the next call returns a newly allocated object, which leaks
initEffects::parseEffectFiles();
//initEffects::parseCustomEffectsFile();
-
+
m_monitorManager = new MonitorManager();
m_shortcutRemoveFocus = new QShortcut(QKeySequence("Esc"), this);
m_projectListDock = new QDockWidget(i18n("Project Tree"), this);
m_projectListDock->setObjectName("project_tree");
- m_projectList = new ProjectList();
+ m_projectList = new ProjectList(m_glContext);
m_projectListDock->setWidget(m_projectList);
addDockWidget(Qt::TopDockWidgetArea, m_projectListDock);
m_clipMonitorDock = new QDockWidget(i18n("Clip Monitor"), this);
m_clipMonitorDock->setObjectName("clip_monitor");
- m_clipMonitor = new Monitor("clip", m_monitorManager, QString(), m_timelineArea);
+ m_clipMonitor = new Monitor(Kdenlive::ClipMonitor, m_monitorManager, m_glContext, 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(clipSelected(DocClipBase*,QPoint,bool)), m_clipMonitor, SLOT(slotSetClipProducer(DocClipBase*,QPoint,bool)));
+ connect(m_projectList, SIGNAL(raiseClipMonitor(bool)), m_clipMonitor, SLOT(slotActivateMonitor(bool)));
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(displayMessage(QString,int,MessageType)), this, SLOT(slotGotProgressInfo(QString,int,MessageType)));
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_projectList, SIGNAL(clipNeedsReload(QString)),this, SLOT(slotUpdateClip(QString)));
+ connect(m_projectList, SIGNAL(updateProfile(QString)), this, SLOT(slotUpdateProjectProfile(QString)));
+ connect(m_projectList, SIGNAL(refreshClip(QString,bool)), m_monitorManager, SLOT(slotRefreshCurrentMonitor(QString)));
+ connect(m_projectList, SIGNAL(findInTimeline(QString)), this, SLOT(slotClipInTimeline(QString)));
connect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), m_projectList, SLOT(slotUpdateClipCut(QPoint)));
+ connect(m_clipMonitor, SIGNAL(extractZone(QString,QPoint)), m_projectList, SLOT(slotCutClipJob(QString,QPoint)));
m_projectMonitorDock = new QDockWidget(i18n("Project Monitor"), this);
m_projectMonitorDock->setObjectName("project_monitor");
- m_projectMonitor = new Monitor("project", m_monitorManager, QString());
+ m_projectMonitor = new Monitor(Kdenlive::ProjectMonitor, m_monitorManager, m_glContext, QString());
m_projectMonitorDock->setWidget(m_projectMonitor);
#ifndef Q_WS_MAC
m_recMonitorDock = new QDockWidget(i18n("Record Monitor"), this);
m_recMonitorDock->setObjectName("record_monitor");
- m_recMonitor = new RecMonitor("record", m_monitorManager);
+ m_recMonitor = new RecMonitor(Kdenlive::RecordMonitor, 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)));
+ connect(m_recMonitor, SIGNAL(showConfigDialog(int,int)), this, SLOT(slotPreferences(int,int)));
+
#endif /* ! Q_WS_MAC */
m_monitorManager->initMonitors(m_clipMonitor, m_projectMonitor, m_recMonitor);
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_effectStackDock = new QDockWidget(i18n("Effect Stack"), this);
m_effectStackDock->setObjectName("effect_stack");
- m_effectStack = new EffectStackView(m_projectMonitor);
+ m_effectStack = new EffectStackView2(m_projectMonitor);
m_effectStackDock->setWidget(m_effectStack);
addDockWidget(Qt::TopDockWidgetArea, m_effectStackDock);
+ connect(m_effectStack, SIGNAL(startFilterJob(ItemInfo,QString,QString,QString,QString,QString,QMap<QString,QString>)), m_projectList, SLOT(slotStartFilterJob(ItemInfo,QString,QString,QString,QString,QString,QMap<QString,QString>)));
m_transitionConfigDock = new QDockWidget(i18n("Transition"), this);
m_transitionConfigDock->setObjectName("transition");
m_effectListDock->setWidget(m_effectList);
addDockWidget(Qt::TopDockWidgetArea, m_effectListDock);
- m_vectorscope = new Vectorscope(m_monitorManager);
+ m_scopeManager = new ScopeManager(m_monitorManager);
+ m_vectorscope = new Vectorscope();
m_vectorscopeDock = new QDockWidget(i18n("Vectorscope"), this);
m_vectorscopeDock->setObjectName(m_vectorscope->widgetName());
m_vectorscopeDock->setWidget(m_vectorscope);
addDockWidget(Qt::TopDockWidgetArea, m_vectorscopeDock);
- connect(m_vectorscopeDock, SIGNAL(visibilityChanged(bool)), m_vectorscope, SLOT(forceUpdate(bool)));
- connect(m_vectorscopeDock, SIGNAL(visibilityChanged(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- connect(m_vectorscope, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- m_gfxScopesList.append(m_vectorscopeDock);
+ m_scopeManager->addScope(m_vectorscope, m_vectorscopeDock);
- m_waveform = new Waveform(m_monitorManager);
+ m_waveform = new Waveform();
m_waveformDock = new QDockWidget(i18n("Waveform"), this);
m_waveformDock->setObjectName(m_waveform->widgetName());
m_waveformDock->setWidget(m_waveform);
addDockWidget(Qt::TopDockWidgetArea, m_waveformDock);
- connect(m_waveformDock, SIGNAL(visibilityChanged(bool)), m_waveform, SLOT(forceUpdate(bool)));
- connect(m_waveformDock, SIGNAL(visibilityChanged(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- connect(m_waveform, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- m_gfxScopesList.append(m_waveformDock);
+ m_scopeManager->addScope(m_waveform, m_waveformDock);
- m_RGBParade = new RGBParade(m_monitorManager);
+ m_RGBParade = new RGBParade();
m_RGBParadeDock = new QDockWidget(i18n("RGB Parade"), this);
m_RGBParadeDock->setObjectName(m_RGBParade->widgetName());
m_RGBParadeDock->setWidget(m_RGBParade);
addDockWidget(Qt::TopDockWidgetArea, m_RGBParadeDock);
- connect(m_RGBParadeDock, SIGNAL(visibilityChanged(bool)), m_RGBParade, SLOT(forceUpdate(bool)));
- connect(m_RGBParadeDock, SIGNAL(visibilityChanged(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- connect(m_RGBParade, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- m_gfxScopesList.append(m_RGBParadeDock);
+ m_scopeManager->addScope(m_RGBParade, m_RGBParadeDock);
- m_histogram = new Histogram(m_monitorManager);
+ m_histogram = new Histogram();
m_histogramDock = new QDockWidget(i18n("Histogram"), this);
m_histogramDock->setObjectName(m_histogram->widgetName());
m_histogramDock->setWidget(m_histogram);
addDockWidget(Qt::TopDockWidgetArea, m_histogramDock);
- connect(m_histogramDock, SIGNAL(visibilityChanged(bool)), m_histogram, SLOT(forceUpdate(bool)));
- connect(m_histogramDock, SIGNAL(visibilityChanged(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- connect(m_histogram, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateGfxScopeFrameRequest()));
- m_gfxScopesList.append(m_histogramDock);
-
+ m_scopeManager->addScope(m_histogram, m_histogramDock);
m_audiosignal = new AudioSignal;
m_audiosignalDock = new QDockWidget(i18n("Audio Signal"), this);
m_audiosignalDock->setObjectName("audiosignal");
m_audiosignalDock->setWidget(m_audiosignal);
addDockWidget(Qt::TopDockWidgetArea, m_audiosignalDock);
- connect(m_audiosignalDock, SIGNAL(visibilityChanged(bool)), this, SLOT(slotUpdateAudioScopeFrameRequest()));
- connect(m_audiosignal, SIGNAL(updateAudioMonitoring()), this, SLOT(slotUpdateAudioScopeFrameRequest()));
+ m_scopeManager->addScope(m_audiosignal, m_audiosignalDock);
m_audioSpectrum = new AudioSpectrum();
m_audioSpectrumDock = new QDockWidget(i18n("AudioSpectrum"), this);
m_audioSpectrumDock->setObjectName(m_audioSpectrum->widgetName());
m_audioSpectrumDock->setWidget(m_audioSpectrum);
addDockWidget(Qt::TopDockWidgetArea, m_audioSpectrumDock);
- m_audioScopesList.append(m_audioSpectrum);
- connect(m_audioSpectrumDock, SIGNAL(visibilityChanged(bool)), this, SLOT(slotUpdateAudioScopeFrameRequest()));
- connect(m_audioSpectrum, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateAudioScopeFrameRequest()));
+ m_scopeManager->addScope(m_audioSpectrum, m_audioSpectrumDock);
m_spectrogram = new Spectrogram();
m_spectrogramDock = new QDockWidget(i18n("Spectrogram"), this);
m_spectrogramDock->setObjectName(m_spectrogram->widgetName());
m_spectrogramDock->setWidget(m_spectrogram);
addDockWidget(Qt::TopDockWidgetArea, m_spectrogramDock);
- m_audioScopesList.append(m_spectrogram);
- connect(m_audioSpectrumDock, SIGNAL(visibilityChanged(bool)), this, SLOT(slotUpdateAudioScopeFrameRequest()));
- connect(m_audioSpectrum, SIGNAL(requestAutoRefresh(bool)), this, SLOT(slotUpdateAudioScopeFrameRequest()));
-
- // Connect the audio signal to the audio scope slots
- bool b = true;
- if (m_projectMonitor) {
- qDebug() << "project monitor connected";
- b &= connect(m_projectMonitor->render, SIGNAL(audioSamplesSignal(QVector<int16_t>, int, int, int)),
- m_audioSpectrum, SLOT(slotReceiveAudio(QVector<int16_t>, int, int, int)));
- b &= connect(m_projectMonitor->render, SIGNAL(audioSamplesSignal(const QVector<int16_t>&, const int&, const int&, const int&)),
- m_audiosignal, SLOT(slotReceiveAudio(const QVector<int16_t>&, const int&, const int&, const int&)));
- b &= connect(m_projectMonitor->render, SIGNAL(audioSamplesSignal(QVector<int16_t>,int,int,int)),
- m_spectrogram, SLOT(slotReceiveAudio(QVector<int16_t>,int,int,int)));
- }
- if (m_clipMonitor) {
- qDebug() << "clip monitor connected";
- b &= connect(m_clipMonitor->render, SIGNAL(audioSamplesSignal(QVector<int16_t>, int, int, int)),
- m_audioSpectrum, SLOT(slotReceiveAudio(QVector<int16_t>, int, int, int)));
- b &= connect(m_clipMonitor->render, SIGNAL(audioSamplesSignal(const QVector<int16_t>&, int, int, int)),
- m_audiosignal, SLOT(slotReceiveAudio(const QVector<int16_t>&, int, int, int)));
- b &= connect(m_clipMonitor->render, SIGNAL(audioSamplesSignal(QVector<int16_t>,int,int,int)),
- m_spectrogram, SLOT(slotReceiveAudio(QVector<int16_t>,int,int,int)));
- }
- // Ensure connections were set up correctly
- Q_ASSERT(b);
-
-
+ m_scopeManager->addScope(m_spectrogram, m_spectrogramDock);
// Add monitors here to keep them at the right of the window
addDockWidget(Qt::TopDockWidgetArea, m_clipMonitorDock);
#ifndef Q_WS_MAC
tabifyDockWidget(m_clipMonitorDock, m_recMonitorDock);
#endif
-
-
-
-
setCentralWidget(m_timelineArea);
-
- m_fileOpenRecent = KStandardAction::openRecent(this, SLOT(openFile(const KUrl &)), actionCollection());
+ m_fileOpenRecent = KStandardAction::openRecent(this, SLOT(openFile(KUrl)), actionCollection());
readOptions();
m_fileRevert = KStandardAction::revert(this, SLOT(slotRevert()), actionCollection());
m_fileRevert->setEnabled(false);
// Prepare layout actions
KActionCategory *layoutActions = new KActionCategory(i18n("Layouts"), actionCollection());
m_loadLayout = new KSelectAction(i18n("Load Layout"), actionCollection());
- for (int i = 1; i < 5; i++) {
- KAction *load = new KAction(KIcon(), i18n("Layout %1").arg(i), this);
- load->setData("_" + QString::number(i));
- layoutActions->addAction("load_layout" + QString::number(i), load);
+ for (int i = 1; i < 5; ++i) {
+ KAction *load = new KAction(KIcon(), i18n("Layout %1", i), this);
+ load->setData('_' + QString::number(i));
+ layoutActions->addAction("load_layout" + QString::number(i), load);
m_loadLayout->addAction(load);
- KAction *save = new KAction(KIcon(), i18n("Save As Layout %1").arg(i), this);
- save->setData("_" + QString::number(i));
+ KAction *save = new KAction(KIcon(), i18n("Save As Layout %1", i), this);
+ save->setData('_' + QString::number(i));
layoutActions->addAction("save_layout" + QString::number(i), save);
}
+ // Required to enable user to add the load layout action to toolbar
layoutActions->addAction("load_layouts", m_loadLayout);
connect(m_loadLayout, SIGNAL(triggered(QAction*)), this, SLOT(slotLoadLayout(QAction*)));
m_effectActions = new KActionCategory(i18n("Effects"), actionCollection());
m_effectList->reloadEffectList(m_effectsMenu, m_effectActions);
m_effectsActionCollection->readSettings();
-
+
+ // Populate View menu with show / hide actions for dock widgets
+ KActionCategory *guiActions = new KActionCategory(i18n("Interface"), actionCollection());
+
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++) {
+ for (int i = 0; i < tabs.count(); ++i) {
tabs.at(i)->setContextMenuPolicy(Qt::CustomContextMenu);
- connect(tabs.at(i), SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(slotSwitchTitles()));
+ connect(tabs.at(i), SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slotSwitchTitles()));
}
/*ScriptingPart* sp = new ScriptingPart(this, QStringList());
guiFactory()->addClient(sp);*/
+ QMenu *trackMenu = (QMenu*)(factory()->container("track_menu", this));
+ if (trackMenu) trackMenu->addActions(m_tracksActionCollection->actions());
+
QMenu *saveLayout = (QMenu*)(factory()->container("layout_save_as", this));
if (saveLayout)
loadPlugins();
loadTranscoders();
+ loadClipActions();
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 *clipInTimeline = static_cast<QMenu*>(factory()->container("clip_in_timeline", this));
clipInTimeline->setIcon(KIcon("go-jump"));
- m_projectList->setupGeneratorMenu(static_cast<QMenu*>(factory()->container("generators", this)),
- static_cast<QMenu*>(factory()->container("transcoders", this)),
- clipInTimeline);
+ QHash<QString,QMenu*> menus;
+ menus.insert("addMenu",static_cast<QMenu*>(factory()->container("generators", this)));
+ menus.insert("extractAudioMenu",static_cast<QMenu*>(factory()->container("extract_audio", this)));
+ menus.insert("transcodeMenu",static_cast<QMenu*>(factory()->container("transcoders", this)));
+ menus.insert("clipActionsMenu",static_cast<QMenu*>(factory()->container("clip_actions", this)));
+ menus.insert("inTimelineMenu",clipInTimeline);
+ m_projectList->setupGeneratorMenu(menus);
// build themes menus
QMenu *themesMenu = static_cast<QMenu*>(factory()->container("themes_menu", this));
if (KdenliveSettings::colortheme() == *it) action->setChecked(true);
}*/
themesMenu->addActions(themegroup->actions());
- connect(themesMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotChangePalette(QAction*)));
+ connect(themesMenu, SIGNAL(triggered(QAction*)), this, SLOT(slotChangePalette(QAction*)));
// Setup and fill effects and transitions menus.
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 *)));
-
- m_effectStack->setMenu(m_effectsMenu);
-
- QMenu *viewMenu = static_cast<QMenu*>(factory()->container("dockwindows", this));
- const QList<QAction *> viewActions = createPopupMenu()->actions();
- viewMenu->insertActions(NULL, viewActions);
+ 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*)));
m_timelineContextMenu = new QMenu(this);
m_timelineContextClipMenu = new QMenu(this);
m_timelineContextClipMenu->addAction(actionCollection()->action("clip_in_project_tree"));
//m_timelineContextClipMenu->addAction(actionCollection()->action("clip_to_project_tree"));
- m_timelineContextClipMenu->addAction(actionCollection()->action("edit_item_duration"));
- m_timelineContextClipMenu->addAction(actionCollection()->action("delete_item"));
+ m_timelineContextClipMenu->addAction(actionCollection()->action("delete_timeline_clip"));
m_timelineContextClipMenu->addSeparator();
m_timelineContextClipMenu->addAction(actionCollection()->action("group_clip"));
m_timelineContextClipMenu->addAction(actionCollection()->action("ungroup_clip"));
m_timelineContextClipMenu->addAction(actionCollection()->action("split_audio"));
+ m_timelineContextClipMenu->addAction(actionCollection()->action("set_audio_align_ref"));
+ m_timelineContextClipMenu->addAction(actionCollection()->action("align_audio"));
m_timelineContextClipMenu->addSeparator();
m_timelineContextClipMenu->addAction(actionCollection()->action("cut_timeline_clip"));
m_timelineContextClipMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Copy)));
m_timelineContextClipMenu->addMenu(m_transitionsMenu);
m_timelineContextClipMenu->addMenu(m_effectsMenu);
- m_timelineContextTransitionMenu->addAction(actionCollection()->action("edit_item_duration"));
- m_timelineContextTransitionMenu->addAction(actionCollection()->action("delete_item"));
+ m_timelineContextTransitionMenu->addAction(actionCollection()->action("delete_timeline_clip"));
m_timelineContextTransitionMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Copy)));
m_timelineContextTransitionMenu->addAction(actionCollection()->action("auto_transition"));
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(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(addEffect(QDomElement)), this, SLOT(slotAddEffect(QDomElement)));
connect(m_effectList, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
slotConnectMonitors();
- // Open or create a file. Command line argument passed in Url has
- // precedence, then "openlastproject", then just a plain empty file.
- // If opening Url fails, openlastproject will _not_ be used.
- if (!Url.isEmpty()) {
- // delay loading so that the window shows up
- m_startUrl = Url;
- QTimer::singleShot(500, this, SLOT(openFile()));
- } else if (KdenliveSettings::openlastproject()) {
- QTimer::singleShot(500, this, SLOT(openLastFile()));
- } else { //if (m_timelineArea->count() == 0) {
- newFile(false);
- }
-
- if (!clipsToLoad.isEmpty() && m_activeDocument) {
- QStringList list = clipsToLoad.split(',');
- QList <QUrl> urls;
- foreach(QString path, list) {
- kDebug() << QDir::current().absoluteFilePath(path);
- urls << QUrl::fromLocalFile(QDir::current().absoluteFilePath(path));
- }
- m_projectList->slotAddClip(urls);
- }
-
#ifdef USE_JOGSHUTTLE
activateShuttleDevice();
#endif
actionCollection()->addAssociatedWidget(m_clipMonitor->container());
actionCollection()->addAssociatedWidget(m_projectMonitor->container());
+
+ QList<QPair<QString, KAction *> > viewActions;
+ QPair <QString, KAction *> pair;
+ KAction *showTimeline = new KAction(i18n("Timeline"), this);
+ showTimeline->setCheckable(true);
+ showTimeline->setChecked(true);
+ connect(showTimeline, SIGNAL(triggered(bool)), this, SLOT(slotShowTimeline(bool)));
+
+ KMenu *viewMenu = static_cast<KMenu*>(factory()->container("dockwindows", this));
+ pair.first = showTimeline->text();
+ pair.second = showTimeline;
+ viewActions.append(pair);
+
+ QList <QDockWidget *> docks = findChildren<QDockWidget *>();
+ for (int i = 0; i < docks.count(); ++i) {
+ QDockWidget* dock = docks.at(i);
+ QAction * a = dock->toggleViewAction();
+ if (!a) continue;
+ KAction* dockInformations = new KAction(this);
+ dockInformations->setText(a->text());
+ dockInformations->setCheckable(true);
+ dockInformations->setChecked(!dock->isHidden());
+ // HACK: since QActions cannot be used in KActionCategory to allow shortcut, we create a duplicate KAction of the dock QAction and link them
+ connect(a,SIGNAL(toggled(bool)), dockInformations, SLOT(setChecked(bool)));
+ connect(dockInformations,SIGNAL(triggered(bool)), a, SLOT(trigger()));
+ pair.first = dockInformations->text();
+ pair.second = dockInformations;
+ viewActions.append(pair);
+ }
+
+ // Sort dock view action by name
+ qSort(viewActions.begin(), viewActions.end(), sortByNames);
+ // Populate view menu
+ for (int i = 0; i < viewActions.count(); ++i)
+ viewMenu->addAction(guiActions->addAction(viewActions.at(i).first, viewActions.at(i).second));
// Populate encoding profiles
- KConfig conf("encodingprofiles.rc", KConfig::FullConfig, "appdata");
+ KConfig conf("encodingprofiles.rc", KConfig::CascadeConfig, "appdata");
if (KdenliveSettings::proxyparams().isEmpty() || KdenliveSettings::proxyextension().isEmpty()) {
KConfigGroup group(&conf, "proxy");
QMap< QString, QString > values = group.entryMap();
KdenliveSettings::setV4l_extension(data.section(';', 1, 1));
}
}
+ if (KdenliveSettings::grab_parameters().isEmpty() || KdenliveSettings::grab_extension().isEmpty()) {
+ KConfigGroup group(&conf, "screengrab");
+ QMap< QString, QString > values = group.entryMap();
+ QMapIterator<QString, QString> i(values);
+ if (i.hasNext()) {
+ i.next();
+ QString data = i.value();
+ KdenliveSettings::setGrab_parameters(data.section(';', 0, 0));
+ KdenliveSettings::setGrab_extension(data.section(';', 1, 1));
+ }
+ }
if (KdenliveSettings::decklink_parameters().isEmpty() || KdenliveSettings::decklink_extension().isEmpty()) {
KConfigGroup group(&conf, "decklink");
QMap< QString, QString > values = group.entryMap();
KdenliveSettings::setDecklink_extension(data.section(';', 1, 1));
}
}
+
+ connect (KGlobalSettings::self(), SIGNAL(kdisplayPaletteChanged()), this, SLOT(slotChangePalette()));
+
+ // Open or create a file. Command line argument passed in Url has
+ // precedence, then "openlastproject", then just a plain empty file.
+ // If opening Url fails, openlastproject will _not_ be used.
+ if (!Url.isEmpty()) {
+ // delay loading so that the window shows up
+ m_startUrl = Url;
+ QTimer::singleShot(500, this, SLOT(openFile()));
+ } else if (KdenliveSettings::openlastproject()) {
+ QTimer::singleShot(500, this, SLOT(openLastFile()));
+ } else { //if (m_timelineArea->count() == 0) {
+ newFile(false);
+ }
+
+ if (!clipsToLoad.isEmpty() && m_activeDocument) {
+ QStringList list = clipsToLoad.split(',');
+ QList <QUrl> urls;
+ foreach(const QString &path, list) {
+ kDebug() << QDir::current().absoluteFilePath(path);
+ urls << QUrl::fromLocalFile(QDir::current().absoluteFilePath(path));
+ }
+ m_projectList->slotAddClip(urls);
+ }
}
MainWindow::~MainWindow()
{
- if (m_stopmotion) {
- delete m_stopmotion;
- }
- m_effectStack->slotClipItemSelected(NULL, 0);
+ delete m_stopmotion;
+
+#ifdef USE_JOGSHUTTLE
+ delete m_jogProcess;
+#endif
+
+ m_effectStack->slotClipItemSelected(NULL);
m_transitionConfig->slotTransitionItemSelected(NULL, 0, QPoint(), false);
if (m_projectMonitor) m_projectMonitor->stop();
delete m_clipMonitor;
delete m_shortcutRemoveFocus;
delete[] m_transitions;
+ delete m_monitorManager;
+ delete m_scopeManager;
Mlt::Factory::close();
+ delete m_glContext;
}
//virtual
}
}
saveOptions();
- if (m_monitorManager) m_monitorManager->stopActiveMonitor();
+ if (m_monitorManager) {
+ m_monitorManager->stopActiveMonitor();
+ }
+
// warn the user to save if document is modified and we have clips in our project list
if (m_activeDocument && m_activeDocument->isModified() &&
((m_projectList->documentClipList().isEmpty() && !m_activeDocument->url().isEmpty()) ||
raise();
activateWindow();
QString message;
- if (m_activeDocument->url().fileName().isEmpty())
+ if (m_activeDocument->url().fileName().isEmpty()) {
message = i18n("Save changes to document?");
- else
- message = i18n("The project <b>\"%1\"</b> has been changed.\nDo you want to save your changes?").arg(m_activeDocument->url().fileName());
+ } else {
+ message = i18n("The project <b>\"%1\"</b> has been changed.\nDo you want to save your changes?", m_activeDocument->url().fileName());
+ }
switch (KMessageBox::warningYesNoCancel(this, message)) {
case KMessageBox::Yes :
// save document here. If saving fails, return false;
QAction *action = qobject_cast<QAction *>(sender());
ClipGenerator *iGenerator = qobject_cast<ClipGenerator *>(action->parent());
- KUrl clipUrl = iGenerator->generatedClip(action->data().toString(), m_activeDocument->projectFolder(),
- QStringList(), QStringList(), m_activeDocument->fps(), m_activeDocument->width(), m_activeDocument->height());
+ KUrl clipUrl = iGenerator->generatedClip(KdenliveSettings::rendererpath(), action->data().toString(), m_activeDocument->projectFolder(),
+ QStringList(), QStringList(), m_activeDocument->fps(), m_activeDocument->width(), m_activeDocument->height());
if (!clipUrl.isEmpty()) {
m_projectList->slotAddClip(QList <QUrl> () << clipUrl);
}
delete m_jogProcess;
m_jogProcess = NULL;
if (KdenliveSettings::enableshuttle() == false) return;
-
- m_jogProcess = new JogShuttle(KdenliveSettings::shuttledevice());
+
+ m_jogProcess = new JogShuttle(JogShuttle::canonicalDevice(KdenliveSettings::shuttledevice()));
m_jogShuttle = new JogShuttleAction(m_jogProcess, JogShuttleConfig::actionMap(KdenliveSettings::shuttlebuttons()));
-
+
connect(m_jogShuttle, SIGNAL(rewindOneFrame()), m_monitorManager, SLOT(slotRewindOneFrame()));
connect(m_jogShuttle, SIGNAL(forwardOneFrame()), m_monitorManager, SLOT(slotForwardOneFrame()));
connect(m_jogShuttle, SIGNAL(rewind(double)), m_monitorManager, SLOT(slotRewind(double)));
connect(m_jogShuttle, SIGNAL(forward(double)), m_monitorManager, SLOT(slotForward(double)));
- connect(m_jogShuttle, SIGNAL(action(const QString&)), this, SLOT(slotDoAction(const QString&)));
+ connect(m_jogShuttle, SIGNAL(action(QString)), this, SLOT(slotDoAction(QString)));
}
#endif /* USE_JOGSHUTTLE */
KToggleFullScreenAction::setFullScreen(this, actionCollection()->action("fullscreen")->isChecked());
}
-void MainWindow::slotAddEffect(const QDomElement effect)
+void MainWindow::slotAddEffect(const QDomElement &effect)
{
if (!m_activeDocument) return;
if (effect.isNull()) {
void MainWindow::slotUpdateClip(const QString &id)
{
- if (!m_activeDocument) return;
+ if (!m_activeDocument) {
+ return;
+ }
DocClipBase *clip = m_activeDocument->clipManager()->getClipById(id);
- if (!clip) return;
- if (clip->numReferences() > 0) m_activeTimeline->projectView()->slotUpdateClip(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);
void MainWindow::slotConnectMonitors()
{
m_projectList->setRenderer(m_projectMonitor->render);
- 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_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 &, bool)), m_projectList, SLOT(slotRemoveInvalidProxy(const QString &, bool)));
+ connect(m_projectList, SIGNAL(pauseMonitor()), m_monitorManager, SLOT(slotPause()));
+ 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_projectMonitor->render, SIGNAL(replyGetImage(QString,QString,int,int)), m_projectList, SLOT(slotReplyGetImage(QString,QString,int,int)));
+ connect(m_projectMonitor->render, SIGNAL(replyGetImage(QString,QImage)), m_projectList, SLOT(slotReplyGetImage(QString,QImage)));
+
+ connect(m_projectMonitor->render, SIGNAL(replyGetFileProperties(QString,Mlt::Producer*,stringMap,stringMap,bool)), m_projectList, SLOT(slotReplyGetFileProperties(QString,Mlt::Producer*,stringMap,stringMap,bool)));
- connect(m_clipMonitor, SIGNAL(refreshClipThumbnail(const QString &, bool)), m_projectList, SLOT(slotRefreshClipThumbnail(const QString &, bool)));
+ connect(m_projectMonitor->render, SIGNAL(removeInvalidClip(QString,bool)), m_projectList, SLOT(slotRemoveInvalidClip(QString,bool)));
+
+ connect(m_projectMonitor->render, SIGNAL(removeInvalidProxy(QString,bool)), m_projectList, SLOT(slotRemoveInvalidProxy(QString,bool)));
+
+ connect(m_clipMonitor, SIGNAL(refreshClipThumbnail(QString,bool)), m_projectList, SLOT(slotRefreshClipThumbnail(QString,bool)));
connect(m_clipMonitor, SIGNAL(adjustMonitorSize()), this, SLOT(slotAdjustClipMonitor()));
connect(m_projectMonitor, SIGNAL(adjustMonitorSize()), this, SLOT(slotAdjustProjectMonitor()));
connect(m_projectMonitor, SIGNAL(requestFrameForAnalysis(bool)), this, SLOT(slotMonitorRequestRenderFrame(bool)));
- 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 *)));
+ 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()
class NameGrabbingKActionCollection {
public:
- NameGrabbingKActionCollection(KActionCollection* collection, QStringList& action_names)
- : m_collection(collection), m_action_names(action_names) {
- m_action_names.clear();
- }
- KAction* addAction(const QString& action_name) {
- m_action_names << action_name;
- return m_collection->addAction(action_name);
- }
- void addAction(const QString& action_name, QAction* action) {
- m_action_names << action_name;
- m_collection->addAction(action_name, action);
- }
- operator KActionCollection*() { return m_collection; }
- const QStringList& actionNames() const { return m_action_names; }
+ NameGrabbingKActionCollection(KActionCollection* collection, QStringList& action_names)
+ : m_collection(collection), m_action_names(action_names) {
+ m_action_names.clear();
+ }
+ KAction* addAction(const QString& action_name) {
+ m_action_names << action_name;
+ return m_collection->addAction(action_name);
+ }
+ void addAction(const QString& action_name, QAction* action) {
+ m_action_names << action_name;
+ m_collection->addAction(action_name, action);
+ }
+ operator KActionCollection*() { return m_collection; }
+ const QStringList& actionNames() const { return m_action_names; }
private:
- KActionCollection* m_collection;
- QStringList& m_action_names;
+ KActionCollection* m_collection;
+ QStringList& m_action_names;
};
void MainWindow::setupActions()
{
-
NameGrabbingKActionCollection collection(actionCollection(), m_action_names);
- m_timecodeFormat = new KComboBox(this);
- m_timecodeFormat->addItem(i18n("hh:mm:ss:ff"));
- m_timecodeFormat->addItem(i18n("Frames"));
- if (KdenliveSettings::frametimecode()) m_timecodeFormat->setCurrentIndex(1);
- connect(m_timecodeFormat, SIGNAL(activated(int)), this, SLOT(slotUpdateTimecodeFormat(int)));
-
m_statusProgressBar = new QProgressBar(this);
m_statusProgressBar->setMinimum(0);
m_statusProgressBar->setMaximum(100);
KToolBar *toolbar = new KToolBar("statusToolBar", this, Qt::BottomToolBarArea);
toolbar->setMovable(false);
- KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window, KSharedConfig::openConfig(KdenliveSettings::colortheme()));
- QColor buttonBg = scheme.background(KColorScheme::LinkBackground).color();
- QColor buttonBord = scheme.foreground(KColorScheme::LinkText).color();
- QColor buttonBord2 = scheme.shade(KColorScheme::LightShade);
- statusBar()->setStyleSheet(QString("QStatusBar QLabel {font-size:%1pt;} QStatusBar::item { border: 0px; font-size:%1pt;padding:0px; }").arg(statusBar()->font().pointSize()));
- QString style1 = QString("QToolBar { border: 0px } QToolButton { border-style: inset; border:1px solid transparent;border-radius: 3px;margin: 0px 3px;padding: 0px;} QToolButton:hover { background: rgb(%7, %8, %9);border-style: inset; border:1px solid rgb(%7, %8, %9);border-radius: 3px;} QToolButton:checked { background-color: rgb(%1, %2, %3); border-style: inset; border:1px solid rgb(%4, %5, %6);border-radius: 3px;}").arg(buttonBg.red()).arg(buttonBg.green()).arg(buttonBg.blue()).arg(buttonBord.red()).arg(buttonBord.green()).arg(buttonBord.blue()).arg(buttonBord2.red()).arg(buttonBord2.green()).arg(buttonBord2.blue());
+
+ setStatusBarStyleSheet(palette());
QString styleBorderless = "QToolButton { border-width: 0px;margin: 1px 3px 0px;padding: 0px;}";
-
+
//create edit mode buttons
m_normalEditTool = new KAction(KIcon("kdenlive-normal-edit"), i18n("Normal mode"), this);
m_normalEditTool->setShortcut(i18nc("Normal editing", "n"));
editGroup->addAction(m_overwriteEditTool);
editGroup->addAction(m_insertEditTool);
editGroup->setExclusive(true);
- connect(editGroup, SIGNAL(triggered(QAction *)), this, SLOT(slotChangeEdit(QAction *)));
+ connect(editGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotChangeEdit(QAction*)));
//connect(m_overwriteEditTool, SIGNAL(toggled(bool)), this, SLOT(slotSetOverwriteMode(bool)));
toolbar->addSeparator();
actionWidget->setMaximumWidth(max);
actionWidget->setMaximumHeight(max - 4);
- toolbar->setStyleSheet(style1);
- connect(toolGroup, SIGNAL(triggered(QAction *)), this, SLOT(slotChangeTool(QAction *)));
+ connect(toolGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotChangeTool(QAction*)));
toolbar->addSeparator();
m_buttonFitZoom = new KAction(KIcon("zoom-fit-best"), i18n("Fit zoom to project"), this);
statusBar()->addWidget(m_messageLabel, 10);
statusBar()->addWidget(m_statusProgressBar, 0);
statusBar()->addPermanentWidget(toolbar);
- statusBar()->insertPermanentFixedItem("00:00:00:00", ID_TIMELINE_POS);
- statusBar()->addPermanentWidget(m_timecodeFormat);
- //statusBar()->setMaximumHeight(statusBar()->font().pointSize() * 3);
+
+ m_timeFormatButton = new KSelectAction("00:00:00:00 / 00:00:00:00", this);
+ m_timeFormatButton->addAction(i18n("hh:mm:ss:ff"));
+ m_timeFormatButton->addAction(i18n("Frames"));
+ if (KdenliveSettings::frametimecode()) m_timeFormatButton->setCurrentItem(1);
+ else m_timeFormatButton->setCurrentItem(0);
+ connect(m_timeFormatButton, SIGNAL(triggered(int)), this, SLOT(slotUpdateTimecodeFormat(int)));
+ m_timeFormatButton->setToolBarMode(KSelectAction::MenuMode);
+ toolbar->addAction(m_timeFormatButton);
+
+ const QFontMetrics metric(statusBar()->font());
+ int requiredWidth = metric.boundingRect("00:00:00:00 / 00:00:00:00").width() + 20;
+ actionWidget = toolbar->widgetForAction(m_timeFormatButton);
+ actionWidget->setObjectName("timecode");
+ actionWidget->setMinimumWidth(requiredWidth);
collection.addAction("normal_mode", m_normalEditTool);
collection.addAction("overwrite_mode", m_overwriteEditTool);
connect(projectAdjust, SIGNAL(triggered(bool)), m_projectList, SLOT(adjustProjectProfileToItem()));
KAction* monitorPlay = new KAction(KIcon("media-playback-start"), i18n("Play"), this);
- KShortcut playShortcut;
- playShortcut.setPrimary(Qt::Key_Space);
- playShortcut.setAlternate(Qt::Key_K);
- monitorPlay->setShortcut(playShortcut);
+ monitorPlay->setShortcut(Qt::Key_Space);
collection.addAction("monitor_play", monitorPlay);
connect(monitorPlay, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotPlay()));
KAction* monitorPause = new KAction(KIcon("media-playback-stop"), i18n("Pause"), this);
+ monitorPause->setShortcut(Qt::Key_K);
collection.addAction("monitor_pause", monitorPause);
connect(monitorPause, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotPause()));
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"));
KAction *fullMon = collection.addAction("monitor_fullscreen");
fullMon->setText(i18n("Switch monitor fullscreen"));
fullMon->setIcon(KIcon("view-fullscreen"));
- connect(fullMon, SIGNAL(triggered(bool)), this, SLOT(slotSwitchFullscreen()));
+ connect(fullMon, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotSwitchFullscreen()));
+
+ KSelectAction *interlace = new KSelectAction(i18n("Deinterlacer"), this);
+ interlace->addAction(i18n("One Field (fast)"));
+ interlace->addAction(i18n("Linear Blend (fast)"));
+ interlace->addAction(i18n("YADIF - temporal only (good)"));
+ interlace->addAction(i18n("YADIF - temporal + spacial (best)"));
+ if (KdenliveSettings::mltdeinterlacer() == "linearblend") interlace->setCurrentItem(1);
+ else if (KdenliveSettings::mltdeinterlacer() == "yadif-temporal") interlace->setCurrentItem(2);
+ else if (KdenliveSettings::mltdeinterlacer() == "yadif") interlace->setCurrentItem(3);
+ else interlace->setCurrentItem(0);
+ collection.addAction("mlt_interlace", interlace);
+ connect(interlace, SIGNAL(triggered(int)), this, SLOT(slotSetDeinterlacer(int)));
+
+ KSelectAction *interpol = new KSelectAction(i18n("Interpolation"), this);
+ interpol->addAction(i18n("Nearest Neighbor (fast)"));
+ interpol->addAction(i18n("Bilinear (good)"));
+ interpol->addAction(i18n("Bicubic (better)"));
+ interpol->addAction(i18n("Hyper/Lanczos (best)"));
+ if (KdenliveSettings::mltinterpolation() == "bilinear") interpol->setCurrentItem(1);
+ else if (KdenliveSettings::mltinterpolation() == "bicubic") interpol->setCurrentItem(2);
+ else if (KdenliveSettings::mltinterpolation() == "hyper") interpol->setCurrentItem(3);
+ else interpol->setCurrentItem(0);
+ collection.addAction("mlt_interpolation", interpol);
+ connect(interpol, SIGNAL(triggered(int)), this, SLOT(slotSetInterpolation(int)));
KAction *insertTree = collection.addAction("insert_project_tree");
insertTree->setText(i18n("Insert zone in project tree"));
collection.addAction("delete_timeline_clip", deleteItem);
connect(deleteItem, SIGNAL(triggered(bool)), this, SLOT(slotDeleteItem()));
+ KAction* alignPlayhead = new KAction(i18n("Align Playhead to Mouse Position"), this);
+ alignPlayhead->setShortcut(Qt::Key_P);
+ collection.addAction("align_playhead", alignPlayhead);
+ connect(alignPlayhead, SIGNAL(triggered(bool)), this, SLOT(slotAlignPlayheadToMousePos()));
+
/*KAction* editTimelineClipSpeed = new KAction(i18n("Change Clip Speed"), this);
collection.addAction("change_clip_speed", editTimelineClipSpeed);
editTimelineClipSpeed->setData("change_speed");
KAction* editItemDuration = new KAction(KIcon("measure"), i18n("Edit Duration"), this);
collection.addAction("edit_item_duration", editItemDuration);
connect(editItemDuration, SIGNAL(triggered(bool)), this, SLOT(slotEditItemDuration()));
+
+ KAction* saveTimelineClip = new KAction(KIcon("document-save"), i18n("Save clip"), this);
+ collection.addAction("save_timeline_clip", saveTimelineClip);
+ connect(saveTimelineClip, SIGNAL(triggered(bool)), this, SLOT(slotSaveTimelineClip()));
KAction* clipInProjectTree = new KAction(KIcon("go-jump-definition"), i18n("Clip in Project Tree"), this);
collection.addAction("clip_in_project_tree", clipInProjectTree);
collection.addAction("edit_clip_marker", editClipMarker);
connect(editClipMarker, SIGNAL(triggered(bool)), this, SLOT(slotEditClipMarker()));
- KAction *addMarkerGuideQuickly = new KAction(KIcon("bookmark-new"), i18n("Add Marker/Guide quickly"), this);
+ KAction* addMarkerGuideQuickly = new KAction(KIcon("bookmark-new"), i18n("Add Marker/Guide quickly"), this);
addMarkerGuideQuickly->setShortcut(Qt::Key_Asterisk);
collection.addAction("add_marker_guide_quickly", addMarkerGuideQuickly);
connect(addMarkerGuideQuickly, SIGNAL(triggered(bool)), this, SLOT(slotAddMarkerGuideQuickly()));
KAction* splitAudio = new KAction(KIcon("document-new"), i18n("Split Audio"), this);
collection.addAction("split_audio", splitAudio);
+ // "A+V" as data means this action should only be available for clips with audio AND video
+ splitAudio->setData("A+V");
connect(splitAudio, SIGNAL(triggered(bool)), this, SLOT(slotSplitAudio()));
+ KAction* setAudioAlignReference = new KAction(i18n("Set Audio Reference"), this);
+ collection.addAction("set_audio_align_ref", setAudioAlignReference);
+ // "A" as data means this action should only be available for clips with audio
+ setAudioAlignReference->setData("A");
+ connect(setAudioAlignReference, SIGNAL(triggered()), this, SLOT(slotSetAudioAlignReference()));
+
+ KAction* alignAudio = new KAction(i18n("Align Audio to Reference"), this);
+ collection.addAction("align_audio", alignAudio);
+ // "A" as data means this action should only be available for clips with audio
+ alignAudio->setData("A");
+ connect(alignAudio, SIGNAL(triggered()), this, SLOT(slotAlignAudio()));
+
KAction* audioOnly = new KAction(KIcon("document-new"), i18n("Audio Only"), this);
collection.addAction("clip_audio_only", audioOnly);
audioOnly->setData("clip_audio_only");
m_clipTypeGroup->addAction(audioOnly);
m_clipTypeGroup->addAction(videoOnly);
m_clipTypeGroup->addAction(audioAndVideo);
- connect(m_clipTypeGroup, SIGNAL(triggered(QAction *)), this, SLOT(slotUpdateClipType(QAction *)));
+ connect(m_clipTypeGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotUpdateClipType(QAction*)));
m_clipTypeGroup->setEnabled(false);
KAction *insertSpace = new KAction(KIcon(), i18n("Insert Space"), this);
collection.addAction("delete_space", removeSpace);
connect(removeSpace, SIGNAL(triggered()), this, SLOT(slotRemoveSpace()));
- KAction *insertTrack = new KAction(KIcon(), i18n("Insert Track"), this);
- collection.addAction("insert_track", insertTrack);
+ m_tracksActionCollection = new KActionCollection(this, KGlobal::mainComponent());
+ m_tracksActionCollection->addAssociatedWidget(m_timelineArea);
+
+ KAction *insertTrack = new KAction(KIcon(), i18n("Insert Track"), m_tracksActionCollection);
+ m_tracksActionCollection->addAction("insert_track", insertTrack);
connect(insertTrack, SIGNAL(triggered()), this, SLOT(slotInsertTrack()));
- KAction *deleteTrack = new KAction(KIcon(), i18n("Delete Track"), this);
- collection.addAction("delete_track", deleteTrack);
+ KAction *deleteTrack = new KAction(KIcon(), i18n("Delete Track"), m_tracksActionCollection);
+ m_tracksActionCollection->addAction("delete_track", deleteTrack);
connect(deleteTrack, SIGNAL(triggered()), this, SLOT(slotDeleteTrack()));
- KAction *configTracks = new KAction(KIcon("configure"), i18n("Configure Tracks"), this);
- collection.addAction("config_tracks", configTracks);
+ KAction *configTracks = new KAction(KIcon("configure"), i18n("Configure Tracks"), m_tracksActionCollection);
+ m_tracksActionCollection->addAction("config_tracks", configTracks);
connect(configTracks, SIGNAL(triggered()), this, SLOT(slotConfigTrack()));
+ KAction *selectTrack = new KAction(KIcon(), i18n("Select All in Current Track"), m_tracksActionCollection);
+ connect(selectTrack, SIGNAL(triggered()), this, SLOT(slotSelectTrack()));
+ m_tracksActionCollection->addAction("select_track", selectTrack);
+
+ QAction *selectAll = KStandardAction::selectAll(this, SLOT(slotSelectAllTracks()), m_tracksActionCollection);
+ selectAll->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+ m_tracksActionCollection->addAction("select_all_tracks", selectAll);
+
KAction *addGuide = new KAction(KIcon("document-new"), i18n("Add Guide"), this);
collection.addAction("add_guide", addGuide);
connect(addGuide, SIGNAL(triggered()), this, SLOT(slotAddGuide()));
pasteEffects->setData("paste_effects");
connect(pasteEffects , SIGNAL(triggered()), this, SLOT(slotPasteEffects()));
- QAction *showTimeline = new KAction(i18n("Show Timeline"), this);
- collection.addAction("show_timeline", showTimeline);
- showTimeline->setCheckable(true);
- showTimeline->setChecked(true);
- connect(showTimeline, SIGNAL(triggered(bool)), this, SLOT(slotShowTimeline(bool)));
-
QAction *showTitleBar = new KAction(i18n("Show Title Bars"), this);
collection.addAction("show_titlebars", showTitleBar);
showTitleBar->setCheckable(true);
KStandardAction::saveAs(this, SLOT(saveFileAs()), collection);
KStandardAction::openNew(this, SLOT(newFile()), collection);
// TODO: make the following connection to slotEditKeys work
- KStandardAction::keyBindings(this, SLOT(slotEditKeys()), collection);
+ //KStandardAction::keyBindings(this, SLOT(slotEditKeys()), collection);
KStandardAction::preferences(this, SLOT(slotPreferences()), collection);
KStandardAction::configureNotifications(this, SLOT(configureNotifications()), collection);
KStandardAction::copy(this, SLOT(slotCopy()), collection);
collection.addAction("add_folder", addFolderButton);
connect(addFolderButton , SIGNAL(triggered()), m_projectList, SLOT(slotAddFolder()));
+ QAction *downloadResources = new KAction(KIcon("download"), i18n("Online Resources"), this);
+ collection.addAction("download_resource", downloadResources);
+ connect(downloadResources , SIGNAL(triggered()), this, SLOT(slotDownloadResources()));
+
QAction *clipProperties = new KAction(KIcon("document-edit"), i18n("Clip Properties"), this);
collection.addAction("clip_properties", clipProperties);
clipProperties->setData("clip_properties");
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(addTitleClip);
addClips->addAction(addTitleTemplateClip);
addClips->addAction(addFolderButton);
+ addClips->addAction(downloadResources);
addClips->addAction(reloadClip);
addClips->addAction(proxyClip);
//KActionCategory *transitionActions = new KActionCategory(i18n("Transitions"), m_effectsActionCollection);
KActionCategory *transitionActions = new KActionCategory(i18n("Transitions"), collection);
m_transitions = new KAction*[transitions.count()];
- for (int i = 0; i < transitions.count(); i++) {
+ for (int i = 0; i < transitions.count(); ++i) {
QStringList effectInfo = transitions.effectIdInfo(i);
m_transitions[i] = new KAction(effectInfo.at(0), this);
m_transitions[i]->setData(effectInfo);
statusBar()->showMessage(a->data().toString(), 3000);
}
+void MainWindow::setStatusBarStyleSheet(const QPalette &p)
+{
+ KColorScheme scheme(p.currentColorGroup(), KColorScheme::Window, KSharedConfig::openConfig(KdenliveSettings::colortheme()));
+ QColor buttonBg = scheme.background(KColorScheme::LinkBackground).color();
+ QColor buttonBord = scheme.foreground(KColorScheme::LinkText).color();
+ QColor buttonBord2 = scheme.shade(KColorScheme::LightShade);
+ statusBar()->setStyleSheet(QString("QStatusBar QLabel {font-size:%1pt;} QStatusBar::item { border: 0px; font-size:%1pt;padding:0px; }").arg(statusBar()->font().pointSize()));
+ QString style1 = QString("QToolBar { border: 0px } QToolButton { border-style: inset; border:1px solid transparent;border-radius: 3px;margin: 0px 3px;padding: 0px;} QToolButton#timecode {padding-right:10px;} QToolButton:hover { background: %3;border-style: inset; border:1px solid %3;border-radius: 3px;} QToolButton:checked { background-color: %1; border-style: inset; border:1px solid %2;border-radius: 3px;}").arg(buttonBg.name()).arg(buttonBord.name()).arg(buttonBord2.name());
+ statusBar()->setStyleSheet(style1);
+}
+
void MainWindow::loadLayouts()
{
QMenu *saveLayout = (QMenu*)(factory()->container("layout_save_as", this));
QStringList entries = layoutGroup.keyList();
QList<QAction *> loadActions = m_loadLayout->actions();
QList<QAction *> saveActions = saveLayout->actions();
- for (int i = 1; i < 5; i++) {
+ for (int i = 1; i < 5; ++i) {
// Rename the layouts actions
foreach(const QString & key, entries) {
if (key.endsWith(QString("_%1").arg(i))) {
// Found previously saved layout
- QString layoutName = key.section("_", 0, -2);
+ QString layoutName = key.section('_', 0, -2);
for (int j = 0; j < loadActions.count(); j++) {
- if (loadActions.at(j)->data().toString().endsWith("_" + QString::number(i))) {
+ if (loadActions.at(j)->data().toString().endsWith('_' + QString::number(i))) {
loadActions[j]->setText(layoutName);
loadActions[j]->setData(key);
break;
}
}
for (int j = 0; j < saveActions.count(); j++) {
- if (saveActions.at(j)->data().toString().endsWith("_" + QString::number(i))) {
- saveActions[j]->setText(i18n("Save as %1").arg(layoutName));
+ if (saveActions.at(j)->data().toString().endsWith('_' + QString::number(i))) {
+ saveActions[j]->setText(i18n("Save as %1", layoutName));
saveActions[j]->setData(key);
break;
}
void MainWindow::slotLoadLayout(QAction *action)
{
- if (!action) return;
+ if (!action) {
+ return;
+ }
+
QString layoutId = action->data().toString();
- if (layoutId.isEmpty()) return;
+ if (layoutId.isEmpty()) {
+ return;
+ }
+
KSharedConfigPtr config = KGlobal::config();
KConfigGroup layouts(config, "Layouts");
QByteArray state = QByteArray::fromBase64(layouts.readEntry(layoutId).toAscii());
int layoutId = originallayoutName.section('_', -1).toInt();
QString layoutName = QInputDialog::getText(this, i18n("Save Layout"), i18n("Layout name:"), QLineEdit::Normal, originallayoutName.section('_', 0, -2));
- if (layoutName.isEmpty()) return;
+ if (layoutName.isEmpty()) {
+ return;
+ }
KSharedConfigPtr config = KGlobal::config();
KConfigGroup layouts(config, "Layouts");
layouts.deleteEntry(originallayoutName);
QByteArray st = saveState();
- layoutName.append("_" + QString::number(layoutId));
+ layoutName.append('_' + QString::number(layoutId));
layouts.writeEntry(layoutName, st.toBase64());
loadLayouts();
}
QString path = QDir::homePath() + "/kdenlive";
if (KStandardDirs::makeDir(path) == false) {
kDebug() << "/// ERROR CREATING PROJECT FOLDER: " << path;
- } else KdenliveSettings::setDefaultprojectfolder(path);
+ } else {
+ KdenliveSettings::setDefaultprojectfolder(path);
+ }
}
}
+ }
+ if (KdenliveSettings::ffmpegpath().isEmpty() || KdenliveSettings::ffplaypath().isEmpty()) {
+ upgrade = true;
}
if (!initialGroup.exists() || upgrade) {
// this is our first run, show Wizard
- Wizard *w = new Wizard(upgrade, this);
+ QPointer<Wizard> w = new Wizard(upgrade, this);
if (w->exec() == QDialog::Accepted && w->isOk()) {
w->adjustSettings();
initialGroup.writeEntry("version", version);
delete w;
} else {
+ delete w;
::exit(1);
}
}
+
KConfigGroup treecolumns(config, "Project Tree");
const QByteArray state = treecolumns.readEntry("columns", QByteArray());
- if (!state.isEmpty())
+ if (!state.isEmpty()) {
m_projectList->setHeaderInfo(state);
+ }
}
void MainWindow::slotRunWizard()
{
- Wizard *w = new Wizard(false, this);
+ QPointer<Wizard> w = new Wizard(false, this);
if (w->exec() == QDialog::Accepted && w->isOk()) {
w->adjustSettings();
}
void MainWindow::newFile(bool showProjectSettings, bool force)
{
- if (!m_timelineArea->isEnabled() && !force)
+ if (!m_timelineArea->isEnabled() && !force) {
return;
+ }
m_fileRevert->setEnabled(false);
QString profileName = KdenliveSettings::default_profile();
KUrl projectFolder = KdenliveSettings::defaultprojectfolder();
QMap <QString, QString> documentProperties;
+ QMap <QString, QString> documentMetadata;
QPoint projectTracks(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks());
if (!showProjectSettings) {
- if (!KdenliveSettings::activatetabs())
- if (!closeCurrentDocument())
+ if (!KdenliveSettings::activatetabs()) {
+ if (!closeCurrentDocument()) {
return;
+ }
+ }
} else {
- ProjectSettings *w = new ProjectSettings(NULL, QStringList(), projectTracks.x(), projectTracks.y(), KdenliveSettings::defaultprojectfolder(), false, true, this);
- if (w->exec() != QDialog::Accepted)
+ QPointer<ProjectSettings> w = new ProjectSettings(NULL, QMap <QString, QString> (), QStringList(), projectTracks.x(), projectTracks.y(), KdenliveSettings::defaultprojectfolder(), false, true, this);
+ if (w->exec() != QDialog::Accepted) {
+ delete w;
return;
- if (!KdenliveSettings::activatetabs())
- if (!closeCurrentDocument())
+ }
+ if (!KdenliveSettings::activatetabs()) {
+ if (!closeCurrentDocument()) {
+ delete w;
return;
- if (KdenliveSettings::videothumbnails() != w->enableVideoThumbs())
+ }
+ }
+ if (KdenliveSettings::videothumbnails() != w->enableVideoThumbs()) {
slotSwitchVideoThumbs();
- if (KdenliveSettings::audiothumbnails() != w->enableAudioThumbs())
+ }
+ if (KdenliveSettings::audiothumbnails() != w->enableAudioThumbs()) {
slotSwitchAudioThumbs();
+ }
profileName = w->selectedProfile();
projectFolder = w->selectedFolder();
projectTracks = w->tracks();
documentProperties.insert("proxyextension", w->proxyExtension());
documentProperties.insert("generateimageproxy", QString::number((int) w->generateImageProxy()));
documentProperties.insert("proxyimageminsize", QString::number(w->proxyImageMinSize()));
+ documentMetadata = w->metadata();
delete w;
}
m_timelineArea->setEnabled(true);
m_projectList->setEnabled(true);
bool openBackup;
- KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, m_commandStack, profileName, documentProperties, projectTracks, m_projectMonitor->render, m_notesWidget, &openBackup, this);
+ KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, m_commandStack, profileName, documentProperties, documentMetadata, projectTracks, m_projectMonitor->render, m_notesWidget, &openBackup, m_glContext, this);
doc->m_autosave = new KAutoSaveFile(KUrl(), doc);
bool ok;
- TrackView *trackView = new TrackView(doc, &ok, this);
+ TrackView *trackView = new TrackView(doc, m_tracksActionCollection->actions(), &ok, this);
m_timelineArea->addTab(trackView, KIcon("kdenlive"), doc->description());
if (!ok) {
// MLT is broken
if (m_timelineArea->count() == 1) {
connectDocumentInfo(doc);
connectDocument(trackView, doc);
- } else
+ } else {
m_timelineArea->setTabBarHidden(false);
- m_monitorManager->activateMonitor("clip");
+ }
+ m_monitorManager->activateMonitor(Kdenlive::ClipMonitor);
m_closeAction->setEnabled(m_timelineArea->count() > 1);
}
void MainWindow::activateDocument()
{
- if (m_timelineArea->currentWidget() == NULL || !m_timelineArea->isEnabled()) return;
+ if (m_timelineArea->currentWidget() == NULL || !m_timelineArea->isEnabled()) {
+ return;
+ }
TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
KdenliveDoc *currentDoc = currentTab->document();
connectDocumentInfo(currentDoc);
bool MainWindow::closeCurrentDocument(bool saveChanges)
{
QWidget *w = m_timelineArea->currentWidget();
- if (!w) return true;
+ if (!w) {
+ return true;
+ }
// closing current document
int ix = m_timelineArea->currentIndex() + 1;
- if (ix == m_timelineArea->count()) ix = 0;
+ if (ix == m_timelineArea->count()) {
+ ix = 0;
+ }
m_timelineArea->setCurrentIndex(ix);
TrackView *tabToClose = (TrackView *) w;
KdenliveDoc *docToClose = tabToClose->document();
if (docToClose && docToClose->isModified() && saveChanges) {
QString message;
- if (m_activeDocument->url().fileName().isEmpty())
+ if (m_activeDocument->url().fileName().isEmpty()) {
message = i18n("Save changes to document?");
- else
- message = i18n("The project <b>\"%1\"</b> has been changed.\nDo you want to save your changes?").arg(m_activeDocument->url().fileName());
+ } else {
+ message = i18n("The project <b>\"%1\"</b> has been changed.\nDo you want to save your changes?", m_activeDocument->url().fileName());
+ }
+
switch (KMessageBox::warningYesNoCancel(this, message)) {
case KMessageBox::Yes :
// save document here. If saving fails, return false;
break;
}
}
+
+ slotTimelineClipSelected(NULL, false);
m_clipMonitor->slotSetClipProducer(NULL);
m_projectList->slotResetProjectList();
m_timelineArea->removeTab(m_timelineArea->indexOf(w));
m_timelineArea->setTabBarHidden(true);
m_closeAction->setEnabled(false);
}
+
if (docToClose == m_activeDocument) {
delete m_activeDocument;
m_activeDocument = NULL;
+ m_monitorManager->setDocument(m_activeDocument);
m_effectStack->clear();
m_transitionConfig->slotTransitionItemSelected(NULL, 0, QPoint(), false);
} else {
delete docToClose;
}
+
if (w == m_activeTimeline) {
delete m_activeTimeline;
m_activeTimeline = NULL;
} else {
delete w;
}
+
return true;
}
bool MainWindow::saveFileAs(const QString &outputFileName)
{
- QString currentSceneList;
m_monitorManager->stopActiveMonitor();
- if (m_activeDocument->saveSceneList(outputFileName, m_projectMonitor->sceneList(), m_projectList->expandedFolders()) == false)
+ if (m_activeDocument->saveSceneList(outputFileName, m_projectMonitor->sceneList(), m_projectList->expandedFolders()) == false) {
return false;
+ }
// Save timeline thumbnails
m_activeTimeline->projectView()->saveThumbnails();
m_activeDocument->setUrl(KUrl(outputFileName));
+ QByteArray hash = QCryptographicHash::hash(KUrl(outputFileName).encodedPath(), QCryptographicHash::Md5).toHex();
if (m_activeDocument->m_autosave == NULL) {
- m_activeDocument->m_autosave = new KAutoSaveFile(KUrl(outputFileName), this);
- } else m_activeDocument->m_autosave->setManagedFile(KUrl(outputFileName));
+ m_activeDocument->m_autosave = new KAutoSaveFile(KUrl(hash), this);
+ } else {
+ m_activeDocument->m_autosave->setManagedFile(KUrl(hash));
+ }
+
setCaption(m_activeDocument->description());
m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
m_timelineArea->setTabToolTip(m_timelineArea->currentIndex(), m_activeDocument->url().path());
m_fileOpenRecent->addUrl(KUrl(outputFileName));
m_fileRevert->setEnabled(true);
m_undoView->stack()->setClean();
+
return true;
}
if (outputFile.isEmpty()) {
return false;
}
+
if (QFile::exists(outputFile)) {
// Show the file dialog again if the user does not want to overwrite the file
- if (KMessageBox::questionYesNo(this, i18n("File %1 already exists.\nDo you want to overwrite it?", outputFile)) == KMessageBox::No)
+ if (KMessageBox::questionYesNo(this, i18n("File %1 already exists.\nDo you want to overwrite it?", outputFile)) == KMessageBox::No) {
return saveFileAs();
+ }
}
+
return saveFileAs(outputFile);
}
bool MainWindow::saveFile()
{
- if (!m_activeDocument) return true;
+ if (!m_activeDocument) {
+ return true;
+ }
+
if (m_activeDocument->url().isEmpty()) {
return saveFileAs();
} else {
return;
}
KUrl url = KFileDialog::getOpenUrl(KUrl("kfiledialog:///projectfolder"), getMimeType());
- if (url.isEmpty()) return;
+ if (url.isEmpty()) {
+ return;
+ }
+
m_fileOpenRecent->addUrl(url);
openFile(url);
}
void MainWindow::openLastFile()
{
- KSharedConfigPtr config = KGlobal::config();
- KUrl::List urls = m_fileOpenRecent->urls();
- //WARNING: this is buggy, we get a random url, not the last one. Bug in KRecentFileAction?
- if (urls.isEmpty()) newFile(false);
- else openFile(urls.last());
+ if (m_fileOpenRecent->selectableActionGroup()->actions().isEmpty()) {
+ // No files in history
+ newFile(false);
+ return;
+ }
+
+ QAction *firstUrlAction = m_fileOpenRecent->selectableActionGroup()->actions().last();
+ if (firstUrlAction) {
+ firstUrlAction->trigger();
+ } else {
+ newFile(false);
+ }
}
void MainWindow::openFile(const KUrl &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()));
+ QPointer<ArchiveWidget> ar = new ArchiveWidget(url);
+ if (ar->exec() == QDialog::Accepted) {
+ openFile(KUrl(ar->extractedProjectFile()));
+ } else if (!m_startUrl.isEmpty()) {
+ // we tried to open an invalid file from command line, init new project
+ newFile(false);
+ }
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()));
+ if (!m_startUrl.isEmpty()) {
+ // we tried to open an invalid file from command line, init new project
+ newFile(false);
+ }
return;
}
-
+
// Check if the document is already opened
const int ct = m_timelineArea->count();
bool isOpened = false;
int i;
- for (i = 0; i < ct; i++) {
+ for (i = 0; i < ct; ++i) {
TrackView *tab = (TrackView *) m_timelineArea->widget(i);
KdenliveDoc *doc = tab->document();
if (doc->url() == url) {
break;
}
}
+
if (isOpened) {
m_timelineArea->setCurrentIndex(i);
return;
}
- if (!KdenliveSettings::activatetabs()) if (!closeCurrentDocument()) return;
+ if (!KdenliveSettings::activatetabs()) {
+ if (!closeCurrentDocument()) {
+ return;
+ }
+ }
// Check for backup file
- QList<KAutoSaveFile *> staleFiles = KAutoSaveFile::staleFiles(url);
+ QByteArray hash = QCryptographicHash::hash(url.encodedPath(), QCryptographicHash::Md5).toHex();
+ QList<KAutoSaveFile *> staleFiles = KAutoSaveFile::staleFiles(KUrl(hash));
if (!staleFiles.isEmpty()) {
if (KMessageBox::questionYesNo(this,
i18n("Auto-saved files exist. Do you want to recover them now?"),
i18n("File Recovery"),
KGuiItem(i18n("Recover")), KGuiItem(i18n("Don't recover"))) == KMessageBox::Yes) {
- recoverFiles(staleFiles);
+ recoverFiles(staleFiles, url);
return;
} else {
// remove the stale files
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.show();
progressDialog.progressBar()->setValue(0);
- qApp->processEvents();
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);
+ KdenliveDoc *doc = new KdenliveDoc(stale ? KUrl(stale->fileName()) : url, KdenliveSettings::defaultprojectfolder(), m_commandStack, KdenliveSettings::default_profile(), QMap <QString, QString> (), QMap <QString, QString> (), QPoint(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks()), m_projectMonitor->render, m_notesWidget, &openBackup, m_glContext, this, &progressDialog);
progressDialog.progressBar()->setValue(1);
progressDialog.progressBar()->setMaximum(4);
progressDialog.setLabelText(i18n("Loading project"));
- qApp->processEvents();
+ progressDialog.repaint();
if (stale == NULL) {
- stale = new KAutoSaveFile(url, doc);
+ QByteArray hash = QCryptographicHash::hash(url.encodedPath(), QCryptographicHash::Md5).toHex();
+ stale = new KAutoSaveFile(KUrl(hash), doc);
doc->m_autosave = stale;
} else {
doc->m_autosave = stale;
- doc->setUrl(stale->managedFile());
+ doc->setUrl(url);//stale->managedFile());
doc->setModified(true);
stale->setParent(doc);
}
connectDocumentInfo(doc);
progressDialog.progressBar()->setValue(2);
- qApp->processEvents();
+ progressDialog.repaint();
bool ok;
- TrackView *trackView = new TrackView(doc, &ok, this);
+ TrackView *trackView = new TrackView(doc, m_tracksActionCollection->actions(), &ok, this);
connectDocument(trackView, doc);
progressDialog.progressBar()->setValue(3);
- qApp->processEvents();
+ progressDialog.repaint();
m_timelineArea->setCurrentIndex(m_timelineArea->addTab(trackView, KIcon("kdenlive"), doc->description()));
if (!ok) {
}
m_timelineArea->setTabToolTip(m_timelineArea->currentIndex(), doc->url().path());
trackView->setDuration(trackView->duration());
- trackView->projectView()->initCursorPos(m_projectMonitor->render->seekPosition().frames(doc->fps()));
- if (m_timelineArea->count() > 1) m_timelineArea->setTabBarHidden(false);
+ if (m_timelineArea->count() > 1) {
+ m_timelineArea->setTabBarHidden(false);
+ }
+
slotGotProgressInfo(QString(), -1);
m_projectMonitor->adjustRulerSize(trackView->duration());
m_projectMonitor->slotZoneMoved(trackView->inPoint(), trackView->outPoint());
progressDialog.progressBar()->setValue(4);
- if (openBackup) slotOpenBackupDialog(url);
+ if (openBackup) {
+ slotOpenBackupDialog(url);
+ }
}
-void MainWindow::recoverFiles(QList<KAutoSaveFile *> staleFiles)
+void MainWindow::recoverFiles(const QList<KAutoSaveFile *> &staleFiles, const KUrl &originUrl)
{
foreach(KAutoSaveFile * stale, staleFiles) {
/*if (!stale->open(QIODevice::QIODevice::ReadOnly)) {
}*/
kDebug() << "// OPENING RECOVERY: " << stale->fileName() << "\nMANAGED: " << stale->managedFile().path();
// the stalefiles also contain ".lock" files so we must ignore them... bug in KAutoSaveFile?
- if (!stale->fileName().endsWith(".lock")) doOpenFile(KUrl(stale->fileName()), stale);
- else KIO::NetAccess::del(KUrl(stale->fileName()), this);
+ if (!stale->fileName().endsWith(".lock")) {
+ doOpenFile(originUrl, stale);
+ } else {
+ KIO::NetAccess::del(KUrl(stale->fileName()), this);
+ }
}
}
KdenliveSettings::setRendererpath(mltPath + "/bin/melt");
}
- if (KdenliveSettings::mltpath().isEmpty())
+ if (KdenliveSettings::mltpath().isEmpty()) {
KdenliveSettings::setMltpath(QString(MLT_PREFIX) + QString("/share/mlt/profiles/"));
+ }
if (KdenliveSettings::rendererpath().isEmpty() || KdenliveSettings::rendererpath().endsWith("inigo")) {
QString meltPath = QString(MLT_PREFIX) + QString("/bin/melt");
- if (!QFile::exists(meltPath))
+ if (!QFile::exists(meltPath)) {
meltPath = KStandardDirs::findExe("melt");
+ }
KdenliveSettings::setRendererpath(meltPath);
}
if (KdenliveSettings::rendererpath().isEmpty()) {
// Cannot find the MLT melt renderer, ask for location
- KUrlRequesterDialog *getUrl = new KUrlRequesterDialog(QString(), i18n("Cannot find the melt program required for rendering (part of MLT)"), this);
+ QPointer<KUrlRequesterDialog> getUrl = new KUrlRequesterDialog(QString(), i18n("Cannot find the melt program required for rendering (part of MLT)"), this);
if (getUrl->exec() == QDialog::Rejected) {
+ delete getUrl;
::exit(0);
}
KUrl rendererPath = getUrl->selectedUrl();
}
if (profilesList.isEmpty()) {
// Cannot find the MLT profiles, ask for location
- KUrlRequesterDialog *getUrl = new KUrlRequesterDialog(KdenliveSettings::mltpath(), i18n("Cannot find your MLT profiles, please give the path"), this);
+ QPointer<KUrlRequesterDialog> getUrl = new KUrlRequesterDialog(KdenliveSettings::mltpath(), i18n("Cannot find your MLT profiles, please give the path"), this);
getUrl->fileDialog()->setMode(KFile::Directory);
if (getUrl->exec() == QDialog::Rejected) {
+ delete getUrl;
::exit(0);
}
KUrl mltPath = getUrl->selectedUrl();
kDebug() << "RESULTING MLT PATH: " << KdenliveSettings::mltpath();
// Parse again MLT profiles to build a list of available video formats
- if (profilesList.isEmpty()) parseProfiles();
+ if (profilesList.isEmpty()) {
+ parseProfiles();
+ }
}
ProfilesDialog *w = new ProfilesDialog;
if (w->exec() == QDialog::Accepted) {
KdenliveSettingsDialog* d = static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"));
- if (d) d->checkProfile();
+ if (d) {
+ d->checkProfile();
+ }
}
delete w;
}
void MainWindow::slotEditProjectSettings()
{
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);
+ QPointer<ProjectSettings> w = new ProjectSettings(m_projectList, m_activeDocument->metadata(), 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) {
#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));
- if (KdenliveSettings::videothumbnails() != w->enableVideoThumbs()) slotSwitchVideoThumbs();
- if (KdenliveSettings::audiothumbnails() != w->enableAudioThumbs()) slotSwitchAudioThumbs();
- if (m_activeDocument->profilePath() != profile) slotUpdateProjectProfile(profile);
+ if (m_renderWidget) {
+ m_renderWidget->setDocumentPath(m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash));
+ }
+ if (KdenliveSettings::videothumbnails() != w->enableVideoThumbs()) {
+ slotSwitchVideoThumbs();
+ }
+ if (KdenliveSettings::audiothumbnails() != w->enableAudioThumbs()) {
+ slotSwitchAudioThumbs();
+ }
+ if (m_activeDocument->profilePath() != profile) {
+ slotUpdateProjectProfile(profile);
+ }
if (m_activeDocument->getDocumentProperty("proxyparams") != w->proxyParams()) {
m_activeDocument->setModified();
m_activeDocument->setDocumentProperty("proxyparams", w->proxyParams());
m_activeDocument->setModified();
slotUpdateProxySettings();
}
+ if (w->metadata() != m_activeDocument->metadata()) {
+ m_activeDocument->setMetadata(w->metadata());
+ }
}
delete w;
}
}
// Deselect current effect / transition
- m_effectStack->slotClipItemSelected(NULL, 0);
+ m_effectStack->slotClipItemSelected(NULL);
m_transitionConfig->slotTransitionItemSelected(NULL, 0, QPoint(), false);
m_clipMonitor->slotSetClipProducer(NULL);
bool updateFps = m_activeDocument->setProfilePath(profile);
KdenliveSettings::setCurrent_profile(profile);
KdenliveSettings::setProject_fps(m_activeDocument->fps());
setCaption(m_activeDocument->description(), m_activeDocument->isModified());
-
m_activeDocument->clipManager()->clearUnusedProducers();
m_monitorManager->resetProfiles(m_activeDocument->timecode());
m_transitionConfig->updateProjectFormat(m_activeDocument->mltProfile(), m_activeDocument->timecode(), m_activeDocument->tracksList());
m_effectStack->updateProjectFormat(m_activeDocument->mltProfile(), m_activeDocument->timecode());
m_projectList->updateProjectFormat(m_activeDocument->timecode());
- if (m_renderWidget) m_renderWidget->setProfile(m_activeDocument->mltProfile());
+ if (m_renderWidget) {
+ m_renderWidget->setProfile(m_activeDocument->mltProfile());
+ }
m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
- if (updateFps) m_activeTimeline->updateProjectFps();
+ 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.
slotUpdateMousePosition(0);
+ m_projectList->slotReloadClip();
// We need to desactivate & reactivate monitors to get a refresh
//m_monitorManager->switchMonitors();
}
{
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&)));
- connect(m_renderWidget, SIGNAL(abortProcess(const QString &)), this, SIGNAL(abortRenderJob(const QString &)));
- connect(m_renderWidget, SIGNAL(openDvdWizard(const QString &, const QString &)), this, SLOT(slotDvdWizard(const QString &, const QString &)));
+ connect(m_renderWidget, SIGNAL(selectedRenderProfile(QMap<QString,QString>)), this, SLOT(slotSetDocumentRenderProfile(QMap<QString,QString>)));
+ connect(m_renderWidget, SIGNAL(prepareRenderingData(bool,bool,QString)), this, SLOT(slotPrepareRendering(bool,bool,QString)));
+ connect(m_renderWidget, SIGNAL(abortProcess(QString)), this, SIGNAL(abortRenderJob(QString)));
+ connect(m_renderWidget, SIGNAL(openDvdWizard(QString)), this, SLOT(slotDvdWizard(QString)));
if (m_activeDocument) {
m_renderWidget->setProfile(m_activeDocument->mltProfile());
m_renderWidget->setGuides(m_activeDocument->guidesXml(), m_activeDocument->projectDuration());
void MainWindow::slotUpdateMousePosition(int pos)
{
- if (m_activeDocument)
- switch (m_timecodeFormat->currentIndex()) {
+ if (m_activeDocument) {
+ switch (m_timeFormatButton->currentItem()) {
case 0:
- statusBar()->changeItem(m_activeDocument->timecode().getTimecodeFromFrames(pos), ID_TIMELINE_POS);
+ m_timeFormatButton->setText(m_activeDocument->timecode().getTimecodeFromFrames(pos) + " / " + m_activeDocument->timecode().getTimecodeFromFrames(m_activeTimeline->duration()));
break;
default:
- statusBar()->changeItem(QString::number(pos), ID_TIMELINE_POS);
+ m_timeFormatButton->setText(QString::number(pos) + " / " + QString::number(m_activeTimeline->duration()));
}
+ }
+}
+
+void MainWindow::slotUpdateProjectDuration(int pos)
+{
+ if (m_activeDocument) {
+ m_activeTimeline->setDuration(pos);
+ slotUpdateMousePosition(m_activeTimeline->projectView()->getMousePos());
+ }
}
void MainWindow::slotUpdateDocumentState(bool modified)
{
if (m_activeDocument) {
if (m_activeDocument == doc) return;
- disconnect(m_activeDocument, SIGNAL(progressInfo(const QString &, int)), this, SLOT(slotGotProgressInfo(const QString &, int)));
+ disconnect(m_activeDocument, SIGNAL(progressInfo(QString,int)), this, SLOT(slotGotProgressInfo(QString,int)));
}
- connect(doc, SIGNAL(progressInfo(const QString &, int)), this, SLOT(slotGotProgressInfo(const QString &, int)));
+ connect(doc, SIGNAL(progressInfo(QString,int)), this, SLOT(slotGotProgressInfo(QString,int)));
}
void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) //changed
m_closeAction->setEnabled(m_timelineArea->count() > 1);
kDebug() << "/////////////////// CONNECTING DOC TO PROJECT VIEW ////////////////";
if (m_activeDocument) {
- if (m_activeDocument == doc) return;
+ if (m_activeDocument == doc) {
+ return;
+ }
if (m_activeTimeline) {
disconnect(m_projectMonitor, SIGNAL(renderPosition(int)), m_activeTimeline, SLOT(moveCursorPos(int)));
disconnect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), m_activeTimeline, SLOT(slotSetZone(QPoint)));
disconnect(m_clipMonitor, SIGNAL(zoneUpdated(QPoint)), m_activeDocument, SLOT(setModified()));
disconnect(m_projectList, SIGNAL(projectModified()), m_activeDocument, SLOT(setModified()));
- disconnect(m_projectMonitor->render, SIGNAL(refreshDocumentProducers(bool, bool)), m_activeDocument, SLOT(checkProjectClips(bool, bool)));
+ 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(addProjectClip(DocClipBase*,bool)), m_projectList, SLOT(slotAddClip(DocClipBase*,bool)));
disconnect(m_activeDocument, SIGNAL(resetProjectList()), m_projectList, SLOT(slotResetProjectList()));
- 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_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_transitionConfig, SLOT(slotTransitionItemSelected(Transition*, int, QPoint, bool)));
- disconnect(m_activeTimeline->projectView(), SIGNAL(transitionItemSelected(Transition*, int, QPoint, bool)), this, SLOT(slotActivateTransitionView(Transition *)));
- disconnect(m_activeTimeline->projectView(), SIGNAL(transitionItemSelected(Transition*, int, QPoint, bool)), m_projectMonitor, SLOT(slotSetSelectedClip(Transition*)));
+ disconnect(m_activeDocument, SIGNAL(signalDeleteProjectClip(QString)), this, SLOT(slotDeleteClip(QString)));
+ disconnect(m_activeDocument, SIGNAL(updateClipDisplay(QString)), m_projectList, SLOT(slotUpdateClip(QString)));
+ disconnect(m_activeDocument, SIGNAL(selectLastAddedClip(QString)), m_projectList, SLOT(slotSelectClip(QString)));
+ disconnect(m_activeTimeline->projectView(), SIGNAL(clipItemSelected(ClipItem*,bool)), this, SLOT(slotTimelineClipSelected(ClipItem*,bool)));
+ disconnect(m_activeTimeline->projectView(), SIGNAL(transitionItemSelected(Transition*,int,QPoint,bool)), m_transitionConfig, SLOT(slotTransitionItemSelected(Transition*,int,QPoint,bool)));
+ disconnect(m_activeTimeline->projectView(), SIGNAL(transitionItemSelected(Transition*,int,QPoint,bool)), this, SLOT(slotActivateTransitionView(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(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(displayMessage(QString,MessageType)), m_messageLabel, SLOT(setMessage(QString,MessageType)));
+ disconnect(m_activeTimeline->projectView(), SIGNAL(showClipFrame(DocClipBase*,QPoint,bool,int)), m_clipMonitor, SLOT(slotSetClipProducer(DocClipBase*,QPoint,bool,int)));
+ disconnect(m_projectList, SIGNAL(gotFilterJobResults(QString,int,int,stringMap,stringMap)), m_activeTimeline->projectView(), SLOT(slotGotFilterJobResults(QString,int,int,stringMap,stringMap)));
+
+ disconnect(m_activeTimeline, SIGNAL(cursorMoved()), m_projectMonitor, SLOT(slotActivateMonitor()));
disconnect(m_activeTimeline, SIGNAL(configTrack(int)), this, SLOT(slotConfigTrack(int)));
disconnect(m_activeDocument, SIGNAL(docModified(bool)), this, SLOT(slotUpdateDocumentState(bool)));
- disconnect(m_effectStack, SIGNAL(updateEffect(ClipItem*, int, QDomElement, QDomElement, int)), m_activeTimeline->projectView(), SLOT(slotUpdateClipEffect(ClipItem*, int, QDomElement, QDomElement, int)));
- disconnect(m_effectStack, SIGNAL(removeEffect(ClipItem*, int, QDomElement)), m_activeTimeline->projectView(), SLOT(slotDeleteEffect(ClipItem*, int, QDomElement)));
- disconnect(m_effectStack, SIGNAL(changeEffectState(ClipItem*, int, int, bool)), m_activeTimeline->projectView(), SLOT(slotChangeEffectState(ClipItem*, int, int, bool)));
- disconnect(m_effectStack, SIGNAL(changeEffectPosition(ClipItem*, int, int, int)), m_activeTimeline->projectView(), SLOT(slotChangeEffectPosition(ClipItem*, int, int, int)));
+ disconnect(m_effectStack, SIGNAL(updateEffect(ClipItem*,int,QDomElement,QDomElement,int,bool)), m_activeTimeline->projectView(), SLOT(slotUpdateClipEffect(ClipItem*,int,QDomElement,QDomElement,int,bool)));
+ disconnect(m_effectStack, SIGNAL(removeEffect(ClipItem*,int,QDomElement)), m_activeTimeline->projectView(), SLOT(slotDeleteEffect(ClipItem*,int,QDomElement)));
+ disconnect(m_effectStack, SIGNAL(addEffect(ClipItem*,QDomElement)), trackView->projectView(), SLOT(slotAddEffect(ClipItem*,QDomElement)));
+ disconnect(m_effectStack, SIGNAL(changeEffectState(ClipItem*,int,QList<int>,bool)), m_activeTimeline->projectView(), SLOT(slotChangeEffectState(ClipItem*,int,QList<int>,bool)));
+ disconnect(m_effectStack, SIGNAL(changeEffectPosition(ClipItem*,int,QList<int>,int)), m_activeTimeline->projectView(), SLOT(slotChangeEffectPosition(ClipItem*,int,QList<int>,int)));
disconnect(m_effectStack, SIGNAL(refreshEffectStack(ClipItem*)), m_activeTimeline->projectView(), SLOT(slotRefreshEffects(ClipItem*)));
disconnect(m_effectStack, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
- disconnect(m_effectStack, SIGNAL(displayMessage(const QString&, int)), this, SLOT(slotGotProgressInfo(const QString&, int)));
- disconnect(m_transitionConfig, SIGNAL(transitionUpdated(Transition *, QDomElement)), m_activeTimeline->projectView() , SLOT(slotTransitionUpdated(Transition *, QDomElement)));
+ disconnect(m_effectStack, SIGNAL(displayMessage(QString,int)), this, SLOT(slotGotProgressInfo(QString,int)));
+ disconnect(m_transitionConfig, SIGNAL(transitionUpdated(Transition*,QDomElement)), m_activeTimeline->projectView() , SLOT(slotTransitionUpdated(Transition*,QDomElement)));
disconnect(m_transitionConfig, SIGNAL(seekTimeline(int)), m_activeTimeline->projectView() , SLOT(setCursorPos(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_transitionConfig, SIGNAL(importClipKeyframes(GraphicsRectItem)), m_activeTimeline->projectView() , SLOT(slotImportClipKeyframes(GraphicsRectItem)));
+
+ disconnect(m_activeTimeline->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(slotActivateMonitor()));
+ 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(refreshClip(const QString &)), m_activeTimeline->projectView(), SLOT(slotRefreshThumbs(const QString &)));
+ disconnect(m_projectList, SIGNAL(refreshClip(QString)), m_activeTimeline->projectView(), SLOT(slotRefreshThumbs(QString)));
+ disconnect(m_projectList, SIGNAL(addMarkers(QString,QList<CommentedTime>)), m_activeTimeline->projectView(), SLOT(slotAddClipMarker(QString,QList<CommentedTime>)));
m_effectStack->clear();
}
//m_activeDocument->setRenderer(NULL);
m_projectList->setDocument(doc);
m_transitionConfig->updateProjectFormat(doc->mltProfile(), doc->timecode(), doc->tracksList());
m_effectStack->updateProjectFormat(doc->mltProfile(), doc->timecode());
- connect(m_projectList, SIGNAL(refreshClip(const QString &, bool)), trackView->projectView(), SLOT(slotRefreshThumbs(const QString &, bool)));
+ connect(m_projectList, SIGNAL(refreshClip(QString,bool)), trackView->projectView(), SLOT(slotRefreshThumbs(QString,bool)));
connect(m_projectList, SIGNAL(projectModified()), doc, SLOT(setModified()));
- connect(m_projectList, SIGNAL(clipNameChanged(const QString, const QString)), trackView->projectView(), SLOT(clipNameChanged(const QString, const QString)));
+ connect(m_projectList, SIGNAL(clipNameChanged(QString,QString)), trackView->projectView(), SLOT(clipNameChanged(QString,QString)));
- //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, SIGNAL(updateTracksInfo()), this, SLOT(slotUpdateTrackInfo()));
connect(trackView, SIGNAL(mousePosition(int)), this, SLOT(slotUpdateMousePosition(int)));
- connect(trackView->projectView(), SIGNAL(forceClipProcessing(const QString &)), m_projectList, SLOT(slotForceProcessing(const QString &)));
+ connect(trackView->projectView(), SIGNAL(forceClipProcessing(QString)), m_projectList, SLOT(slotForceProcessing(QString)));
+
+ connect(trackView->projectView(), SIGNAL(importKeyframes(GraphicsRectItem,QString,int)), this, SLOT(slotProcessImportKeyframes(GraphicsRectItem,QString,int)));
+
connect(m_projectMonitor, SIGNAL(renderPosition(int)), trackView, SLOT(moveCursorPos(int)));
connect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), trackView, SLOT(slotSetZone(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(bool, bool)), doc, SLOT(checkProjectClips(bool, bool)));
+ 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(addProjectClip(DocClipBase*,bool)), m_projectList, SLOT(slotAddClip(DocClipBase*,bool)));
connect(doc, SIGNAL(resetProjectList()), m_projectList, SLOT(slotResetProjectList()));
- connect(doc, SIGNAL(signalDeleteProjectClip(const QString &)), this, SLOT(slotDeleteClip(const QString &)));
- 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(signalDeleteProjectClip(QString)), this, SLOT(slotDeleteClip(QString)));
+ connect(doc, SIGNAL(updateClipDisplay(QString)), m_projectList, SLOT(slotUpdateClip(QString)));
+ connect(doc, SIGNAL(selectLastAddedClip(QString)), m_projectList, SLOT(slotSelectClip(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(doc, SIGNAL(saveTimelinePreview(QString)), trackView, SLOT(slotSaveTimelinePreview(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->projectView(), SIGNAL(updateClipMarkers(DocClipBase *)), this, SLOT(slotUpdateClipMarkers(DocClipBase*)));
- connect(trackView, SIGNAL(showTrackEffects(int, TrackInfo)), m_effectStack, SLOT(slotTrackItemSelected(int, TrackInfo)));
- connect(trackView, SIGNAL(showTrackEffects(int, TrackInfo)), this, SLOT(slotActivateEffectStackView()));
+ connect(trackView->projectView(), SIGNAL(updateClipMarkers(DocClipBase*)), this, SLOT(slotUpdateClipMarkers(DocClipBase*)));
+ connect(trackView, SIGNAL(showTrackEffects(int,TrackInfo)), this, SLOT(slotTrackSelected(int,TrackInfo)));
- connect(trackView->projectView(), SIGNAL(clipItemSelected(ClipItem*, int, bool)), this, SLOT(slotActivateEffectStackView(ClipItem*, int, bool)));
- connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition*, int, QPoint, bool)), m_transitionConfig, SLOT(slotTransitionItemSelected(Transition*, int, QPoint, bool)));
- connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition*, int, QPoint, bool)), this, SLOT(slotActivateTransitionView(Transition *)));
+ connect(trackView->projectView(), SIGNAL(clipItemSelected(ClipItem*,bool)), this, SLOT(slotTimelineClipSelected(ClipItem*,bool)));
+ connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition*,int,QPoint,bool)), m_transitionConfig, SLOT(slotTransitionItemSelected(Transition*,int,QPoint,bool)));
+ connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition*,int,QPoint,bool)), this, SLOT(slotActivateTransitionView(Transition*)));
m_zoomSlider->setValue(doc->zoom().x());
connect(trackView->projectView(), SIGNAL(zoomIn()), this, SLOT(slotZoomIn()));
connect(trackView->projectView(), SIGNAL(zoomOut()), this, SLOT(slotZoomOut()));
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(displayMessage(QString,MessageType)), m_messageLabel, SLOT(setMessage(QString,MessageType)));
- connect(trackView->projectView(), SIGNAL(showClipFrame(DocClipBase *, QPoint, const int)), m_clipMonitor, SLOT(slotSetClipProducer(DocClipBase *, QPoint, const int)));
+ connect(trackView->projectView(), SIGNAL(showClipFrame(DocClipBase*,QPoint,bool,int)), m_clipMonitor, SLOT(slotSetClipProducer(DocClipBase*,QPoint,bool,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(transitionItemSelected(Transition*, int, QPoint, bool)), m_projectMonitor, SLOT(slotSetSelectedClip(Transition*)));
+ connect(trackView->projectView(), SIGNAL(transitionItemSelected(Transition*,int,QPoint,bool)), m_projectMonitor, SLOT(slotSetSelectedClip(Transition*)));
+
+ connect(m_projectList, SIGNAL(gotFilterJobResults(QString,int,int,stringMap,stringMap)), trackView->projectView(), SLOT(slotGotFilterJobResults(QString,int,int,stringMap,stringMap)));
+
+ connect(m_projectList, SIGNAL(addMarkers(QString,QList<CommentedTime>)), trackView->projectView(), SLOT(slotAddClipMarker(QString,QList<CommentedTime>)));
- connect(m_effectStack, SIGNAL(updateEffect(ClipItem*, int, QDomElement, QDomElement, int)), trackView->projectView(), SLOT(slotUpdateClipEffect(ClipItem*, int, QDomElement, QDomElement, int)));
- connect(m_effectStack, SIGNAL(updateClipRegion(ClipItem*, int, QString)), trackView->projectView(), SLOT(slotUpdateClipRegion(ClipItem*, int, QString)));
- connect(m_effectStack, SIGNAL(removeEffect(ClipItem*, int, QDomElement)), trackView->projectView(), SLOT(slotDeleteEffect(ClipItem*, int, QDomElement)));
- connect(m_effectStack, SIGNAL(changeEffectState(ClipItem*, int, int, bool)), trackView->projectView(), SLOT(slotChangeEffectState(ClipItem*, int, int, bool)));
- connect(m_effectStack, SIGNAL(changeEffectPosition(ClipItem*, int, int, int)), trackView->projectView(), SLOT(slotChangeEffectPosition(ClipItem*, int, int, int)));
+ // Effect stack signals
+ connect(m_effectStack, SIGNAL(updateEffect(ClipItem*,int,QDomElement,QDomElement,int,bool)), trackView->projectView(), SLOT(slotUpdateClipEffect(ClipItem*,int,QDomElement,QDomElement,int,bool)));
+ connect(m_effectStack, SIGNAL(updateClipRegion(ClipItem*,int,QString)), trackView->projectView(), SLOT(slotUpdateClipRegion(ClipItem*,int,QString)));
+ connect(m_effectStack, SIGNAL(removeEffect(ClipItem*,int,QDomElement)), trackView->projectView(), SLOT(slotDeleteEffect(ClipItem*,int,QDomElement)));
+ connect(m_effectStack, SIGNAL(addEffect(ClipItem*,QDomElement)), trackView->projectView(), SLOT(slotAddEffect(ClipItem*,QDomElement)));
+ connect(m_effectStack, SIGNAL(changeEffectState(ClipItem*,int,QList<int>,bool)), trackView->projectView(), SLOT(slotChangeEffectState(ClipItem*,int,QList<int>,bool)));
+ connect(m_effectStack, SIGNAL(changeEffectPosition(ClipItem*,int,QList<int>,int)), trackView->projectView(), SLOT(slotChangeEffectPosition(ClipItem*,int,QList<int>,int)));
+
connect(m_effectStack, SIGNAL(refreshEffectStack(ClipItem*)), trackView->projectView(), SLOT(slotRefreshEffects(ClipItem*)));
- connect(m_transitionConfig, SIGNAL(transitionUpdated(Transition *, QDomElement)), trackView->projectView() , SLOT(slotTransitionUpdated(Transition *, QDomElement)));
- connect(m_transitionConfig, SIGNAL(seekTimeline(int)), trackView->projectView() , SLOT(setCursorPos(int)));
- connect(m_effectStack, SIGNAL(seekTimeline(int)), trackView->projectView() , SLOT(setCursorPos(int)));
+ connect(m_effectStack, SIGNAL(seekTimeline(int)), trackView->projectView(), SLOT(seekCursorPos(int)));
+ connect(m_effectStack, SIGNAL(importClipKeyframes(GraphicsRectItem)), trackView->projectView(), SLOT(slotImportClipKeyframes(GraphicsRectItem)));
connect(m_effectStack, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
- connect(m_effectStack, SIGNAL(displayMessage(const QString&, int)), this, SLOT(slotGotProgressInfo(const QString&, int)));
+ connect(m_effectStack, SIGNAL(displayMessage(QString,int)), this, SLOT(slotGotProgressInfo(QString,int)));
+
+ // Transition config signals
+ connect(m_transitionConfig, SIGNAL(transitionUpdated(Transition*,QDomElement)), trackView->projectView() , SLOT(slotTransitionUpdated(Transition*,QDomElement)));
+ connect(m_transitionConfig, SIGNAL(importClipKeyframes(GraphicsRectItem)), trackView->projectView() , SLOT(slotImportClipKeyframes(GraphicsRectItem)));
+ connect(m_transitionConfig, SIGNAL(seekTimeline(int)), trackView->projectView() , SLOT(seekCursorPos(int)));
- connect(trackView->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(activateMonitor()));
- connect(trackView, SIGNAL(zoneMoved(int, int)), this, SLOT(slotZoneMoved(int, int)));
+ connect(trackView->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(slotActivateMonitor()));
+ connect(trackView, SIGNAL(zoneMoved(int,int)), this, SLOT(slotZoneMoved(int,int)));
connect(m_projectList, SIGNAL(loadingIsOver()), trackView->projectView(), SLOT(slotUpdateAllThumbs()));
-
-
- trackView->projectView()->setContextMenu(m_timelineContextMenu, m_timelineContextClipMenu, m_timelineContextTransitionMenu, m_clipTypeGroup, (QMenu*)(factory()->container("marker_menu", this)));
+ trackView->projectView()->setContextMenu(m_timelineContextMenu, m_timelineContextClipMenu, m_timelineContextTransitionMenu, m_clipTypeGroup, static_cast<QMenu*>(factory()->container("marker_menu", this)));
m_activeTimeline = trackView;
if (m_renderWidget) {
slotCheckRenderStatus();
m_saveAction->setEnabled(doc->isModified());
m_normalEditTool->setChecked(true);
m_activeDocument = doc;
+ connect(m_projectMonitor, SIGNAL(durationChanged(int)), this, SLOT(slotUpdateProjectDuration(int)));
+ m_monitorManager->setDocument(m_activeDocument);
m_activeTimeline->updateProjectFps();
m_activeDocument->checkProjectClips();
#ifndef Q_WS_MAC
#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");
+
+ // Make sure monitor is visible so that it is painted black on startup
+ show();
+ m_monitorManager->activateMonitor(Kdenlive::ClipMonitor, true);
// set tool to select tool
m_buttonSelectTool->setChecked(true);
}
KShortcutsDialog dialog(KShortcutsEditor::AllActions, KShortcutsEditor::LetterShortcutsAllowed, this);
dialog.addCollection(actionCollection(), i18nc("general keyboard shortcuts", "General"));
dialog.addCollection(m_effectsActionCollection, i18nc("effects and transitions keyboard shortcuts", "Effects & Transitions"));
+ dialog.addCollection(m_tracksActionCollection, i18nc("timeline track keyboard shortcuts", "Timeline and Tracks"));
dialog.configure();
}
* cached, in which case you want to display the cached dialog
* instead of creating another one
*/
- if (m_stopmotion) m_stopmotion->slotLive(false);
+ if (m_stopmotion) {
+ m_stopmotion->slotLive(false);
+ }
+
if (KConfigDialog::showDialog("settings")) {
KdenliveSettingsDialog* d = static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"));
if (page != -1) d->showPage(page, option);
// KConfigDialog didn't find an instance of this dialog, so lets
// create it :
-
+
// Get the mappable actions in localized form
QMap<QString, QString> actions;
KActionCollection* collection = actionCollection();
foreach (const QString& action_name, m_action_names) {
actions[collection->action(action_name)->text()] = action_name;
}
-
+
KdenliveSettingsDialog* dialog = new KdenliveSettingsDialog(actions, this);
- connect(dialog, SIGNAL(settingsChanged(const QString&)), this, SLOT(updateConfiguration()));
+ connect(dialog, SIGNAL(settingsChanged(QString)), this, SLOT(updateConfiguration()));
connect(dialog, SIGNAL(doResetProfile()), m_monitorManager, SLOT(slotResetProfiles()));
#ifndef Q_WS_MAC
connect(dialog, SIGNAL(updateCaptureFolder()), this, SLOT(slotUpdateCaptureFolder()));
#endif
dialog->show();
- if (page != -1) dialog->showPage(page, option);
+ if (page != -1) {
+ dialog->showPage(page, option);
+ }
}
void MainWindow::slotUpdateCaptureFolder()
// Update list of transcoding profiles
loadTranscoders();
+ loadClipActions();
#ifdef USE_JOGSHUTTLE
activateShuttleDevice();
#endif
void MainWindow::slotSwitchVideoThumbs()
{
KdenliveSettings::setVideothumbnails(!KdenliveSettings::videothumbnails());
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->projectView()->slotUpdateAllThumbs();
+ }
m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
}
if (m_activeTimeline) {
m_activeTimeline->refresh();
m_activeTimeline->projectView()->checkAutoScroll();
- if (m_activeDocument)
+ if (m_activeDocument) {
m_activeDocument->clipManager()->checkAudioThumbs();
+ }
}
m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
}
void MainWindow::slotSwitchMarkersComments()
{
KdenliveSettings::setShowmarkers(!KdenliveSettings::showmarkers());
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->refresh();
+ }
m_buttonShowMarkers->setChecked(KdenliveSettings::showmarkers());
}
QWidget *widget = QApplication::focusWidget();
while (widget) {
if (widget == m_effectStackDock) {
- m_effectStack->slotItemDel();
+ m_effectStack->deleteCurrentEffect();
return;
}
widget = widget->parentWidget();
}
// effect stack has no focus
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->projectView()->deleteSelectedClips();
+ }
}
}
void MainWindow::slotUpdateClipMarkers(DocClipBase *clip)
{
- if (m_clipMonitor->isActive())
+ if (m_clipMonitor->isActive()) {
m_clipMonitor->checkOverlay();
+ }
m_clipMonitor->updateMarkers(clip);
}
return;
}
QString id = clip->getId();
- CommentedTime marker(pos, i18n("Marker"));
- MarkerDialog d(clip, marker, m_activeDocument->timecode(), i18n("Add Marker"), this);
- if (d.exec() == QDialog::Accepted)
- m_activeTimeline->projectView()->slotAddClipMarker(id, d.newMarker().time(), d.newMarker().comment());
+ CommentedTime marker(pos, i18n("Marker"), KdenliveSettings::default_marker_type());
+ QPointer<MarkerDialog> d = new MarkerDialog(clip, marker,
+ m_activeDocument->timecode(), i18n("Add Marker"), this);
+ if (d->exec() == QDialog::Accepted) {
+ m_activeTimeline->projectView()->slotAddClipMarker(id, QList <CommentedTime>() << d->newMarker());
+ QString hash = clip->getClipHash();
+ if (!hash.isEmpty()) m_activeDocument->cacheImage(hash + '#' + QString::number(d->newMarker().time().frames(m_activeDocument->fps())), d->markerImage());
+ }
+ delete d;
}
void MainWindow::slotDeleteClipMarker()
}
QString id = clip->getId();
- QString oldcomment = clip->markerComment(pos);
- if (oldcomment.isEmpty()) {
+ CommentedTime oldMarker = clip->markerAt(pos);
+ if (oldMarker == CommentedTime()) {
m_messageLabel->setMessage(i18n("No marker found at cursor time"), ErrorMessage);
return;
}
- CommentedTime marker(pos, oldcomment);
- MarkerDialog d(clip, marker, m_activeDocument->timecode(), i18n("Edit Marker"), this);
- if (d.exec() == QDialog::Accepted) {
- m_activeTimeline->projectView()->slotAddClipMarker(id, d.newMarker().time(), d.newMarker().comment());
- if (d.newMarker().time() != pos) {
+ QPointer<MarkerDialog> d = new MarkerDialog(clip, oldMarker,
+ m_activeDocument->timecode(), i18n("Edit Marker"), this);
+ if (d->exec() == QDialog::Accepted) {
+ m_activeTimeline->projectView()->slotAddClipMarker(id, QList <CommentedTime>() <<d->newMarker());
+ QString hash = clip->getClipHash();
+ if (!hash.isEmpty()) m_activeDocument->cacheImage(hash + '#' + QString::number(d->newMarker().time().frames(m_activeDocument->fps())), d->markerImage());
+ if (d->newMarker().time() != pos) {
// remove old marker
- m_activeTimeline->projectView()->slotAddClipMarker(id, pos, QString());
+ oldMarker.setMarkerType(-1);
+ m_activeTimeline->projectView()->slotAddClipMarker(id, QList <CommentedTime>() <<oldMarker);
}
}
+ delete d;
}
void MainWindow::slotAddMarkerGuideQuickly()
m_messageLabel->setMessage(i18n("Cannot find clip to add marker"), ErrorMessage);
return;
}
-
- m_activeTimeline->projectView()->slotAddClipMarker(clip->getId(), pos, m_activeDocument->timecode().getDisplayTimecode(pos, false));
+ //TODO: allow user to set default marker category
+ CommentedTime marker(pos, m_activeDocument->timecode().getDisplayTimecode(pos, false), KdenliveSettings::default_marker_type());
+ m_activeTimeline->projectView()->slotAddClipMarker(clip->getId(), QList <CommentedTime>() <<marker);
} else {
m_activeTimeline->projectView()->slotAddGuide(false);
}
void MainWindow::slotInsertTrack(int ix)
{
- m_projectMonitor->activateMonitor();
- if (m_activeTimeline)
+ m_monitorManager->activateMonitor(Kdenlive::ProjectMonitor);
+ if (m_activeTimeline) {
+ if (ix == -1) {
+ ix = m_activeTimeline->projectView()->selectedTrack();
+ }
m_activeTimeline->projectView()->slotInsertTrack(ix);
- if (m_activeDocument)
+ }
+ if (m_activeDocument) {
m_transitionConfig->updateProjectFormat(m_activeDocument->mltProfile(), m_activeDocument->timecode(), m_activeDocument->tracksList());
+ }
}
void MainWindow::slotDeleteTrack(int ix)
{
- m_projectMonitor->activateMonitor();
- if (m_activeTimeline)
+ m_monitorManager->activateMonitor(Kdenlive::ProjectMonitor);
+ if (m_activeTimeline) {
+ if (ix == -1) {
+ ix = m_activeTimeline->projectView()->selectedTrack();
+ }
m_activeTimeline->projectView()->slotDeleteTrack(ix);
- if (m_activeDocument)
+ }
+ if (m_activeDocument) {
m_transitionConfig->updateProjectFormat(m_activeDocument->mltProfile(), m_activeDocument->timecode(), m_activeDocument->tracksList());
+ }
}
void MainWindow::slotConfigTrack(int ix)
{
- m_projectMonitor->activateMonitor();
+ m_monitorManager->activateMonitor(Kdenlive::ProjectMonitor);
if (m_activeTimeline)
m_activeTimeline->projectView()->slotConfigTracks(ix);
if (m_activeDocument)
m_transitionConfig->updateProjectFormat(m_activeDocument->mltProfile(), m_activeDocument->timecode(), m_activeDocument->tracksList());
}
+void MainWindow::slotSelectTrack()
+{
+ m_monitorManager->activateMonitor(Kdenlive::ProjectMonitor);
+ if (m_activeTimeline) {
+ m_activeTimeline->projectView()->slotSelectClipsInTrack();
+ }
+}
+
+void MainWindow::slotSelectAllTracks()
+{
+ m_monitorManager->activateMonitor(Kdenlive::ProjectMonitor);
+ if (m_activeTimeline)
+ m_activeTimeline->projectView()->slotSelectAllClips();
+}
+
void MainWindow::slotEditGuide()
{
if (m_activeTimeline)
m_activeTimeline->projectView()->editItemDuration();
}
-void MainWindow::slotAddProjectClip(KUrl url)
+void MainWindow::slotAddProjectClip(const KUrl &url, const stringMap &data)
{
- if (m_activeDocument)
- m_activeDocument->slotAddClipFile(url, QString());
+ if (m_activeDocument) {
+ m_activeDocument->slotAddClipFile(url, data);
+ }
}
-void MainWindow::slotAddProjectClipList(KUrl::List urls)
+void MainWindow::slotAddProjectClipList(const KUrl::List &urls)
{
if (m_activeDocument)
- m_activeDocument->slotAddClipList(urls, QString());
+ m_activeDocument->slotAddClipList(urls);
}
void MainWindow::slotAddTransition(QAction *result)
void MainWindow::slotAddVideoEffect(QAction *result)
{
- if (!result) return;
- const int EFFECT_VIDEO = 1;
- const int EFFECT_AUDIO = 2;
+ if (!result) {
+ return;
+ }
+ const int VideoEffect = 1;
+ const int AudioEffect = 2;
QStringList info = result->data().toStringList();
- if (info.isEmpty() || info.size() < 3) return;
+ if (info.isEmpty() || info.size() < 3) {
+ return;
+ }
QDomElement effect ;
- if (info.at(2) == QString::number((int) EFFECT_VIDEO))
- effect = videoEffects.getEffectByTag(info.at(0), info.at(1));
- else if (info.at(2) == QString::number((int) EFFECT_AUDIO))
- effect = audioEffects.getEffectByTag(info.at(0), info.at(1));
- else
- effect = customEffects.getEffectByTag(info.at(0), info.at(1));
- if (!effect.isNull()) slotAddEffect(effect);
- else m_messageLabel->setMessage(i18n("Cannot find effect %1 / %2").arg(info.at(0)).arg(info.at(1)), ErrorMessage);
+ if (info.last() == QString::number((int) VideoEffect)) {
+ effect = videoEffects.getEffectByTag(info.at(0), info.at(1));
+ } else if (info.last() == QString::number((int) AudioEffect)) {
+ effect = audioEffects.getEffectByTag(info.at(0), info.at(1));
+ } else {
+ effect = customEffects.getEffectByTag(info.at(0), info.at(1));
+ }
+
+ if (!effect.isNull()) {
+ slotAddEffect(effect);
+ } else {
+ m_messageLabel->setMessage(i18n("Cannot find effect %1 / %2", info.at(0), info.at(1)), ErrorMessage);
+ }
}
value = qMax(m_zoomSlider->minimum(), value);
value = qMin(m_zoomSlider->maximum(), value);
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->slotChangeZoom(value);
+ }
m_zoomOut->setEnabled(value < m_zoomSlider->maximum());
m_zoomIn->setEnabled(value > m_zoomSlider->minimum());
void MainWindow::slotShowZoomSliderToolTip(int zoomlevel)
{
- if (zoomlevel != -1)
+ if (zoomlevel != -1) {
slotUpdateZoomSliderToolTip(zoomlevel);
+ }
QPoint global = m_zoomSlider->rect().topLeft();
global.ry() += m_zoomSlider->height() / 2;
m_zoomSlider->setToolTip(i18n("Zoom Level: %1/13", (13 - zoomlevel)));
}
-void MainWindow::slotGotProgressInfo(const QString &message, int progress)
+void MainWindow::slotGotProgressInfo(const QString &message, int progress, MessageType type)
{
- m_statusProgressBar->setValue(progress);
+ if (type == DefaultMessage) {
+ m_statusProgressBar->setValue(progress);
+ }
+ m_messageLabel->setMessage(message, type);
if (progress >= 0) {
- if (!message.isEmpty())
- m_messageLabel->setMessage(message, InformationMessage);//statusLabel->setText(message);
- m_statusProgressBar->setVisible(true);
- } else if (progress == -2) {
- if (!message.isEmpty())
- m_messageLabel->setMessage(message, ErrorMessage);
- m_statusProgressBar->setVisible(false);
+ if (type == DefaultMessage) {
+ m_statusProgressBar->setVisible(true);
+ }
} else {
- m_messageLabel->setMessage(QString(), DefaultMessage);
m_statusProgressBar->setVisible(false);
}
}
void MainWindow::slotShowClipProperties(DocClipBase *clip)
{
- if (clip->clipType() == TEXT) {
+ if (clip->clipType() == Text) {
QString titlepath = m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash) + "titles/";
if (!clip->getProperty("resource").isEmpty() && clip->getProperty("xmldata").isEmpty()) {
// template text clip
dia_ui.description->setText(clip->getProperty("description"));
if (dia->exec() == QDialog::Accepted) {
QString textTemplate = dia_ui.template_list->comboBox()->itemData(dia_ui.template_list->comboBox()->currentIndex()).toString();
- if (textTemplate.isEmpty()) textTemplate = dia_ui.template_list->comboBox()->currentText();
+ if (textTemplate.isEmpty()) {
+ textTemplate = dia_ui.template_list->comboBox()->currentText();
+ }
QMap <QString, QString> newprops;
}
QString newtemplate = newprops.value("xmltemplate");
- if (newtemplate.isEmpty()) newtemplate = templatePath;
+ if (newtemplate.isEmpty()) {
+ newtemplate = templatePath;
+ }
// template modified we need to update xmldata
QString description = newprops.value("description");
- if (description.isEmpty()) description = clip->getProperty("description");
- else newprops.insert("templatetext", description);
+ if (description.isEmpty()) {
+ description = clip->getProperty("description");
+ } else {
+ newprops.insert("templatetext", description);
+ }
+
//newprops.insert("xmldata", m_projectList->generateTemplateXml(newtemplate, description).toString());
if (!newprops.isEmpty()) {
- EditClipCommand *command = new EditClipCommand(m_projectList, clip->getId(), clip->properties(), newprops, true);
+ EditClipCommand *command = new EditClipCommand(m_projectList, clip->getId(), clip->currentProperties(newprops), newprops, true);
m_activeDocument->commandStack()->push(command);
}
}
return;
}
QString path = clip->getProperty("resource");
- TitleWidget *dia_ui = new TitleWidget(KUrl(), m_activeDocument->timecode(), titlepath, m_projectMonitor->render, this);
+ QPointer<TitleWidget> dia_ui = new TitleWidget(KUrl(), m_activeDocument->timecode(), titlepath, m_projectMonitor->render, this);
QDomDocument doc;
doc.setContent(clip->getProperty("xmldata"));
dia_ui->setXml(doc);
if (dia_ui->exec() == QDialog::Accepted) {
QMap <QString, QString> newprops;
newprops.insert("xmldata", dia_ui->xml().toString());
- if (dia_ui->outPoint() != clip->duration().frames(m_activeDocument->fps()) - 1) {
+ if (dia_ui->duration() != clip->duration().frames(m_activeDocument->fps())) {
// duration changed, we need to update duration
- newprops.insert("out", QString::number(dia_ui->outPoint()));
+ newprops.insert("out", QString::number(dia_ui->duration() - 1));
int currentLength = QString(clip->producerProperty("length")).toInt();
- if (currentLength <= dia_ui->outPoint())
- newprops.insert("length", QString::number(dia_ui->outPoint() + 1));
- else newprops.insert("length", clip->producerProperty("length"));
+ if (currentLength <= dia_ui->duration()) {
+ newprops.insert("length", QString::number(dia_ui->duration()));
+ } else {
+ newprops.insert("length", clip->producerProperty("length"));
+ }
}
if (!path.isEmpty()) {
// we are editing an external file, asked if we want to detach from that file or save the result to that title file.
if (KMessageBox::questionYesNo(this, i18n("You are editing an external title clip (%1). Do you want to save your changes to the title file or save the changes for this project only?", path), i18n("Save Title"), KGuiItem(i18n("Save to title file")), KGuiItem(i18n("Save in project only"))) == KMessageBox::Yes) {
// save to external file
dia_ui->saveTitle(path);
- } else newprops.insert("resource", QString());
+ } else {
+ newprops.insert("resource", QString());
+ }
}
- EditClipCommand *command = new EditClipCommand(m_projectList, clip->getId(), clip->properties(), newprops, true);
+ EditClipCommand *command = new EditClipCommand(m_projectList, clip->getId(), clip->currentProperties(newprops), newprops, true);
m_activeDocument->commandStack()->push(command);
//m_activeTimeline->projectView()->slotUpdateClip(clip->getId());
m_activeDocument->setModified(true);
//m_activeDocument->editTextClip(clip->getProperty("xml"), clip->getId());
return;
}
+
+ // Check if we already have a properties dialog opened for that clip
+ QList <ClipProperties *> list = findChildren<ClipProperties *>();
+ for (int i = 0; i < list.size(); ++i) {
+ if (list.at(i)->clipId() == clip->getId()) {
+ // We have one dialog, show it
+ list.at(i)->raise();
+ return;
+ }
+ }
// 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)));
+
+ if (clip->clipType() == AV || clip->clipType() == Video || clip->clipType() == Playlist || clip->clipType() == SlideShow) {
+ // request clip thumbnails
+ connect(m_activeDocument->clipManager(), SIGNAL(gotClipPropertyThumbnail(QString,QImage)), dia, SLOT(slotGotThumbnail(QString,QImage)));
+ connect(dia, SIGNAL(requestThumb(QString,QList<int>)), m_activeDocument->clipManager(), SLOT(slotRequestThumbs(QString,QList<int>)));
+ m_activeDocument->clipManager()->slotRequestThumbs(QString('?' + clip->getId()), QList<int>() << clip->getClipThumbFrame());
+ }
+
+ connect(dia, SIGNAL(addMarkers(QString,QList<CommentedTime>)), m_activeTimeline->projectView(), SLOT(slotAddClipMarker(QString,QList<CommentedTime>)));
+ connect(dia, SIGNAL(editAnalysis(QString,QString,QString)), m_activeTimeline->projectView(), SLOT(slotAddClipExtraData(QString,QString,QString)));
+ connect(m_activeTimeline->projectView(), SIGNAL(updateClipMarkers(DocClipBase*)), dia, SLOT(slotFillMarkersList(DocClipBase*)));
+ connect(m_activeTimeline->projectView(), SIGNAL(updateClipExtraData(DocClipBase*)), dia, SLOT(slotUpdateAnalysisData(DocClipBase*)));
+ connect(m_projectList, SIGNAL(updateAnalysisData(DocClipBase*)), dia, SLOT(slotUpdateAnalysisData(DocClipBase*)));
+ connect(dia, SIGNAL(loadMarkers(QString)), m_activeTimeline->projectView(), SLOT(slotLoadClipMarkers(QString)));
+ connect(dia, SIGNAL(saveMarkers(QString)), m_activeTimeline->projectView(), SLOT(slotSaveClipMarkers(QString)));
+ connect(dia, SIGNAL(deleteProxy(QString)), m_projectList, SLOT(slotDeleteProxy(QString)));
+ connect(dia, SIGNAL(applyNewClipProperties(QString,QMap<QString,QString>,QMap<QString,QString>,bool,bool)), this, SLOT(slotApplyNewClipProperties(QString,QMap<QString,QString>,QMap<QString,QString>,bool,bool)));
dia->show();
}
-void MainWindow::slotApplyNewClipProperties(const QString id, QMap <QString, QString> props, QMap <QString, QString> newprops, bool refresh, bool reload)
+void MainWindow::slotApplyNewClipProperties(const QString &id, const QMap <QString, QString> &props, const QMap <QString, QString> &newprops, bool refresh, bool reload)
{
- if (newprops.isEmpty()) return;
+ if (newprops.isEmpty()) {
+ return;
+ }
+
EditClipCommand *command = new EditClipCommand(m_projectList, id, props, newprops, true);
m_activeDocument->commandStack()->push(command);
m_activeDocument->setModified();
}
-void MainWindow::slotShowClipProperties(QList <DocClipBase *> cliplist, QMap<QString, QString> commonproperties)
+void MainWindow::slotShowClipProperties(const QList <DocClipBase *> &cliplist, const QMap<QString, QString> &commonproperties)
{
- ClipProperties dia(cliplist, m_activeDocument->timecode(), commonproperties, this);
- if (dia.exec() == QDialog::Accepted) {
+ QPointer<ClipProperties> dia = new ClipProperties(cliplist,
+ m_activeDocument->timecode(), commonproperties, this);
+ if (dia->exec() == QDialog::Accepted) {
QUndoCommand *command = new QUndoCommand();
command->setText(i18n("Edit clips"));
- QMap <QString, QString> newImageProps = dia.properties();
+ QMap <QString, QString> newImageProps = dia->properties();
// Transparency setting applies only for images
QMap <QString, QString> newProps = newImageProps;
newProps.remove("transparency");
- for (int i = 0; i < cliplist.count(); i++) {
+ for (int i = 0; i < cliplist.count(); ++i) {
DocClipBase *clip = cliplist.at(i);
- if (clip->clipType() == IMAGE)
- new EditClipCommand(m_projectList, clip->getId(), clip->properties(), newImageProps, true, command);
- else
- new EditClipCommand(m_projectList, clip->getId(), clip->properties(), newProps, true, command);
+ if (clip->clipType() == Image)
+ new EditClipCommand(m_projectList, clip->getId(), clip->currentProperties(newImageProps), newImageProps, true, command);
+ else
+ new EditClipCommand(m_projectList, clip->getId(), clip->currentProperties(newProps), newProps, true, command);
}
m_activeDocument->commandStack()->push(command);
- for (int i = 0; i < cliplist.count(); i++)
- m_activeTimeline->projectView()->slotUpdateClip(cliplist.at(i)->getId(), dia.needsTimelineReload());
+ for (int i = 0; i < cliplist.count(); ++i) {
+ m_activeTimeline->projectView()->slotUpdateClip(cliplist.at(i)->getId(), dia->needsTimelineReload());
+ }
}
+ delete dia;
}
void MainWindow::customEvent(QEvent* e)
if (e->type() == QEvent::User)
m_messageLabel->setMessage(static_cast <MltErrorEvent *>(e)->message(), MltError);
}
-void MainWindow::slotActivateEffectStackView(ClipItem* item, int ix, bool raise)
+
+void MainWindow::slotTimelineClipSelected(ClipItem* item, bool raise)
{
- Q_UNUSED(item)
- Q_UNUSED(ix)
+ if (item != m_mainClip) {
+ if (m_mainClip) {
+ m_mainClip->setMainSelectedClip(false);
+ }
+ if (item) {
+ item->setMainSelectedClip(true);
+ }
+ m_mainClip = item;
+ }
- if (raise)
+ m_effectStack->slotClipItemSelected(item);
+ m_projectMonitor->slotSetSelectedClip(item);
+ if (raise) {
m_effectStack->raiseWindow(m_effectStackDock);
+ }
}
-void MainWindow::slotActivateTransitionView(Transition *t)
+void MainWindow::slotTrackSelected(int index, const TrackInfo &info, bool raise)
{
- if (t)
+ m_effectStack->slotTrackItemSelected(index, info);
+ if (raise) {
+ m_effectStack->raiseWindow(m_effectStackDock);
+ }
+}
+
+void MainWindow::slotActivateTransitionView(Transition *transition)
+{
+ if (transition)
m_transitionConfig->raiseWindow(m_transitionConfigDock);
}
void MainWindow::slotSnapRewind()
{
if (m_projectMonitor->isActive()) {
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->projectView()->slotSeekToPreviousSnap();
+ }
} else {
m_clipMonitor->slotSeekToPreviousSnap();
}
void MainWindow::slotSnapForward()
{
if (m_projectMonitor->isActive()) {
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->projectView()->slotSeekToNextSnap();
+ }
} else {
m_clipMonitor->slotSeekToNextSnap();
}
void MainWindow::slotClipStart()
{
if (m_projectMonitor->isActive()) {
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->projectView()->clipStart();
+ }
}
}
void MainWindow::slotClipEnd()
{
if (m_projectMonitor->isActive()) {
- if (m_activeTimeline)
+ if (m_activeTimeline) {
m_activeTimeline->projectView()->clipEnd();
+ }
}
}
void MainWindow::slotChangeTool(QAction * action)
{
if (action == m_buttonSelectTool)
- slotSetTool(SELECTTOOL);
+ slotSetTool(SelectTool);
else if (action == m_buttonRazorTool)
- slotSetTool(RAZORTOOL);
+ slotSetTool(RazorTool);
else if (action == m_buttonSpacerTool)
- slotSetTool(SPACERTOOL);
+ slotSetTool(SpacerTool);
}
void MainWindow::slotChangeEdit(QAction * action)
return;
if (action == m_overwriteEditTool)
- m_activeTimeline->projectView()->setEditMode(OVERWRITEEDIT);
+ m_activeTimeline->projectView()->setEditMode(OverwriteEdit);
else if (action == m_insertEditTool)
- m_activeTimeline->projectView()->setEditMode(INSERTEDIT);
+ m_activeTimeline->projectView()->setEditMode(InsertEdit);
else
- m_activeTimeline->projectView()->setEditMode(NORMALEDIT);
+ m_activeTimeline->projectView()->setEditMode(NormalEdit);
}
-void MainWindow::slotSetTool(PROJECTTOOL tool)
+void MainWindow::slotSetTool(ProjectTool tool)
{
if (m_activeDocument && m_activeTimeline) {
//m_activeDocument->setTool(tool);
QString message;
switch (tool) {
- case SPACERTOOL:
+ case SpacerTool:
message = i18n("Ctrl + click to use spacer on current track only");
break;
- case RAZORTOOL:
+ case RazorTool:
message = i18n("Click on a clip to cut it");
break;
default:
void MainWindow::slotFind()
{
- if (!m_activeDocument || !m_activeTimeline) return;
+ if (!m_activeDocument || !m_activeTimeline) {
+ return;
+ }
+
m_projectSearch->setEnabled(false);
m_findActivated = true;
m_findString.clear();
void MainWindow::slotFindNext()
{
- if (m_activeTimeline && m_activeTimeline->projectView()->findNextString(m_findString))
+ if (m_activeTimeline && m_activeTimeline->projectView()->findNextString(m_findString)) {
statusBar()->showMessage(i18n("Found: %1", m_findString));
- else
+ } else {
statusBar()->showMessage(i18n("Reached end of project"));
+ }
m_findTimer.start(4000);
}
}
inTimelineMenu->addActions(actionList);
- if (matching.empty())
+ if (matching.empty()) {
inTimelineMenu->setEnabled(false);
- else
+ } else {
inTimelineMenu->setEnabled(true);
+ }
}
}
void MainWindow::slotClipInProjectTree()
{
if (m_activeTimeline) {
- const QStringList &clipIds = m_activeTimeline->projectView()->selectedClips();
- if (clipIds.isEmpty())
+ QStringList clipIds;
+ if (m_mainClip) {
+ clipIds << m_mainClip->clipProducer();
+ } else {
+ clipIds = m_activeTimeline->projectView()->selectedClips();
+ }
+ if (clipIds.isEmpty()) {
return;
+ }
m_projectListDock->raise();
- for (int i = 0; i < clipIds.count(); i++)
- m_projectList->selectItemById(clipIds.at(i));
- if (m_projectMonitor->isActive())
+ m_projectList->selectItemById(clipIds.at(0));
+ if (m_projectMonitor->isActive()) {
slotSwitchMonitors();
+ }
}
}
if (m_activeTimeline) {
const QList<ClipItem *> clips = m_activeTimeline->projectView()->selectedClipItems();
if (clips.isEmpty()) return;
- for (int i = 0; i < clips.count(); i++) {
+ for (int i = 0; i < clips.count(); ++i) {
m_projectList->slotAddXmlClip(clips.at(i)->itemXml());
}
//m_projectList->selectItemById(clipIds.at(i));
if (ke->key() == Qt::Key_Backspace) {
m_findString = m_findString.left(m_findString.length() - 1);
- if (!m_findString.isEmpty())
+ if (!m_findString.isEmpty()) {
findAhead();
- else
+ } else {
findTimeout();
+ }
m_findTimer.start(4000);
ke->accept();
}
-void MainWindow::slotSaveZone(Render *render, QPoint zone, DocClipBase *baseClip, KUrl path)
+void MainWindow::slotSaveZone(Render *render, const QPoint &zone, DocClipBase *baseClip, KUrl path)
{
KDialog *dialog = new KDialog(this);
dialog->setCaption("Save clip zone");
QLabel *label1 = new QLabel(i18n("Save clip zone as:"), 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");
+ 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);
}
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());
+ delete dialog;
return;
}
}
}
else render->saveZone(url->url(), edit->text(), zone);
}
+ delete dialog;
}
{
KNS3::Entry::List entries;
#if KDE_IS_VERSION(4,3,80)
- KNS3::DownloadDialog dialog(configFile);
- dialog.exec();
- entries = dialog.changedEntries();
+ QPointer<KNS3::DownloadDialog> dialog = new KNS3::DownloadDialog(configFile);
+ if (dialog->exec()) entries = dialog->changedEntries();
foreach(const KNS3::Entry & entry, entries) {
if (entry.status() == KNS3::Entry::Installed)
kDebug() << "// Installed files: " << entry.installedFiles();
}
+ delete dialog;
#else
KNS::Engine engine(0);
if (engine.init(configFile))
m_activeTimeline->projectView()->splitAudio();
}
+void MainWindow::slotSetAudioAlignReference()
+{
+ if (m_activeTimeline) {
+ m_activeTimeline->projectView()->setAudioAlignReference();
+ }
+}
+
+void MainWindow::slotAlignAudio()
+{
+ if (m_activeTimeline) {
+ m_activeTimeline->projectView()->alignAudio();
+ }
+}
+
void MainWindow::slotUpdateClipType(QAction *action)
{
if (m_activeTimeline) {
}
}
-void MainWindow::slotDvdWizard(const QString &url, const QString &profile)
+void MainWindow::slotDvdWizard(const QString &url)
{
// We must stop the monitors since we create a new on in the dvd wizard
- m_clipMonitor->stop();
- m_projectMonitor->stop();
- DvdWizard w(url, profile, this);
- w.exec();
- m_projectMonitor->start();
+ m_monitorManager->activateMonitor(Kdenlive::DvdMonitor);
+ QPointer<DvdWizard> w = new DvdWizard(m_monitorManager, url, this);
+ w->exec();
+ delete w;
+ m_monitorManager->activateMonitor(Kdenlive::ClipMonitor);
}
void MainWindow::slotShowTimeline(bool show)
kDebug() << "CURRENT WIDGET: " << par->objectName();
}
+void MainWindow::loadClipActions()
+{
+ QMenu* actionMenu= static_cast<QMenu*>(factory()->container("clip_actions", this));
+ if (actionMenu){
+ actionMenu->clear();
+ Mlt::Profile profile;
+ Mlt::Filter *filter = Mlt::Factory::filter(profile,(char*)"videostab");
+ if (filter) {
+ if (!filter->is_valid()) {
+ delete filter;
+ }
+ else {
+ delete filter;
+ QAction *action=actionMenu->addAction(i18n("Stabilize (vstab)"));
+ action->setData("videostab");
+ connect(action,SIGNAL(triggered()), this, SLOT(slotStartClipAction()));
+ }
+ }
+ filter = Mlt::Factory::filter(profile,(char*)"videostab2");
+ if (filter) {
+ if (!filter->is_valid()) {
+ delete filter;
+ }
+ else {
+ delete filter;
+ QAction *action=actionMenu->addAction(i18n("Stabilize (transcode)"));
+ action->setData("videostab2");
+ connect(action,SIGNAL(triggered()), this, SLOT(slotStartClipAction()));
+ }
+ }
+ filter = Mlt::Factory::filter(profile,(char*)"motion_est");
+ if (filter) {
+ if (!filter->is_valid()) {
+ delete filter;
+ }
+ else {
+ delete filter;
+ QAction *action=actionMenu->addAction(i18n("Automatic scene split"));
+ action->setData("motion_est");
+ connect(action,SIGNAL(triggered()), this, SLOT(slotStartClipAction()));
+ }
+ }
+ if (KdenliveSettings::producerslist().contains("framebuffer")) {
+ QAction *action=actionMenu->addAction(i18n("Reverse clip"));
+ action->setData("framebuffer");
+ connect(action,SIGNAL(triggered()), this, SLOT(slotStartClipAction()));
+ }
+ }
+
+}
+
void MainWindow::loadTranscoders()
{
QMenu *transMenu = static_cast<QMenu*>(factory()->container("transcoders", this));
transMenu->clear();
- KSharedConfigPtr config = KSharedConfig::openConfig("kdenlivetranscodingrc");
+ QMenu *extractAudioMenu = static_cast<QMenu*>(factory()->container("extract_audio", this));
+ extractAudioMenu->clear();
+
+ KSharedConfigPtr config = KSharedConfig::openConfig("kdenlivetranscodingrc", KConfig::CascadeConfig);
KConfigGroup transConfig(config, "Transcoding");
// read the entries
QMap< QString, QString > profiles = transConfig.entryMap();
QMapIterator<QString, QString> i(profiles);
while (i.hasNext()) {
i.next();
- QStringList data = i.value().split(";", QString::SkipEmptyParts);
- QAction *a = transMenu->addAction(i.key());
+ QStringList data = i.value().split(';');
+ QAction *a;
+ // separate audio transcoding in a separate menu
+ if (data.count() > 2 && data.at(2) == "audio") {
+ a = extractAudioMenu->addAction(i.key());
+ }
+ else {
+ a = transMenu->addAction(i.key());
+ }
a->setData(data);
- if (data.count() > 1)
- a->setToolTip(data.at(1));
+ if (data.count() > 1) a->setToolTip(data.at(1));
connect(a, SIGNAL(triggered()), this, SLOT(slotTranscode()));
}
}
-void MainWindow::slotTranscode(KUrl::List urls)
+void MainWindow::slotStartClipAction()
+{
+ QString condition,filtername;
+ QStringList ids;
+
+ // Stablize selected clips
+ QAction *action = qobject_cast<QAction *>(sender());
+ if (action){
+ filtername=action->data().toString();
+ }
+ m_projectList->startClipFilterJob(filtername, condition);
+}
+
+void MainWindow::slotTranscode(const KUrl::List &urls)
{
QString params;
QString desc;
QAction *action = qobject_cast<QAction *>(sender());
QStringList data = action->data().toStringList();
params = data.at(0);
- if (data.count() > 1) desc = data.at(1);
- if (data.count() > 2) condition = data.at(2);
- urls << m_projectList->getConditionalUrls(condition);
- urls.removeAll(KUrl());
+ if (data.count() > 1)
+ desc = data.at(1);
+ if (data.count() > 3)
+ condition = data.at(3);
+ m_projectList->slotTranscodeClipJob(condition, params, desc);
+ return;
}
if (urls.isEmpty()) {
m_messageLabel->setMessage(i18n("No clip to transcode"), ErrorMessage);
return;
}
- ClipTranscode *d = new ClipTranscode(urls, params, desc);
+ ClipTranscode *d = new ClipTranscode(urls, params, QStringList(), desc);
connect(d, SIGNAL(addClip(KUrl)), this, SLOT(slotAddProjectClip(KUrl)));
d->show();
- //QProcess::startDetached("ffmpeg", parameters);
}
void MainWindow::slotTranscodeClip()
slotTranscode(urls);
}
-void MainWindow::slotSetDocumentRenderProfile(QMap <QString, QString> props)
+void MainWindow::slotSetDocumentRenderProfile(const QMap <QString, QString> &props)
{
if (m_activeDocument == NULL) return;
QMapIterator<QString, QString> i(props);
QString scriptPath;
QString playlistPath;
if (scriptExport) {
- bool ok;
- QString scriptsFolder = m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash) + "scripts/";
- QString path = m_renderWidget->getFreeScriptName();
- scriptPath = QInputDialog::getText(this, i18n("Create Render Script"), i18n("Script name (will be saved in: %1)", scriptsFolder), QLineEdit::Normal, KUrl(path).fileName(), &ok);
- if (!ok || scriptPath.isEmpty()) return;
- scriptPath.prepend(scriptsFolder);
+ //QString scriptsFolder = m_activeDocument->projectFolder().path(KUrl::AddTrailingSlash) + "scripts/";
+ QString path = m_renderWidget->getFreeScriptName(m_activeDocument->url());
+ QPointer<KUrlRequesterDialog> getUrl = new KUrlRequesterDialog(path, i18n("Create Render Script"), this);
+ getUrl->fileDialog()->setMode(KFile::File);
+ getUrl->fileDialog()->setOperationMode(KFileDialog::Saving);
+ if (getUrl->exec() == QDialog::Rejected) {
+ delete getUrl;
+ return;
+ }
+ scriptPath = getUrl->selectedUrl().path();
+ delete getUrl;
QFile f(scriptPath);
if (f.exists()) {
if (KMessageBox::warningYesNo(this, i18n("Script file already exists. Do you want to overwrite it?")) != KMessageBox::Yes)
QDomElement guidesxml = m_activeDocument->guidesXml();
QDomNodeList nodes = guidesxml.elementsByTagName("guide");
- for (int i = 0; i < nodes.count(); i++) {
+ for (int i = 0; i < nodes.count(); ++i) {
QDomElement e = nodes.item(i).toElement();
if (!e.isNull()) {
QString comment = e.attribute("comment");
// Always insert a guide in pos 0
QDomElement chapter = doc.createElement("chapter");
chapters.insertBefore(chapter, QDomNode());
- chapter.setAttribute("title", i18n("Start"));
+ chapter.setAttribute("title", i18nc("the first in a list of chapters", "Start"));
chapter.setAttribute("time", "0");
}
// save chapters file
QDomElement tractor = doc.documentElement().firstChildElement("tractor");
if (!tractor.isNull()) {
QDomNodeList props = tractor.elementsByTagName("property");
- for (int i = 0; i < props.count(); i++) {
+ 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()) {
QString root = doc.documentElement().attribute("root");
QDomElement e = producers.item(n).toElement();
producerResource = EffectsList::property(e, "resource");
if (producerResource.isEmpty()) continue;
- if (!producerResource.startsWith("/")) {
- producerResource.prepend(root + "/");
+ if (!producerResource.startsWith('/')) {
+ producerResource.prepend(root + '/');
}
if (producerResource.contains('?')) {
// slowmotion producer
- suffix = "?" + producerResource.section('?', 1);
+ suffix = '?' + producerResource.section('?', 1);
producerResource = producerResource.section('?', 0, 0);
}
else suffix.clear();
}
}
}
-
+
/*QMapIterator<QString, QString> i(proxies);
while (i.hasNext()) {
i.next();
}*/
}
playlistContent = doc.toString();
-
+
// Do save scenelist
QFile file(playlistPath);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
- m_messageLabel->setMessage(i18n("Cannot write to file %1").arg(playlistPath), ErrorMessage);
+ m_messageLabel->setMessage(i18n("Cannot write to file %1", playlistPath), ErrorMessage);
return;
}
file.write(playlistContent.toUtf8());
if (file.error() != QFile::NoError) {
- m_messageLabel->setMessage(i18n("Cannot write to file %1").arg(playlistPath), ErrorMessage);
+ m_messageLabel->setMessage(i18n("Cannot write to file %1", playlistPath), ErrorMessage);
file.close();
return;
}
file.close();
- m_renderWidget->slotExport(scriptExport, m_activeTimeline->inPoint(), m_activeTimeline->outPoint(), playlistPath, scriptPath, exportAudio);
+ m_renderWidget->slotExport(scriptExport, m_activeTimeline->inPoint(), m_activeTimeline->outPoint(), m_activeDocument->metadata(), playlistPath, scriptPath, exportAudio);
}
void MainWindow::slotUpdateTimecodeFormat(int ix)
m_effectStack->updateTimecodeFormat();
//m_activeTimeline->projectView()->clearSelection();
m_activeTimeline->updateRuler();
+ slotUpdateMousePosition(m_activeTimeline->projectView()->getMousePos());
}
void MainWindow::slotRemoveFocus()
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)
+ // 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 };
+ 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++ ) {
+
+ 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::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 ) );
}
kapp->setPalette(plt);
+ slotChangePalette();
const QObjectList children = statusBar()->children();
foreach(QObject * child, children) {
((QWidget*)subchild)->setPalette(plt);
}
}
- if (m_activeTimeline) {
- m_activeTimeline->projectView()->updatePalette();
- }
}
else m_projectList->focusTree();
}
-void MainWindow::slotSwitchFullscreen()
-{
- if (m_projectMonitor->isActive()) m_projectMonitor->slotSwitchFullScreen();
- else m_clipMonitor->slotSwitchFullScreen();
-}
-
void MainWindow::slotInsertZoneToTree()
{
if (!m_clipMonitor->isActive() || m_clipMonitor->activeClip() == NULL) return;
}
-void MainWindow::slotDeleteProjectClips(QStringList ids, QMap<QString, QString> folderids)
+void MainWindow::slotDeleteProjectClips(const QStringList &ids, const QMap<QString, QString> &folderids)
{
if (m_activeDocument && m_activeTimeline) {
if (!ids.isEmpty()) {
void MainWindow::slotShowTitleBars(bool show)
{
QList <QDockWidget *> docks = findChildren<QDockWidget *>();
- for (int i = 0; i < docks.count(); i++) {
+ for (int i = 0; i < docks.count(); ++i) {
QDockWidget* dock = docks.at(i);
if (show) {
dock->setTitleBarWidget(0);
m_projectMonitor->render->sendFrameForAnalysis = true;
return;
} else {
- for (int i = 0; i < m_gfxScopesList.count(); i++) {
+ for (int i = 0; i < m_gfxScopesList.count(); ++i) {
if (m_gfxScopesList.at(i)->isVisible() && tabifiedDockWidgets(m_gfxScopesList.at(i)).isEmpty() && static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->autoRefreshEnabled()) {
request = true;
break;
}
}
-void MainWindow::slotUpdateGfxScopeFrameRequest()
-{
- // We need a delay to make sure widgets are hidden after a close event for example
- QTimer::singleShot(500, this, SLOT(slotDoUpdateGfxScopeFrameRequest()));
-}
-
-void MainWindow::slotDoUpdateGfxScopeFrameRequest()
-{
- // Check scopes
- bool request = false;
- for (int i = 0; i < m_gfxScopesList.count(); i++) {
- if (!m_gfxScopesList.at(i)->widget()->visibleRegion().isEmpty() && static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->autoRefreshEnabled()) {
- kDebug() << "SCOPE VISIBLE: " << static_cast<AbstractGfxScopeWidget *>(m_gfxScopesList.at(i)->widget())->widgetName();
- request = true;
- break;
- }
- }
- if (!request) {
- if (!m_projectMonitor->effectSceneDisplayed()) {
- 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::slotUpdateAudioScopeFrameRequest()
-{
- QTimer::singleShot(500, this, SLOT(slotDoUpdateAudioScopeFrameRequest()));
-}
-
-void MainWindow::slotDoUpdateAudioScopeFrameRequest()
-{
- bool request = false;
- for (int i = 0; i < m_audioScopesList.count(); i++) {
- if (!m_audioScopesList.at(i)->visibleRegion().isEmpty() && m_audioScopesList.at(i)->autoRefreshEnabled()) {
- kDebug() << "AUDIO SCOPE VISIBLE: " << m_audioScopesList.at(i)->widgetName();
- request = true;
- break;
- }
- }
- // Handle audio signal separately (no common interface)
- if (!m_audiosignal->visibleRegion().isEmpty() && m_audiosignal->monitoringEnabled()) {
- kDebug() << "AUDIO SCOPE VISIBLE: " << "audiosignal";
- request = true;
- }
-#ifdef DEBUG_MAINW
- qDebug() << "Scopes Requesting Audio data: " << request;
-#endif
- KdenliveSettings::setMonitor_audio(request);
- m_monitorManager->slotUpdateAudioMonitoring();
-}
-
-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();
- }
- 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_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)));
-
//static_cast<AbstractScopeWidget *>(m_scopesList.at(i)->widget())->slotMonitorCapture();
+ connect(m_stopmotion, SIGNAL(addOrUpdateSequence(QString)), m_projectList, SLOT(slotAddOrUpdateSequence(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)));
+ //static_cast<AbstractScopeWidget *>(m_scopesList.at(i)->widget())->slotMonitorCapture();
//}
}
m_stopmotion->show();
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();
+ if (d->exec()) {
+ m_messageLabel->setMessage(i18n("Archiving project"), OperationCompletedMessage);
+ }
}
-void MainWindow::slotOpenBackupDialog(const KUrl url)
+void MainWindow::slotOpenBackupDialog(const KUrl &url)
{
KUrl projectFile;
KUrl projectFolder;
projectId = m_activeDocument->getDocumentProperty("documentid");
}
- BackupWidget *dia = new BackupWidget(projectFile, projectFolder, projectId, this);
+ QPointer<BackupWidget> dia = new BackupWidget(projectFile, projectFolder, projectId, this);
if (dia->exec() == QDialog::Accepted) {
QString requestedBackup = dia->selectedFile();
m_activeDocument->backupLastSavedVersion(projectFile.path());
kDebug()<<"-----------------------------------------\n"<<"Time elapsed: "<<m_timer.elapsed()<<"\n-------------------------";
}
+
+void MainWindow::slotDownloadResources()
+{
+ QString currentFolder;
+ if (m_activeDocument) currentFolder = m_activeDocument->projectFolder().path();
+ else currentFolder = KdenliveSettings::defaultprojectfolder();
+ ResourceWidget *d = new ResourceWidget(currentFolder);
+ connect(d, SIGNAL(addClip(KUrl,stringMap)), this, SLOT(slotAddProjectClip(KUrl,stringMap)));
+ d->show();
+}
+
+void MainWindow::slotChangePalette()
+{
+ QPalette plt = QApplication::palette();
+ if (m_effectStack) m_effectStack->updatePalette();
+ if (m_projectList) m_projectList->updatePalette();
+ if (m_effectList) m_effectList->updatePalette();
+
+ if (m_clipMonitor) m_clipMonitor->setPalette(plt);
+ if (m_projectMonitor) m_projectMonitor->setPalette(plt);
+
+ setStatusBarStyleSheet(plt);
+ if (m_activeTimeline) {
+ m_activeTimeline->updatePalette();
+ }
+}
+
+void MainWindow::slotSaveTimelineClip()
+{
+ if (m_activeTimeline && m_projectMonitor->render) {
+ ClipItem *clip = m_activeTimeline->projectView()->getActiveClipUnderCursor(true);
+ if (!clip) {
+ m_messageLabel->setMessage(i18n("Select a clip to save"), InformationMessage);
+ return;
+ }
+ KUrl url = KFileDialog::getSaveUrl(m_activeDocument->projectFolder(), "video/mlt-playlist");
+ if (!url.isEmpty()) m_projectMonitor->render->saveClip(m_activeDocument->tracksCount() - clip->track(), clip->startPos(), url);
+ }
+}
+
+void MainWindow::slotProcessImportKeyframes(GraphicsRectItem type, const QString& data, int maximum)
+{
+ if (type == AVWidget) {
+ // This data should be sent to the effect stack
+ m_effectStack->setKeyframes(data, maximum);
+ }
+ else if (type == TransitionWidget) {
+ // This data should be sent to the transition stack
+ m_transitionConfig->setKeyframes(data, maximum);
+ }
+ else {
+ // Error
+ }
+}
+
+void MainWindow::slotAlignPlayheadToMousePos()
+{
+ m_monitorManager->activateMonitor(Kdenlive::ProjectMonitor);
+ m_activeTimeline->projectView()->slotAlignPlayheadToMousePos();
+}
+
+void MainWindow::slotSetDeinterlacer(int ix)
+{
+ QString value;
+ switch (ix) {
+
+ case 1:
+ value = "linearblend";
+ break;
+ case 2:
+ value = "yadif-nospatial";
+ break;
+ case 3:
+ value = "yadif";
+ break;
+ default:
+ value = "onefield";
+ }
+ KdenliveSettings::setMltdeinterlacer(value);
+ m_monitorManager->setConsumerProperty("deinterlace_method", value);
+}
+
+void MainWindow::slotSetInterpolation(int ix)
+{
+ QString value;
+ switch (ix) {
+ case 1:
+ value = "bilinear";
+ break;
+ case 2:
+ value = "bicubic";
+ break;
+ case 3:
+ value = "hyper";
+ break;
+ default:
+ value = "nearest";
+ }
+ KdenliveSettings::setMltinterpolation(value);
+ m_monitorManager->setConsumerProperty("rescale", value);
+}
+
#include "mainwindow.moc"
#ifdef DEBUG_MAINW
projects / kdenlive / blobdiff