X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmainwindow.cpp;h=d73d5ea859daebe5576cf042b43e812950fd7a90;hb=cd421a62b814c3374918a95ab12474cab8d173b1;hp=a45f030195eff2cfc78686b01986d93fef02ba4f;hpb=059a756716f3d4e91e07a006e4fc343899c310db;p=kdenlive

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index a45f0301..d73d5ea8 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -17,13 +17,14 @@
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
-
+#include <stdlib.h>
 
 #include <QTextStream>
 #include <QTimer>
 #include <QAction>
 #include <QtTest>
 #include <QtCore>
+#include <QKeyEvent>
 
 #include <KApplication>
 #include <KAction>
@@ -47,6 +48,9 @@
 #include <KMenu>
 #include <locale.h>
 #include <ktogglefullscreenaction.h>
+#include <KFileItem>
+#include <KNotification>
+#include <KNotifyConfigWidget>
 
 #include <mlt++/Mlt.h>
 
@@ -57,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,39 +76,51 @@
 #include "renderer.h"
 #include "jogshuttle.h"
 #include "clipproperties.h"
+#include "wizard.h"
+#include "editclipcommand.h"
+#include "titlewidget.h"
+
+static const int ID_STATUS_MSG = 1;
+static const int ID_EDITMODE_MSG = 2;
+static const int ID_TIMELINE_MSG = 3;
+static const int ID_TIMELINE_BUTTONS = 5;
+static const int ID_TIMELINE_POS = 6;
+static const int ID_TIMELINE_FORMAT = 7;
 
-#define ID_STATUS_MSG 1
-#define ID_EDITMODE_MSG 2
-#define ID_TIMELINE_MSG 3
-#define ID_TIMELINE_BUTTONS 5
-#define ID_TIMELINE_POS 6
-#define ID_TIMELINE_FORMAT 7
+namespace Mlt {
+class Producer;
+};
 
 EffectsList MainWindow::videoEffects;
 EffectsList MainWindow::audioEffects;
 EffectsList MainWindow::customEffects;
 EffectsList MainWindow::transitions;
 
-MainWindow::MainWindow(QWidget *parent)
+MainWindow::MainWindow(const QString &MltPath, QWidget *parent)
         : KXmlGuiWindow(parent),
-        m_activeDocument(NULL), m_activeTimeline(NULL), m_renderWidget(NULL), m_jogProcess(NULL) {
+        m_activeDocument(NULL), m_activeTimeline(NULL), m_renderWidget(NULL), m_jogProcess(NULL), m_findActivated(false), m_initialized(false) {
     setlocale(LC_NUMERIC, "POSIX");
-    parseProfiles();
     setFont(KGlobalSettings::toolBarFont());
+    parseProfiles(MltPath);
     m_commandStack = new QUndoGroup;
     m_timelineArea = new KTabWidget(this);
     m_timelineArea->setTabReorderingEnabled(true);
     m_timelineArea->setTabBarHidden(true);
 
     QToolButton *closeTabButton = new QToolButton;
-    connect(closeTabButton, SIGNAL(clicked()), this, SLOT(slotRemoveTab()));
+    connect(closeTabButton, SIGNAL(clicked()), this, SLOT(closeCurrentDocument()));
     closeTabButton->setIcon(KIcon("tab-close"));
     closeTabButton->adjustSize();
     closeTabButton->setToolTip(i18n("Close the current tab"));
     m_timelineArea->setCornerWidget(closeTabButton);
     connect(m_timelineArea, SIGNAL(currentChanged(int)), this, SLOT(activateDocument()));
 
+    connect(&m_findTimer, SIGNAL(timeout()), this, SLOT(findTimeout()));
+    m_findTimer.setSingleShot(true);
+
     initEffects::parseEffectFiles();
+    //initEffects::parseCustomEffectsFile();
+
     m_monitorManager = new MonitorManager();
 
     projectListDock = new QDockWidget(i18n("Project Tree"), this);
@@ -134,6 +149,10 @@ MainWindow::MainWindow(QWidget *parent)
     transitionConfigDock->setWidget(transitionConfig);
     addDockWidget(Qt::TopDockWidgetArea, transitionConfigDock);
 
+    KdenliveSettings::setCurrent_profile(KdenliveSettings::default_profile());
+    m_fileOpenRecent = KStandardAction::openRecent(this, SLOT(openFile(const KUrl &)),
+                       actionCollection());
+    readOptions();
 
     clipMonitorDock = new QDockWidget(i18n("Clip Monitor"), this);
     clipMonitorDock->setObjectName("clip_monitor");
@@ -155,6 +174,7 @@ MainWindow::MainWindow(QWidget *parent)
     addDockWidget(Qt::TopDockWidgetArea, recMonitorDock);
 
     connect(m_recMonitor, SIGNAL(addProjectClip(KUrl)), this, SLOT(slotAddProjectClip(KUrl)));
+    connect(m_recMonitor, SIGNAL(showConfigDialog(int, int)), this, SLOT(slotPreferences(int, int)));
 
     undoViewDock = new QDockWidget(i18n("Undo History"), this);
     undoViewDock->setObjectName("undo_history");
@@ -165,20 +185,21 @@ MainWindow::MainWindow(QWidget *parent)
     m_undoView->setGroup(m_commandStack);
     addDockWidget(Qt::TopDockWidgetArea, undoViewDock);
 
-    overviewDock = new QDockWidget(i18n("Project Overview"), this);
-    overviewDock->setObjectName("project_overview");
+    //overviewDock = new QDockWidget(i18n("Project Overview"), this);
+    //overviewDock->setObjectName("project_overview");
     //m_overView = new CustomTrackView(NULL, NULL, this);
     //overviewDock->setWidget(m_overView);
-    addDockWidget(Qt::TopDockWidgetArea, overviewDock);
+    //addDockWidget(Qt::TopDockWidgetArea, overviewDock);
 
     setupActions();
-    tabifyDockWidget(projectListDock, effectListDock);
+    //tabifyDockWidget(projectListDock, effectListDock);
     tabifyDockWidget(projectListDock, effectStackDock);
     tabifyDockWidget(projectListDock, transitionConfigDock);
-    tabifyDockWidget(projectListDock, undoViewDock);
-    projectListDock->raise();
+    //tabifyDockWidget(projectListDock, undoViewDock);
+
 
     tabifyDockWidget(clipMonitorDock, projectMonitorDock);
+    tabifyDockWidget(clipMonitorDock, recMonitorDock);
     setCentralWidget(m_timelineArea);
 
     setupGUI(Default, NULL /*"kdenliveui.rc"*/);
@@ -186,58 +207,107 @@ MainWindow::MainWindow(QWidget *parent)
 
     // build effects menus
     QAction *action;
-    QMenu *videoEffectsMenu = (QMenu*)(factory()->container("video_effects_menu", this));
+    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);
         videoEffectsMenu->addAction(action);
     }
-    QMenu *audioEffectsMenu = (QMenu*)(factory()->container("audio_effects_menu", this));
+    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);
         audioEffectsMenu->addAction(action);
     }
-    QMenu *customEffectsMenu = (QMenu*)(factory()->container("custom_effects_menu", this));
+    m_customEffectsMenu = static_cast<QMenu*>(factory()->container("custom_effects_menu", this));
     effects = customEffects.effectNames();
+    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);
-        customEffectsMenu->addAction(action);
+        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);
+
     connect(videoEffectsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddVideoEffect(QAction *)));
     connect(audioEffectsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddAudioEffect(QAction *)));
-    connect(customEffectsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddCustomEffect(QAction *)));
+    connect(m_customEffectsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddCustomEffect(QAction *)));
 
     m_timelineContextMenu = new QMenu(this);
     m_timelineContextClipMenu = new QMenu(this);
     m_timelineContextTransitionMenu = new QMenu(this);
 
