X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmainwindow.cpp;h=7ae740d668e6b0d1578445cdcffba4741de425b4;hb=9cebbfefb3320c9ff001ac3005b6ad33d1e4fcfd;hp=67316c90a5a44fcf6626a89d708b3bc526885c26;hpb=f40783ad873f1b58fdb9dee53f0bb8cf5d5768bf;p=kdenlive

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 67316c90..7ae740d6 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -17,7 +17,7 @@
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
-
+#include <stdlib.h>
 
 #include <QTextStream>
 #include <QTimer>
@@ -49,8 +49,10 @@
 #include <locale.h>
 #include <ktogglefullscreenaction.h>
 #include <KFileItem>
-
-#include <mlt++/Mlt.h>
+#include <KNotification>
+#include <KNotifyConfigWidget>
+#include <knewstuff2/engine.h>
+#include <knewstuff2/ui/knewstuffaction.h>
 
 #include "mainwindow.h"
 #include "kdenlivesettings.h"
@@ -59,7 +61,6 @@
 #include "profilesdialog.h"
 #include "projectsettings.h"
 #include "events.h"
-#include "renderjob.h"
 #include "clipmanager.h"
 #include "projectlist.h"
 #include "monitor.h"
@@ -73,11 +74,17 @@
 #include "transitionsettings.h"
 #include "renderwidget.h"
 #include "renderer.h"
+#ifndef NO_JOGSHUTTLE
 #include "jogshuttle.h"
+#endif /* NO_JOGSHUTTLE */
 #include "clipproperties.h"
 #include "wizard.h"
 #include "editclipcommand.h"
 #include "titlewidget.h"
+#include "markerdialog.h"
+#include "clipitem.h"
+
+#include "interfaces.h"
 
 static const int ID_STATUS_MSG = 1;
 static const int ID_EDITMODE_MSG = 2;
@@ -95,12 +102,16 @@ EffectsList MainWindow::audioEffects;
 EffectsList MainWindow::customEffects;
 EffectsList MainWindow::transitions;
 
-MainWindow::MainWindow(QWidget *parent)
+MainWindow::MainWindow(const QString &MltPath, const KUrl & Url, QWidget *parent)
         : KXmlGuiWindow(parent),
