* 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 "mainwindow.h"
+#include "mainwindowadaptor.h"
+#include "kdenlivesettings.h"
+#include "kdenlivesettingsdialog.h"
+#include "initeffects.h"
+#include "profilesdialog.h"
+#include "projectsettings.h"
+#include "events.h"
+#include "clipmanager.h"
+#include "projectlist.h"
+#include "monitor.h"
+#include "recmonitor.h"
+#include "monitormanager.h"
+#include "kdenlivedoc.h"
+#include "trackview.h"
+#include "customtrackview.h"
+#include "effectslistview.h"
+#include "effectstackview.h"
+#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"
+#include "kdenlive-config.h"
#include <KApplication>
#include <KAction>
#include <knewstuff2/engine.h>
#include <knewstuff2/ui/knewstuffaction.h>
-#include <mlt++/Mlt.h>
+#include <QTextStream>
+#include <QTimer>
+#include <QAction>
+#include <QKeyEvent>
-#include "mainwindow.h"
-#include "kdenlivesettings.h"
-#include "kdenlivesettingsdialog.h"
-#include "initeffects.h"
-#include "profilesdialog.h"
-#include "projectsettings.h"
-#include "events.h"
-#include "clipmanager.h"
-#include "projectlist.h"
-#include "monitor.h"
-#include "recmonitor.h"
-#include "monitormanager.h"
-#include "kdenlivedoc.h"
-#include "trackview.h"
-#include "customtrackview.h"
-#include "effectslistview.h"
-#include "effectstackview.h"
-#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 <stdlib.h>
+
+static const char version[] = VERSION;
static const int ID_STATUS_MSG = 1;
static const int ID_EDITMODE_MSG = 2;
static const int ID_TIMELINE_POS = 6;
static const int ID_TIMELINE_FORMAT = 7;
-namespace Mlt {
+namespace Mlt
+{
class Producer;
};
EffectsList MainWindow::customEffects;
EffectsList MainWindow::transitions;
-MainWindow::MainWindow(const QString &MltPath, const KUrl & Url, QWidget *parent)
- : KXmlGuiWindow(parent),
- m_activeDocument(NULL), m_activeTimeline(NULL), m_renderWidget(NULL),
+MainWindow::MainWindow(const QString &MltPath, const KUrl & Url, QWidget *parent) :
+ KXmlGuiWindow(parent),
+ m_activeDocument(NULL),
+ m_activeTimeline(NULL),
+ m_renderWidget(NULL),
#ifndef NO_JOGSHUTTLE
m_jogProcess(NULL),
#endif /* NO_JOGSHUTTLE */
- m_findActivated(false), m_initialized(false) {
+ m_findActivated(false),
+ m_initialized(false)
+{
+
+ // Create DBus interface
+ new MainWindowAdaptor(this);
+ QDBusConnection dbus = QDBusConnection::sessionBus();
+ dbus.registerObject("/MainWindow", this);
+
setlocale(LC_NUMERIC, "POSIX");
setFont(KGlobalSettings::toolBarFont());
parseProfiles(MltPath);
tabifyDockWidget(clipMonitorDock, recMonitorDock);
setCentralWidget(m_timelineArea);
+
setupGUI();
+ /*ScriptingPart* sp = new ScriptingPart(this, QStringList());
+ guiFactory()->addClient(sp);*/
+
+ loadPlugins();
//kDebug() << factory() << " " << factory()->container("video_effects_menu", this);
- m_projectMonitor->setupMenu(static_cast<QMenu*>(factory()->container("monitor_go", this)));
- m_clipMonitor->setupMenu(static_cast<QMenu*>(factory()->container("monitor_go", this)), static_cast<QMenu*>(factory()->container("marker_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;
effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
}
- foreach(QStringList value, effectsList) {
+ foreach(const QStringList &value, effectsList) {
action = new QAction(value.at(0), this);
action->setData(value);
videoEffectsMenu->addAction(action);
effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
}
- foreach(QStringList value, effectsList) {
+ foreach(const QStringList &value, effectsList) {
action = new QAction(value.at(0), this);
action->setData(value);
audioEffectsMenu->addAction(action);
effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
}
- foreach(QStringList value, effectsList) {
+ foreach(const QStringList &value, effectsList) {
action = new QAction(value.at(0), this);
action->setData(value);
m_customEffectsMenu->addAction(action);
effectInfo = transitions.effectIdInfo(ix);
effectsList.insert(effectInfo.at(0).toLower(), effectInfo);
}
- foreach(QStringList value, effectsList) {
+ foreach(const QStringList &value, effectsList) {
action = new QAction(value.at(0), this);
action->setData(value);
transitionsMenu->addAction(action);
m_timelineContextClipMenu->addAction(actionCollection()->action("delete_timeline_clip"));
m_timelineContextClipMenu->addAction(actionCollection()->action("change_clip_speed"));
+ m_timelineContextClipMenu->addAction(actionCollection()->action("group_clip"));
+ m_timelineContextClipMenu->addAction(actionCollection()->action("ungroup_clip"));
m_timelineContextClipMenu->addAction(actionCollection()->action("cut_timeline_clip"));
m_timelineContextClipMenu->addAction(actionCollection()->action(KStandardAction::name(KStandardAction::Copy)));
m_timelineContextClipMenu->addAction(actionCollection()->action("paste_effects"));
+ m_timelineContextClipMenu->addAction(actionCollection()->action("split_audio"));
QMenu *markersMenu = (QMenu*)(factory()->container("marker_menu", this));
m_timelineContextClipMenu->addMenu(markersMenu);
projectListDock->raise();
}
-void MainWindow::queryQuit() {
+void MainWindow::queryQuit()
+{
kDebug() << "----- SAVING CONFUIG";
if (queryClose()) kapp->quit();
}
//virtual
-bool MainWindow::queryClose() {
+bool MainWindow::queryClose()
+{
saveOptions();
if (m_monitorManager) m_monitorManager->stopActiveMonitor();
if (m_activeDocument && m_activeDocument->isModified()) {
return true;
}
-void MainWindow::saveProperties(KConfig*) {
+
+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(const 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)
+{
+ QMenu *addMenu = static_cast<QMenu*>(factory()->container("generators", this));
+ ClipGenerator *iGenerator = qobject_cast<ClipGenerator *>(plugin);
+ 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(const QString &text, texts) {
+ QAction *action = new QAction(text, plugin);
+ action->setData(text);
+ 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->data().toString(), m_activeDocument->projectFolder(), QStringList(), QStringList(), 25, 720, 576);
+ if (!clipUrl.isEmpty()) {
+ m_projectList->slotAddClip(QList <QUrl> () << clipUrl);
+ }
+}
+
+void MainWindow::saveProperties(KConfig*)
+{
// save properties here,used by session management
saveFile();
}
-void MainWindow::readProperties(KConfig *config) {
+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() {
+void MainWindow::slotReloadEffects()
+{
initEffects::parseCustomEffectsFile();
m_customEffectsMenu->clear();
const QStringList effects = customEffects.effectNames();
}
#ifndef NO_JOGSHUTTLE
-void MainWindow::activateShuttleDevice() {
+void MainWindow::activateShuttleDevice()
+{
if (m_jogProcess) delete m_jogProcess;
m_jogProcess = NULL;
if (KdenliveSettings::enableshuttle() == false) return;
connect(m_jogProcess, SIGNAL(button(int)), this, SLOT(slotShuttleButton(int)));
}
-void MainWindow::slotShuttleButton(int code) {
+void MainWindow::slotShuttleButton(int code)
+{
switch (code) {
case 5:
slotShuttleAction(KdenliveSettings::shuttle1());
}
}
-void MainWindow::slotShuttleAction(int code) {
+void MainWindow::slotShuttleAction(int code)
+{
switch (code) {
case 0:
return;
}
#endif /* NO_JOGSHUTTLE */
-void MainWindow::configureNotifications() {
+void MainWindow::configureNotifications()
+{
KNotifyConfigWidget::configure(this);
}
-void MainWindow::slotFullScreen() {
+void MainWindow::slotFullScreen()
+{
KToggleFullScreenAction::setFullScreen(this, actionCollection()->action("fullscreen")->isChecked());
}
-void MainWindow::slotAddEffect(QDomElement effect, GenTime pos, int track) {
+void MainWindow::slotAddEffect(QDomElement effect, GenTime pos, int track)
+{
if (!m_activeDocument) return;
if (effect.isNull()) {
kDebug() << "--- ERROR, TRYING TO APPEND NULL EFFECT";
currentTimeLine->projectView()->slotAddEffect(effect.cloneNode().toElement(), pos, track);
}
-void MainWindow::slotRaiseMonitor(bool clipMonitor) {
+void MainWindow::slotRaiseMonitor(bool clipMonitor)
+{
if (clipMonitor) clipMonitorDock->raise();
else projectMonitorDock->raise();
}
-void MainWindow::slotSetClipDuration(const QString &id, int duration) {
+void MainWindow::slotSetClipDuration(const QString &id, int duration)
+{
if (!m_activeDocument) return;
m_activeDocument->setProducerDuration(id, duration);
}
-void MainWindow::slotConnectMonitors() {
+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 &, bool)), m_projectMonitor->render, SLOT(getFileProperties(const QDomElement &, const QString &, bool)));
+ connect(m_projectMonitor->render, SIGNAL(replyGetImage(const QString &, const QPixmap &)), m_projectList, SLOT(slotReplyGetImage(const QString &, const QPixmap &)));
+ connect(m_projectMonitor->render, SIGNAL(replyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &, bool)), m_projectList, SLOT(slotReplyGetFileProperties(const QString &, Mlt::Producer*, const QMap < QString, QString > &, const QMap < QString, QString > &, bool)));
- 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 &)));
connect(m_projectMonitor, SIGNAL(saveZone(Render *, QPoint)), this, SLOT(slotSaveZone(Render *, QPoint)));
}
-void MainWindow::slotAdjustClipMonitor() {
+void MainWindow::slotAdjustClipMonitor()
+{
clipMonitorDock->updateGeometry();
clipMonitorDock->adjustSize();
m_clipMonitor->resetSize();
}
-void MainWindow::slotAdjustProjectMonitor() {
+void MainWindow::slotAdjustProjectMonitor()
+{
projectMonitorDock->updateGeometry();
projectMonitorDock->adjustSize();
m_projectMonitor->resetSize();
}
-void MainWindow::setupActions() {
+void MainWindow::setupActions()
+{
KActionCollection* collection = actionCollection();
m_timecodeFormat = new KComboBox(this);
m_projectSearchNext->setShortcut(Qt::Key_F3);
m_projectSearchNext->setEnabled(false);
- KAction* profilesAction = new KAction(KIcon("document-new"), i18n("Manage Profiles"), this);
+ KAction* profilesAction = new KAction(KIcon("document-new"), i18n("Manage Project Profiles"), this);
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");
+ KNS::standardAction(i18n("Download New Lumas..."), this, SLOT(slotGetNewLumaStuff()), actionCollection(), "get_new_lumas");
+
+ KNS::standardAction(i18n("Download New Render Profiles..."), this, SLOT(slotGetNewRenderStuff()), actionCollection(), "get_new_profiles");
+
+ KNS::standardAction(i18n("Download New Project Profiles..."), this, SLOT(slotGetNewMltProfileStuff()), actionCollection(), "get_new_mlt_profiles");
+
+ 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);
collection->addAction("project_settings", projectAction);
collection->addAction("monitor_play", monitorPlay);
connect(monitorPlay, SIGNAL(triggered(bool)), m_monitorManager, SLOT(slotPlay()));
+ 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 *dvdWizard = new KAction(KIcon("media-optical"), i18n("DVD Wizard"), this);
+ collection->addAction("dvd_wizard", dvdWizard);
+ connect(dvdWizard, SIGNAL(triggered(bool)), this, SLOT(slotDvdWizard()));
+
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);
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);
collection->addAction("monitor_seek_snap_backward", monitorSeekSnapBackward);
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);
collection->addAction("monitor_seek_snap_forward", monitorSeekSnapForward);
KAction* editTimelineClipSpeed = new KAction(i18n("Change Clip Speed"), this);
collection->addAction("change_clip_speed", editTimelineClipSpeed);
+ editTimelineClipSpeed->setData("change_speed");
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* groupClip = new KAction(KIcon("object-group"), i18n("Group Clips"), this);
+ collection->addAction("group_clip", groupClip);
+ connect(groupClip, SIGNAL(triggered(bool)), this, SLOT(slotGroupClips()));
+
+ KAction* ungroupClip = new KAction(KIcon("object-ungroup"), i18n("Ungroup Clips"), this);
+ collection->addAction("ungroup_clip", ungroupClip);
+ ungroupClip->setData("ungroup_clip");
+ connect(ungroupClip, SIGNAL(triggered(bool)), this, SLOT(slotUnGroupClips()));
+
KAction* cutTimelineClip = new KAction(KIcon("edit-cut"), i18n("Cut Clip"), this);
cutTimelineClip->setShortcut(Qt::SHIFT + Qt::Key_R);
collection->addAction("cut_timeline_clip", cutTimelineClip);
collection->addAction("edit_clip_marker", editClipMarker);
connect(editClipMarker, SIGNAL(triggered(bool)), this, SLOT(slotEditClipMarker()));
+ KAction* splitAudio = new KAction(KIcon("document-new"), i18n("Split Audio"), this);
+ collection->addAction("split_audio", splitAudio);
+ connect(splitAudio, SIGNAL(triggered(bool)), this, SLOT(slotSplitAudio()));
+
+ KAction* audioOnly = new KAction(KIcon("document-new"), i18n("Audio Only"), this);
+ collection->addAction("clip_audio_only", audioOnly);
+ audioOnly->setData("clip_audio_only");
+ audioOnly->setCheckable(true);
+
+ KAction* videoOnly = new KAction(KIcon("document-new"), i18n("Video Only"), this);
+ collection->addAction("clip_video_only", videoOnly);
+ videoOnly->setData("clip_video_only");
+ videoOnly->setCheckable(true);
+
+ KAction* audioAndVideo = new KAction(KIcon("document-new"), i18n("Audio and Video"), this);
+ collection->addAction("clip_audio_and_video", audioAndVideo);
+ audioAndVideo->setData("clip_audio_and_video");
+ audioAndVideo->setCheckable(true);
+
+ m_clipTypeGroup = new QActionGroup(this);
+ m_clipTypeGroup->addAction(audioOnly);
+ m_clipTypeGroup->addAction(videoOnly);
+ m_clipTypeGroup->addAction(audioAndVideo);
+ connect(m_clipTypeGroup, SIGNAL(triggered(QAction *)), this, SLOT(slotUpdateClipType(QAction *)));
+ m_clipTypeGroup->setEnabled(false);
+
KAction *insertSpace = new KAction(KIcon(), i18n("Insert Space"), this);
collection->addAction("insert_space", insertSpace);
connect(insertSpace, SIGNAL(triggered()), this, SLOT(slotInsertSpace()));
QAction *pasteEffects = new KAction(KIcon("edit-paste"), i18n("Paste Effects"), this);
collection->addAction("paste_effects", pasteEffects);
+ pasteEffects->setData("paste_effects");
connect(pasteEffects , SIGNAL(triggered()), this, SLOT(slotPasteEffects()));
+ QAction *showTimeline = new KAction(i18n("Show Timeline"), this);
+ collection->addAction("show_timeline", showTimeline);
+ showTimeline->setCheckable(true);
+ showTimeline->setChecked(true);
+ connect(showTimeline, SIGNAL(triggered(bool)), this, SLOT(slotShowTimeline(bool)));
+
+ /*QAction *maxCurrent = new KAction(i18n("Maximize Current Widget"), this);
+ collection->addAction("maximize_current", maxCurrent);
+ maxCurrent->setCheckable(true);
+ maxCurrent->setChecked(false);
+ connect(maxCurrent, SIGNAL(triggered(bool)), this, SLOT(slotMaximizeCurrent(bool)));*/
+
+
m_closeAction = KStandardAction::close(this, SLOT(closeCurrentDocument()), collection);
KStandardAction::quit(this, SLOT(queryQuit()), collection);
KStandardAction::fullScreen(this, SLOT(slotFullScreen()), this, collection);
+ /*
+ //TODO: Add status tooltip to actions ?
connect(collection, SIGNAL(actionHovered(QAction*)),
- this, SLOT(slotDisplayActionMessage(QAction*)));
+ this, SLOT(slotDisplayActionMessage(QAction*)));*/
+
+
+ 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()));
+
+ QAction *clipProperties = new KAction(KIcon("document-edit"), i18n("Clip Properties"), this);
+ collection->addAction("clip_properties", clipProperties);
+ clipProperties->setData("clip_properties");
+ connect(clipProperties , SIGNAL(triggered()), m_projectList, SLOT(slotEditClip()));
+ clipProperties->setEnabled(false);
+
+ QAction *openClip = new KAction(KIcon("document-open"), i18n("Edit Clip"), this);
+ collection->addAction("edit_clip", openClip);
+ openClip->setData("edit_clip");
+ connect(openClip , SIGNAL(triggered()), m_projectList, SLOT(slotOpenClip()));
+ openClip->setEnabled(false);
+
+ QAction *deleteClip = new KAction(KIcon("edit-delete"), i18n("Delete Clip"), this);
+ collection->addAction("delete_clip", deleteClip);
+ deleteClip->setData("delete_clip");
+ connect(deleteClip , SIGNAL(triggered()), m_projectList, SLOT(slotRemoveClip()));
+ deleteClip->setEnabled(false);
+
+ QAction *reloadClip = new KAction(KIcon("view-refresh"), i18n("Reload Clip"), this);
+ collection->addAction("reload_clip", reloadClip);
+ reloadClip->setData("reload_clip");
+ connect(reloadClip , SIGNAL(triggered()), m_projectList, SLOT(slotReloadClip()));
+ reloadClip->setEnabled(false);
+
+ QMenu *addClips = new QMenu();
+ addClips->addAction(addClip);
+ addClips->addAction(addColorClip);
+ addClips->addAction(addSlideClip);
+ addClips->addAction(addTitleClip);
+ addClips->addAction(addFolderButton);
+
+ addClips->addAction(reloadClip);
+ addClips->addAction(clipProperties);
+ addClips->addAction(openClip);
+ addClips->addAction(deleteClip);
+ m_projectList->setupMenu(addClips, addClip);
+
//connect(collection, SIGNAL( clearStatusText() ),
//statusBar(), SLOT( clear() ) );
}
-void MainWindow::slotDisplayActionMessage(QAction *a) {
+void MainWindow::slotDisplayActionMessage(QAction *a)
+{
statusBar()->showMessage(a->data().toString(), 3000);
}
-void MainWindow::saveOptions() {
+void MainWindow::saveOptions()
+{
KdenliveSettings::self()->writeConfig();
KSharedConfigPtr config = KGlobal::config();
m_fileOpenRecent->saveEntries(KConfigGroup(config, "Recent Files"));
config->sync();
}
-void MainWindow::readOptions() {
+void MainWindow::readOptions()
+{
KSharedConfigPtr config = KGlobal::config();
m_fileOpenRecent->loadEntries(KConfigGroup(config, "Recent Files"));
KConfigGroup initialGroup(config, "version");
- if (!initialGroup.exists()) {
+ bool upgrade = false;
+ if (initialGroup.exists()) {
+ if (initialGroup.readEntry("version", QString()).section(' ', 0, 0) != QString(version).section(' ', 0, 0))
+ upgrade = true;
+
+ 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);
+ }
+ }
+
+ }
+
+ if (!initialGroup.exists() || upgrade) {
// this is our first run, show Wizard
- Wizard *w = new Wizard(this);
+ Wizard *w = new Wizard(upgrade, this);
if (w->exec() == QDialog::Accepted && w->isOk()) {
w->adjustSettings();
- initialGroup.writeEntry("version", "0.7");
+ initialGroup.writeEntry("version", version);
delete w;
} else {
::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());
m_projectList->setHeaderInfo(state);
}
-void MainWindow::newFile(bool showProjectSettings) {
+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(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks());
ProjectSettings *w = new ProjectSettings(projectTracks.x(), projectTracks.y(), KdenliveSettings::defaultprojectfolder(), false, this);
if (w->exec() != QDialog::Accepted) return;
if (!KdenliveSettings::activatetabs()) closeCurrentDocument();
+ KdenliveSettings::setVideothumbnails(w->enableVideoThumbs());
+ m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
+ KdenliveSettings::setAudiothumbnails(w->enableAudioThumbs());
+ m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
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());
m_closeAction->setEnabled(m_timelineArea->count() > 1);
}
-void MainWindow::activateDocument() {
+void MainWindow::activateDocument()
+{
if (m_timelineArea->currentWidget() == NULL) return;
TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
KdenliveDoc *currentDoc = currentTab->document();
connectDocument(currentTab, currentDoc);
}
-void MainWindow::closeCurrentDocument() {
+void MainWindow::closeCurrentDocument()
+{
QWidget *w = m_timelineArea->currentWidget();
if (!w) return;
// closing current document
switch (KMessageBox::warningYesNoCancel(this, i18n("Save changes to document ?"))) {
case KMessageBox::Yes :
// save document here. If saving fails, return false;
- saveFile();
+ if (saveFile() == false) return;
break;
case KMessageBox::Cancel :
return;
}
}
-bool MainWindow::saveFileAs(const QString &outputFileName) {
- QDomDocument currentSceneList = m_projectMonitor->sceneList();
+bool MainWindow::saveFileAs(const QString &outputFileName)
+{
+ QString currentSceneList;
+ if (KdenliveSettings::dropbframes()) {
+ KdenliveSettings::setDropbframes(false);
+ m_activeDocument->clipManager()->updatePreviewSettings();
+ currentSceneList = m_projectMonitor->sceneList();
+ KdenliveSettings::setDropbframes(true);
+ m_activeDocument->clipManager()->updatePreviewSettings();
+ } else currentSceneList = m_projectMonitor->sceneList();
+
if (m_activeDocument->saveSceneList(outputFileName, currentSceneList) == false)
return false;
return true;
}
-bool MainWindow::saveFileAs() {
+bool MainWindow::saveFileAs()
+{
// Check that the Kdenlive mime type is correctly installed
QString mimetype = "application/x-kdenlive";
KMimeType::Ptr mime = KMimeType::mimeType(mimetype);
return saveFileAs(outputFile);
}
-bool MainWindow::saveFile() {
+bool MainWindow::saveFile()
+{
if (!m_activeDocument) return true;
if (m_activeDocument->url().isEmpty()) {
return saveFileAs();
}
}
-void MainWindow::openFile() {
+void MainWindow::openFile()
+{
// 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);
+ KUrl url = KFileDialog::getOpenUrl(KUrl("kfiledialog:///projectfolder"), mimetype);
if (url.isEmpty()) return;
m_fileOpenRecent->addUrl(url);
openFile(url);
}
-void MainWindow::openLastFile() {
+void MainWindow::openLastFile()
+{
KSharedConfigPtr config = KGlobal::config();
KUrl::List urls = m_fileOpenRecent->urls();
+ //WARNING: this is buggy, we get a random url, not the last one. Bug in KRecentFileAction ?
if (urls.isEmpty()) newFile(false);
else openFile(urls.last());
}
-void MainWindow::openFile(const KUrl &url) {
+void MainWindow::openFile(const KUrl &url)
+{
// Check if the document is already opened
const int ct = m_timelineArea->count();
bool isOpened = false;
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);
+void MainWindow::doOpenFile(const KUrl &url, KAutoSaveFile *stale)
+{
+ KdenliveDoc *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;
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) {
+void MainWindow::recoverFiles(QList<KAutoSaveFile *> staleFiles)
+{
if (!KdenliveSettings::activatetabs()) closeCurrentDocument();
foreach(KAutoSaveFile *stale, staleFiles) {
/*if (!stale->open(QIODevice::QIODevice::ReadOnly)) {
}
-void MainWindow::parseProfiles(const QString &mltPath) {
+void MainWindow::parseProfiles(const QString &mltPath)
+{
//kdDebug()<<" + + YOUR MLT INSTALL WAS FOUND IN: "<< MLT_PREFIX <<endl;
//KdenliveSettings::setDefaulttmpfolder();
}
-void MainWindow::slotEditProfiles() {
+void MainWindow::slotEditProfiles()
+{
ProfilesDialog *w = new ProfilesDialog;
- w->exec();
+ if (w->exec() == QDialog::Accepted) {
+ KdenliveSettingsDialog* d = static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"));
+ if (d) d->checkProfile();
+ }
delete w;
}
-void MainWindow::slotEditProjectSettings() {
+void MainWindow::slotEditProjectSettings()
+{
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->setProjectFolder(w->selectedFolder());
+ if (m_renderWidget) m_renderWidget->setDocumentPath(w->selectedFolder().path());
if (m_activeDocument->profilePath() != profile) {
// Profile was changed
m_activeDocument->setProfilePath(profile);
m_monitorManager->resetProfiles(m_activeDocument->timecode());
if (m_renderWidget) m_renderWidget->setProfile(m_activeDocument->mltProfile());
m_timelineArea->setTabText(m_timelineArea->currentIndex(), m_activeDocument->description());
+ m_activeDocument->clipManager()->resetProducersList(m_projectMonitor->render->producersList());
// We need to desactivate & reactivate monitors to get a refresh
m_monitorManager->switchMonitors();
delete w;
}
-void MainWindow::slotRenderProject() {
+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)));
+ QString projectfolder = m_activeDocument ? m_activeDocument->projectFolder().path() : KdenliveSettings::defaultprojectfolder();
+ m_renderWidget = new RenderWidget(projectfolder, this);
+ connect(m_renderWidget, SIGNAL(doRender(const QString&, const QString&, const QStringList &, const QStringList &, bool, bool, double, double, bool, const QString &)), this, SLOT(slotDoRender(const QString&, const QString&, const QStringList &, const QStringList &, bool, bool, double, double, bool, const QString &)));
+ connect(m_renderWidget, SIGNAL(abortProcess(const QString &)), this, SIGNAL(abortRenderJob(const QString &)));
+ connect(m_renderWidget, SIGNAL(openDvdWizard(const QString &, const QString &)), this, SLOT(slotDvdWizard(const QString &, const QString &)));
if (m_activeDocument) {
m_renderWidget->setProfile(m_activeDocument->mltProfile());
m_renderWidget->setGuides(m_activeDocument->guidesXml(), m_activeDocument->projectDuration());
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, const QString &scriptExport)
+{
+ kDebug() << "// SCRIPT EXPORT: " << scriptExport;
if (dest.isEmpty()) return;
- int in;
- int out;
+ int in = 0;
+ int out = 0;
TrackView *currentTab = (TrackView *) m_timelineArea->currentWidget();
if (currentTab && zoneOnly) {
in = currentTab->inPoint();
KTemporaryFile temp;
temp.setAutoRemove(false);
temp.setSuffix(".westley");
- if (temp.open()) {
- m_projectMonitor->saveSceneList(temp.fileName());
+ if (!scriptExport.isEmpty() || temp.open()) {
+ if (KdenliveSettings::dropbframes()) {
+ KdenliveSettings::setDropbframes(false);
+ m_activeDocument->clipManager()->updatePreviewSettings();
+ if (!scriptExport.isEmpty()) m_projectMonitor->saveSceneList(scriptExport + ".westley");
+ else m_projectMonitor->saveSceneList(temp.fileName());
+ KdenliveSettings::setDropbframes(true);
+ m_activeDocument->clipManager()->updatePreviewSettings();
+ } else {
+ if (!scriptExport.isEmpty()) m_projectMonitor->saveSceneList(scriptExport + ".westley");
+ else m_projectMonitor->saveSceneList(temp.fileName());
+ }
+
QStringList args;
- args << "-erase";
+ if (scriptExport.isEmpty()) args << "-erase";
+ if (KdenliveSettings::usekuiserver()) args << "-kuiserver";
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 (!QFile::exists(KdenliveSettings::rendererpath())) {
KMessageBox::sorry(this, i18n("Cannot find the inigo program required for rendering (part of Mlt)"));
+ setRenderingProgress(dest, -3);
return;
}
- args << KdenliveSettings::rendererpath() << m_activeDocument->profilePath() << render << videoPlayer << temp.fileName() << dest << avformat_args;
+ 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
+ if (scriptExport.isEmpty()) args << "consumer:" + temp.fileName();
+ else args << "consumer:$SOURCE";
+ } else {
+ if (scriptExport.isEmpty()) args << temp.fileName();
+ else args << "$SOURCE";
+ }
+ if (scriptExport.isEmpty()) args << dest;
+ else args << "$TARGET";
+ args << avformat_args;
QString renderer = QCoreApplication::applicationDirPath() + QString("/kdenlive_render");
if (!QFile::exists(renderer)) renderer = "kdenlive_render";
- QProcess::startDetached(renderer, args);
+ if (scriptExport.isEmpty()) {
+ QProcess::startDetached(renderer, args);
+ KNotification::event("RenderStarted", i18n("Rendering <i>%1</i> started", dest), QPixmap(), this);
+ } else {
+ // Generate script file
+ QFile file(scriptExport);
+ if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+ KMessageBox::error(this, i18n("Cannot write to file %1", scriptExport));
+ return;
+ }
- KNotification::event("RenderStarted", i18n("Rendering <i>%1</i> started", dest), QPixmap(), this);
+ QTextStream out(&file);
+ out << "#! /bin/sh" << "\n" << "\n";
+ out << "SOURCE=" << "\"" + scriptExport + ".westley\"" << "\n";
+ out << "TARGET=" << "\"" + dest + "\"" << "\n";
+ out << renderer << " " << args.join(" ") << "\n" << "\n";
+ if (file.error() != QFile::NoError) {
+ KMessageBox::error(this, i18n("Cannot write to file %1", scriptExport));
+ file.close();
+ return;
+ }
+ file.close();
+ QFile::setPermissions(scriptExport, file.permissions() | QFile::ExeUser);
+ }
}
}
-void MainWindow::slotUpdateMousePosition(int pos) {
+void MainWindow::setRenderingProgress(const QString &url, int progress)
+{
+ if (m_renderWidget) m_renderWidget->setRenderJob(url, progress);
+}
+
+void MainWindow::setRenderingFinished(const QString &url, int status, const QString &error)
+{
+ if (m_renderWidget) m_renderWidget->setRenderStatus(url, status, error);
+}
+
+void MainWindow::slotUpdateMousePosition(int pos)
+{
if (m_activeDocument)
switch (m_timecodeFormat->currentIndex()) {
case 0:
}
}
-void MainWindow::slotUpdateDocumentState(bool modified) {
+void MainWindow::slotUpdateDocumentState(bool modified)
+{
+ if (!m_activeDocument) return;
setCaption(m_activeDocument->description(), modified);
m_saveAction->setEnabled(modified);
if (modified) {
}
}
-void MainWindow::connectDocumentInfo(KdenliveDoc *doc) {
+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
+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)), 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_projectMonitor->render, SIGNAL(refreshDocumentProducers()), m_activeDocument, SLOT(checkProjectClips()));
disconnect(m_activeDocument, SIGNAL(guidesUpdated()), this, SLOT(slotGuidesUpdated()));
disconnect(m_activeDocument, SIGNAL(addProjectClip(DocClipBase *, bool)), m_projectList, SLOT(slotAddClip(DocClipBase *, bool)));
- disconnect(m_activeDocument, SIGNAL(addProjectFolder(const QString, const QString &, bool, bool)), m_projectList, SLOT(slotAddFolder(const QString, const QString &, bool, bool)));
+ disconnect(m_activeDocument, SIGNAL(resetProjectList()), m_projectList, SLOT(slotResetProjectList()));
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_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_activeTimeline, SIGNAL(transitionItemSelected(Transition*, bool)), this, SLOT(slotActivateTransitionView(Transition *)));
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(effectStack, SIGNAL(refreshEffectStack(ClipItem*)), m_activeTimeline->projectView(), SLOT(slotRefreshEffects(ClipItem*)));
disconnect(effectStack, SIGNAL(reloadEffects()), this, SLOT(slotReloadEffects()));
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(m_activeTimeline, 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();
}
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(m_projectList, SIGNAL(clipNameChanged(const QString, const QString)), trackView->projectView(), SLOT(clipNameChanged(const QString, const QString)));
+
+
connect(trackView, SIGNAL(cursorMoved()), m_projectMonitor, SLOT(activateMonitor()));
connect(trackView, SIGNAL(insertTrack(int)), this, SLOT(slotInsertTrack(int)));
connect(trackView, SIGNAL(deleteTrack(int)), this, SLOT(slotDeleteTrack(int)));
connect(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(m_projectMonitor->render, SIGNAL(refreshDocumentProducers()), doc, SLOT(checkProjectClips()));
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(resetProjectList()), m_projectList, SLOT(slotResetProjectList()));
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(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()));
+ connect(trackView, SIGNAL(transitionItemSelected(Transition*, bool)), this, SLOT(slotActivateTransitionView(Transition *)));
m_zoomSlider->setValue(doc->zoom());
connect(m_zoomSlider, SIGNAL(valueChanged(int)), trackView, SLOT(slotChangeZoom(int)));
connect(trackView->projectView(), SIGNAL(zoomIn()), this, SLOT(slotZoomIn()));
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);
+ trackView->projectView()->setContextMenu(m_timelineContextMenu, m_timelineContextClipMenu, m_timelineContextTransitionMenu, m_clipTypeGroup);
m_activeTimeline = trackView;
- if (m_renderWidget) m_renderWidget->setProfile(doc->mltProfile());
- doc->setRenderer(m_projectMonitor->render);
+ if (m_renderWidget) {
+ m_renderWidget->setProfile(doc->mltProfile());
+ m_renderWidget->setDocumentPath(doc->projectFolder().path());
+ }
+ //doc->setRenderer(m_projectMonitor->render);
m_commandStack->setActiveStack(doc->commandStack());
KdenliveSettings::setProject_display_ratio(doc->dar());
m_projectList->updateAllClips();
setCaption(doc->description(), doc->isModified());
m_saveAction->setEnabled(doc->isModified());
m_activeDocument = doc;
+ if (KdenliveSettings::dropbframes()) slotUpdatePreviewSettings();
+
+ // 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() {
+void MainWindow::slotGuidesUpdated()
+{
if (m_renderWidget) m_renderWidget->setGuides(m_activeDocument->guidesXml(), m_activeDocument->projectDuration());
}
-void MainWindow::slotPreferences(int page, int option) {
+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")) {
KdenliveSettingsDialog* d = static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"));
if (page != -1) d->showPage(page, option);
- d->checkProfile();
return;
}
KdenliveSettingsDialog* dialog = new KdenliveSettingsDialog(this);
connect(dialog, SIGNAL(settingsChanged(const QString&)), this, SLOT(updateConfiguration()));
connect(dialog, SIGNAL(doResetProfile()), m_monitorManager, SLOT(slotResetProfiles()));
+ connect(dialog, SIGNAL(updatePreviewSettings()), this, SLOT(slotUpdatePreviewSettings()));
+ connect(dialog, SIGNAL(updateCaptureFolder()), m_recMonitor, SLOT(slotUpdateCaptureFolder()));
+ //connect(dialog, SIGNAL(updatePreviewSettings()), this, SLOT(slotUpdatePreviewSettings()));
dialog->show();
if (page != -1) dialog->showPage(page, option);
}
-void MainWindow::updateConfiguration() {
+void MainWindow::slotUpdatePreviewSettings()
+{
+ if (m_activeDocument) {
+ m_clipMonitor->slotSetXml(NULL, 0);
+ m_activeDocument->updatePreviewSettings();
+ }
+}
+
+void MainWindow::updateConfiguration()
+{
//TODO: we should apply settings to all projects, not only the current one
if (m_activeTimeline) {
m_activeTimeline->refresh();
}
-void MainWindow::slotSwitchVideoThumbs() {
+
+void MainWindow::slotSwitchVideoThumbs()
+{
KdenliveSettings::setVideothumbnails(!KdenliveSettings::videothumbnails());
if (m_activeTimeline) {
- m_activeTimeline->refresh();
+ m_activeTimeline->projectView()->slotUpdateAllThumbs();
}
m_buttonVideoThumbs->setChecked(KdenliveSettings::videothumbnails());
}
-void MainWindow::slotSwitchAudioThumbs() {
+void MainWindow::slotSwitchAudioThumbs()
+{
KdenliveSettings::setAudiothumbnails(!KdenliveSettings::audiothumbnails());
if (m_activeTimeline) {
m_activeTimeline->refresh();
m_buttonAudioThumbs->setChecked(KdenliveSettings::audiothumbnails());
}
-void MainWindow::slotSwitchMarkersComments() {
+void MainWindow::slotSwitchMarkersComments()
+{
KdenliveSettings::setShowmarkers(!KdenliveSettings::showmarkers());
if (m_activeTimeline) {
m_activeTimeline->refresh();
m_buttonShowMarkers->setChecked(KdenliveSettings::showmarkers());
}
-void MainWindow::slotSwitchSnap() {
+void MainWindow::slotSwitchSnap()
+{
KdenliveSettings::setSnaptopoints(!KdenliveSettings::snaptopoints());
m_buttonSnap->setChecked(KdenliveSettings::snaptopoints());
}
-void MainWindow::slotDeleteTimelineClip() {
+void MainWindow::slotDeleteTimelineClip()
+{
if (QApplication::focusWidget()->parentWidget()->parentWidget() == projectListDock) m_projectList->slotRemoveClip();
else if (m_activeTimeline) {
m_activeTimeline->projectView()->deleteSelectedClips();
}
}
-void MainWindow::slotChangeClipSpeed() {
+void MainWindow::slotChangeClipSpeed()
+{
if (m_activeTimeline) {
m_activeTimeline->projectView()->changeClipSpeed();
}
}
-void MainWindow::slotAddClipMarker() {
+void MainWindow::slotAddClipMarker()
+{
DocClipBase *clip = NULL;
GenTime pos;
if (m_projectMonitor->isActive()) {
if (m_clipMonitor->isActive()) m_clipMonitor->checkOverlay();
}
-void MainWindow::slotDeleteClipMarker() {
+void MainWindow::slotDeleteClipMarker()
+{
DocClipBase *clip = NULL;
GenTime pos;
if (m_projectMonitor->isActive()) {
}
-void MainWindow::slotDeleteAllClipMarkers() {
+void MainWindow::slotDeleteAllClipMarkers()
+{
DocClipBase *clip = NULL;
if (m_projectMonitor->isActive()) {
if (m_activeTimeline) {
if (m_clipMonitor->isActive()) m_clipMonitor->checkOverlay();
}
-void MainWindow::slotEditClipMarker() {
+void MainWindow::slotEditClipMarker()
+{
DocClipBase *clip = NULL;
GenTime pos;
if (m_projectMonitor->isActive()) {
}
}
-void MainWindow::slotAddGuide() {
+void MainWindow::slotAddGuide()
+{
if (m_activeTimeline)
m_activeTimeline->projectView()->slotAddGuide();
}
-void MainWindow::slotInsertSpace() {
+void MainWindow::slotInsertSpace()
+{
if (m_activeTimeline)
m_activeTimeline->projectView()->slotInsertSpace();
}
-void MainWindow::slotRemoveSpace() {
+void MainWindow::slotRemoveSpace()
+{
if (m_activeTimeline)
m_activeTimeline->projectView()->slotRemoveSpace();
}
-void MainWindow::slotInsertTrack(int ix) {
+void MainWindow::slotInsertTrack(int ix)
+{
m_projectMonitor->activateMonitor();
if (m_activeTimeline)
m_activeTimeline->projectView()->slotInsertTrack(ix);
}
-void MainWindow::slotDeleteTrack(int ix) {
+void MainWindow::slotDeleteTrack(int ix)
+{
m_projectMonitor->activateMonitor();
if (m_activeTimeline)
m_activeTimeline->projectView()->slotDeleteTrack(ix);
}
-void MainWindow::slotChangeTrack(int ix) {
+void MainWindow::slotChangeTrack(int ix)
+{
m_projectMonitor->activateMonitor();
if (m_activeTimeline)
m_activeTimeline->projectView()->slotChangeTrack(ix);
}
-void MainWindow::slotEditGuide() {
+void MainWindow::slotEditGuide()
+{
if (m_activeTimeline)
m_activeTimeline->projectView()->slotEditGuide();
}
-void MainWindow::slotDeleteGuide() {
+void MainWindow::slotDeleteGuide()
+{
if (m_activeTimeline)
m_activeTimeline->projectView()->slotDeleteGuide();
}
-void MainWindow::slotDeleteAllGuides() {
+void MainWindow::slotDeleteAllGuides()
+{
if (m_activeTimeline)
m_activeTimeline->projectView()->slotDeleteAllGuides();
}
-void MainWindow::slotCutTimelineClip() {
+void MainWindow::slotCutTimelineClip()
+{
if (m_activeTimeline) {
m_activeTimeline->projectView()->cutSelectedClips();
}
}
-void MainWindow::slotAddProjectClip(KUrl url) {
+void MainWindow::slotGroupClips()
+{
+ if (m_activeTimeline) {
+ m_activeTimeline->projectView()->groupClips();
+ }
+}
+
+void MainWindow::slotUnGroupClips()
+{
+ if (m_activeTimeline) {
+ m_activeTimeline->projectView()->groupClips(false);
+ }
+}
+
+void MainWindow::slotAddProjectClip(KUrl url)
+{
if (m_activeDocument)
m_activeDocument->slotAddClipFile(url, QString());
}
-void MainWindow::slotAddTransition(QAction *result) {
+void MainWindow::slotAddTransition(QAction *result)
+{
if (!result) return;
QStringList info = result->data().toStringList();
if (info.isEmpty()) return;
}
}
-void MainWindow::slotAddVideoEffect(QAction *result) {
+void MainWindow::slotAddVideoEffect(QAction *result)
+{
if (!result) return;
QStringList info = result->data().toStringList();
if (info.isEmpty()) return;
slotAddEffect(effect);
}
-void MainWindow::slotAddAudioEffect(QAction *result) {
+void MainWindow::slotAddAudioEffect(QAction *result)
+{
if (!result) return;
QStringList info = result->data().toStringList();
if (info.isEmpty()) return;
slotAddEffect(effect);
}
-void MainWindow::slotAddCustomEffect(QAction *result) {
+void MainWindow::slotAddCustomEffect(QAction *result)
+{
if (!result) return;
QStringList info = result->data().toStringList();
if (info.isEmpty()) return;
slotAddEffect(effect);
}
-void MainWindow::slotZoomIn() {
+void MainWindow::slotZoomIn()
+{
m_zoomSlider->setValue(m_zoomSlider->value() - 1);
}
-void MainWindow::slotZoomOut() {
+void MainWindow::slotZoomOut()
+{
m_zoomSlider->setValue(m_zoomSlider->value() + 1);
}
-void MainWindow::slotFitZoom() {
+void MainWindow::slotFitZoom()
+{
if (m_activeTimeline) {
m_zoomSlider->setValue(m_activeTimeline->fitZoom());
}
}
-void MainWindow::slotGotProgressInfo(const QString &message, int progress) {
+void MainWindow::slotGotProgressInfo(const QString &message, int progress)
+{
statusProgressBar->setValue(progress);
if (progress >= 0) {
if (!message.isEmpty()) m_messageLabel->setMessage(message, InformationMessage);//statusLabel->setText(message);
}
}
-void MainWindow::slotShowClipProperties(DocClipBase *clip) {
+void MainWindow::slotShowClipProperties(DocClipBase *clip)
+{
if (clip->clipType() == TEXT) {
QString titlepath = m_activeDocument->projectFolder().path() + "/titles/";
QString path = clip->getProperty("resource");
doc.setContent(clip->getProperty("xmldata"));
dia_ui->setXml(doc);
if (dia_ui->exec() == QDialog::Accepted) {
- QPixmap pix = dia_ui->renderedPixmap();
+ QImage pix = dia_ui->renderedPixmap();
pix.save(path);
//slotAddClipFile(KUrl("/tmp/kdenlivetitle.png"), QString(), -1);
//m_clipManager->slotEditTextClipFile(id, dia_ui->xml().toString());
}
}
-void MainWindow::customEvent(QEvent* e) {
+void MainWindow::customEvent(QEvent* e)
+{
if (e->type() == QEvent::User) {
// The timeline playing position changed...
- kDebug() << "RECIEVED JOG EVEMNT!!!";
+ kDebug() << "RECEIVED JOG EVEMNT!!!";
}
}
-void MainWindow::slotActivateEffectStackView() {
+void MainWindow::slotActivateEffectStackView()
+{
effectStack->raiseWindow(effectStackDock);
}
-void MainWindow::slotActivateTransitionView() {
- transitionConfig->raiseWindow(transitionConfigDock);
+void MainWindow::slotActivateTransitionView(Transition *t)
+{
+ if (t) transitionConfig->raiseWindow(transitionConfigDock);
}
-void MainWindow::slotSnapRewind() {
+void MainWindow::slotSnapRewind()
+{
if (m_projectMonitor->isActive()) {
if (m_activeTimeline)
m_activeTimeline->projectView()->slotSeekToPreviousSnap();
} else m_clipMonitor->slotSeekToPreviousSnap();
}
-void MainWindow::slotSnapForward() {
+void MainWindow::slotSnapForward()
+{
if (m_projectMonitor->isActive()) {
if (m_activeTimeline)
m_activeTimeline->projectView()->slotSeekToNextSnap();
} else m_clipMonitor->slotSeekToNextSnap();
}
-void MainWindow::slotClipStart() {
+void MainWindow::slotClipStart()
+{
if (m_projectMonitor->isActive()) {
if (m_activeTimeline)
m_activeTimeline->projectView()->clipStart();
}
}
-void MainWindow::slotClipEnd() {
+void MainWindow::slotClipEnd()
+{
if (m_projectMonitor->isActive()) {
if (m_activeTimeline)
m_activeTimeline->projectView()->clipEnd();
}
}
-void MainWindow::slotChangeTool(QAction * action) {
+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) {
+void MainWindow::slotSetTool(PROJECTTOOL tool)
+{
if (m_activeDocument && m_activeTimeline) {
//m_activeDocument->setTool(tool);
m_activeTimeline->projectView()->setTool(tool);
}
}
-void MainWindow::slotCopy() {
+void MainWindow::slotCopy()
+{
if (!m_activeDocument || !m_activeTimeline) return;
m_activeTimeline->projectView()->copyClip();
}
-void MainWindow::slotPaste() {
+void MainWindow::slotPaste()
+{
if (!m_activeDocument || !m_activeTimeline) return;
m_activeTimeline->projectView()->pasteClip();
}
-void MainWindow::slotPasteEffects() {
+void MainWindow::slotPasteEffects()
+{
if (!m_activeDocument || !m_activeTimeline) return;
m_activeTimeline->projectView()->pasteClipEffects();
}
-void MainWindow::slotFind() {
+void MainWindow::slotFind()
+{
if (!m_activeDocument || !m_activeTimeline) return;
m_projectSearch->setEnabled(false);
m_findActivated = true;
- m_findString = QString();
+ m_findString.clear();
m_activeTimeline->projectView()->initSearchStrings();
statusBar()->showMessage(i18n("Starting -- find text as you type"));
m_findTimer.start(5000);
qApp->installEventFilter(this);
}
-void MainWindow::slotFindNext() {
+void MainWindow::slotFindNext()
+{
if (m_activeTimeline && m_activeTimeline->projectView()->findNextString(m_findString)) {
statusBar()->showMessage(i18n("Found : %1", m_findString));
} else {
m_findTimer.start(4000);
}
-void MainWindow::findAhead() {
+void MainWindow::findAhead()
+{
if (m_activeTimeline && m_activeTimeline->projectView()->findString(m_findString)) {
m_projectSearchNext->setEnabled(true);
statusBar()->showMessage(i18n("Found : %1", m_findString));
}
}
-void MainWindow::findTimeout() {
+void MainWindow::findTimeout()
+{
m_projectSearchNext->setEnabled(false);
m_findActivated = false;
- m_findString = QString();
+ m_findString.clear();
statusBar()->showMessage(i18n("Find stopped"), 3000);
if (m_activeTimeline) m_activeTimeline->projectView()->clearSearchStrings();
m_projectSearch->setEnabled(true);
removeEventFilter(this);
}
-void MainWindow::keyPressEvent(QKeyEvent *ke) {
+void MainWindow::keyPressEvent(QKeyEvent *ke)
+{
if (m_findActivated) {
if (ke->key() == Qt::Key_Backspace) {
m_findString = m_findString.left(m_findString.length() - 1);
/** Gets called when the window gets hidden */
-void MainWindow::hideEvent(QHideEvent *event) {
+void MainWindow::hideEvent(QHideEvent */*event*/)
+{
// kDebug() << "I was hidden";
// issue http://www.kdenlive.org/mantis/view.php?id=231
- if (this->isMinimized()) {
+ if (isMinimized()) {
// kDebug() << "I am minimized";
if (m_monitorManager) m_monitorManager->stopActiveMonitor();
}
}
-bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
+bool MainWindow::eventFilter(QObject *obj, QEvent *event)
+{
if (m_findActivated) {
if (event->type() == QEvent::ShortcutOverride) {
QKeyEvent* ke = (QKeyEvent*) event;
}
}
-void MainWindow::slotSaveZone(Render *render, QPoint zone) {
+void MainWindow::slotSaveZone(Render *render, QPoint zone)
+{
KDialog *dialog = new KDialog(this);
dialog->setCaption("Save clip zone");
dialog->setButtons(KDialog::Ok | KDialog::Cancel);
}
-void MainWindow::slotSetInPoint() {
+void MainWindow::slotSetInPoint()
+{
if (m_clipMonitor->isActive()) {
m_clipMonitor->slotSetZoneStart();
} else m_activeTimeline->projectView()->setInPoint();
}
-void MainWindow::slotSetOutPoint() {
+void MainWindow::slotSetOutPoint()
+{
if (m_clipMonitor->isActive()) {
m_clipMonitor->slotSetZoneEnd();
} else m_activeTimeline->projectView()->setOutPoint();
}
-void MainWindow::slotGetNewStuff() {
- kDebug() << "// GET NEW STUFF";
+void MainWindow::slotGetNewLumaStuff()
+{
//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) {
initEffects::refreshLumas();
}
-void MainWindow::slotAutoTransition() {
- m_activeTimeline->projectView()->autoTransition();
+void MainWindow::slotGetNewRenderStuff()
+{
+ //KNS::Entry::List download();
+
+ KNS::Engine engine(0);
+ if (engine.init("kdenlive_render.knsrc")) {
+ KNS::Entry::List entries = engine.downloadDialogModal(this);
+
+ if (entries.size() > 0) {
+ 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;
+ }
+ }
+ }
+ }
+ if (m_renderWidget) m_renderWidget->reloadProfiles();
+ }
+}
+
+void MainWindow::slotGetNewMltProfileStuff()
+{
+ //KNS::Entry::List download();
+
+ KNS::Engine engine(0);
+ if (engine.init("kdenlive_mltprofiles.knsrc")) {
+ KNS::Entry::List entries = engine.downloadDialogModal(this);
+
+ if (entries.size() > 0) {
+ 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;
+ }
+ }
+ }
+
+ // update the list of profiles in settings dialog
+ KdenliveSettingsDialog* d = static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"));
+ if (d) d->checkProfile();
+ }
+ }
+}
+
+void MainWindow::slotAutoTransition()
+{
+ if (m_activeTimeline) m_activeTimeline->projectView()->autoTransition();
+}
+
+void MainWindow::slotSplitAudio()
+{
+ if (m_activeTimeline) m_activeTimeline->projectView()->splitAudio();
+}
+
+void MainWindow::slotUpdateClipType(QAction *action)
+{
+ if (m_activeTimeline) {
+ if (action->data().toString() == "clip_audio_only") m_activeTimeline->projectView()->setAudioOnly();
+ else if (action->data().toString() == "clip_video_only") m_activeTimeline->projectView()->setVideoOnly();
+ else m_activeTimeline->projectView()->setAudioAndVideo();
+ }
+}
+
+void MainWindow::slotDvdWizard(const QString &url, const QString &profile)
+{
+ DvdWizard *w = new DvdWizard(url, profile, this);
+ w->exec();
+}
+
+void MainWindow::slotShowTimeline(bool show)
+{
+ if (show == false) {
+ m_timelineState = saveState();
+ centralWidget()->setHidden(true);
+ } else {
+ centralWidget()->setHidden(false);
+ restoreState(m_timelineState);
+ }
+}
+
+void MainWindow::slotMaximizeCurrent(bool show)
+{
+ //TODO: is there a way to maximize current widget?
+ //if (show == true)
+ {
+ m_timelineState = saveState();
+ QWidget *par = focusWidget()->parentWidget();
+ while (par->parentWidget() && par->parentWidget() != this) {
+ par = par->parentWidget();
+ }
+ kDebug() << "CURRENT WIDGET: " << par->objectName();
+ }
+ /*else {
+ //centralWidget()->setHidden(false);
+ //restoreState(m_timelineState);
+ }*/
}
#include "mainwindow.moc"