-    action = actionCollection()->action("delete_timeline_clip");
-    m_timelineContextClipMenu->addAction(action);
-    action = actionCollection()->action("add_clip_marker");
-    m_timelineContextClipMenu->addAction(action);
+
+    QMenu *transitionsMenu = new QMenu(i18n("Add Transition"), this);
+    effects = transitions.effectNames();
+    foreach(const QString &name, effects) {
+        action = new QAction(name, this);
+        action->setData(name);
+        transitionsMenu->addAction(action);
+    }
+    connect(transitionsMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotAddTransition(QAction *)));
+
+    m_timelineContextMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Paste)));
+
+    m_timelineContextClipMenu->addAction(actionCollection()->action("delete_timeline_clip"));
+    m_timelineContextClipMenu->addAction(actionCollection()->action("change_clip_speed"));
+    m_timelineContextClipMenu->addAction(actionCollection()->action("cut_timeline_clip"));
+    m_timelineContextClipMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Copy)));
+    m_timelineContextClipMenu->addAction(actionCollection()->action("paste_effects"));
+
+    QMenu *markersMenu = (QMenu*)(factory()->container("marker_menu", this));
+    m_timelineContextClipMenu->addMenu(markersMenu);
+    m_timelineContextClipMenu->addMenu(transitionsMenu);
     m_timelineContextClipMenu->addMenu(videoEffectsMenu);
     m_timelineContextClipMenu->addMenu(audioEffectsMenu);
-    m_timelineContextClipMenu->addMenu(customEffectsMenu);
+    //TODO: re-enable custom effects menu when it is implemented
+    m_timelineContextClipMenu->addMenu(m_customEffectsMenu);
 
-    m_timelineContextTransitionMenu->addAction(action);
+    m_timelineContextTransitionMenu->addAction(actionCollection()->action("delete_timeline_clip"));
+    m_timelineContextTransitionMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Copy)));
 
     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()));
     connect(m_monitorManager, SIGNAL(raiseClipMonitor(bool)), this, SLOT(slotRaiseMonitor(bool)));
     connect(m_effectList, SIGNAL(addEffect(QDomElement)), this, SLOT(slotAddEffect(QDomElement)));
+    connect(m_effectList, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
+
     m_monitorManager->initMonitors(m_clipMonitor, m_projectMonitor);
     slotConnectMonitors();
 
     setAutoSaveSettings();
-    newFile();
+
+    if (KdenliveSettings::openlastproject()) {
+        openLastFile();
+    } 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();
+        }
+        else*/
+        newFile();
+    }
 
     activateShuttleDevice();
+    projectListDock->raise();
 }
 
 void MainWindow::queryQuit() {
@@ -252,6 +322,7 @@ bool MainWindow::queryClose() {
         switch (KMessageBox::warningYesNoCancel(this, i18n("Save changes to document ?"))) {
         case KMessageBox::Yes :
             // save document here. If saving fails, return false;
+            saveFile();
             return true;
         case KMessageBox::No :
             return true;
@@ -262,6 +333,34 @@ bool MainWindow::queryClose() {
     return true;
 }
 
+void MainWindow::saveProperties(KConfig*) {
+    // save properties here,used by session management
+    saveFile();
+}
+
+
+void MainWindow::readProperties(KConfig *config) {
+    // read properties here,used by session management
+    QString Lastproject = config->group("Recent Files").readPathEntry("File1", QString());
+    openFile(KUrl(Lastproject));
+}
+
+void MainWindow::slotReloadEffects() {
+    initEffects::parseCustomEffectsFile();
+    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);
+        m_customEffectsMenu->addAction(action);
+    }
+    m_effectList->reloadEffectList();
+}
+
 void MainWindow::activateShuttleDevice() {
     if (m_jogProcess) delete m_jogProcess;
     m_jogProcess = NULL;
@@ -308,6 +407,10 @@ void MainWindow::slotShuttleAction(int code) {
     }
 }
 
+void MainWindow::configureNotifications() {
+    KNotifyConfigWidget::configure(this);
+}
+
 void MainWindow::slotFullScreen() {
     //KToggleFullScreenAction::setFullScreen(this, actionCollection()->action("fullscreen")->isChecked());
 }
@@ -327,7 +430,7 @@ void MainWindow::slotRaiseMonitor(bool clipMonitor) {
     else projectMonitorDock->raise();
 }
 
-void MainWindow::slotSetClipDuration(int id, int duration) {
+void MainWindow::slotSetClipDuration(const QString &id, int duration) {
     if (!m_activeDocument) return;
     m_activeDocument->setProducerDuration(id, duration);
 }
@@ -335,16 +438,38 @@ void MainWindow::slotSetClipDuration(int id, int duration) {
 void MainWindow::slotConnectMonitors() {
 
     m_projectList->setRenderer(m_clipMonitor->render);
-    connect(m_projectList, SIGNAL(clipSelected(const QDomElement &)), m_clipMonitor, SLOT(slotSetXml(const QDomElement &)));
-    connect(m_projectList, SIGNAL(receivedClipDuration(int, int)), this, SLOT(slotSetClipDuration(int, int)));
+    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 &, int)), m_clipMonitor->render, SLOT(getFileProperties(const QDomElement &, int)));
-    connect(m_clipMonitor->render, SIGNAL(replyGetImage(int, int, const QPixmap &, int, int)), m_projectList, SLOT(slotReplyGetImage(int, int, const QPixmap &, int, int)));
-    connect(m_clipMonitor->render, SIGNAL(replyGetFileProperties(int, const QMap < QString, QString > &, const QMap < QString, QString > &)), m_projectList, SLOT(slotReplyGetFileProperties(int, const QMap < QString, QString > &, const QMap < QString, QString > &)));
+    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_clipMonitor->render, SIGNAL(removeInvalidClip(const QString &)), m_projectList, SLOT(slotRemoveInvalidClip(const QString &)));
+
+    connect(m_clipMonitor, SIGNAL(refreshClipThumbnail(const QString &)), m_projectList, SLOT(slotRefreshClipThumbnail(const QString &)));
+
+    connect(m_clipMonitor, SIGNAL(adjustMonitorSize()), this, SLOT(slotAdjustClipMonitor()));
+    connect(m_projectMonitor, SIGNAL(adjustMonitorSize()), this, SLOT(slotAdjustProjectMonitor()));
+
+    connect(m_clipMonitor, SIGNAL(saveZone(Render *, QPoint)), this, SLOT(slotSaveZone(Render *, QPoint)));
+    connect(m_projectMonitor, SIGNAL(saveZone(Render *, QPoint)), this, SLOT(slotSaveZone(Render *, QPoint)));
+}
+
+void MainWindow::slotAdjustClipMonitor() {
+    clipMonitorDock->updateGeometry();
+    clipMonitorDock->adjustSize();
+    m_clipMonitor->resetSize();
+}
+
+void MainWindow::slotAdjustProjectMonitor() {
+    projectMonitorDock->updateGeometry();
+    projectMonitorDock->adjustSize();
+    m_projectMonitor->resetSize();
 }
 
 void MainWindow::setupActions() {
 
+    KActionCollection* collection = actionCollection();
     m_timecodeFormat = new KComboBox(this);
     m_timecodeFormat->addItem(i18n("hh:mm:ss::ff"));
     m_timecodeFormat->addItem(i18n("Frames"));
@@ -354,7 +479,6 @@ void MainWindow::setupActions() {
     statusProgressBar->setMaximum(100);
     statusProgressBar->setMaximumWidth(150);
     statusProgressBar->setVisible(false);
-    statusLabel = new QLabel(this);
 
     QWidget *w = new QWidget;
 
@@ -366,7 +490,7 @@ void MainWindow::setupActions() {
 
     m_toolGroup = new QActionGroup(this);
 
-    QString style1 = "QToolButton { background-color: rgba(230, 230, 230, 20); border-style: inset; border:1px solid #666666;border-radius: 3px;margin: 0px 3px} QToolButton:checked { background-color: rgba(224, 0, 0, 100); border-style: inset; border:1px solid #666666;border-radius: 3px;}";
+    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->setCheckable(true);
@@ -379,6 +503,17 @@ void MainWindow::setupActions() {
     m_toolGroup->addAction(m_buttonSelectTool);
     m_toolGroup->addAction(m_buttonRazorTool);
     m_toolGroup->setExclusive(true);
+    toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
+
+    QWidget * actionWidget;
+    actionWidget = toolbar->widgetForAction(m_buttonSelectTool);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
+    actionWidget = toolbar->widgetForAction(m_buttonRazorTool);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
     toolbar->setStyleSheet(style1);
     connect(m_toolGroup, SIGNAL(triggered(QAction *)), this, SLOT(slotChangeTool(QAction *)));
 
@@ -387,160 +522,271 @@ void MainWindow::setupActions() {
     m_buttonFitZoom->setCheckable(false);
     connect(m_buttonFitZoom, SIGNAL(triggered()), this, SLOT(slotFitZoom()));
 
+    actionWidget = toolbar->widgetForAction(m_buttonFitZoom);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
     m_zoomSlider = new QSlider(Qt::Horizontal, this);
     m_zoomSlider->setMaximum(13);
+    m_zoomSlider->setPageStep(1);
 
     m_zoomSlider->setMaximumWidth(150);
     m_zoomSlider->setMinimumWidth(100);
 
-    const int contentHeight = QFontMetrics(w->font()).height() + 3;
-    QString style = "QSlider::groove:horizontal { border: 1px solid #999999;height: 8px }";
-    style.append("QSlider::handle:horizontal {  background-color: white; border: 1px solid #999999;width: 8px;margin: -2px 0;border-radius: 3px; }");
+    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 + 5);
+    statusBar()->setMinimumHeight(contentHeight);
 
 
     toolbar->addWidget(m_zoomSlider);
 
-    m_buttonVideoThumbs = toolbar->addAction(KIcon("video-mpeg"), i18n("Show videoo thumbnails"));
+    m_buttonVideoThumbs = toolbar->addAction(KIcon("kdenlive-show-videothumb"), i18n("Show video thumbnails"));
     m_buttonVideoThumbs->setCheckable(true);
-    m_buttonVideoThumbs->setChecked(KdenliveSettings::audiothumbnails());
+    m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
     connect(m_buttonVideoThumbs, SIGNAL(triggered()), this, SLOT(slotSwitchVideoThumbs()));
 
-    m_buttonAudioThumbs = toolbar->addAction(KIcon("audio-mpeg"), i18n("Show audio thumbnails"));
+    m_buttonAudioThumbs = toolbar->addAction(KIcon("kdenlive-show-audiothumb"), i18n("Show audio thumbnails"));
     m_buttonAudioThumbs->setCheckable(true);
-    m_buttonAudioThumbs->setChecked(KdenliveSettings::videothumbnails());
+    m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
     connect(m_buttonAudioThumbs, SIGNAL(triggered()), this, SLOT(slotSwitchAudioThumbs()));
 
-    m_buttonShowMarkers = toolbar->addAction(KIcon("audio-mpeg"), i18n("Show markers comments"));
+    m_buttonShowMarkers = toolbar->addAction(KIcon("kdenlive-show-markers"), i18n("Show markers comments"));
     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->setCheckable(true);
+    m_buttonSnap->setChecked(KdenliveSettings::snaptopoints());
+    connect(m_buttonSnap, SIGNAL(triggered()), this, SLOT(slotSwitchSnap()));
     layout->addWidget(toolbar);
 
-    statusBar()->insertPermanentWidget(0, statusProgressBar, 1);
-    statusBar()->insertPermanentWidget(1, statusLabel, 1);
+
+    actionWidget = toolbar->widgetForAction(m_buttonVideoThumbs);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
+    actionWidget = toolbar->widgetForAction(m_buttonAudioThumbs);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
+    actionWidget = toolbar->widgetForAction(m_buttonShowMarkers);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
+    actionWidget = toolbar->widgetForAction(m_buttonSnap);
+    actionWidget->setMaximumWidth(24);
+    actionWidget->setMinimumHeight(17);
+
+    m_messageLabel = new StatusBarMessageLabel(this);
+    m_messageLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::MinimumExpanding);
+
+    statusBar()->addWidget(m_messageLabel, 10);
+    statusBar()->addWidget(statusProgressBar, 0);
     statusBar()->insertPermanentWidget(ID_TIMELINE_BUTTONS, w);
     statusBar()->insertPermanentFixedItem("00:00:00:00", ID_TIMELINE_POS);
     statusBar()->insertPermanentWidget(ID_TIMELINE_FORMAT, m_timecodeFormat);
     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);
 
-    KAction* clearAction = new KAction(KIcon("document-new"), i18n("Clear"), this);
-    clearAction->setShortcut(Qt::CTRL + Qt::Key_W);
-    actionCollection()->addAction("clear", clearAction);
-    /*connect(clearAction, SIGNAL(triggered(bool)),
-            textArea, SLOT(clear()));*/
+    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);
+
+    m_projectSearch = new KAction(KIcon("edit-find"), i18n("Find"), this);
+    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);
+    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* projectAction = new KAction(KIcon("document-new"), i18n("Project Settings"), this);
-    actionCollection()->addAction("project_settings", projectAction);
+    KAction* projectAction = new KAction(KIcon("configure"), i18n("Project Settings"), this);
+    collection->addAction("project_settings", projectAction);
     connect(projectAction, SIGNAL(triggered(bool)), this, SLOT(slotEditProjectSettings()));
 