-        m_activeDocument(NULL), m_activeTimeline(NULL), m_renderWidget(NULL), m_jogProcess(NULL), m_findActivated(false), m_initialized(false) {
+        m_activeDocument(NULL), m_activeTimeline(NULL), m_renderWidget(NULL),
+#ifndef NO_JOGSHUTTLE
+        m_jogProcess(NULL),
+#endif /* NO_JOGSHUTTLE */
+        m_findActivated(false), m_initialized(false) {
     setlocale(LC_NUMERIC, "POSIX");
     setFont(KGlobalSettings::toolBarFont());
-    parseProfiles();
+    parseProfiles(MltPath);
     m_commandStack = new QUndoGroup;
     m_timelineArea = new KTabWidget(this);
     m_timelineArea->setTabReorderingEnabled(true);
@@ -118,6 +129,8 @@ MainWindow::MainWindow(QWidget *parent)
     m_findTimer.setSingleShot(true);
 
     initEffects::parseEffectFiles();
+    //initEffects::parseCustomEffectsFile();
+
     m_monitorManager = new MonitorManager();
 
     projectListDock = new QDockWidget(i18n("Project Tree"), this);
@@ -199,33 +212,70 @@ MainWindow::MainWindow(QWidget *parent)
     tabifyDockWidget(clipMonitorDock, recMonitorDock);
     setCentralWidget(m_timelineArea);
 
-    setupGUI(Default, NULL /*"kdenliveui.rc"*/);
-    kDebug() << factory() << " " << factory()->container("video_effects_menu", this);
+    setupGUI();
+    loadPlugins();
+    //kDebug() << factory() << " " << factory()->container("video_effects_menu", this);
+
+    m_projectMonitor->setupMenu(static_cast<QMenu*>(factory()->container("monitor_go", this)), m_playZone, m_loopZone);
+    m_clipMonitor->setupMenu(static_cast<QMenu*>(factory()->container("monitor_go", this)), m_playZone, m_loopZone, static_cast<QMenu*>(factory()->container("marker_menu", this)));
+    m_projectList->setupGeneratorMenu(static_cast<QMenu*>(factory()->container("generators", this)));
 
     // build effects menus
     QAction *action;
     QMenu *videoEffectsMenu = static_cast<QMenu*>(factory()->container("video_effects_menu", this));
-    QStringList effects = videoEffects.effectNames();
-    foreach(const QString &name, effects) {
-        action = new QAction(name, this);
-        action->setData(name);
+
+    QStringList effectInfo;
+    QMap<QString, QStringList> effectsList;
+    for (int ix = 0; ix < videoEffects.count(); ix++) {
+        effectInfo = videoEffects.effectIdInfo(ix);
+        effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
+    }
+
+    foreach(QStringList value, effectsList) {
+        action = new QAction(value.at(0), this);
+        action->setData(value);
         videoEffectsMenu->addAction(action);
     }
+
     QMenu *audioEffectsMenu = static_cast<QMenu*>(factory()->container("audio_effects_menu", this));
-    effects = audioEffects.effectNames();
-    foreach(const QString &name, effects) {
-        action = new QAction(name, this);
-        action->setData(name);
+
+
+    effectsList.clear();
+    for (int ix = 0; ix < audioEffects.count(); ix++) {
+        effectInfo = audioEffects.effectIdInfo(ix);
+        effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
+    }
+
+    foreach(QStringList value, effectsList) {
+        action = new QAction(value.at(0), this);
+        action->setData(value);
         audioEffectsMenu->addAction(action);
     }
+
     m_customEffectsMenu = static_cast<QMenu*>(factory()->container("custom_effects_menu", this));
-    effects = customEffects.effectNames();
-    foreach(const QString &name, effects) {
-        action = new QAction(name, this);
-        action->setData(name);
+
+    if (customEffects.isEmpty()) m_customEffectsMenu->setEnabled(false);
+    else m_customEffectsMenu->setEnabled(true);
+
+    effectsList.clear();
+    for (int ix = 0; ix < customEffects.count(); ix++) {
+        effectInfo = customEffects.effectIdInfo(ix);
+        effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
+    }
+
+    foreach(QStringList value, effectsList) {
+        action = new QAction(value.at(0), this);
+        action->setData(value);
         m_customEffectsMenu->addAction(action);
     }
 
+    QMenu *newEffect = new QMenu(this);
+    newEffect->addMenu(videoEffectsMenu);
+    newEffect->addMenu(audioEffectsMenu);
+    newEffect->addMenu(m_customEffectsMenu);
+    effectStack->setMenu(newEffect);
+
+
     QMenu *viewMenu = static_cast<QMenu*>(factory()->container("dockwindows", this));
     const QList<QAction *> viewActions = createPopupMenu()->actions();
     viewMenu->insertActions(NULL, viewActions);
@@ -240,14 +290,22 @@ MainWindow::MainWindow(QWidget *parent)
 
 
     QMenu *transitionsMenu = new QMenu(i18n("Add Transition"), this);
-    effects = transitions.effectNames();
-    foreach(const QString &name, effects) {
-        action = new QAction(name, this);
-        action->setData(name);
+    QStringList effects = transitions.effectNames();
+
+    effectsList.clear();
+    for (int ix = 0; ix < transitions.count(); ix++) {
+        effectInfo = transitions.effectIdInfo(ix);
+        effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
+    }
+    foreach(QStringList value, effectsList) {
+        action = new QAction(value.at(0), this);
+        action->setData(value);
         transitionsMenu->addAction(action);
     }
     connect(transitionsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddTransition(QAction *)));
 
+    m_timelineContextMenu->addAction(actionCollection()->action("insert_space"));
+    m_timelineContextMenu->addAction(actionCollection()->action("delete_space"));
     m_timelineContextMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Paste)));
 
     m_timelineContextClipMenu->addAction(actionCollection()->action("delete_timeline_clip"));
@@ -261,11 +319,14 @@ MainWindow::MainWindow(QWidget *parent)
     m_timelineContextClipMenu->addMenu(transitionsMenu);
     m_timelineContextClipMenu->addMenu(videoEffectsMenu);
     m_timelineContextClipMenu->addMenu(audioEffectsMenu);
+    //TODO: re-enable custom effects menu when it is implemented
     m_timelineContextClipMenu->addMenu(m_customEffectsMenu);
 
     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(projectMonitorDock, SIGNAL(visibilityChanged(bool)), m_projectMonitor, SLOT(refreshMonitor(bool)));
     connect(clipMonitorDock, SIGNAL(visibilityChanged(bool)), m_clipMonitor, SLOT(refreshMonitor(bool)));
     //connect(m_monitorManager, SIGNAL(connectMonitors()), this, SLOT(slotConnectMonitors()));
@@ -276,23 +337,23 @@ MainWindow::MainWindow(QWidget *parent)
     m_monitorManager->initMonitors(m_clipMonitor, m_projectMonitor);
     slotConnectMonitors();
 
-    setAutoSaveSettings();
-
-    if (KdenliveSettings::openlastproject()) {
-        openLastFile();
+    // 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()) {
+        openFile(Url);
     } else {
-        /*QList<KAutoSaveFile *> staleFiles = KAutoSaveFile::allStaleFiles();
-        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);
-            }
-            else newFile();
+        if (KdenliveSettings::openlastproject()) {
+            openLastFile();
         }
-        else*/
-        newFile();
+    }
+    if (m_timelineArea->count() == 0) {
+        newFile(false);
     }
 
+#ifndef NO_JOGSHUTTLE
     activateShuttleDevice();
+#endif /* NO_JOGSHUTTLE */
     projectListDock->raise();
 }
 
@@ -304,12 +365,12 @@ void MainWindow::queryQuit() {
 //virtual
 bool MainWindow::queryClose() {
     saveOptions();
+    if (m_monitorManager) m_monitorManager->stopActiveMonitor();
     if (m_activeDocument && m_activeDocument->isModified()) {
         switch (KMessageBox::warningYesNoCancel(this, i18n("Save changes to document ?"))) {
         case KMessageBox::Yes :
             // save document here. If saving fails, return false;
-            saveFile();
-            return true;
+            return saveFile();
         case KMessageBox::No :
             return true;
         default: // cancel
@@ -319,6 +380,73 @@ bool MainWindow::queryClose() {
     return true;
 }
 
+
+void MainWindow::loadPlugins() {
+    foreach(QObject *plugin, QPluginLoader::staticInstances())
+    populateMenus(plugin);
+
+    QStringList directories = KGlobal::dirs()->findDirs("module", QString());
+    QStringList filters;
+    filters << "libkdenlive*";
+    foreach(const QString &folder, directories) {
+        kDebug() << "// PARSING FIOLER: " << folder;
+        QDir pluginsDir(folder);
+        foreach(QString fileName, pluginsDir.entryList(filters, QDir::Files)) {
+            kDebug() << "// FOUND PLUGIN: " << fileName << "= " << pluginsDir.absoluteFilePath(fileName);
+            QPluginLoader loader(pluginsDir.absoluteFilePath(fileName));
+            QObject *plugin = loader.instance();
+            if (plugin) {
+                populateMenus(plugin);
+                m_pluginFileNames += fileName;
+            } else kDebug() << "// ERROR LOADING PLUGIN: " << fileName << ", " << loader.errorString();
+        }
+    }
+    //exit(1);
+}
+
+void MainWindow::populateMenus(QObject *plugin) {
+    kDebug() << "// POP MENU";
+    QMenu *addMenu = static_cast<QMenu*>(factory()->container("generators", this));
+    ClipGenerator *iGenerator = qobject_cast<ClipGenerator *>(plugin);
+    kDebug() << "// POP MENU 2";
+    if (addMenu) kDebug() << "// POP MENU 3";
+    if (iGenerator)
+        addToMenu(plugin, iGenerator->generators(), addMenu, SLOT(generateClip()),
+                  NULL);
+}
+
+void MainWindow::addToMenu(QObject *plugin, const QStringList &texts,
+                           QMenu *menu, const char *member,
+                           QActionGroup *actionGroup) {
+    kDebug() << "// ADD to MENU" << texts;
+    foreach(QString text, texts) {
+        QAction *action = new QAction(text, plugin);
+        connect(action, SIGNAL(triggered()), this, member);
+        menu->addAction(action);
+
+        if (actionGroup) {
+            action->setCheckable(true);
+            actionGroup->addAction(action);
+        }
+    }
+}
+
+void MainWindow::aboutPlugins() {
+    //PluginDialog dialog(pluginsDir.path(), m_pluginFileNames, this);
+    //dialog.exec();
+}
+
+
+void MainWindow::generateClip() {
+    QAction *action = qobject_cast<QAction *>(sender());
+    ClipGenerator *iGenerator = qobject_cast<ClipGenerator *>(action->parent());
+
+    KUrl clipUrl = iGenerator->generatedClip(action->text(), m_activeDocument->projectFolder(), QStringList(), QStringList(), 25, 720, 576);
+    if (!clipUrl.isEmpty()) {
+        m_projectList->slotAddClip(clipUrl);
+    }
+}
+
 void MainWindow::saveProperties(KConfig*) {
     // save properties here,used by session management
     saveFile();
@@ -336,6 +464,9 @@ void MainWindow::slotReloadEffects() {
     m_customEffectsMenu->clear();
     const QStringList effects = customEffects.effectNames();
     QAction *action;
+    if (effects.isEmpty()) m_customEffectsMenu->setEnabled(false);
+    else m_customEffectsMenu->setEnabled(true);
+
     foreach(const QString &name, effects) {
         action = new QAction(name, this);
         action->setData(name);
@@ -344,6 +475,7 @@ void MainWindow::slotReloadEffects() {
     m_effectList->reloadEffectList();
 }
 
+#ifndef NO_JOGSHUTTLE
 void MainWindow::activateShuttleDevice() {
     if (m_jogProcess) delete m_jogProcess;
     m_jogProcess = NULL;
@@ -389,9 +521,14 @@ void MainWindow::slotShuttleAction(int code) {
         break;
     }
 }
+#endif /* NO_JOGSHUTTLE */
+
+void MainWindow::configureNotifications() {
+    KNotifyConfigWidget::configure(this);
+}
 
 void MainWindow::slotFullScreen() {
-    //KToggleFullScreenAction::setFullScreen(this, actionCollection()->action("fullscreen")->isChecked());
+    KToggleFullScreenAction::setFullScreen(this, actionCollection()->action("fullscreen")->isChecked());
 }
 
 void MainWindow::slotAddEffect(QDomElement effect, GenTime pos, int track) {
@@ -401,7 +538,7 @@ void MainWindow::slotAddEffect(QDomElement effect, GenTime pos, int track) {
         return;
     }
     TrackView *currentTimeLine = (TrackView *) m_timelineArea->currentWidget();
-    currentTimeLine->projectView()->slotAddEffect(effect, pos, track);
+    currentTimeLine->projectView()->slotAddEffect(effect.cloneNode().toElement(), pos, track);
 }
 
 void MainWindow::slotRaiseMonitor(bool clipMonitor) {
@@ -416,14 +553,14 @@ void MainWindow::slotSetClipDuration(const QString &id, int duration) {
 
 void MainWindow::slotConnectMonitors() {
 
-    m_projectList->setRenderer(m_clipMonitor->render);
+    m_projectList->setRenderer(m_projectMonitor->render);
     connect(m_projectList, SIGNAL(receivedClipDuration(const QString &, int)), this, SLOT(slotSetClipDuration(const QString &, int)));
     connect(m_projectList, SIGNAL(showClipProperties(DocClipBase *)), this, SLOT(slotShowClipProperties(DocClipBase *)));
-    connect(m_projectList, SIGNAL(getFileProperties(const QDomElement &, const QString &)), m_clipMonitor->render, SLOT(getFileProperties(const QDomElement &, const QString &)));
-    connect(m_clipMonitor->render, SIGNAL(replyGetImage(const QString &, int, const QPixmap &, int, int)), m_projectList, SLOT(slotReplyGetImage(const QString &, int, const QPixmap &, int, int)));
-    connect(m_clipMonitor->render, SIGNAL(replyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &)), m_projectList, SLOT(slotReplyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &)));
+    connect(m_projectList, SIGNAL(getFileProperties(const QDomElement &, const QString &)), m_projectMonitor->render, SLOT(getFileProperties(const QDomElement &, const QString &)));
+    connect(m_projectMonitor->render, SIGNAL(replyGetImage(const QString &, int, const QPixmap &, int, int)), m_projectList, SLOT(slotReplyGetImage(const QString &, int, const QPixmap &, int, int)));
+    connect(m_projectMonitor->render, SIGNAL(replyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &)), m_projectList, SLOT(slotReplyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &)));
 
-    connect(m_clipMonitor->render, SIGNAL(removeInvalidClip(const QString &)), m_projectList, SLOT(slotRemoveInvalidClip(const QString &)));
+    connect(m_projectMonitor->render, SIGNAL(removeInvalidClip(const QString &)), m_projectList, SLOT(slotRemoveInvalidClip(const QString &)));
 
     connect(m_clipMonitor, SIGNAL(refreshClipThumbnail(const QString &)), m_projectList, SLOT(slotRefreshClipThumbnail(const QString &)));
 
@@ -448,6 +585,7 @@ void MainWindow::slotAdjustProjectMonitor() {
 
 void MainWindow::setupActions() {
 
+    KActionCollection* collection = actionCollection();
     m_timecodeFormat = new KComboBox(this);
     m_timecodeFormat->addItem(i18n("hh:mm:ss::ff"));
     m_timecodeFormat->addItem(i18n("Frames"));
@@ -470,16 +608,24 @@ void MainWindow::setupActions() {
 
     QString style1 = "QToolButton {background-color: rgba(230, 230, 230, 220); border-style: inset; border:1px solid #999999;border-radius: 3px;margin: 0px 3px;padding: 0px;} QToolButton:checked { background-color: rgba(224, 224, 0, 100); border-style: inset; border:1px solid #cc6666;border-radius: 3px;}";
 
-    m_buttonSelectTool = toolbar->addAction(KIcon("kdenlive-select-tool"), i18n("Selection tool"));
+    m_buttonSelectTool = new KAction(KIcon("kdenlive-select-tool"), i18n("Selection tool"), this);
+    toolbar->addAction(m_buttonSelectTool);
     m_buttonSelectTool->setCheckable(true);
     m_buttonSelectTool->setChecked(true);
 
-    m_buttonRazorTool = toolbar->addAction(KIcon("edit-cut"), i18n("Razor tool"));
+    m_buttonRazorTool = new KAction(KIcon("edit-cut"), i18n("Razor tool"), this);
+    toolbar->addAction(m_buttonRazorTool);
     m_buttonRazorTool->setCheckable(true);
     m_buttonRazorTool->setChecked(false);
 
+    m_buttonSpacerTool = new KAction(KIcon("kdenlive-spacer-tool"), i18n("Spacer tool"), this);
+    toolbar->addAction(m_buttonSpacerTool);
+    m_buttonSpacerTool->setCheckable(true);
+    m_buttonSpacerTool->setChecked(false);
+
     m_toolGroup->addAction(m_buttonSelectTool);
     m_toolGroup->addAction(m_buttonRazorTool);
+    m_toolGroup->addAction(m_buttonSpacerTool);
     m_toolGroup->setExclusive(true);
     toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
 
@@ -492,11 +638,16 @@ void MainWindow::setupActions() {
     actionWidget->setMaximumWidth(24);
     actionWidget->setMinimumHeight(17);
 
+    actionWidget = toolbar->widgetForAction(m_buttonSpacerTool);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
     toolbar->setStyleSheet(style1);
     connect(m_toolGroup, SIGNAL(triggered(QAction *)), this, SLOT(slotChangeTool(QAction *)));
 
     toolbar->addSeparator();
-    m_buttonFitZoom = toolbar->addAction(KIcon("zoom-fit-best"), i18n("Fit zoom to project"));
+    m_buttonFitZoom = new KAction(KIcon("zoom-fit-best"), i18n("Fit zoom to project"), this);
+    toolbar->addAction(m_buttonFitZoom);
     m_buttonFitZoom->setCheckable(false);
     connect(m_buttonFitZoom, SIGNAL(triggered()), this, SLOT(slotFitZoom()));
 
@@ -512,33 +663,38 @@ void MainWindow::setupActions() {
     m_zoomSlider->setMinimumWidth(100);
 
     const int contentHeight = QFontMetrics(w->font()).height() + 8;
+
     QString style = "QSlider::groove:horizontal { background-color: rgba(230, 230, 230, 220);border: 1px solid #999999;height: 8px;border-radius: 3px;margin-top:3px }";
     style.append("QSlider::handle:horizontal {  background-color: white; border: 1px solid #999999;width: 9px;margin: -2px 0;border-radius: 3px; }");
+
     m_zoomSlider->setStyleSheet(style);
 
-    //m_zoomSlider->setMaximumHeight(contentHeight);
     //m_zoomSlider->height() + 5;
     statusBar()->setMinimumHeight(contentHeight);
 
 
     toolbar->addWidget(m_zoomSlider);
 
-    m_buttonVideoThumbs = toolbar->addAction(KIcon("kdenlive-show-videothumb"), i18n("Show video thumbnails"));
+    m_buttonVideoThumbs = new KAction(KIcon("kdenlive-show-videothumb"), i18n("Show video thumbnails"), this);
+    toolbar->addAction(m_buttonVideoThumbs);
     m_buttonVideoThumbs->setCheckable(true);
     m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
     connect(m_buttonVideoThumbs, SIGNAL(triggered()), this, SLOT(slotSwitchVideoThumbs()));
 
-    m_buttonAudioThumbs = toolbar->addAction(KIcon("kdenlive-show-audiothumb"), i18n("Show audio thumbnails"));
+    m_buttonAudioThumbs = new KAction(KIcon("kdenlive-show-audiothumb"), i18n("Show audio thumbnails"), this);
+    toolbar->addAction(m_buttonAudioThumbs);
     m_buttonAudioThumbs->setCheckable(true);
     m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
     connect(m_buttonAudioThumbs, SIGNAL(triggered()), this, SLOT(slotSwitchAudioThumbs()));
 
-    m_buttonShowMarkers = toolbar->addAction(KIcon("kdenlive-show-markers"), i18n("Show markers comments"));
+    m_buttonShowMarkers = new KAction(KIcon("kdenlive-show-markers"), i18n("Show markers comments"), this);
+    toolbar->addAction(m_buttonShowMarkers);
     m_buttonShowMarkers->setCheckable(true);
     m_buttonShowMarkers->setChecked(KdenliveSettings::showmarkers());
     connect(m_buttonShowMarkers, SIGNAL(triggered()), this, SLOT(slotSwitchMarkersComments()));
 
-    m_buttonSnap = toolbar->addAction(KIcon("kdenlive-snap"), i18n("Snap"));
+    m_buttonSnap = new KAction(KIcon("kdenlive-snap"), i18n("Snap"), this);
+    toolbar->addAction(m_buttonSnap);
     m_buttonSnap->setCheckable(true);
     m_buttonSnap->setChecked(KdenliveSettings::snaptopoints());
     connect(m_buttonSnap, SIGNAL(triggered()), this, SLOT(slotSwitchSnap()));
@@ -572,36 +728,54 @@ void MainWindow::setupActions() {
     statusBar()->setMaximumHeight(statusBar()->font().pointSize() * 4);
     m_messageLabel->hide();
 
-    actionCollection()->addAction("select_tool", m_buttonSelectTool);
-    actionCollection()->addAction("razor_tool", m_buttonRazorTool);
+    collection->addAction("select_tool", m_buttonSelectTool);
+    collection->addAction("razor_tool", m_buttonRazorTool);
+    collection->addAction("spacer_tool", m_buttonSpacerTool);
+
+    collection->addAction("show_video_thumbs", m_buttonVideoThumbs);
+    collection->addAction("show_audio_thumbs", m_buttonAudioThumbs);
+    collection->addAction("show_markers", m_buttonShowMarkers);
+    collection->addAction("snap", m_buttonSnap);
+    collection->addAction("zoom_fit", m_buttonFitZoom);
+
+    KAction* zoomIn = new KAction(KIcon("zoom-in"), i18n("Zoom In"), this);
+    collection->addAction("zoom_in", zoomIn);
+    connect(zoomIn, SIGNAL(triggered(bool)), this, SLOT(slotZoomIn()));
+    zoomIn->setShortcut(Qt::CTRL + Qt::Key_Plus);
 
-    actionCollection()->addAction("show_video_thumbs", m_buttonVideoThumbs);
-    actionCollection()->addAction("show_audio_thumbs", m_buttonAudioThumbs);
-    actionCollection()->addAction("show_markers", m_buttonShowMarkers);
-    actionCollection()->addAction("snap", m_buttonSnap);
-    actionCollection()->addAction("zoom_fit", m_buttonFitZoom);
+    KAction* zoomOut = new KAction(KIcon("zoom-out"), i18n("Zoom Out"), this);
+    collection->addAction("zoom_out", zoomOut);
+    connect(zoomOut, SIGNAL(triggered(bool)), this, SLOT(slotZoomOut()));
+    zoomOut->setShortcut(Qt::CTRL + Qt::Key_Minus);
 
     m_projectSearch = new KAction(KIcon("edit-find"), i18n("Find"), this);
-    actionCollection()->addAction("project_find", m_projectSearch);
+    collection->addAction("project_find", m_projectSearch);
     connect(m_projectSearch, SIGNAL(triggered(bool)), this, SLOT(slotFind()));
     m_projectSearch->setShortcut(Qt::Key_Slash);
 
     m_projectSearchNext = new KAction(KIcon("go-down-search"), i18n("Find Next"), this);
-    actionCollection()->addAction("project_find_next", m_projectSearchNext);
+    collection->addAction("project_find_next", m_projectSearchNext);
     connect(m_projectSearchNext, SIGNAL(triggered(bool)), this, SLOT(slotFindNext()));
     m_projectSearchNext->setShortcut(Qt::Key_F3);
     m_projectSearchNext->setEnabled(false);
 
     KAction* profilesAction = new KAction(KIcon("document-new"), i18n("Manage Profiles"), this);
-    actionCollection()->addAction("manage_profiles", profilesAction);
+    collection->addAction("manage_profiles", profilesAction);
     connect(profilesAction, SIGNAL(triggered(bool)), this, SLOT(slotEditProfiles()));
 
+    KAction* fileGHNS = KNS::standardAction(i18n("Download New Lumas..."), this, SLOT(slotGetNewStuff()), actionCollection(), "get_new_stuff");
+
+    KAction* wizAction = new KAction(KIcon("configure"), i18n("Run Config Wizard"), this);
+    collection->addAction("run_wizard", wizAction);
+    connect(wizAction, SIGNAL(triggered(bool)), this, SLOT(slotRunWizard()));
+
     KAction* projectAction = new KAction(KIcon("configure"), i18n("Project Settings"), this);
-    actionCollection()->addAction("project_settings", projectAction);
+    collection->addAction("project_settings", projectAction);
     connect(projectAction, SIGNAL(triggered(bool)), this, SLOT(slotEditProjectSettings()));
 
     KAction* projectRender = new KAction(KIcon("media-record"), i18n("Render"), this);
-    actionCollection()->addAction("project_render", projectRender);
+    collection->addAction("project_render", projectRender);
+    projectRender->setShortcut(Qt::CTRL + Qt::Key_Return);
     connect(projectRender, SIGNAL(triggered(bool)), this, SLOT(slotRenderProject()));
 
     KAction* monitorPlay = new KAction(KIcon("media-playback-start"), i18n("Play"), this);
@@ -609,158 +783,229 @@ void MainWindow::setupActions() {
     playShortcut.setPrimary(Qt::Key_Space);
     playShortcut.setAlternate(Qt::Key_K);
     monitorPlay->setShortcut(playShortcut);
-    actionCollection()->addAction("monitor_play", monitorPlay);
+    collection->addAction("monitor_play", monitorPlay);
     connect(monitorPlay, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotPlay()));
 
-    KAction *markIn = actionCollection()->addAction("mark_in");
-    markIn->setText(i18n("Set in point"));
+    m_playZone = new KAction(KIcon("media-playback-start"), i18n("Play Zone"), this);
+    m_playZone->setShortcut(Qt::CTRL + Qt::Key_Space);
+    collection->addAction("monitor_play_zone", m_playZone);
+    connect(m_playZone, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotPlayZone()));
+
+    m_loopZone = new KAction(KIcon("media-playback-start"), i18n("Loop Zone"), this);
+    m_loopZone->setShortcut(Qt::ALT + Qt::Key_Space);
+    collection->addAction("monitor_loop_zone", m_loopZone);
+    connect(m_loopZone, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotLoopZone()));
+
+    KAction *markIn = collection->addAction("mark_in");
+    markIn->setText(i18n("Set In Point"));
     markIn->setShortcut(Qt::Key_I);
     connect(markIn, SIGNAL(triggered(bool)), this, SLOT(slotSetInPoint()));
 
-    KAction *markOut = actionCollection()->addAction("mark_out");
-    markOut->setText(i18n("Set in point"));
+    KAction *markOut = collection->addAction("mark_out");
+    markOut->setText(i18n("Set Out Point"));
     markOut->setShortcut(Qt::Key_O);
     connect(markOut, SIGNAL(triggered(bool)), this, SLOT(slotSetOutPoint()));
 
     KAction* monitorSeekBackward = new KAction(KIcon("media-seek-backward"), i18n("Rewind"), this);
     monitorSeekBackward->setShortcut(Qt::Key_J);
-    actionCollection()->addAction("monitor_seek_backward", monitorSeekBackward);
+    collection->addAction("monitor_seek_backward", monitorSeekBackward);
     connect(monitorSeekBackward, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotRewind()));
 
     KAction* monitorSeekBackwardOneFrame = new KAction(KIcon("media-skip-backward"), i18n("Rewind 1 Frame"), this);
     monitorSeekBackwardOneFrame->setShortcut(Qt::Key_Left);
-    actionCollection()->addAction("monitor_seek_backward-one-frame", monitorSeekBackwardOneFrame);
+    collection->addAction("monitor_seek_backward-one-frame", monitorSeekBackwardOneFrame);
     connect(monitorSeekBackwardOneFrame, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotRewindOneFrame()));
 
+    KAction* monitorSeekBackwardOneSecond = new KAction(KIcon("media-skip-backward"), i18n("Rewind 1 Second"), this);
+    monitorSeekBackwardOneSecond->setShortcut(Qt::SHIFT + Qt::Key_Left);
+    collection->addAction("monitor_seek_backward-one-second", monitorSeekBackwardOneSecond);
+    connect(monitorSeekBackwardOneSecond, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotRewindOneSecond()));
+
     KAction* monitorSeekSnapBackward = new KAction(KIcon("media-seek-backward"), i18n("Go to Previous Snap Point"), this);
     monitorSeekSnapBackward->setShortcut(Qt::ALT + Qt::Key_Left);
-    actionCollection()->addAction("monitor_seek_snap_backward", monitorSeekSnapBackward);
+    collection->addAction("monitor_seek_snap_backward", monitorSeekSnapBackward);
     connect(monitorSeekSnapBackward, SIGNAL(triggered(bool)), this, SLOT(slotSnapRewind()));
 
     KAction* monitorSeekForward = new KAction(KIcon("media-seek-forward"), i18n("Forward"), this);
     monitorSeekForward->setShortcut(Qt::Key_L);
-    actionCollection()->addAction("monitor_seek_forward", monitorSeekForward);
+    collection->addAction("monitor_seek_forward", monitorSeekForward);
     connect(monitorSeekForward, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotForward()));
 
     KAction* clipStart = new KAction(KIcon("media-seek-backward"), i18n("Go to Clip Start"), this);
     clipStart->setShortcut(Qt::Key_Home);
-    actionCollection()->addAction("seek_clip_start", clipStart);
+    collection->addAction("seek_clip_start", clipStart);
     connect(clipStart, SIGNAL(triggered(bool)), this, SLOT(slotClipStart()));
 
     KAction* clipEnd = new KAction(KIcon("media-seek-forward"), i18n("Go to Clip End"), this);
     clipEnd->setShortcut(Qt::Key_End);
-    actionCollection()->addAction("seek_clip_end", clipEnd);
+    collection->addAction("seek_clip_end", clipEnd);
     connect(clipEnd, SIGNAL(triggered(bool)), this, SLOT(slotClipEnd()));
 
-    KAction* projectStart = new KAction(KIcon("media-seek-backward"), i18n("Go to Project Start"), this);
+    KAction* projectStart = new KAction(KIcon("go-first"), i18n("Go to Project Start"), this);
     projectStart->setShortcut(Qt::CTRL + Qt::Key_Home);
-    actionCollection()->addAction("seek_start", projectStart);
+    collection->addAction("seek_start", projectStart);
     connect(projectStart, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotStart()));
 
-    KAction* projectEnd = new KAction(KIcon("media-seek-forward"), i18n("Go to Project End"), this);
+    KAction* projectEnd = new KAction(KIcon("go-last"), i18n("Go to Project End"), this);
     projectEnd->setShortcut(Qt::CTRL + Qt::Key_End);
-    actionCollection()->addAction("seek_end", projectEnd);
+    collection->addAction("seek_end", projectEnd);
     connect(projectEnd, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotEnd()));
 
     KAction* monitorSeekForwardOneFrame = new KAction(KIcon("media-skip-forward"), i18n("Forward 1 Frame"), this);
     monitorSeekForwardOneFrame->setShortcut(Qt::Key_Right);
-    actionCollection()->addAction("monitor_seek_forward-one-frame", monitorSeekForwardOneFrame);
+    collection->addAction("monitor_seek_forward-one-frame", monitorSeekForwardOneFrame);
     connect(monitorSeekForwardOneFrame, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotForwardOneFrame()));
 
+    KAction* monitorSeekForwardOneSecond = new KAction(KIcon("media-skip-forward"), i18n("Forward 1 Second"), this);
+    monitorSeekForwardOneSecond->setShortcut(Qt::SHIFT + Qt::Key_Right);
+    collection->addAction("monitor_seek_forward-one-second", monitorSeekForwardOneSecond);
+    connect(monitorSeekForwardOneSecond, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotForwardOneSecond()));
+
     KAction* monitorSeekSnapForward = new KAction(KIcon("media-seek-forward"), i18n("Go to Next Snap Point"), this);
     monitorSeekSnapForward->setShortcut(Qt::ALT + Qt::Key_Right);
-    actionCollection()->addAction("monitor_seek_snap_forward", monitorSeekSnapForward);
+    collection->addAction("monitor_seek_snap_forward", monitorSeekSnapForward);
     connect(monitorSeekSnapForward, SIGNAL(triggered(bool)), this, SLOT(slotSnapForward()));
 
     KAction* deleteTimelineClip = new KAction(KIcon("edit-delete"), i18n("Delete Selected Item"), this);
     deleteTimelineClip->setShortcut(Qt::Key_Delete);
-    actionCollection()->addAction("delete_timeline_clip", deleteTimelineClip);
+    collection->addAction("delete_timeline_clip", deleteTimelineClip);
     connect(deleteTimelineClip, SIGNAL(triggered(bool)), this, SLOT(slotDeleteTimelineClip()));
 
-    KAction* editTimelineClipSpeed = new KAction(KIcon("edit-delete"), i18n("Change Clip Speed"), this);
-    actionCollection()->addAction("change_clip_speed", editTimelineClipSpeed);
+    KAction* editTimelineClipSpeed = new KAction(i18n("Change Clip Speed"), this);
+    collection->addAction("change_clip_speed", editTimelineClipSpeed);
     connect(editTimelineClipSpeed, SIGNAL(triggered(bool)), this, SLOT(slotChangeClipSpeed()));
 
+    KAction *stickTransition = collection->addAction("auto_transition");
+    stickTransition->setData(QString("auto"));
+    stickTransition->setCheckable(true);
+    stickTransition->setEnabled(false);
+    stickTransition->setText(i18n("Automatic Transition"));
+    connect(stickTransition, SIGNAL(triggered(bool)), this, SLOT(slotAutoTransition()));
+
     KAction* cutTimelineClip = new KAction(KIcon("edit-cut"), i18n("Cut Clip"), this);
     cutTimelineClip->setShortcut(Qt::SHIFT + Qt::Key_R);
-    actionCollection()->addAction("cut_timeline_clip", cutTimelineClip);
+    collection->addAction("cut_timeline_clip", cutTimelineClip);
     connect(cutTimelineClip, SIGNAL(triggered(bool)), this, SLOT(slotCutTimelineClip()));
 
-    KAction* addClipMarker = new KAction(KIcon("bookmark-new"), i18n("Add Marker to Clip"), this);
-    actionCollection()->addAction("add_clip_marker", addClipMarker);
+    KAction* addClipMarker = new KAction(KIcon("bookmark-new"), i18n("Add Marker"), this);
+    collection->addAction("add_clip_marker", addClipMarker);
     connect(addClipMarker, SIGNAL(triggered(bool)), this, SLOT(slotAddClipMarker()));
 
-    KAction* deleteClipMarker = new KAction(KIcon("edit-delete"), i18n("Delete Marker from Clip"), this);
-    actionCollection()->addAction("delete_clip_marker", deleteClipMarker);
+    KAction* deleteClipMarker = new KAction(KIcon("edit-delete"), i18n("Delete Marker"), this);
+    collection->addAction("delete_clip_marker", deleteClipMarker);
     connect(deleteClipMarker, SIGNAL(triggered(bool)), this, SLOT(slotDeleteClipMarker()));
 
-    KAction* deleteAllClipMarkers = new KAction(KIcon("edit-delete"), i18n("Delete All Markers from Clip"), this);
-    actionCollection()->addAction("delete_all_clip_markers", deleteAllClipMarkers);
+    KAction* deleteAllClipMarkers = new KAction(KIcon("edit-delete"), i18n("Delete All Markers"), this);
+    collection->addAction("delete_all_clip_markers", deleteAllClipMarkers);
     connect(deleteAllClipMarkers, SIGNAL(triggered(bool)), this, SLOT(slotDeleteAllClipMarkers()));
 
     KAction* editClipMarker = new KAction(KIcon("document-properties"), i18n("Edit Marker"), this);
-    actionCollection()->addAction("edit_clip_marker", editClipMarker);
+    collection->addAction("edit_clip_marker", editClipMarker);
     connect(editClipMarker, SIGNAL(triggered(bool)), this, SLOT(slotEditClipMarker()));
 
+    KAction *insertSpace = new KAction(KIcon(), i18n("Insert Space"), this);
+    collection->addAction("insert_space", insertSpace);
+    connect(insertSpace, SIGNAL(triggered()), this, SLOT(slotInsertSpace()));
+
+    KAction *removeSpace = new KAction(KIcon(), i18n("Remove 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);
+    connect(insertTrack, SIGNAL(triggered()), this, SLOT(slotInsertTrack()));
+
+    KAction *deleteTrack = new KAction(KIcon(), i18n("Delete Track"), this);
+    collection->addAction("delete_track", deleteTrack);
+    connect(deleteTrack, SIGNAL(triggered()), this, SLOT(slotDeleteTrack()));
+
+    KAction *changeTrack = new KAction(KIcon(), i18n("Change Track"), this);
+    collection->addAction("change_track", changeTrack);
+    connect(changeTrack, SIGNAL(triggered()), this, SLOT(slotChangeTrack()));
+
     KAction *addGuide = new KAction(KIcon("document-new"), i18n("Add Guide"), this);
-    actionCollection()->addAction("add_guide", addGuide);
+    collection->addAction("add_guide", addGuide);
     connect(addGuide, SIGNAL(triggered()), this, SLOT(slotAddGuide()));
 
     QAction *delGuide = new KAction(KIcon("edit-delete"), i18n("Delete Guide"), this);
-    actionCollection()->addAction("delete_guide", delGuide);
+    collection->addAction("delete_guide", delGuide);
     connect(delGuide, SIGNAL(triggered()), this, SLOT(slotDeleteGuide()));
 
     QAction *editGuide = new KAction(KIcon("document-properties"), i18n("Edit Guide"), this);
-    actionCollection()->addAction("edit_guide", editGuide);
+    collection->addAction("edit_guide", editGuide);
     connect(editGuide, SIGNAL(triggered()), this, SLOT(slotEditGuide()));
 
     QAction *delAllGuides = new KAction(KIcon("edit-delete"), i18n("Delete All Guides"), this);
-    actionCollection()->addAction("delete_all_guides", delAllGuides);
+    collection->addAction("delete_all_guides", delAllGuides);
     connect(delAllGuides, SIGNAL(triggered()), this, SLOT(slotDeleteAllGuides()));
 
     QAction *pasteEffects = new KAction(KIcon("edit-paste"), i18n("Paste Effects"), this);
-    actionCollection()->addAction("paste_effects", pasteEffects);
+    collection->addAction("paste_effects", pasteEffects);
     connect(pasteEffects , SIGNAL(triggered()), this, SLOT(slotPasteEffects()));
 
-    KStandardAction::quit(this, SLOT(queryQuit()),
-                          actionCollection());
+    m_closeAction = KStandardAction::close(this, SLOT(closeCurrentDocument()), collection);
+
+    KStandardAction::quit(this, SLOT(queryQuit()), collection);
 
-    KStandardAction::open(this, SLOT(openFile()),
-                          actionCollection());
+    KStandardAction::open(this, SLOT(openFile()), collection);
 
-    m_saveAction = KStandardAction::save(this, SLOT(saveFile()),
-                                         actionCollection());
+    m_saveAction = KStandardAction::save(this, SLOT(saveFile()), collection);
 
-    KStandardAction::saveAs(this, SLOT(saveFileAs()),
-                            actionCollection());
+    KStandardAction::saveAs(this, SLOT(saveFileAs()), collection);
 
-    KStandardAction::openNew(this, SLOT(newFile()),
-                             actionCollection());
+    KStandardAction::openNew(this, SLOT(newFile()), collection);
 
-    KStandardAction::preferences(this, SLOT(slotPreferences()),
-                                 actionCollection());
+    KStandardAction::preferences(this, SLOT(slotPreferences()), collection);
 
-    KStandardAction::copy(this, SLOT(slotCopy()),
-                          actionCollection());
+    KStandardAction::configureNotifications(this , SLOT(configureNotifications()), collection);
 
-    KStandardAction::paste(this, SLOT(slotPaste()),
-                           actionCollection());
+    KStandardAction::copy(this, SLOT(slotCopy()), collection);
 
-    KAction *undo = KStandardAction::undo(m_commandStack, SLOT(undo()),
-                                          actionCollection());
+    KStandardAction::paste(this, SLOT(slotPaste()), collection);
+
+    KAction *undo = KStandardAction::undo(m_commandStack, SLOT(undo()), collection);
     undo->setEnabled(false);
     connect(m_commandStack, SIGNAL(canUndoChanged(bool)), undo, SLOT(setEnabled(bool)));
 
-    KAction *redo = KStandardAction::redo(m_commandStack, SLOT(redo()),
-                                          actionCollection());
+    KAction *redo = KStandardAction::redo(m_commandStack, SLOT(redo()), collection);
     redo->setEnabled(false);
     connect(m_commandStack, SIGNAL(canRedoChanged(bool)), redo, SLOT(setEnabled(bool)));
 
-    KStandardAction::fullScreen(this, SLOT(slotFullScreen()), this, actionCollection());
+    KStandardAction::fullScreen(this, SLOT(slotFullScreen()), this, collection);
 
-    connect(actionCollection(), SIGNAL(actionHovered(QAction*)),
+    connect(collection, SIGNAL(actionHovered(QAction*)),
             this, SLOT(slotDisplayActionMessage(QAction*)));
-    //connect(actionCollection(), SIGNAL( clearStatusText() ),
+
+
+    QAction *addClip = new KAction(KIcon("kdenlive-add-clip"), i18n("Add Clip"), this);
+    collection->addAction("add_clip", addClip);
+    connect(addClip , SIGNAL(triggered()), m_projectList, SLOT(slotAddClip()));
+
+    QAction *addColorClip = new KAction(KIcon("kdenlive-add-color-clip"), i18n("Add Color Clip"), this);
+    collection->addAction("add_color_clip", addColorClip);
+    connect(addColorClip , SIGNAL(triggered()), m_projectList, SLOT(slotAddColorClip()));
+
+    QAction *addSlideClip = new KAction(KIcon("kdenlive-add-slide-clip"), i18n("Add Slideshow Clip"), this);
+    collection->addAction("add_slide_clip", addSlideClip);
+    connect(addSlideClip , SIGNAL(triggered()), m_projectList, SLOT(slotAddSlideshowClip()));
+
+    QAction *addTitleClip = new KAction(KIcon("kdenlive-add-text-clip"), i18n("Add Title Clip"), this);
+    collection->addAction("add_text_clip", addTitleClip);
+    connect(addTitleClip , SIGNAL(triggered()), m_projectList, SLOT(slotAddTitleClip()));
+
+    QAction *addFolderButton = new KAction(KIcon("folder-new"), i18n("Create Folder"), this);
+    collection->addAction("add_folder", addFolderButton);
+    connect(addFolderButton , SIGNAL(triggered()), m_projectList, SLOT(slotAddFolder()));
+
+    QMenu *addClips = new QMenu();
+    addClips->addAction(addClip);
+    addClips->addAction(addColorClip);
+    addClips->addAction(addSlideClip);
+    addClips->addAction(addTitleClip);
+    addClips->addAction(addFolderButton);
+    m_projectList->setupMenu(addClips, addClip);
+
+    //connect(collection, SIGNAL( clearStatusText() ),
     //statusBar(), SLOT( clear() ) );
 }
 
@@ -772,6 +1017,8 @@ void MainWindow::saveOptions() {
     KdenliveSettings::self()->writeConfig();
     KSharedConfigPtr config = KGlobal::config();
     m_fileOpenRecent->saveEntries(KConfigGroup(config, "Recent Files"));
+    KConfigGroup treecolumns(config, "Project Tree");
+    treecolumns.writeEntry("columns", m_projectList->headerInfo());
     config->sync();
 }
 
@@ -787,27 +1034,47 @@ void MainWindow::readOptions() {
             initialGroup.writeEntry("version", "0.7");
             delete w;
         } else {
-            delete w;
-            // TODO: find a better way to exit application faster
-            QTimer::singleShot(1000, this, SLOT(queryQuit()));
+            ::exit(1);
+        }
+    } else if (initialGroup.readEntry("version") == "0.7") {
+        //Add new settings from 0.7.1
+        if (KdenliveSettings::defaultprojectfolder().isEmpty()) {
+            QString path = QDir::homePath() + "/kdenlive";
+            if (KStandardDirs::makeDir(path)  == false) kDebug() << "/// ERROR CREATING PROJECT FOLDER: " << path;
+            KdenliveSettings::setDefaultprojectfolder(path);
         }
     }
+    KConfigGroup treecolumns(config, "Project Tree");
+    const QByteArray state = treecolumns.readEntry("columns", QByteArray());
+    if (!state.isEmpty())
+        m_projectList->setHeaderInfo(state);
 }
 
-void MainWindow::newFile() {
+void MainWindow::slotRunWizard() {
+    Wizard *w = new Wizard(this);
+    if (w->exec() == QDialog::Accepted && w->isOk()) {
+        w->adjustSettings();
+    }
+    delete w;
+}
+
+void MainWindow::newFile(bool showProjectSettings) {
     QString profileName;
     KUrl projectFolder;
-    QPoint projectTracks(3, 2);
-    if (m_timelineArea->count() == 0) profileName = KdenliveSettings::default_profile();
-    else {
-        ProjectSettings *w = new ProjectSettings;
+    QPoint projectTracks(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks());
+    if (!showProjectSettings && m_timelineArea->count() == 0) {
+        if (!KdenliveSettings::activatetabs()) closeCurrentDocument();
+        profileName = KdenliveSettings::default_profile();
+    } else {
+        ProjectSettings *w = new ProjectSettings(projectTracks.x(), projectTracks.y(), KdenliveSettings::defaultprojectfolder(), false, this);
         if (w->exec() != QDialog::Accepted) return;
+        if (!KdenliveSettings::activatetabs()) closeCurrentDocument();
         profileName = w->selectedProfile();
         projectFolder = w->selectedFolder();
         projectTracks = w->tracks();
         delete w;
     }
-    KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, m_commandStack, profileName, projectTracks,  this);
+    KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, m_commandStack, profileName, projectTracks, m_projectMonitor->render, this);
     doc->m_autosave = new KAutoSaveFile(KUrl(), doc);
     TrackView *trackView = new TrackView(doc, this);
     m_timelineArea->addTab(trackView, KIcon("kdenlive"), doc->description());
@@ -815,6 +1082,7 @@ void MainWindow::newFile() {
         connectDocumentInfo(doc);
         connectDocument(trackView, doc);
     } else m_timelineArea->setTabBarHidden(false);
+    m_closeAction->setEnabled(m_timelineArea->count() > 1);
 }
 
 void MainWindow::activateDocument() {
@@ -827,6 +1095,7 @@ void MainWindow::activateDocument() {
 
 void MainWindow::closeCurrentDocument() {
     QWidget *w = m_timelineArea->currentWidget();
+    if (!w) return;
     // closing current document
     int ix = m_timelineArea->currentIndex() + 1;
     if (ix == m_timelineArea->count()) ix = 0;
@@ -846,14 +1115,26 @@ void MainWindow::closeCurrentDocument() {
         }
     }
     m_timelineArea->removeTab(m_timelineArea->indexOf(w));
-    if (m_timelineArea->count() == 1) m_timelineArea->setTabBarHidden(true);
+    if (m_timelineArea->count() == 1) {
+        m_timelineArea->setTabBarHidden(true);
+        m_closeAction->setEnabled(false);
+    }
     delete docToClose;
     delete w;
-    if (m_timelineArea->count() == 0) m_activeDocument = NULL;
+    if (m_timelineArea->count() == 0) {
+        m_activeDocument = NULL;
+        effectStack->clear();
+        transitionConfig->slotTransitionItemSelected(NULL, false);
+    }
 }
 
-void MainWindow::saveFileAs(const QString &outputFileName) {
-    m_projectMonitor->saveSceneList(outputFileName, m_activeDocument->documentInfoXml());
+bool MainWindow::saveFileAs(const QString &outputFileName) {
+    QDomDocument currentSceneList = m_projectMonitor->sceneList();
+    if (m_activeDocument->saveSceneList(outputFileName, currentSceneList) == false)
+        return false;
+
+    // Save timeline thumbnails
+    m_activeTimeline->projectView()->saveThumbnails();
     m_activeDocument->setUrl(KUrl(outputFileName));
     if (m_activeDocument->m_autosave == NULL) {
         m_activeDocument->m_autosave = new KAutoSaveFile(KUrl(outputFileName), this);
@@ -863,28 +1144,41 @@ void MainWindow::saveFileAs(const QString &outputFileName) {
     m_timelineArea->setTabToolTip(m_timelineArea->currentIndex(), m_activeDocument->url().path());
     m_activeDocument->setModified(false);
     m_fileOpenRecent->addUrl(KUrl(outputFileName));
+    return true;
 }
 
-void MainWindow::saveFileAs() {
-    QString outputFile = KFileDialog::getSaveFileName(KUrl(), "*.kdenlive|Kdenlive project files (*.kdenlive)");
+bool MainWindow::saveFileAs() {
+    // Check that the Kdenlive mime type is correctly installed
+    QString mimetype = "application/x-kdenlive";
+    KMimeType::Ptr mime = KMimeType::mimeType(mimetype);
+    if (!mime) mimetype = "*.kdenlive";
+
+    QString outputFile = KFileDialog::getSaveFileName(KUrl(), mimetype);
+    if (outputFile.isEmpty()) return false;
     if (QFile::exists(outputFile)) {
-        if (KMessageBox::questionYesNo(this, i18n("File already exists.\nDo you want to overwrite it ?")) == KMessageBox::No) return;
+        if (KMessageBox::questionYesNo(this, i18n("File already exists.\nDo you want to overwrite it ?")) == KMessageBox::No) return false;
     }
-    saveFileAs(outputFile);
+    return saveFileAs(outputFile);
 }
 
-void MainWindow::saveFile() {
-    if (!m_activeDocument) return;
+bool MainWindow::saveFile() {
+    if (!m_activeDocument) return true;
     if (m_activeDocument->url().isEmpty()) {
-        saveFileAs();
+        return saveFileAs();
     } else {
-        saveFileAs(m_activeDocument->url().path());
+        bool result = saveFileAs(m_activeDocument->url().path());
         m_activeDocument->m_autosave->resize(0);
+        return result;
     }
 }
 
 void MainWindow::openFile() {
-    KUrl url = KFileDialog::getOpenUrl(KUrl(), "*.kdenlive|Kdenlive project files (*.kdenlive)\n*.westley|MLT project files (*.westley)");
+    // Check that the Kdenlive mime type is correctly installed
+    QString mimetype = "application/x-kdenlive";
+    KMimeType::Ptr mime = KMimeType::mimeType(mimetype);
+    if (!mime) mimetype = "*.kdenlive";
+
+    KUrl url = KFileDialog::getOpenUrl(KUrl(), mimetype);
     if (url.isEmpty()) return;
     m_fileOpenRecent->addUrl(url);
     openFile(url);
@@ -893,11 +1187,29 @@ void MainWindow::openFile() {
 void MainWindow::openLastFile() {
     KSharedConfigPtr config = KGlobal::config();
     KUrl::List urls = m_fileOpenRecent->urls();
-    if (urls.isEmpty()) newFile();
+    //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());
 }
 
 void MainWindow::openFile(const KUrl &url) {
+    // Check if the document is already opened
+    const int ct = m_timelineArea->count();
+    bool isOpened = false;
+    int i;
+    for (i = 0; i < ct; i++) {
+        TrackView *tab = (TrackView *) m_timelineArea->widget(i);
+        KdenliveDoc *doc = tab->document();
+        if (doc->url() == url) {
+            isOpened = true;
+            break;
+        }
+    }
+    if (isOpened) {
+        m_timelineArea->setCurrentIndex(i);
+        return;
+    }
+
     // Check for backup file
     QList<KAutoSaveFile *> staleFiles = KAutoSaveFile::staleFiles(url);
     if (!staleFiles.isEmpty()) {
@@ -921,7 +1233,7 @@ void MainWindow::openFile(const KUrl &url) {
 
 void MainWindow::doOpenFile(const KUrl &url, KAutoSaveFile *stale) {
     KdenliveDoc *doc;
-    doc = new KdenliveDoc(url, KUrl(), m_commandStack, QString(), QPoint(3, 2), this);
+    doc = new KdenliveDoc(url, KUrl(), m_commandStack, QString(), QPoint(3, 2), m_projectMonitor->render, this);
     if (stale == NULL) {
         stale = new KAutoSaveFile(url, doc);
         doc->m_autosave = stale;
@@ -935,9 +1247,14 @@ void MainWindow::doOpenFile(const KUrl &url, KAutoSaveFile *stale) {
     TrackView *trackView = new TrackView(doc, this);
     m_timelineArea->setCurrentIndex(m_timelineArea->addTab(trackView, KIcon("kdenlive"), doc->description()));
     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);
     slotGotProgressInfo(QString(), -1);
     m_clipMonitor->refreshMonitor(true);
+    m_projectMonitor->adjustRulerSize(trackView->duration());
+    m_projectMonitor->slotZoneMoved(trackView->inPoint(), trackView->outPoint());
 }
 
 void MainWindow::recoverFiles(QList<KAutoSaveFile *> staleFiles) {
@@ -957,15 +1274,23 @@ void MainWindow::recoverFiles(QList<KAutoSaveFile *> staleFiles) {
 }
 
 
-void MainWindow::parseProfiles() {
+void MainWindow::parseProfiles(const QString &mltPath) {
     //kdDebug()<<" + + YOUR MLT INSTALL WAS FOUND IN: "<< MLT_PREFIX <<endl;
 
     //KdenliveSettings::setDefaulttmpfolder();
+    if (!mltPath.isEmpty()) {
+        KdenliveSettings::setMltpath(mltPath + "/share/mlt/profiles/");
+        KdenliveSettings::setRendererpath(mltPath + "/bin/inigo");
+    }
+
     if (KdenliveSettings::mltpath().isEmpty()) {
         KdenliveSettings::setMltpath(QString(MLT_PREFIX) + QString("/share/mlt/profiles/"));
     }
     if (KdenliveSettings::rendererpath().isEmpty()) {
-        KdenliveSettings::setRendererpath(KStandardDirs::findExe("inigo"));
+        QString inigoPath = QString(MLT_PREFIX) + QString("/bin/inigo");
+        if (!QFile::exists(inigoPath))
+            inigoPath = KStandardDirs::findExe("inigo");
+        else KdenliveSettings::setRendererpath(inigoPath);
     }
     QStringList profilesFilter;
     profilesFilter << "*";
@@ -984,10 +1309,12 @@ void MainWindow::parseProfiles() {
             // 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);
             getUrl->fileDialog()->setMode(KFile::Directory);
-            getUrl->exec();
+            if (getUrl->exec() == QDialog::Rejected) {
+                ::exit(0);
+            }
             KUrl mltPath = getUrl->selectedUrl();
             delete getUrl;
-            if (mltPath.isEmpty()) kapp->quit();
+            if (mltPath.isEmpty()) ::exit(0);
             KdenliveSettings::setMltpath(mltPath.path());
             QStringList profilesList = QDir(KdenliveSettings::mltpath()).entryList(profilesFilter, QDir::Files);
         }
@@ -996,10 +1323,12 @@ void MainWindow::parseProfiles() {
     if (KdenliveSettings::rendererpath().isEmpty()) {
         // Cannot find the MLT inigo renderer, ask for location
         KUrlRequesterDialog *getUrl = new KUrlRequesterDialog(QString(), i18n("Cannot find the inigo program required for rendering (part of Mlt)"), this);
-        getUrl->exec();
+        if (getUrl->exec() == QDialog::Rejected) {
+            ::exit(0);
+        }
         KUrl rendererPath = getUrl->selectedUrl();
         delete getUrl;
-        if (rendererPath.isEmpty()) kapp->quit();
+        if (rendererPath.isEmpty()) ::exit(0);
         KdenliveSettings::setRendererpath(rendererPath.path());
     }
 
@@ -1017,19 +1346,25 @@ void MainWindow::slotEditProfiles() {
 }
 
 void MainWindow::slotEditProjectSettings() {
-    ProjectSettings *w = new ProjectSettings;
+    QPoint p = m_activeDocument->getTracksCount();
+    ProjectSettings *w = new ProjectSettings(p.x(), p.y(), m_activeDocument->projectFolder().path(), true, this);
+
     if (w->exec() == QDialog::Accepted) {
         QString profile = w->selectedProfile();
-        m_activeDocument->setProfilePath(profile);
-        KdenliveSettings::setCurrent_profile(profile);
-        KdenliveSettings::setProject_fps(m_activeDocument->fps());
-        setCaption(m_activeDocument->description(), m_activeDocument->isModified());
-        m_monitorManager->resetProfiles(m_activeDocument->timecode());
-        if (m_renderWidget) m_renderWidget->setDocumentStandard(m_activeDocument->getDocumentStandard());
-        m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
-
-        // We need to desactivate & reactivate monitors to get a refresh
-        m_monitorManager->switchMonitors();
+        m_activeDocument->setProjectFolder(w->selectedFolder());
+        if (m_activeDocument->profilePath() != profile) {
+            // Profile was changed
+            m_activeDocument->setProfilePath(profile);
+            KdenliveSettings::setCurrent_profile(profile);
+            KdenliveSettings::setProject_fps(m_activeDocument->fps());
+            setCaption(m_activeDocument->description(), m_activeDocument->isModified());
+            m_monitorManager->resetProfiles(m_activeDocument->timecode());
+            if (m_renderWidget) m_renderWidget->setProfile(m_activeDocument->mltProfile());
+            m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
+
+            // We need to desactivate & reactivate monitors to get a refresh
+            m_monitorManager->switchMonitors();
+        }
     }
     delete w;
 }
@@ -1037,8 +1372,11 @@ void MainWindow::slotEditProjectSettings() {
 void MainWindow::slotRenderProject() {
     if (!m_renderWidget) {
         m_renderWidget = new RenderWidget(this);
-        connect(m_renderWidget, SIGNAL(doRender(const QString&, const QString&, const QStringList &, const QStringList &, bool, bool, double, double)), this, SLOT(slotDoRender(const QString&, const QString&, const QStringList &, const QStringList &, bool, bool, double, double)));
-        if (m_activeDocument) m_renderWidget->setGuides(m_activeDocument->guidesXml(), m_activeDocument->projectDuration());
+        connect(m_renderWidget, SIGNAL(doRender(const QString&, const QString&, const QStringList &, const QStringList &, bool, bool, double, double, bool)), this, SLOT(slotDoRender(const QString&, const QString&, const QStringList &, const QStringList &, bool, bool, double, double, bool)));
+        if (m_activeDocument) {
+            m_renderWidget->setProfile(m_activeDocument->mltProfile());
+            m_renderWidget->setGuides(m_activeDocument->guidesXml(), m_activeDocument->projectDuration());
+        }
     }
     /*TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
     if (currentTab) m_renderWidget->setTimeline(currentTab);
@@ -1046,7 +1384,7 @@ void MainWindow::slotRenderProject() {
     m_renderWidget->show();
 }
 
-void MainWindow::slotDoRender(const QString &dest, const QString &render, const QStringList &overlay_args, const QStringList &avformat_args, bool zoneOnly, bool playAfter, double guideStart, double guideEnd) {
+void MainWindow::slotDoRender(const QString &dest, const QString &render, const QStringList &overlay_args, const QStringList &avformat_args, bool zoneOnly, bool playAfter, double guideStart, double guideEnd, bool resizeProfile) {
     if (dest.isEmpty()) return;
     int in;
     int out;
@@ -1072,9 +1410,29 @@ void MainWindow::slotDoRender(const QString &dest, const QString &render, const
             videoPlayer = KdenliveSettings::defaultplayerapp();
             if (videoPlayer.isEmpty()) KMessageBox::sorry(this, i18n("Cannot play video after rendering because the default video player application is not set.\nPlease define it in Kdenlive settings dialog."));
         }
-        args << KdenliveSettings::rendererpath() << m_activeDocument->profilePath() << render << videoPlayer << temp.fileName() << dest << avformat_args;
-        QProcess::startDetached("kdenlive_render", args);
-        kDebug() << "///  STARTING RENDER PROCESS\n\nARGS:\n" << args;
+        if (!QFile::exists(KdenliveSettings::rendererpath())) {
+            KMessageBox::sorry(this, i18n("Cannot find the inigo program required for rendering (part of Mlt)"));
+            return;
+        }
+        args << KdenliveSettings::rendererpath() << m_activeDocument->profilePath() << render << videoPlayer;
+
+        for (int i = 0; i < avformat_args.count(); i++) {
+            if (avformat_args.at(i).startsWith("profile=")) {
+                if (avformat_args.at(i).section('=', 1) != m_activeDocument->profilePath()) resizeProfile = true;
+                break;
+            }
+        }
+
+        if (resizeProfile) {
+            // The rendering profile is different from project profile, so use MLT's special producer_consumer
+            args << "consumer:" + temp.fileName();
+        } else args << temp.fileName();
+        args << dest << avformat_args;
+        QString renderer = QCoreApplication::applicationDirPath() + QString("/kdenlive_render");
+        if (!QFile::exists(renderer)) renderer = "kdenlive_render";
+        QProcess::startDetached(renderer, args);
+
+        KNotification::event("RenderStarted", i18n("Rendering <i>%1</i> started", dest), QPixmap(), this);
     }
 }
 
@@ -1111,44 +1469,52 @@ void MainWindow::connectDocumentInfo(KdenliveDoc *doc) {
 
 void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) { //changed
     //m_projectMonitor->stop();
+    m_closeAction->setEnabled(m_timelineArea->count() > 1);
     kDebug() << "///////////////////   CONNECTING DOC TO PROJECT VIEW ////////////////";
     if (m_activeDocument) {
         if (m_activeDocument == doc) return;
         m_activeDocument->backupMltPlaylist();
         if (m_activeTimeline) {
             disconnect(m_projectMonitor, SIGNAL(renderPosition(int)), m_activeTimeline, SLOT(moveCursorPos(int)));
-            disconnect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), trackView, SLOT(slotSetZone(QPoint)));
+            disconnect(m_projectMonitor, SIGNAL(zoneUpdated(QPoint)), m_activeTimeline, SLOT(slotSetZone(QPoint)));
             disconnect(m_projectMonitor, SIGNAL(durationChanged(int)), m_activeTimeline, SLOT(setDuration(int)));
             disconnect(m_projectList, SIGNAL(projectModified()), m_activeDocument, SLOT(setModified()));
+
+
             disconnect(m_activeDocument, SIGNAL(guidesUpdated()), this, SLOT(slotGuidesUpdated()));
-            disconnect(m_activeDocument, SIGNAL(addProjectClip(DocClipBase *)), m_projectList, SLOT(slotAddClip(DocClipBase *)));
+            disconnect(m_activeDocument, SIGNAL(addProjectClip(DocClipBase *, bool)), m_projectList, SLOT(slotAddClip(DocClipBase *, bool)));
             disconnect(m_activeDocument, SIGNAL(addProjectFolder(const QString, const QString &, bool, bool)), m_projectList, SLOT(slotAddFolder(const QString, const QString &, bool, bool)));
             disconnect(m_activeDocument, SIGNAL(signalDeleteProjectClip(const QString &)), m_projectList, SLOT(slotDeleteClip(const QString &)));
             disconnect(m_activeDocument, SIGNAL(updateClipDisplay(const QString &)), m_projectList, SLOT(slotUpdateClip(const QString &)));
             disconnect(m_activeDocument, SIGNAL(selectLastAddedClip(const QString &)), m_projectList, SLOT(slotSelectClip(const QString &)));
             disconnect(m_activeDocument, SIGNAL(deleteTimelineClip(const QString &)), m_activeTimeline, SLOT(slotDeleteClip(const QString &)));
-            disconnect(m_activeTimeline, SIGNAL(clipItemSelected(ClipItem*)), effectStack, SLOT(slotClipItemSelected(ClipItem*)));
-            disconnect(m_activeTimeline, SIGNAL(clipItemSelected(ClipItem*)), this, SLOT(slotActivateEffectStackView()));
-            disconnect(m_activeTimeline, SIGNAL(transitionItemSelected(Transition*)), transitionConfig, SLOT(slotTransitionItemSelected(Transition*)));
-            disconnect(m_activeTimeline, SIGNAL(transitionItemSelected(Transition*)), this, SLOT(slotActivateTransitionView()));
+            disconnect(m_activeTimeline->projectView(), SIGNAL(clipItemSelected(ClipItem*, int)), effectStack, SLOT(slotClipItemSelected(ClipItem*, int)));
+            disconnect(m_activeTimeline->projectView(), SIGNAL(clipItemSelected(ClipItem*, int)), this, SLOT(slotActivateEffectStackView()));
+            disconnect(m_activeTimeline, SIGNAL(transitionItemSelected(Transition*, bool)), transitionConfig, SLOT(slotTransitionItemSelected(Transition*, bool)));
+            disconnect(m_activeTimeline, SIGNAL(transitionItemSelected(Transition*, bool)), this, SLOT(slotActivateTransitionView()));
             disconnect(m_zoomSlider, SIGNAL(valueChanged(int)), m_activeTimeline, SLOT(slotChangeZoom(int)));
             disconnect(m_activeTimeline->projectView(), SIGNAL(displayMessage(const QString&, MessageType)), m_messageLabel, SLOT(setMessage(const QString&, MessageType)));
             disconnect(m_activeTimeline->projectView(), SIGNAL(showClipFrame(DocClipBase *, const int)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *, 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, SIGNAL(changeTrack(int)), this, SLOT(slotChangeTrack(int)));
             disconnect(m_activeDocument, SIGNAL(docModified(bool)), this, SLOT(slotUpdateDocumentState(bool)));
             disconnect(effectStack, SIGNAL(updateClipEffect(ClipItem*, QDomElement, QDomElement, int)), m_activeTimeline->projectView(), SLOT(slotUpdateClipEffect(ClipItem*, QDomElement, QDomElement, int)));
             disconnect(effectStack, SIGNAL(removeEffect(ClipItem*, QDomElement)), m_activeTimeline->projectView(), SLOT(slotDeleteEffect(ClipItem*, QDomElement)));
             disconnect(effectStack, SIGNAL(changeEffectState(ClipItem*, int, bool)), m_activeTimeline->projectView(), SLOT(slotChangeEffectState(ClipItem*, int, bool)));
-            disconnect(effectStack, SIGNAL(changeEffectPosition(ClipItem*, int, int)), trackView->projectView(), SLOT(slotChangeEffectPosition(ClipItem*, int, int)));
+            disconnect(effectStack, SIGNAL(changeEffectPosition(ClipItem*, int, int)), m_activeTimeline->projectView(), SLOT(slotChangeEffectPosition(ClipItem*, int, int)));
             disconnect(effectStack, SIGNAL(refreshEffectStack(ClipItem*)), m_activeTimeline->projectView(), SLOT(slotRefreshEffects(ClipItem*)));
             disconnect(effectStack, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
-            disconnect(transitionConfig, SIGNAL(transitionUpdated(Transition *, QDomElement)), trackView->projectView() , SLOT(slotTransitionUpdated(Transition *, QDomElement)));
-            disconnect(transitionConfig, SIGNAL(seekTimeline(int)), trackView->projectView() , SLOT(setCursorPos(int)));
+            disconnect(transitionConfig, SIGNAL(transitionUpdated(Transition *, QDomElement)), m_activeTimeline->projectView() , SLOT(slotTransitionUpdated(Transition *, QDomElement)));
+            disconnect(transitionConfig, SIGNAL(transitionTrackUpdated(Transition *, int)), m_activeTimeline->projectView() , SLOT(slotTransitionTrackUpdated(Transition *, int)));
+            disconnect(transitionConfig, SIGNAL(seekTimeline(int)), m_activeTimeline->projectView() , SLOT(setCursorPos(int)));
             disconnect(m_activeTimeline->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(activateMonitor()));
-            disconnect(trackView, SIGNAL(zoneMoved(int, int)), m_projectMonitor, SLOT(slotZoneMoved(int, int)));
+            disconnect(m_activeTimeline, SIGNAL(zoneMoved(int, int)), this, SLOT(slotZoneMoved(int, int)));
+            disconnect(m_projectList, SIGNAL(loadingIsOver()), m_activeTimeline->projectView(), SLOT(slotUpdateAllThumbs()));
             effectStack->clear();
         }
-        m_activeDocument->setRenderer(NULL);
+        //m_activeDocument->setRenderer(NULL);
         disconnect(m_projectList, SIGNAL(clipSelected(DocClipBase *)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *)));
         m_clipMonitor->stop();
     }
@@ -1156,15 +1522,19 @@ void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) { //cha
     KdenliveSettings::setProject_fps(doc->fps());
     m_monitorManager->resetProfiles(doc->timecode());
     m_projectList->setDocument(doc);
-    transitionConfig->updateProjectFormat(doc->mltProfile());
+    transitionConfig->updateProjectFormat(doc->mltProfile(), doc->timecode(), trackView->tracksNumber());
+    effectStack->updateProjectFormat(doc->mltProfile(), doc->timecode());
     connect(m_projectList, SIGNAL(clipSelected(DocClipBase *)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *)));
     connect(m_projectList, SIGNAL(projectModified()), doc, SLOT(setModified()));
     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(changeTrack(int)), this, SLOT(slotChangeTrack(int)));
     connect(trackView, SIGNAL(mousePosition(int)), this, SLOT(slotUpdateMousePosition(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(durationChanged(int)), trackView, SLOT(setDuration(int)));
-    connect(doc, SIGNAL(addProjectClip(DocClipBase *)), m_projectList, SLOT(slotAddClip(DocClipBase *)));
+    connect(doc, SIGNAL(addProjectClip(DocClipBase *, bool)), m_projectList, SLOT(slotAddClip(DocClipBase *, bool)));
     connect(doc, SIGNAL(addProjectFolder(const QString, const QString &, bool, bool)), m_projectList, SLOT(slotAddFolder(const QString, const QString &, bool, bool)));
     connect(doc, SIGNAL(signalDeleteProjectClip(const QString &)), m_projectList, SLOT(slotDeleteClip(const QString &)));
     connect(doc, SIGNAL(updateClipDisplay(const QString &)), m_projectList, SLOT(slotUpdateClip(const QString &)));
@@ -1175,10 +1545,10 @@ void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) { //cha
     connect(doc, SIGNAL(guidesUpdated()), this, SLOT(slotGuidesUpdated()));
 
 
-    connect(trackView, SIGNAL(clipItemSelected(ClipItem*)), effectStack, SLOT(slotClipItemSelected(ClipItem*)));
-    connect(trackView, SIGNAL(clipItemSelected(ClipItem*)), this, SLOT(slotActivateEffectStackView()));
-    connect(trackView, SIGNAL(transitionItemSelected(Transition*)), transitionConfig, SLOT(slotTransitionItemSelected(Transition*)));
-    connect(trackView, SIGNAL(transitionItemSelected(Transition*)), this, SLOT(slotActivateTransitionView()));
+    connect(trackView->projectView(), SIGNAL(clipItemSelected(ClipItem*, int)), effectStack, SLOT(slotClipItemSelected(ClipItem*, int)));
+    connect(trackView->projectView(), SIGNAL(clipItemSelected(ClipItem*, int)), this, SLOT(slotActivateEffectStackView()));
+    connect(trackView, SIGNAL(transitionItemSelected(Transition*, bool)), transitionConfig, SLOT(slotTransitionItemSelected(Transition*, bool)));
+    connect(trackView, SIGNAL(transitionItemSelected(Transition*, bool)), this, SLOT(slotActivateTransitionView()));
     m_zoomSlider->setValue(doc->zoom());
     connect(m_zoomSlider, SIGNAL(valueChanged(int)), trackView, SLOT(slotChangeZoom(int)));
     connect(trackView->projectView(), SIGNAL(zoomIn()), this, SLOT(slotZoomIn()));
@@ -1194,20 +1564,22 @@ void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) { //cha
     connect(effectStack, SIGNAL(changeEffectPosition(ClipItem*, int, int)), trackView->projectView(), SLOT(slotChangeEffectPosition(ClipItem*, int, int)));
     connect(effectStack, SIGNAL(refreshEffectStack(ClipItem*)), trackView->projectView(), SLOT(slotRefreshEffects(ClipItem*)));
     connect(transitionConfig, SIGNAL(transitionUpdated(Transition *, QDomElement)), trackView->projectView() , SLOT(slotTransitionUpdated(Transition *, QDomElement)));
+    connect(transitionConfig, SIGNAL(transitionTrackUpdated(Transition *, int)), trackView->projectView() , SLOT(slotTransitionTrackUpdated(Transition *, int)));
     connect(transitionConfig, SIGNAL(seekTimeline(int)), trackView->projectView() , SLOT(setCursorPos(int)));
     connect(effectStack, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
 
     connect(trackView->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(activateMonitor()));
-    connect(trackView, SIGNAL(zoneMoved(int, int)), m_projectMonitor, SLOT(slotZoneMoved(int, int)));
+    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_activeTimeline = trackView;
-    if (m_renderWidget) m_renderWidget->setDocumentStandard(doc->getDocumentStandard());
-    doc->setRenderer(m_projectMonitor->render);
+    if (m_renderWidget) m_renderWidget->setProfile(doc->mltProfile());
+    //doc->setRenderer(m_projectMonitor->render);
     m_commandStack->setActiveStack(doc->commandStack());
     KdenliveSettings::setProject_display_ratio(doc->dar());
-    doc->updateAllProjectClips();
-
+    m_projectList->updateAllClips();
+    //doc->clipManager()->checkAudioThumbs();
 
     //m_overView->setScene(trackView->projectScene());
     //m_overView->scale(m_overView->width() / trackView->duration(), m_overView->height() / (50 * trackView->tracksNumber()));
@@ -1216,6 +1588,14 @@ void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) { //cha
     setCaption(doc->description(), doc->isModified());
     m_saveAction->setEnabled(doc->isModified());
     m_activeDocument = doc;
+
+    // set tool to select tool
+    m_buttonSelectTool->setChecked(true);
+}
+
+void MainWindow::slotZoneMoved(int start, int end) {
+    m_activeDocument->setZone(start, end);
+    m_projectMonitor->slotZoneMoved(start, end);
 }
 
 void MainWindow::slotGuidesUpdated() {
@@ -1227,7 +1607,9 @@ void MainWindow::slotPreferences(int page, int option) {
     // cached, in which case you want to display the cached dialog
     // instead of creating another one
     if (KConfigDialog::showDialog("settings")) {
-        if (page != -1) static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"))->showPage(page, option);
+        KdenliveSettingsDialog* d = static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"));
+        if (page != -1) d->showPage(page, option);
+        d->checkProfile();
         return;
     }
 
@@ -1250,7 +1632,9 @@ void MainWindow::updateConfiguration() {
     }
     m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
     m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
+#ifndef NO_JOGSHUTTLE
     activateShuttleDevice();
+#endif /* NO_JOGSHUTTLE */
 
 }
 
@@ -1282,12 +1666,13 @@ void MainWindow::slotSwitchMarkersComments() {
 
 void MainWindow::slotSwitchSnap() {
     KdenliveSettings::setSnaptopoints(!KdenliveSettings::snaptopoints());
-    m_buttonShowMarkers->setChecked(KdenliveSettings::snaptopoints());
+    m_buttonSnap->setChecked(KdenliveSettings::snaptopoints());
 }
 
 
 void MainWindow::slotDeleteTimelineClip() {
-    if (m_activeTimeline) {
+    if (QApplication::focusWidget()->parentWidget()->parentWidget() == projectListDock) m_projectList->slotRemoveClip();
+    else if (m_activeTimeline) {
         m_activeTimeline->projectView()->deleteSelectedClips();
     }
 }
@@ -1299,26 +1684,120 @@ void MainWindow::slotChangeClipSpeed() {
 }
 
 void MainWindow::slotAddClipMarker() {
-    if (m_activeTimeline) {
-        m_activeTimeline->projectView()->slotAddClipMarker();
+    DocClipBase *clip = NULL;
+    GenTime pos;
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline) {
+            ClipItem *item = m_activeTimeline->projectView()->getActiveClipUnderCursor();
+            if (item) {
+                pos = m_projectMonitor->position() - item->startPos() + item->cropStart();
+                clip = item->baseClip();
+            }
+        }
+    } else {
+        clip = m_clipMonitor->activeClip();
+        pos = m_clipMonitor->position();
+    }
+    if (!clip) {
+        m_messageLabel->setMessage(i18n("Cannot find clip to add marker"), ErrorMessage);
+        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());
+    }
+    if (m_clipMonitor->isActive()) m_clipMonitor->checkOverlay();
 }
 
 void MainWindow::slotDeleteClipMarker() {
-    if (m_activeTimeline) {
-        m_activeTimeline->projectView()->slotDeleteClipMarker();
+    DocClipBase *clip = NULL;
+    GenTime pos;
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline) {
+            ClipItem *item = m_activeTimeline->projectView()->getActiveClipUnderCursor();
+            if (item) {
+                pos = m_projectMonitor->position() - item->startPos() + item->cropStart();
+                clip = item->baseClip();
+            }
+        }
+    } else {
+        clip = m_clipMonitor->activeClip();
+        pos = m_clipMonitor->position();
     }
+    if (!clip) {
+        m_messageLabel->setMessage(i18n("Cannot find clip to remove marker"), ErrorMessage);
+        return;
+    }
+
+    QString id = clip->getId();
+    QString comment = clip->markerComment(pos);
+    if (comment.isEmpty()) {
+        m_messageLabel->setMessage(i18n("No marker found at cursor time"), ErrorMessage);
+        return;
+    }
+    m_activeTimeline->projectView()->slotDeleteClipMarker(comment, id, pos);
+    if (m_clipMonitor->isActive()) m_clipMonitor->checkOverlay();
+
 }
 
 void MainWindow::slotDeleteAllClipMarkers() {
-    if (m_activeTimeline) {
-        m_activeTimeline->projectView()->slotDeleteAllClipMarkers();
+    DocClipBase *clip = NULL;
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline) {
+            ClipItem *item = m_activeTimeline->projectView()->getActiveClipUnderCursor();
+            if (item) {
+                clip = item->baseClip();
+            }
+        }
+    } else {
+        clip = m_clipMonitor->activeClip();
     }
+    if (!clip) {
+        m_messageLabel->setMessage(i18n("Cannot find clip to remove marker"), ErrorMessage);
+        return;
+    }
+    m_activeTimeline->projectView()->slotDeleteAllClipMarkers(clip->getId());
+    if (m_clipMonitor->isActive()) m_clipMonitor->checkOverlay();
 }
 
 void MainWindow::slotEditClipMarker() {
-    if (m_activeTimeline) {
-        m_activeTimeline->projectView()->slotEditClipMarker();
+    DocClipBase *clip = NULL;
+    GenTime pos;
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline) {
+            ClipItem *item = m_activeTimeline->projectView()->getActiveClipUnderCursor();
+            if (item) {
+                pos = m_projectMonitor->position() - item->startPos() + item->cropStart();
+                clip = item->baseClip();
+            }
+        }
+    } else {
+        clip = m_clipMonitor->activeClip();
+        pos = m_clipMonitor->position();
+    }
+    if (!clip) {
+        m_messageLabel->setMessage(i18n("Cannot find clip to remove marker"), ErrorMessage);
+        return;
+    }
+
+    QString id = clip->getId();
+    QString oldcomment = clip->markerComment(pos);
+    if (oldcomment.isEmpty()) {
+        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) {
+            // remove old marker
+            m_activeTimeline->projectView()->slotAddClipMarker(id, pos, QString());
+        }
+        if (m_clipMonitor->isActive()) m_clipMonitor->checkOverlay();
     }
 }
 
@@ -1327,6 +1806,34 @@ void MainWindow::slotAddGuide() {
         m_activeTimeline->projectView()->slotAddGuide();
 }
 
+void MainWindow::slotInsertSpace() {
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotInsertSpace();
+}
+
+void MainWindow::slotRemoveSpace() {
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotRemoveSpace();
+}
+
+void MainWindow::slotInsertTrack(int ix) {
+    m_projectMonitor->activateMonitor();
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotInsertTrack(ix);
+}
+
+void MainWindow::slotDeleteTrack(int ix) {
+    m_projectMonitor->activateMonitor();
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotDeleteTrack(ix);
+}
+
+void MainWindow::slotChangeTrack(int ix) {
+    m_projectMonitor->activateMonitor();
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotChangeTrack(ix);
+}
+
 void MainWindow::slotEditGuide() {
     if (m_activeTimeline)
         m_activeTimeline->projectView()->slotEditGuide();
@@ -1355,27 +1862,35 @@ void MainWindow::slotAddProjectClip(KUrl url) {
 
 void MainWindow::slotAddTransition(QAction *result) {
     if (!result) return;
-    QDomElement effect = transitions.getEffectByName(result->data().toString());
-    if (m_activeTimeline) {
-        m_activeTimeline->projectView()->slotAddTransitionToSelectedClips(effect);
+    QStringList info = result->data().toStringList();
+    if (info.isEmpty()) return;
+    QDomElement transition = transitions.getEffectByTag(info.at(1), info.at(2));
+    if (m_activeTimeline && !transition.isNull()) {
+        m_activeTimeline->projectView()->slotAddTransitionToSelectedClips(transition.cloneNode().toElement());
     }
 }
 
 void MainWindow::slotAddVideoEffect(QAction *result) {
     if (!result) return;
-    QDomElement effect = videoEffects.getEffectByName(result->data().toString());
+    QStringList info = result->data().toStringList();
+    if (info.isEmpty()) return;
+    QDomElement effect = videoEffects.getEffectByTag(info.at(1), info.at(2));
     slotAddEffect(effect);
 }
 
 void MainWindow::slotAddAudioEffect(QAction *result) {
     if (!result) return;
-    QDomElement effect = audioEffects.getEffectByName(result->data().toString());
+    QStringList info = result->data().toStringList();
+    if (info.isEmpty()) return;
+    QDomElement effect = audioEffects.getEffectByTag(info.at(1), info.at(2));
     slotAddEffect(effect);
 }
 
 void MainWindow::slotAddCustomEffect(QAction *result) {
     if (!result) return;
-    QDomElement effect = customEffects.getEffectByName(result->data().toString());
+    QStringList info = result->data().toStringList();
+    if (info.isEmpty()) return;
+    QDomElement effect = customEffects.getEffectByTag(info.at(1), info.at(2));
     slotAddEffect(effect);
 }
 
@@ -1406,22 +1921,23 @@ void MainWindow::slotGotProgressInfo(const QString &message, int progress) {
 
 void MainWindow::slotShowClipProperties(DocClipBase *clip) {
     if (clip->clipType() == TEXT) {
-        QString path = clip->getProperty("xml");
-        TitleWidget *dia_ui = new TitleWidget(KUrl()/*path + ".kdenlivetitle")*/, path, m_projectMonitor->render, this);
+        QString titlepath = m_activeDocument->projectFolder().path() + "/titles/";
+        QString path = clip->getProperty("resource");
+        TitleWidget *dia_ui = new TitleWidget(KUrl(), titlepath, m_projectMonitor->render, this);
         QDomDocument doc;
         doc.setContent(clip->getProperty("xmldata"));
         dia_ui->setXml(doc);
         if (dia_ui->exec() == QDialog::Accepted) {
-            kDebug() << "//  UPDATUING CLIP TITLE: " << path;
             QPixmap pix = dia_ui->renderedPixmap();
-            pix.save(path + ".png");
+            pix.save(path);
             //slotAddClipFile(KUrl("/tmp/kdenlivetitle.png"), QString(), -1);
             //m_clipManager->slotEditTextClipFile(id, dia_ui->xml().toString());
             QMap <QString, QString> newprops;
             newprops.insert("xmldata", dia_ui->xml().toString());
             EditClipCommand *command = new EditClipCommand(m_projectList, clip->getId(), clip->properties(), newprops, true);
             m_activeDocument->commandStack()->push(command);
-            //setModified(true);
+            m_clipMonitor->refreshMonitor(true);
+            m_activeDocument->setModified(true);
         }
         delete dia_ui;
 
@@ -1460,14 +1976,14 @@ void MainWindow::slotSnapRewind() {
     if (m_projectMonitor->isActive()) {
         if (m_activeTimeline)
             m_activeTimeline->projectView()->slotSeekToPreviousSnap();
-    }
+    } else m_clipMonitor->slotSeekToPreviousSnap();
 }
 
 void MainWindow::slotSnapForward() {
     if (m_projectMonitor->isActive()) {
         if (m_activeTimeline)
             m_activeTimeline->projectView()->slotSeekToNextSnap();
-    }
+    } else m_clipMonitor->slotSeekToNextSnap();
 }
 
 void MainWindow::slotClipStart() {
@@ -1487,6 +2003,7 @@ void MainWindow::slotClipEnd() {
 void MainWindow::slotChangeTool(QAction * action) {
     if (action == m_buttonSelectTool) slotSetTool(SELECTTOOL);
     else if (action == m_buttonRazorTool) slotSetTool(RAZORTOOL);
+    else if (action == m_buttonSpacerTool) slotSetTool(SPACERTOOL);
 }
 
 void MainWindow::slotSetTool(PROJECTTOOL tool) {
@@ -1581,6 +2098,17 @@ void MainWindow::keyPressEvent(QKeyEvent *ke) {
     } else KXmlGuiWindow::keyPressEvent(ke);
 }
 
+
+/** Gets called when the window gets hidden */
+void MainWindow::hideEvent(QHideEvent *event) {
+    // kDebug() << "I was hidden";
+    // issue http://www.kdenlive.org/mantis/view.php?id=231
+    if (this->isMinimized()) {
+        // kDebug() << "I am minimized";
+        if (m_monitorManager) m_monitorManager->stopActiveMonitor();
+    }
+}
+
 bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
     if (m_findActivated) {
         if (event->type() == QEvent::ShortcutOverride) {
@@ -1632,4 +2160,26 @@ void MainWindow::slotSetOutPoint() {
     } else m_activeTimeline->projectView()->setOutPoint();
 }
 
+void MainWindow::slotGetNewStuff() {
+    //KNS::Entry::List download();
+    KNS::Entry::List entries = KNS::Engine::download();
+    int numberInstalled = 0;
+    // list of changed entries
+    kDebug() << "// PARSING KNS";
+    foreach(KNS::Entry* entry, entries) {
+        // care only about installed ones
+        if (entry->status() == KNS::Entry::Installed) {
+            foreach(const QString &file, entry->installedFiles()) {
+                kDebug() << "// CURRENTLY INSTALLED: " << file;
+            }
+        }
+    }
+    qDeleteAll(entries);
+    initEffects::refreshLumas();
+}
+
+void MainWindow::slotAutoTransition() {
+    m_activeTimeline->projectView()->autoTransition();
+}
+
 #include "mainwindow.moc"