-    KAction* projectRender = new KAction(KIcon("document-new"), i18n("Render Project"), this);
-    actionCollection()->addAction("project_render", projectRender);
+    KAction* projectRender = new KAction(KIcon("media-record"), i18n("Render"), this);
+    collection->addAction("project_render", projectRender);
     connect(projectRender, SIGNAL(triggered(bool)), this, SLOT(slotRenderProject()));
 
     KAction* monitorPlay = new KAction(KIcon("media-playback-start"), i18n("Play"), this);
-    monitorPlay->setShortcut(Qt::Key_Space);
-    actionCollection()->addAction("monitor_play", monitorPlay);
+    KShortcut playShortcut;
+    playShortcut.setPrimary(Qt::Key_Space);
+    playShortcut.setAlternate(Qt::Key_K);
+    monitorPlay->setShortcut(playShortcut);
+    collection->addAction("monitor_play", monitorPlay);
     connect(monitorPlay, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotPlay()));
 
+    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 = 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* 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);
+    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);
+    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);
+    projectStart->setShortcut(Qt::CTRL + Qt::Key_Home);
+    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);
+    projectEnd->setShortcut(Qt::CTRL + Qt::Key_End);
+    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* 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);
+    collection->addAction("change_clip_speed", editTimelineClipSpeed);
+    connect(editTimelineClipSpeed, SIGNAL(triggered(bool)), this, SLOT(slotChangeClipSpeed()));
+
     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("edit-delete"), i18n("Add Marker to Clip"), this);
-    actionCollection()->addAction("add_clip_marker", addClipMarker);
+    KAction* addClipMarker = new KAction(KIcon("bookmark-new"), i18n("Add Marker to Clip"), 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);
+    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);
+    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);
+    collection->addAction("edit_clip_marker", editClipMarker);
+    connect(editClipMarker, SIGNAL(triggered(bool)), this, SLOT(slotEditClipMarker()));
+
+    KAction *addGuide = new KAction(KIcon("document-new"), i18n("Add Guide"), this);
+    collection->addAction("add_guide", addGuide);
+    connect(addGuide, SIGNAL(triggered()), this, SLOT(slotAddGuide()));
+
+    QAction *delGuide = new KAction(KIcon("edit-delete"), i18n("Delete Guide"), this);
+    collection->addAction("delete_guide", delGuide);
+    connect(delGuide, SIGNAL(triggered()), this, SLOT(slotDeleteGuide()));
+
+    QAction *editGuide = new KAction(KIcon("document-properties"), i18n("Edit Guide"), this);
+    collection->addAction("edit_guide", editGuide);
+    connect(editGuide, SIGNAL(triggered()), this, SLOT(slotEditGuide()));
+
+    QAction *delAllGuides = new KAction(KIcon("edit-delete"), i18n("Delete All Guides"), this);
+    collection->addAction("delete_all_guides", delAllGuides);
+    connect(delAllGuides, SIGNAL(triggered()), this, SLOT(slotDeleteAllGuides()));
+
+    QAction *pasteEffects = new KAction(KIcon("edit-paste"), i18n("Paste Effects"), this);
+    collection->addAction("paste_effects", pasteEffects);
+    connect(pasteEffects , SIGNAL(triggered()), this, SLOT(slotPasteEffects()));
+
     KStandardAction::quit(this, SLOT(queryQuit()),
-                          actionCollection());
+                          collection);
 
     KStandardAction::open(this, SLOT(openFile()),
-                          actionCollection());
-
-    m_fileOpenRecent = KStandardAction::openRecent(this, SLOT(openFile(const KUrl &)),
-                       actionCollection());
+                          collection);
 
-    KStandardAction::save(this, SLOT(saveFile()),
-                          actionCollection());
+    m_saveAction = KStandardAction::save(this, SLOT(saveFile()),
+                                         collection);
 
     KStandardAction::saveAs(this, SLOT(saveFileAs()),
-                            actionCollection());
+                            collection);
 
     KStandardAction::openNew(this, SLOT(newFile()),
-                             actionCollection());
+                             collection);
 
     KStandardAction::preferences(this, SLOT(slotPreferences()),
-                                 actionCollection());
+                                 collection);
 
-    KStandardAction::undo(this, SLOT(undo()),
-                          actionCollection());
+    KStandardAction::configureNotifications(this , SLOT(configureNotifications()) , collection);
 
-    KStandardAction::redo(this, SLOT(redo()),
-                          actionCollection());
+    KStandardAction::copy(this, SLOT(slotCopy()),
+                          collection);
 
-    KStandardAction::fullScreen(this, SLOT(slotFullScreen()), this, actionCollection());
+    KStandardAction::paste(this, SLOT(slotPaste()),
+                           collection);
 
-    connect(actionCollection(), SIGNAL(actionHovered(QAction*)),
-            this, SLOT(slotDisplayActionMessage(QAction*)));
-    //connect(actionCollection(), SIGNAL( clearStatusText() ),
-    //statusBar(), SLOT( clear() ) );
+    KAction *undo = KStandardAction::undo(m_commandStack, SLOT(undo()),
+                                          collection);
+    undo->setEnabled(false);
+    connect(m_commandStack, SIGNAL(canUndoChanged(bool)), undo, SLOT(setEnabled(bool)));
 
-    readOptions();
-}
+    KAction *redo = KStandardAction::redo(m_commandStack, SLOT(redo()),
+                                          collection);
+    redo->setEnabled(false);
+    connect(m_commandStack, SIGNAL(canRedoChanged(bool)), redo, SLOT(setEnabled(bool)));
 
-void MainWindow::undo() {
-    m_commandStack->undo();
-}
+    KStandardAction::fullScreen(this, SLOT(slotFullScreen()), this, collection);
 
-void MainWindow::redo() {
-    m_commandStack->redo();
+    connect(collection, SIGNAL(actionHovered(QAction*)),
+            this, SLOT(slotDisplayActionMessage(QAction*)));
+    //connect(collection, SIGNAL( clearStatusText() ),
+    //statusBar(), SLOT( clear() ) );
 }
 
 void MainWindow::slotDisplayActionMessage(QAction *a) {
@@ -557,36 +803,52 @@ void MainWindow::saveOptions() {
 void MainWindow::readOptions() {
     KSharedConfigPtr config = KGlobal::config();
     m_fileOpenRecent->loadEntries(KConfigGroup(config, "Recent Files"));
+    KConfigGroup initialGroup(config, "version");
+    if (!initialGroup.exists()) {
+        // this is our first run, show Wizard
+        Wizard *w = new Wizard(this);
+        if (w->exec() == QDialog::Accepted && w->isOk()) {
+            w->adjustSettings();
+            initialGroup.writeEntry("version", "0.7");
+            delete w;
+        } else {
+            ::exit(1);
+        }
+    }
 }
 
 void MainWindow::newFile() {
     QString profileName;
     KUrl projectFolder;
+    QPoint projectTracks(3, 2);
     if (m_timelineArea->count() == 0) profileName = KdenliveSettings::default_profile();
     else {
         ProjectSettings *w = new ProjectSettings;
         if (w->exec() != QDialog::Accepted) return;
         profileName = w->selectedProfile();
         projectFolder = w->selectedFolder();
+        projectTracks = w->tracks();
         delete w;
     }
-    MltVideoProfile prof = ProfilesDialog::getVideoProfile(profileName);
-    if (prof.width == 0) prof = ProfilesDialog::getVideoProfile("dv_pal");
-    KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, prof, m_commandStack);
+    KdenliveDoc *doc = new KdenliveDoc(KUrl(), projectFolder, m_commandStack, profileName, projectTracks,  this);
+    doc->m_autosave = new KAutoSaveFile(KUrl(), doc);
     TrackView *trackView = new TrackView(doc, this);
-    m_timelineArea->addTab(trackView, KIcon("kdenlive"), i18n("Untitled") + " / " + prof.description);
-    if (m_timelineArea->count() == 1)
+    m_timelineArea->addTab(trackView, KIcon("kdenlive"), doc->description());
+    if (m_timelineArea->count() == 1) {
+        connectDocumentInfo(doc);
         connectDocument(trackView, doc);
-    else m_timelineArea->setTabBarHidden(false);
+    } else m_timelineArea->setTabBarHidden(false);
 }
 
 void MainWindow::activateDocument() {
+    if (m_timelineArea->currentWidget() == NULL) return;
     TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
     KdenliveDoc *currentDoc = currentTab->document();
+    connectDocumentInfo(currentDoc);
     connectDocument(currentTab, currentDoc);
 }
 
-void MainWindow::slotRemoveTab() {
+void MainWindow::closeCurrentDocument() {
     QWidget *w = m_timelineArea->currentWidget();
     // closing current document
     int ix = m_timelineArea->currentIndex() + 1;
@@ -594,23 +856,40 @@ void MainWindow::slotRemoveTab() {
     m_timelineArea->setCurrentIndex(ix);
     TrackView *tabToClose = (TrackView *) w;
     KdenliveDoc *docToClose = tabToClose->document();
+    if (docToClose && docToClose->isModified()) {
+        switch (KMessageBox::warningYesNoCancel(this, i18n("Save changes to document ?"))) {
+        case KMessageBox::Yes :
+            // save document here. If saving fails, return false;
+            saveFile();
+            break;
+        case KMessageBox::Cancel :
+            return;
+        default:
+            break;
+        }
+    }
     m_timelineArea->removeTab(m_timelineArea->indexOf(w));
     if (m_timelineArea->count() == 1) m_timelineArea->setTabBarHidden(true);
     delete docToClose;
     delete w;
+    if (m_timelineArea->count() == 0) m_activeDocument = NULL;
 }
 
 void MainWindow::saveFileAs(const QString &outputFileName) {
     m_projectMonitor->saveSceneList(outputFileName, m_activeDocument->documentInfoXml());
     m_activeDocument->setUrl(KUrl(outputFileName));
+    if (m_activeDocument->m_autosave == NULL) {
+        m_activeDocument->m_autosave = new KAutoSaveFile(KUrl(outputFileName), this);
+    } else m_activeDocument->m_autosave->setManagedFile(KUrl(outputFileName));
     setCaption(m_activeDocument->description());
     m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
     m_timelineArea->setTabToolTip(m_timelineArea->currentIndex(), m_activeDocument->url().path());
     m_activeDocument->setModified(false);
+    m_fileOpenRecent->addUrl(KUrl(outputFileName));
 }
 
 void MainWindow::saveFileAs() {
-    QString outputFile = KFileDialog::getSaveFileName();
+    QString outputFile = KFileDialog::getSaveFileName(KUrl(), "*.kdenlive|Kdenlive project files (*.kdenlive)");
     if (QFile::exists(outputFile)) {
         if (KMessageBox::questionYesNo(this, i18n("File already exists.\nDo you want to overwrite it ?")) == KMessageBox::No) return;
     }
@@ -623,38 +902,101 @@ void MainWindow::saveFile() {
         saveFileAs();
     } else {
         saveFileAs(m_activeDocument->url().path());
+        m_activeDocument->m_autosave->resize(0);
     }
 }
 
-void MainWindow::openFile() { //changed
-    KUrl url = KFileDialog::getOpenUrl(KUrl(), "application/vnd.kde.kdenlive;*.kdenlive");
+void MainWindow::openFile() {
+    KUrl url = KFileDialog::getOpenUrl(KUrl(), "*.kdenlive|Kdenlive project files (*.kdenlive)\n*.westley|MLT project files (*.westley)");
     if (url.isEmpty()) return;
     m_fileOpenRecent->addUrl(url);
     openFile(url);
 }
 
-void MainWindow::openFile(const KUrl &url) { //new
-    //TODO: get video profile from url before opening it
-    MltVideoProfile prof = ProfilesDialog::getVideoProfile(KdenliveSettings::default_profile());
-    if (prof.width == 0) prof = ProfilesDialog::getVideoProfile("dv_pal");
-    KdenliveDoc *doc = new KdenliveDoc(url, KUrl(), prof, m_commandStack);
+void MainWindow::openLastFile() {
+    KSharedConfigPtr config = KGlobal::config();
+    KUrl::List urls = m_fileOpenRecent->urls();
+    if (urls.isEmpty()) newFile();
+    else openFile(urls.last());
+}
+
+void MainWindow::openFile(const KUrl &url) {
+    // Check for backup file
+    QList<KAutoSaveFile *> staleFiles = KAutoSaveFile::staleFiles(url);
+    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);
+            return;
+        } else {
+            // remove the stale files
+            foreach(KAutoSaveFile *stale, staleFiles) {
+                stale->open(QIODevice::ReadWrite);
+                delete stale;
+            }
+        }
+    }
+    if (!KdenliveSettings::activatetabs()) closeCurrentDocument();
+    doOpenFile(url, NULL);
+}
+
+void MainWindow::doOpenFile(const KUrl &url, KAutoSaveFile *stale) {
+    KdenliveDoc *doc;
+    doc = new KdenliveDoc(url, KUrl(), m_commandStack, QString(), QPoint(3, 2), this);
+    if (stale == NULL) {
+        stale = new KAutoSaveFile(url, doc);
+        doc->m_autosave = stale;
+    } else {
+        doc->m_autosave = stale;
+        doc->setUrl(stale->managedFile());
+        doc->setModified(true);
+        stale->setParent(doc);
+    }
+    connectDocumentInfo(doc);
     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());
     if (m_timelineArea->count() > 1) m_timelineArea->setTabBarHidden(false);
-    //connectDocument(trackView, doc);
+    slotGotProgressInfo(QString(), -1);
+    m_clipMonitor->refreshMonitor(true);
+}
+
+void MainWindow::recoverFiles(QList<KAutoSaveFile *> staleFiles) {
+    if (!KdenliveSettings::activatetabs()) closeCurrentDocument();
+    foreach(KAutoSaveFile *stale, staleFiles) {
+        /*if (!stale->open(QIODevice::QIODevice::ReadOnly)) {
+                  // show an error message; we could not steal the lockfile
+                  // maybe another application got to the file before us?
+                  delete stale;
+                  continue;
+        }*/
+        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);
+    }
 }
 
 
-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 << "*";
@@ -673,10 +1015,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()) exit(1);
+            if (mltPath.isEmpty()) ::exit(0);
             KdenliveSettings::setMltpath(mltPath.path());
             QStringList profilesList = QDir(KdenliveSettings::mltpath()).entryList(profilesFilter, QDir::Files);
         }
@@ -684,11 +1028,13 @@ void MainWindow::parseProfiles() {
 
     if (KdenliveSettings::rendererpath().isEmpty()) {
         // Cannot find the MLT inigo renderer, ask for location
-        KUrlRequesterDialog *getUrl = new KUrlRequesterDialog(KdenliveSettings::mltpath(), i18n("Cannot find the inigo program required for rendering (part of Mlt)"), this);
-        getUrl->exec();
+        KUrlRequesterDialog *getUrl = new KUrlRequesterDialog(QString(), i18n("Cannot find the inigo program required for rendering (part of Mlt)"), this);
+        if (getUrl->exec() == QDialog::Rejected) {
+            ::exit(0);
+        }
         KUrl rendererPath = getUrl->selectedUrl();
         delete getUrl;
-        if (rendererPath.isEmpty()) exit(1);
+        if (rendererPath.isEmpty()) ::exit(0);
         KdenliveSettings::setRendererpath(rendererPath.path());
     }
 
@@ -710,11 +1056,11 @@ void MainWindow::slotEditProjectSettings() {
     if (w->exec() == QDialog::Accepted) {
         QString profile = w->selectedProfile();
         m_activeDocument->setProfilePath(profile);
-        m_monitorManager->resetProfiles(profile);
-        setCaption(m_activeDocument->description());
-        KdenliveSettings::setCurrent_profile(m_activeDocument->profilePath());
+        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_monitorManager->setTimecode(m_activeDocument->timecode());
         m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
 
         // We need to desactivate & reactivate monitors to get a refresh
@@ -726,7 +1072,8 @@ 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 &, bool, bool)), this, SLOT(slotDoRender(const QString&, const QString&, const QStringList &, bool, bool)));
+        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());
     }
     /*TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
     if (currentTab) m_renderWidget->setTimeline(currentTab);
@@ -734,7 +1081,7 @@ void MainWindow::slotRenderProject() {
     m_renderWidget->show();
 }
 
-void MainWindow::slotDoRender(const QString &dest, const QString &render, const QStringList &avformat_args, bool zoneOnly, bool playAfter) {
+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) {
     if (dest.isEmpty()) return;
     int in;
     int out;
@@ -751,10 +1098,21 @@ void MainWindow::slotDoRender(const QString &dest, const QString &render, const
         QStringList args;
         args << "-erase";
         if (zoneOnly) args << "in=" + QString::number(in) << "out=" + QString::number(out);
+        else if (guideStart != -1) {
+            args << "in=" + QString::number(GenTime(guideStart).frames(m_activeDocument->fps())) << "out=" + QString::number(GenTime(guideEnd).frames(m_activeDocument->fps()));
+        }
+        if (!overlay_args.isEmpty()) args << "preargs=" + overlay_args.join(" ");
         QString videoPlayer = "-";
-        if (playAfter) videoPlayer = "kmplayer";
-        args << "inigo" << m_activeDocument->profilePath() << render << videoPlayer << temp.fileName() << dest << avformat_args;
-        QProcess::startDetached("kdenlive_render", args);
+        if (playAfter) {
+            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;
+        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);
     }
 }
 
@@ -771,6 +1129,7 @@ void MainWindow::slotUpdateMousePosition(int pos) {
 
 void MainWindow::slotUpdateDocumentState(bool modified) {
     setCaption(m_activeDocument->description(), modified);
+    m_saveAction->setEnabled(modified);
     if (modified) {
         m_timelineArea->setTabTextColor(m_timelineArea->currentIndex(), palette().color(QPalette::Link));
         m_timelineArea->setTabIcon(m_timelineArea->currentIndex(), KIcon("document-save"));
@@ -780,6 +1139,14 @@ void MainWindow::slotUpdateDocumentState(bool modified) {
     }
 }
 
+void MainWindow::connectDocumentInfo(KdenliveDoc *doc) {
+    if (m_activeDocument) {
+        if (m_activeDocument == doc) return;
+        disconnect(m_activeDocument, SIGNAL(progressInfo(const QString &, int)), this, SLOT(slotGotProgressInfo(const QString &, int)));
+    }
+    connect(doc, SIGNAL(progressInfo(const QString &, int)), this, SLOT(slotGotProgressInfo(const QString &, int)));
+}
+
 void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) { //changed
     //m_projectMonitor->stop();
     kDebug() << "///////////////////   CONNECTING DOC TO PROJECT VIEW ////////////////";
@@ -788,105 +1155,136 @@ void MainWindow::connectDocument(TrackView *trackView, KdenliveDoc *doc) { //cha
         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(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(addProjectFolder(const QString, int, bool, bool)), m_projectList, SLOT(slotAddFolder(const QString, int, bool, bool)));
-            disconnect(m_activeDocument, SIGNAL(signalDeleteProjectClip(int)), m_projectList, SLOT(slotDeleteClip(int)));
-            disconnect(m_activeDocument, SIGNAL(updateClipDisplay(int)), m_projectList, SLOT(slotUpdateClip(int)));
-            disconnect(m_activeDocument, SIGNAL(refreshClipThumbnail(int)), m_projectList, SLOT(slotRefreshClipThumbnail(int)));
-            disconnect(m_activeDocument, SIGNAL(deletTimelineClip(int)), m_activeTimeline, SLOT(slotDeleteClip(int)));
-            disconnect(m_activeDocument, SIGNAL(thumbsProgress(KUrl, int)), this, SLOT(slotGotProgressInfo(KUrl, int)));
+            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(trackView, SIGNAL(clipItemSelected(ClipItem*)), this, SLOT(slotActivateEffectStackView()));
+            disconnect(m_activeTimeline, SIGNAL(clipItemSelected(ClipItem*)), this, SLOT(slotActivateEffectStackView()));
             disconnect(m_activeTimeline, SIGNAL(transitionItemSelected(Transition*)), transitionConfig, SLOT(slotTransitionItemSelected(Transition*)));
-            disconnect(trackView, SIGNAL(transitionItemSelected(Transition*)), this, SLOT(slotActivateTransitionView()));
+            disconnect(m_activeTimeline, SIGNAL(transitionItemSelected(Transition*)), 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_activeDocument, SIGNAL(docModified(bool)), this, SLOT(slotUpdateDocumentState(bool)));
-            disconnect(effectStack, SIGNAL(updateClipEffect(ClipItem*, QDomElement, QDomElement)), m_activeTimeline->projectView(), SLOT(slotUpdateClipEffect(ClipItem*, QDomElement, QDomElement)));
+            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*, QDomElement, bool)), m_activeTimeline->projectView(), SLOT(slotChangeEffectState(ClipItem*, QDomElement, bool)));
+            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(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(m_activeTimeline->projectView(), SIGNAL(activateDocumentMonitor()), m_projectMonitor, SLOT(activateMonitor()));
+            disconnect(trackView, SIGNAL(zoneMoved(int, int)), m_projectMonitor, SLOT(slotZoneMoved(int, int)));
+            effectStack->clear();
         }
         m_activeDocument->setRenderer(NULL);
-        disconnect(m_projectList, SIGNAL(clipSelected(const QDomElement &)), m_clipMonitor, SLOT(slotSetXml(const QDomElement &)));
+        disconnect(m_projectList, SIGNAL(clipSelected(DocClipBase *)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *)));
         m_clipMonitor->stop();
     }
-    m_monitorManager->resetProfiles(doc->profilePath());
+    KdenliveSettings::setCurrent_profile(doc->profilePath());
+    KdenliveSettings::setProject_fps(doc->fps());
+    m_monitorManager->resetProfiles(doc->timecode());
     m_projectList->setDocument(doc);
-    connect(m_projectList, SIGNAL(clipSelected(const QDomElement &)), m_clipMonitor, SLOT(slotSetXml(const QDomElement &)));
+    transitionConfig->updateProjectFormat(doc->mltProfile());
+    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(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(addProjectFolder(const QString, int, bool, bool)), m_projectList, SLOT(slotAddFolder(const QString, int, bool, bool)));
-    connect(doc, SIGNAL(signalDeleteProjectClip(int)), m_projectList, SLOT(slotDeleteClip(int)));
-    connect(doc, SIGNAL(updateClipDisplay(int)), m_projectList, SLOT(slotUpdateClip(int)));
-    connect(doc, SIGNAL(refreshClipThumbnail(int)), m_projectList, SLOT(slotRefreshClipThumbnail(int)));
+    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 &)));
+    connect(doc, SIGNAL(selectLastAddedClip(const QString &)), m_projectList, SLOT(slotSelectClip(const QString &)));
 
-    connect(doc, SIGNAL(deletTimelineClip(int)), trackView, SLOT(slotDeleteClip(int)));
-    connect(doc, SIGNAL(thumbsProgress(KUrl, int)), this, SLOT(slotGotProgressInfo(KUrl, int)));
+    connect(doc, SIGNAL(deleteTimelineClip(const QString &)), trackView, SLOT(slotDeleteClip(const QString &)));
     connect(doc, SIGNAL(docModified(bool)), this, SLOT(slotUpdateDocumentState(bool)));
-
+    connect(doc, SIGNAL(guidesUpdated()), this, SLOT(slotGuidesUpdated()));
 
 
     connect(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()));
-    m_zoomSlider->setValue(trackView->currentZoom());
+    m_zoomSlider->setValue(doc->zoom());
     connect(m_zoomSlider, SIGNAL(valueChanged(int)), trackView, SLOT(slotChangeZoom(int)));
     connect(trackView->projectView(), SIGNAL(zoomIn()), this, SLOT(slotZoomIn()));
     connect(trackView->projectView(), SIGNAL(zoomOut()), this, SLOT(slotZoomOut()));
-    connect(effectStack, SIGNAL(updateClipEffect(ClipItem*, QDomElement, QDomElement)), trackView->projectView(), SLOT(slotUpdateClipEffect(ClipItem*, QDomElement, QDomElement)));
+    connect(trackView->projectView(), SIGNAL(displayMessage(const QString&, MessageType)), m_messageLabel, SLOT(setMessage(const QString&, MessageType)));
+
+    connect(trackView->projectView(), SIGNAL(showClipFrame(DocClipBase *, const int)), m_clipMonitor, SLOT(slotSetXml(DocClipBase *, const int)));
+
+
+    connect(effectStack, SIGNAL(updateClipEffect(ClipItem*, QDomElement, QDomElement, int)), trackView->projectView(), SLOT(slotUpdateClipEffect(ClipItem*, QDomElement, QDomElement, int)));
     connect(effectStack, SIGNAL(removeEffect(ClipItem*, QDomElement)), trackView->projectView(), SLOT(slotDeleteEffect(ClipItem*, QDomElement)));
-    connect(effectStack, SIGNAL(changeEffectState(ClipItem*, QDomElement, bool)), trackView->projectView(), SLOT(slotChangeEffectState(ClipItem*, QDomElement, bool)));
+    connect(effectStack, SIGNAL(changeEffectState(ClipItem*, int, bool)), trackView->projectView(), SLOT(slotChangeEffectState(ClipItem*, int, bool)));
     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(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)));
+
     trackView->projectView()->setContextMenu(m_timelineContextMenu, m_timelineContextClipMenu, m_timelineContextTransitionMenu);
     m_activeTimeline = trackView;
-    KdenliveSettings::setCurrent_profile(doc->profilePath());
     if (m_renderWidget) m_renderWidget->setDocumentStandard(doc->getDocumentStandard());
-    m_monitorManager->setTimecode(doc->timecode());
     doc->setRenderer(m_projectMonitor->render);
     m_commandStack->setActiveStack(doc->commandStack());
-    if (m_commandStack->isClean()) kDebug() << "////////////  UNDO STACK IS CLEAN";
-    else  kDebug() << "////////////  UNDO STACK IS NOT CLEAN*******************";
+    KdenliveSettings::setProject_display_ratio(doc->dar());
+    m_projectList->updateAllClips();
+    trackView->projectView()->updateAllThumbs();
+
 
     //m_overView->setScene(trackView->projectScene());
     //m_overView->scale(m_overView->width() / trackView->duration(), m_overView->height() / (50 * trackView->tracksNumber()));
     //m_overView->fitInView(m_overView->itemAt(0, 50), Qt::KeepAspectRatio);
 
-    setCaption(doc->description());
+    setCaption(doc->description(), doc->isModified());
+    m_saveAction->setEnabled(doc->isModified());
     m_activeDocument = doc;
 }
 
-void MainWindow::slotPreferences() {
+void MainWindow::slotGuidesUpdated() {
+    if (m_renderWidget) m_renderWidget->setGuides(m_activeDocument->guidesXml(), m_activeDocument->projectDuration());
+}
+
+void MainWindow::slotPreferences(int page, int option) {
     //An instance of your dialog could be already created and could be
     // cached, in which case you want to display the cached dialog
     // instead of creating another one
-    if (KConfigDialog::showDialog("settings"))
+    if (KConfigDialog::showDialog("settings")) {
+        if (page != -1) static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"))->showPage(page, option);
         return;
+    }
 
     // KConfigDialog didn't find an instance of this dialog, so lets
     // create it :
     KdenliveSettingsDialog* dialog = new KdenliveSettingsDialog(this);
     connect(dialog, SIGNAL(settingsChanged(const QString&)), this, SLOT(updateConfiguration()));
+    connect(dialog, SIGNAL(doResetProfile()), m_monitorManager, SLOT(slotResetProfiles()));
     dialog->show();
+    if (page != -1) dialog->showPage(page, option);
 }
 
 void MainWindow::updateConfiguration() {
     //TODO: we should apply settings to all projects, not only the current one
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        currentTab->refresh();
-        currentTab->projectView()->checkAutoScroll();
-        currentTab->projectView()->checkTrackHeight();
+    if (m_activeTimeline) {
+        m_activeTimeline->refresh();
+        m_activeTimeline->projectView()->checkAutoScroll();
+        m_activeTimeline->projectView()->checkTrackHeight();
         if (m_activeDocument) m_activeDocument->clipManager()->checkAudioThumbs();
     }
     m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
@@ -897,19 +1295,17 @@ void MainWindow::updateConfiguration() {
 
 void MainWindow::slotSwitchVideoThumbs() {
     KdenliveSettings::setVideothumbnails(!KdenliveSettings::videothumbnails());
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        currentTab->refresh();
+    if (m_activeTimeline) {
+        m_activeTimeline->refresh();
     }
     m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
 }
 
 void MainWindow::slotSwitchAudioThumbs() {
     KdenliveSettings::setAudiothumbnails(!KdenliveSettings::audiothumbnails());
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        currentTab->refresh();
-        currentTab->projectView()->checkAutoScroll();
+    if (m_activeTimeline) {
+        m_activeTimeline->refresh();
+        m_activeTimeline->projectView()->checkAutoScroll();
         if (m_activeDocument) m_activeDocument->clipManager()->checkAudioThumbs();
     }
     m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
@@ -917,34 +1313,78 @@ void MainWindow::slotSwitchAudioThumbs() {
 
 void MainWindow::slotSwitchMarkersComments() {
     KdenliveSettings::setShowmarkers(!KdenliveSettings::showmarkers());
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        currentTab->refresh();
+    if (m_activeTimeline) {
+        m_activeTimeline->refresh();
     }
     m_buttonShowMarkers->setChecked(KdenliveSettings::showmarkers());
 }
 
-
+void MainWindow::slotSwitchSnap() {
+    KdenliveSettings::setSnaptopoints(!KdenliveSettings::snaptopoints());
+    m_buttonShowMarkers->setChecked(KdenliveSettings::snaptopoints());
+}
 
 
 void MainWindow::slotDeleteTimelineClip() {
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        currentTab->projectView()->deleteSelectedClips();
+    if (projectListDock->isActiveWindow()) m_projectList->slotRemoveClip();
+    else if (m_activeTimeline) {
+        m_activeTimeline->projectView()->deleteSelectedClips();
+    }
+}
+
+void MainWindow::slotChangeClipSpeed() {
+    if (m_activeTimeline) {
+        m_activeTimeline->projectView()->changeClipSpeed();
     }
 }
 
 void MainWindow::slotAddClipMarker() {
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        currentTab->projectView()->slotAddClipMarker();
+    if (m_activeTimeline) {
+        m_activeTimeline->projectView()->slotAddClipMarker();
     }
 }
 
+void MainWindow::slotDeleteClipMarker() {
+    if (m_activeTimeline) {
+        m_activeTimeline->projectView()->slotDeleteClipMarker();
+    }
+}
+
+void MainWindow::slotDeleteAllClipMarkers() {
+    if (m_activeTimeline) {
+        m_activeTimeline->projectView()->slotDeleteAllClipMarkers();
+    }
+}
+
+void MainWindow::slotEditClipMarker() {
+    if (m_activeTimeline) {
+        m_activeTimeline->projectView()->slotEditClipMarker();
+    }
+}
+
+void MainWindow::slotAddGuide() {
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotAddGuide();
+}
+
+void MainWindow::slotEditGuide() {
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotEditGuide();
+}
+
+void MainWindow::slotDeleteGuide() {
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotDeleteGuide();
+}
+
+void MainWindow::slotDeleteAllGuides() {
+    if (m_activeTimeline)
+        m_activeTimeline->projectView()->slotDeleteAllGuides();
+}
+
 void MainWindow::slotCutTimelineClip() {
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        currentTab->projectView()->cutSelectedClips();
+    if (m_activeTimeline) {
+        m_activeTimeline->projectView()->cutSelectedClips();
     }
 }
 
@@ -953,6 +1393,14 @@ void MainWindow::slotAddProjectClip(KUrl url) {
         m_activeDocument->slotAddClipFile(url, QString());
 }
 
+void MainWindow::slotAddTransition(QAction *result) {
+    if (!result) return;
+    QDomElement effect = transitions.getEffectByName(result->data().toString());
+    if (m_activeTimeline) {
+        m_activeTimeline->projectView()->slotAddTransitionToSelectedClips(effect);
+    }
+}
+
 void MainWindow::slotAddVideoEffect(QAction *result) {
     if (!result) return;
     QDomElement effect = videoEffects.getEffectByName(result->data().toString());
@@ -967,6 +1415,7 @@ void MainWindow::slotAddAudioEffect(QAction *result) {
 
 void MainWindow::slotAddCustomEffect(QAction *result) {
     if (!result) return;
+    if (result->data().toString().isEmpty()) return;
     QDomElement effect = customEffects.getEffectByName(result->data().toString());
     slotAddEffect(effect);
 }
@@ -980,35 +1429,57 @@ void MainWindow::slotZoomOut() {
 }
 
 void MainWindow::slotFitZoom() {
-    TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-    if (currentTab) {
-        m_zoomSlider->setValue(currentTab->fitZoom());
+    if (m_activeTimeline) {
+        m_zoomSlider->setValue(m_activeTimeline->fitZoom());
     }
 }
 
-void MainWindow::slotGotProgressInfo(KUrl url, int progress) {
+void MainWindow::slotGotProgressInfo(const QString &message, int progress) {
     statusProgressBar->setValue(progress);
-    if (progress > 0) {
-        statusLabel->setText(tr("Creating Audio Thumbs"));
+    if (progress >= 0) {
+        if (!message.isEmpty()) m_messageLabel->setMessage(message, InformationMessage);//statusLabel->setText(message);
         statusProgressBar->setVisible(true);
     } else {
-        statusLabel->setText("");
+        m_messageLabel->setMessage(QString(), DefaultMessage);
         statusProgressBar->setVisible(false);
     }
 }
 
 void MainWindow::slotShowClipProperties(DocClipBase *clip) {
     if (clip->clipType() == TEXT) {
-        m_activeDocument->editTextClip(clip->getProperty("xml"), clip->getId());
+        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) {
+            QPixmap pix = dia_ui->renderedPixmap();
+            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);
+            m_clipMonitor->refreshMonitor(true);
+            m_activeDocument->setModified(true);
+        }
+        delete dia_ui;
+
+        //m_activeDocument->editTextClip(clip->getProperty("xml"), clip->getId());
         return;
     }
     ClipProperties dia(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)));
     if (dia.exec() == QDialog::Accepted) {
-        m_projectList->slotUpdateClipProperties(dia.clipId(), dia.properties());
+        EditClipCommand *command = new EditClipCommand(m_projectList, dia.clipId(), clip->properties(), dia.properties(), true);
+        m_activeDocument->commandStack()->push(command);
+
+        //m_projectList->slotUpdateClipProperties(dia.clipId(), dia.properties());
         if (dia.needsTimelineRefresh()) {
             // update clip occurences in timeline
-            TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-            currentTab->projectView()->slotUpdateClip(dia.clipId());
+            m_activeTimeline->projectView()->slotUpdateClip(dia.clipId());
         }
     }
 }
@@ -1028,16 +1499,30 @@ void MainWindow::slotActivateTransitionView() {
 }
 
 void MainWindow::slotSnapRewind() {
-    if (m_monitorManager->projectMonitorFocused()) {
-        TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-        currentTab->projectView()->slotSeekToPreviousSnap();
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline)
+            m_activeTimeline->projectView()->slotSeekToPreviousSnap();
     }
 }
 
 void MainWindow::slotSnapForward() {
-    if (m_monitorManager->projectMonitorFocused()) {
-        TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-        currentTab->projectView()->slotSeekToNextSnap();
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline)
+            m_activeTimeline->projectView()->slotSeekToNextSnap();
+    }
+}
+
+void MainWindow::slotClipStart() {
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline)
+            m_activeTimeline->projectView()->clipStart();
+    }
+}
+
+void MainWindow::slotClipEnd() {
+    if (m_projectMonitor->isActive()) {
+        if (m_activeTimeline)
+            m_activeTimeline->projectView()->clipEnd();
     }
 }
 
@@ -1047,11 +1532,146 @@ void MainWindow::slotChangeTool(QAction * action) {
 }
 
 void MainWindow::slotSetTool(PROJECTTOOL tool) {
-    if (m_activeDocument) {
+    if (m_activeDocument && m_activeTimeline) {
         //m_activeDocument->setTool(tool);
-        TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
-        currentTab->projectView()->setTool(tool);
+        m_activeTimeline->projectView()->setTool(tool);
     }
 }
 
+void MainWindow::slotCopy() {
+    if (!m_activeDocument || !m_activeTimeline) return;
+    m_activeTimeline->projectView()->copyClip();
+}
+
+void MainWindow::slotPaste() {
+    if (!m_activeDocument || !m_activeTimeline) return;
+    m_activeTimeline->projectView()->pasteClip();
+}
+
+void MainWindow::slotPasteEffects() {
+    if (!m_activeDocument || !m_activeTimeline) return;
+    m_activeTimeline->projectView()->pasteClipEffects();
+}
+
+void MainWindow::slotFind() {
+    if (!m_activeDocument || !m_activeTimeline) return;
+    m_projectSearch->setEnabled(false);
+    m_findActivated = true;
+    m_findString = QString();
+    m_activeTimeline->projectView()->initSearchStrings();
+    statusBar()->showMessage(i18n("Starting -- find text as you type"));
+    m_findTimer.start(5000);
+    qApp->installEventFilter(this);
+}
+
+void MainWindow::slotFindNext() {
+    if (m_activeTimeline && m_activeTimeline->projectView()->findNextString(m_findString)) {
+        statusBar()->showMessage(i18n("Found : %1", m_findString));
+    } else {
+        statusBar()->showMessage(i18n("Reached end of project"));
+    }
+    m_findTimer.start(4000);
+}
+
+void MainWindow::findAhead() {
+    if (m_activeTimeline && m_activeTimeline->projectView()->findString(m_findString)) {
+        m_projectSearchNext->setEnabled(true);
+        statusBar()->showMessage(i18n("Found : %1", m_findString));
+    } else {
+        m_projectSearchNext->setEnabled(false);
+        statusBar()->showMessage(i18n("Not found : %1", m_findString));
+    }
+}
+
+void MainWindow::findTimeout() {
+    m_projectSearchNext->setEnabled(false);
+    m_findActivated = false;
+    m_findString = QString();
+    statusBar()->showMessage(i18n("Find stopped"), 3000);
+    if (m_activeTimeline) m_activeTimeline->projectView()->clearSearchStrings();
+    m_projectSearch->setEnabled(true);
+    removeEventFilter(this);
+}
+
+void MainWindow::keyPressEvent(QKeyEvent *ke) {
+    if (m_findActivated) {
+        if (ke->key() == Qt::Key_Backspace) {
+            m_findString = m_findString.left(m_findString.length() - 1);
+
+            if (!m_findString.isEmpty()) {
+                findAhead();
+            } else {
+                findTimeout();
+            }
+
+            m_findTimer.start(4000);
+            ke->accept();
+            return;
+        } else if (ke->key() == Qt::Key_Escape) {
+            findTimeout();
+            ke->accept();
+            return;
+        } else if (ke->key() == Qt::Key_Space || !ke->text().trimmed().isEmpty()) {
+            m_findString += ke->text();
+
+            findAhead();
+
+            m_findTimer.start(4000);
+            ke->accept();
+            return;
+        }
+    } else KXmlGuiWindow::keyPressEvent(ke);
+}
+
+bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
+    if (m_findActivated) {
+        if (event->type() == QEvent::ShortcutOverride) {
+            QKeyEvent* ke = (QKeyEvent*) event;
+            if (ke->text().trimmed().isEmpty()) return false;
+            ke->accept();
+            return true;
+        } else return false;
+    } else {
+        // pass the event on to the parent class
+        return QMainWindow::eventFilter(obj, event);
+    }
+}
+
+void MainWindow::slotSaveZone(Render *render, QPoint zone) {
+    KDialog *dialog = new KDialog(this);
+    dialog->setCaption("Save clip zone");
+    dialog->setButtons(KDialog::Ok | KDialog::Cancel);
+
+    QWidget *widget = new QWidget(dialog);
+    dialog->setMainWidget(widget);
+
+    QVBoxLayout *vbox = new QVBoxLayout(widget);
+    QLabel *label1 = new QLabel(i18n("Save clip zone as:"), this);
+    QString path = m_activeDocument->projectFolder().path();
+    path.append("/");
+    path.append("untitled.westley");
+    KUrlRequester *url = new KUrlRequester(KUrl(path), this);
+    url->setFilter("video/mlt-playlist");
+    QLabel *label2 = new QLabel(i18n("Description:"), this);
+    KLineEdit *edit = new KLineEdit(this);
+    vbox->addWidget(label1);
+    vbox->addWidget(url);
+    vbox->addWidget(label2);
+    vbox->addWidget(edit);
+    if (dialog->exec() == QDialog::Accepted) render->saveZone(url->url(), edit->text(), zone);
+
+}
+
+void MainWindow::slotSetInPoint() {
+    if (m_clipMonitor->isActive()) {
+        m_clipMonitor->slotSetZoneStart();
+    } else m_activeTimeline->projectView()->setInPoint();
+}
+
+void MainWindow::slotSetOutPoint() {
+    if (m_clipMonitor->isActive()) {
+        m_clipMonitor->slotSetZoneEnd();
+    } else m_activeTimeline->projectView()->setOutPoint();
+}
+
 #include "mainwindow.moc"