#include <QDomDocument>
#include <QInputDialog>
-QStringList SamplePlugin::generators() const {
+QStringList SamplePlugin::generators() const
+{
return QStringList() << i18n("Countdown") << i18n("Noise");
}
-KUrl SamplePlugin::generatedClip(const QString &generator, const KUrl &projectFolder, const QStringList &/*lumaNames*/, const QStringList &/*lumaFiles*/, const double fps, const int /*width*/, const int /*height*/) {
+KUrl SamplePlugin::generatedClip(const QString &generator, const KUrl &projectFolder, const QStringList &/*lumaNames*/, const QStringList &/*lumaFiles*/, const double fps, const int /*width*/, const int /*height*/)
+{
QString prePath;
if (generator == i18n("Noise")) {
prePath = projectFolder.path() + "/noise";
#include "interfaces.h"
-class SamplePlugin : public QObject, public ClipGenerator {
+class SamplePlugin : public QObject, public ClipGenerator
+{
Q_OBJECT
Q_INTERFACES(ClipGenerator)
#include "renderjob.h"
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
QCoreApplication app(argc, argv);
QStringList args = app.arguments();
QStringList preargs;
#include <QThread>
// Can't believe I need to do this to sleep.
-class SleepThread : QThread {
+class SleepThread : QThread
+{
public:
virtual void run() {};
static void msleep(unsigned long msecs) {
static QDBusConnection connection(QLatin1String(""));
-RenderJob::RenderJob(bool erase, bool usekuiserver, const QString &renderer, const QString &profile, const QString &rendermodule, const QString &player, const QString &scenelist, const QString &dest, const QStringList &preargs, const QStringList &args, int in, int out) : QObject(), m_usekuiserver(usekuiserver), m_jobUiserver(NULL), m_kdenliveinterface(NULL) {
+RenderJob::RenderJob(bool erase, bool usekuiserver, const QString &renderer, const QString &profile, const QString &rendermodule, const QString &player, const QString &scenelist, const QString &dest, const QStringList &preargs, const QStringList &args, int in, int out) : QObject(), m_usekuiserver(usekuiserver), m_jobUiserver(NULL), m_kdenliveinterface(NULL)
+{
m_scenelist = scenelist;
m_dest = dest;
m_player = player;
}
-RenderJob::~RenderJob() {
+RenderJob::~RenderJob()
+{
if (m_renderProcess) delete m_renderProcess;
// m_logfile.close();
}
-void RenderJob::slotAbort(const QString& url) {
+void RenderJob::slotAbort(const QString& url)
+{
if (m_dest == url) slotAbort();
}
-void RenderJob::slotAbort() {
+void RenderJob::slotAbort()
+{
qDebug() << "Kdenlive-render: JOBÂ ABORTED BY USER...";
m_renderProcess->kill();
qApp->quit();
}
-void RenderJob::receivedStderr() {
+void RenderJob::receivedStderr()
+{
QString result = QString(m_renderProcess->readAllStandardError()).simplified();
if (!result.startsWith("Current Frame")) m_errorMessage.append(result + "<br>");
else {
}
}
-void RenderJob::start() {
+void RenderJob::start()
+{
QDBusConnectionInterface* interface = QDBusConnection::sessionBus().interface();
if (interface && m_usekuiserver) {
if (!interface->isServiceRegistered("org.kde.JobViewServer")) {
}
-void RenderJob::initKdenliveDbusInterface() {
+void RenderJob::initKdenliveDbusInterface()
+{
QString kdenliveId;
QDBusConnection connection = QDBusConnection::sessionBus();
QDBusConnectionInterface *ibus = connection.interface();
}
-void RenderJob::slotIsOver(int /*exitcode*/, QProcess::ExitStatus status) {
+void RenderJob::slotIsOver(int /*exitcode*/, QProcess::ExitStatus status)
+{
if (m_jobUiserver) m_jobUiserver->call("terminate", QString());
if (m_erase) {
QFile f(m_scenelist);
#include <QTemporaryFile>
#include <QTextStream>
-class RenderJob : public QObject {
+class RenderJob : public QObject
+{
Q_OBJECT
public:
#include <QPainter>
#include <QToolTip>
-AbstractClipItem::AbstractClipItem(const ItemInfo info, const QRectF& rect, double fps): QGraphicsRectItem(rect), m_track(0), m_fps(fps), m_editedKeyframe(-1), m_selectedKeyframe(0), m_keyframeFactor(1) {
+AbstractClipItem::AbstractClipItem(const ItemInfo info, const QRectF& rect, double fps): QGraphicsRectItem(rect), m_track(0), m_fps(fps), m_editedKeyframe(-1), m_selectedKeyframe(0), m_keyframeFactor(1)
+{
setFlags(/*QGraphicsItem::ItemClipsToShape | */QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
setTrack(info.track);
m_startPos = info.startPos;
m_cropDuration = info.endPos - info.startPos;
}
-ItemInfo AbstractClipItem::info() const {
+ItemInfo AbstractClipItem::info() const
+{
ItemInfo itemInfo;
itemInfo.startPos = startPos();
itemInfo.endPos = endPos();
return itemInfo;
}
-GenTime AbstractClipItem::endPos() const {
+GenTime AbstractClipItem::endPos() const
+{
return m_startPos + m_cropDuration;
}
-int AbstractClipItem::track() const {
+int AbstractClipItem::track() const
+{
return m_track;
}
-GenTime AbstractClipItem::cropStart() const {
+GenTime AbstractClipItem::cropStart() const
+{
return m_cropStart;
}
-GenTime AbstractClipItem::cropDuration() const {
+GenTime AbstractClipItem::cropDuration() const
+{
return m_cropDuration;
}
-void AbstractClipItem::setCropStart(GenTime pos) {
+void AbstractClipItem::setCropStart(GenTime pos)
+{
m_cropStart = pos;
}
-void AbstractClipItem::updateItem() {
+void AbstractClipItem::updateItem()
+{
m_track = (int)(scenePos().y() / KdenliveSettings::trackheight());
m_startPos = GenTime((int) scenePos().x(), m_fps);
}
-void AbstractClipItem::updateRectGeometry() {
+void AbstractClipItem::updateRectGeometry()
+{
setRect(0, 0, cropDuration().frames(m_fps) - 0.02, rect().height());
}
-void AbstractClipItem::resizeStart(int posx, double speed) {
+void AbstractClipItem::resizeStart(int posx, double speed)
+{
GenTime durationDiff = GenTime(posx, m_fps) - m_startPos;
if (durationDiff == GenTime()) return;
//kDebug() << "-- RESCALE DIFF=" << durationDiff.frames(25) << ", CLIP: " << startPos().frames(25) << "-" << endPos().frames(25);
}*/
}
-void AbstractClipItem::resizeEnd(int posx, double speed, bool /*updateKeyFrames*/) {
+void AbstractClipItem::resizeEnd(int posx, double speed, bool /*updateKeyFrames*/)
+{
GenTime durationDiff = GenTime(posx, m_fps) - endPos();
if (durationDiff == GenTime()) return;
//kDebug() << "// DUR DIFF1:" << durationDiff.frames(25) << ", ADJUSTED: " << durationDiff.frames(25) * speed << ", SPED:" << speed;
}
}
-GenTime AbstractClipItem::duration() const {
+GenTime AbstractClipItem::duration() const
+{
return m_cropDuration;
}
-GenTime AbstractClipItem::startPos() const {
+GenTime AbstractClipItem::startPos() const
+{
return m_startPos;
}
-void AbstractClipItem::setTrack(int track) {
+void AbstractClipItem::setTrack(int track)
+{
m_track = track;
}
-double AbstractClipItem::fps() const {
+double AbstractClipItem::fps() const
+{
return m_fps;
}
-GenTime AbstractClipItem::maxDuration() const {
+GenTime AbstractClipItem::maxDuration() const
+{
return m_maxDuration;
}
-void AbstractClipItem::setMaxDuration(const GenTime &max) {
+void AbstractClipItem::setMaxDuration(const GenTime &max)
+{
m_maxDuration = max;
}
-QPainterPath AbstractClipItem::upperRectPart(QRectF br) {
+QPainterPath AbstractClipItem::upperRectPart(QRectF br)
+{
QPainterPath roundRectPathUpper;
double roundingY = 20;
double roundingX = 20;
return roundRectPathUpper;
}
-QPainterPath AbstractClipItem::lowerRectPart(QRectF br) {
+QPainterPath AbstractClipItem::lowerRectPart(QRectF br)
+{
QPainterPath roundRectPathLower;
double roundingY = 20;
double roundingX = 20;
return roundRectPathLower;
}
-void AbstractClipItem::drawKeyFrames(QPainter *painter, QRectF /*exposedRect*/) {
+void AbstractClipItem::drawKeyFrames(QPainter *painter, QRectF /*exposedRect*/)
+{
if (m_keyframes.count() < 2) return;
QRectF br = rect();
double maxw = br.width() / m_cropDuration.frames(m_fps);
if (isSelected()) painter->fillRect(l2.x2() - 3, l2.y2() - 3, 6, 6, QBrush(color));
}
-int AbstractClipItem::mouseOverKeyFrames(QPointF pos) {
+int AbstractClipItem::mouseOverKeyFrames(QPointF pos)
+{
QRectF br = sceneBoundingRect();
double maxw = br.width() / m_cropDuration.frames(m_fps);
double maxh = br.height() / 100.0 * m_keyframeFactor;
return -1;
}
-void AbstractClipItem::updateSelectedKeyFrame() {
+void AbstractClipItem::updateSelectedKeyFrame()
+{
if (m_editedKeyframe == -1) return;
QRectF br = sceneBoundingRect();
double maxw = br.width() / m_cropDuration.frames(m_fps);
update(br.x() + maxw * (m_selectedKeyframe - m_cropStart.frames(m_fps)) - 3, br.bottom() - m_keyframes[m_selectedKeyframe] * maxh - 3, 12, 12);
}
-int AbstractClipItem::selectedKeyFramePos() const {
+int AbstractClipItem::selectedKeyFramePos() const
+{
return m_editedKeyframe;
}
-double AbstractClipItem::selectedKeyFrameValue() const {
+double AbstractClipItem::selectedKeyFrameValue() const
+{
return m_keyframes[m_editedKeyframe];
}
-void AbstractClipItem::updateKeyFramePos(const GenTime pos, const double value) {
+void AbstractClipItem::updateKeyFramePos(const GenTime pos, const double value)
+{
if (!m_keyframes.contains(m_selectedKeyframe)) return;
int newpos = (int) pos.frames(m_fps);
int start = m_cropStart.frames(m_fps);
update();
}
-double AbstractClipItem::keyFrameFactor() const {
+double AbstractClipItem::keyFrameFactor() const
+{
return m_keyframeFactor;
}
-void AbstractClipItem::addKeyFrame(const GenTime pos, const double value) {
+void AbstractClipItem::addKeyFrame(const GenTime pos, const double value)
+{
QRectF br = sceneBoundingRect();
double maxh = 100.0 / br.height() / m_keyframeFactor;
double newval = (br.bottom() - value) * maxh;
update();
}
-bool AbstractClipItem::hasKeyFrames() const {
+bool AbstractClipItem::hasKeyFrames() const
+{
return !m_keyframes.isEmpty();
}
return rectInView;
}*/
-CustomTrackScene* AbstractClipItem::projectScene() {
+CustomTrackScene* AbstractClipItem::projectScene()
+{
if (scene()) return static_cast <CustomTrackScene*>(scene());
return NULL;
}
-void AbstractClipItem::setItemLocked(bool locked) {
+void AbstractClipItem::setItemLocked(bool locked)
+{
if (locked) {
setSelected(false);
setFlag(QGraphicsItem::ItemIsMovable, false);
} else setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
}
-bool AbstractClipItem::isItemLocked() const {
+bool AbstractClipItem::isItemLocked() const
+{
return !(flags() & (QGraphicsItem::ItemIsSelectable));
}
class CustomTrackScene;
-class AbstractClipItem : public QObject , public QGraphicsRectItem {
+class AbstractClipItem : public QObject , public QGraphicsRectItem
+{
Q_OBJECT
public:
AbstractClipItem(const ItemInfo info, const QRectF& rect, double fps);
#include <QMimeData>
-AbstractGroupItem::AbstractGroupItem(double fps): QGraphicsItemGroup(), m_fps(fps) {
+AbstractGroupItem::AbstractGroupItem(double fps): QGraphicsItemGroup(), m_fps(fps)
+{
setZValue(2);
setFlags(QGraphicsItem::ItemClipsToShape | QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
setAcceptDrops(true);
}
-int AbstractGroupItem::type() const {
+int AbstractGroupItem::type() const
+{
return GROUPWIDGET;
}
-int AbstractGroupItem::track() const {
+int AbstractGroupItem::track() const
+{
return (int)(scenePos().y() / KdenliveSettings::trackheight());
}
-CustomTrackScene* AbstractGroupItem::projectScene() {
+CustomTrackScene* AbstractGroupItem::projectScene()
+{
if (scene()) return static_cast <CustomTrackScene*>(scene());
return NULL;
}
-QPainterPath AbstractGroupItem::groupShape(QPointF offset) {
+QPainterPath AbstractGroupItem::groupShape(QPointF offset)
+{
QPainterPath path;
QList<QGraphicsItem *> children = childItems();
for (int i = 0; i < children.count(); i++) {
return path;
}
-void AbstractGroupItem::addItem(QGraphicsItem * item) {
+void AbstractGroupItem::addItem(QGraphicsItem * item)
+{
addToGroup(item);
//fixItemRect();
}
-void AbstractGroupItem::fixItemRect() {
+void AbstractGroupItem::fixItemRect()
+{
QPointF start = boundingRect().topLeft();
if (start != QPointF(0, 0)) {
translate(0 - start.x(), 0 - start.y());
}*/
// virtual
-void AbstractGroupItem::paint(QPainter *p, const QStyleOptionGraphicsItem *option, QWidget *) {
+void AbstractGroupItem::paint(QPainter *p, const QStyleOptionGraphicsItem *option, QWidget *)
+{
const double scale = option->matrix.m11();
QRect clipRect = option->exposedRect.toRect();
clipRect.adjust(0, 0, 1 / scale + 0.5, 1);
}
//virtual
-QVariant AbstractGroupItem::itemChange(GraphicsItemChange change, const QVariant &value) {
+QVariant AbstractGroupItem::itemChange(GraphicsItemChange change, const QVariant &value)
+{
if (change == ItemPositionChange && scene()) {
// calculate new position.
const int trackHeight = KdenliveSettings::trackheight();
}
//virtual
-void AbstractGroupItem::dropEvent(QGraphicsSceneDragDropEvent * event) {
+void AbstractGroupItem::dropEvent(QGraphicsSceneDragDropEvent * event)
+{
QString effects = QString(event->mimeData()->data("kdenlive/effectslist"));
QDomDocument doc;
doc.setContent(effects, true);
}
//virtual
-void AbstractGroupItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event) {
+void AbstractGroupItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
+{
event->setAccepted(event->mimeData()->hasFormat("kdenlive/effectslist"));
}
-void AbstractGroupItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) {
+void AbstractGroupItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
+{
Q_UNUSED(event);
}
class CustomTrackScene;
-class AbstractGroupItem : public QObject , public QGraphicsItemGroup {
+class AbstractGroupItem : public QObject , public QGraphicsItemGroup
+{
Q_OBJECT
public:
AbstractGroupItem(double fps);
#include <KLocale>
-AddClipCommand::AddClipCommand(KdenliveDoc *doc, const QDomElement &xml, const QString &id, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_doc(doc), m_xml(xml), m_id(id), m_doIt(doIt) {
+AddClipCommand::AddClipCommand(KdenliveDoc *doc, const QDomElement &xml, const QString &id, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_doc(doc), m_xml(xml), m_id(id), m_doIt(doIt)
+{
if (doIt) setText(i18n("Add clip"));
else setText(i18n("Delete clip"));
}
// virtual
-void AddClipCommand::undo() {
+void AddClipCommand::undo()
+{
kDebug() << "---- undoing action";
if (m_doIt) m_doc->deleteClip(m_id);
else m_doc->addClip(m_xml, m_id);
}
// virtual
-void AddClipCommand::redo() {
+void AddClipCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt) m_doc->addClip(m_xml, m_id);
else m_doc->deleteClip(m_id);
class KdenliveDoc;
-class AddClipCommand : public QUndoCommand {
+class AddClipCommand : public QUndoCommand
+{
public:
AddClipCommand(KdenliveDoc *doc, const QDomElement &xml, const QString &id, bool doIt, QUndoCommand * parent = 0);
#include <KLocale>
-AddEffectCommand::AddEffectCommand(CustomTrackView *view, const int track, GenTime pos, QDomElement effect, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_effect(effect), m_doIt(doIt) {
+AddEffectCommand::AddEffectCommand(CustomTrackView *view, const int track, GenTime pos, QDomElement effect, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_effect(effect), m_doIt(doIt)
+{
QString effectName;
QDomNode namenode = effect.elementsByTagName("name").item(0);
if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
// virtual
-void AddEffectCommand::undo() {
+void AddEffectCommand::undo()
+{
kDebug() << "---- undoing action";
if (m_doIt) m_view->deleteEffect(m_track, m_pos, m_effect);
else m_view->addEffect(m_track, m_pos, m_effect);
}
// virtual
-void AddEffectCommand::redo() {
+void AddEffectCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt) m_view->addEffect(m_track, m_pos, m_effect);
else m_view->deleteEffect(m_track, m_pos, m_effect);
class CustomTrackView;
-class AddEffectCommand : public QUndoCommand {
+class AddEffectCommand : public QUndoCommand
+{
public:
AddEffectCommand(CustomTrackView *view, const int track, GenTime pos, QDomElement effect, bool doIt, QUndoCommand * parent = 0);
#include <KLocale>
-AddFolderCommand::AddFolderCommand(ProjectList *view, const QString folderName, const QString &clipId, bool doIt, QUndoCommand *parent) : QUndoCommand(parent), m_view(view), m_name(folderName), m_id(clipId), m_doIt(doIt) {
+AddFolderCommand::AddFolderCommand(ProjectList *view, const QString folderName, const QString &clipId, bool doIt, QUndoCommand *parent) : QUndoCommand(parent), m_view(view), m_name(folderName), m_id(clipId), m_doIt(doIt)
+{
if (doIt) setText(i18n("Add folder"));
else setText(i18n("Delete folder"));
}
// virtual
-void AddFolderCommand::undo() {
+void AddFolderCommand::undo()
+{
if (m_doIt) m_view->slotAddFolder(m_name, m_id, true);
else m_view->slotAddFolder(m_name, m_id, false);
}
// virtual
-void AddFolderCommand::redo() {
+void AddFolderCommand::redo()
+{
if (m_doIt) m_view->slotAddFolder(m_name, m_id, false);
else m_view->slotAddFolder(m_name, m_id, true);
}
class ProjectList;
-class AddFolderCommand : public QUndoCommand {
+class AddFolderCommand : public QUndoCommand
+{
public:
AddFolderCommand(ProjectList *view, const QString folderName, const QString &clipId, bool doIt, QUndoCommand *parent = 0);
#include <KLocale>
-AddMarkerCommand::AddMarkerCommand(CustomTrackView *view, const QString &oldcomment, const QString &comment, const QString &id, const GenTime &pos, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_oldcomment(oldcomment), m_comment(comment), m_id(id), m_pos(pos), m_doIt(doIt) {
+AddMarkerCommand::AddMarkerCommand(CustomTrackView *view, const QString &oldcomment, const QString &comment, const QString &id, const GenTime &pos, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_oldcomment(oldcomment), m_comment(comment), m_id(id), m_pos(pos), m_doIt(doIt)
+{
if (m_comment.isEmpty()) setText(i18n("Delete marker"));
else if (m_oldcomment.isEmpty()) setText(i18n("Add marker"));
else setText(i18n("Edit marker"));
// virtual
-void AddMarkerCommand::undo() {
+void AddMarkerCommand::undo()
+{
m_view->addMarker(m_id, m_pos, m_oldcomment);
}
// virtual
-void AddMarkerCommand::redo() {
+void AddMarkerCommand::redo()
+{
if (m_doIt) {
m_view->addMarker(m_id, m_pos, m_comment);
}
class CustomTrackView;
-class AddMarkerCommand : public QUndoCommand {
+class AddMarkerCommand : public QUndoCommand
+{
public:
AddMarkerCommand(CustomTrackView *view, const QString &oldcomment, const QString &comment, const QString &id, const GenTime &pos, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-AddTimelineClipCommand::AddTimelineClipCommand(CustomTrackView *view, QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects, bool doIt, bool doRemove, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_xml(xml), m_clipId(clipId), m_clipInfo(info), m_effects(effects), m_doIt(doIt), m_remove(doRemove) {
+AddTimelineClipCommand::AddTimelineClipCommand(CustomTrackView *view, QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects, bool doIt, bool doRemove, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_xml(xml), m_clipId(clipId), m_clipInfo(info), m_effects(effects), m_doIt(doIt), m_remove(doRemove)
+{
if (!m_remove) setText(i18n("Add timeline clip"));
else setText(i18n("Delete timeline clip"));
}
// virtual
-void AddTimelineClipCommand::undo() {
+void AddTimelineClipCommand::undo()
+{
if (!m_remove) m_view->deleteClip(m_clipInfo);
else m_view->addClip(m_xml, m_clipId, m_clipInfo, m_effects);
}
// virtual
-void AddTimelineClipCommand::redo() {
+void AddTimelineClipCommand::redo()
+{
if (m_doIt) {
if (!m_remove) m_view->addClip(m_xml, m_clipId, m_clipInfo, m_effects);
else m_view->deleteClip(m_clipInfo);
class CustomTrackView;
-class AddTimelineClipCommand : public QUndoCommand {
+class AddTimelineClipCommand : public QUndoCommand
+{
public:
AddTimelineClipCommand(CustomTrackView *view, QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects, bool doIt, bool doRemove, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-AddTrackCommand::AddTrackCommand(CustomTrackView *view, int ix, TrackInfo info, bool addTrack, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_ix(ix), m_info(info), m_addTrack(addTrack), m_doIt(doIt) {
+AddTrackCommand::AddTrackCommand(CustomTrackView *view, int ix, TrackInfo info, bool addTrack, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_ix(ix), m_info(info), m_addTrack(addTrack), m_doIt(doIt)
+{
if (addTrack) setText(i18n("Add track"));
else setText(i18n("Delete track"));
}
// virtual
-void AddTrackCommand::undo() {
+void AddTrackCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
if (m_addTrack) m_view->removeTrack(m_ix);
else m_view->addTrack(m_info, m_ix);
}
// virtual
-void AddTrackCommand::redo() {
+void AddTrackCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt) {
if (m_addTrack) m_view->addTrack(m_info, m_ix);
class CustomTrackView;
-class AddTrackCommand : public QUndoCommand {
+class AddTrackCommand : public QUndoCommand
+{
public:
AddTrackCommand(CustomTrackView *view, int ix, TrackInfo info, bool addTrack, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-AddTransitionCommand::AddTransitionCommand(CustomTrackView *view, ItemInfo info, int transitiontrack, QDomElement params, bool remove, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_info(info), m_track(transitiontrack), m_params(params), m_remove(remove), m_doIt(doIt) {
+AddTransitionCommand::AddTransitionCommand(CustomTrackView *view, ItemInfo info, int transitiontrack, QDomElement params, bool remove, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_info(info), m_track(transitiontrack), m_params(params), m_remove(remove), m_doIt(doIt)
+{
if (m_remove) setText(i18n("Delete transition from clip"));
else setText(i18n("Add transition to clip"));
}
// virtual
-void AddTransitionCommand::undo() {
+void AddTransitionCommand::undo()
+{
if (m_remove) m_view->addTransition(m_info, m_track, m_params);
else m_view->deleteTransition(m_info, m_track, m_params);
}
// virtual
-void AddTransitionCommand::redo() {
+void AddTransitionCommand::redo()
+{
if (m_doIt) {
if (m_remove) m_view->deleteTransition(m_info, m_track, m_params);
else m_view->addTransition(m_info, m_track, m_params);
class CustomTrackView;
-class AddTransitionCommand : public QUndoCommand {
+class AddTransitionCommand : public QUndoCommand
+{
public:
AddTransitionCommand(CustomTrackView *view, ItemInfo info, int transitiontrack, QDomElement params, bool remove, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-ChangeClipTypeCommand::ChangeClipTypeCommand(CustomTrackView *view, const int track, const GenTime &pos, bool videoOnly, bool audioOnly, bool originalVideo, bool originalAudio, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_videoOnly(videoOnly), m_audioOnly(audioOnly), m_originalVideoOnly(originalVideo), m_originalAudioOnly(originalAudio), m_doIt(doIt) {
+ChangeClipTypeCommand::ChangeClipTypeCommand(CustomTrackView *view, const int track, const GenTime &pos, bool videoOnly, bool audioOnly, bool originalVideo, bool originalAudio, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_videoOnly(videoOnly), m_audioOnly(audioOnly), m_originalVideoOnly(originalVideo), m_originalAudioOnly(originalAudio), m_doIt(doIt)
+{
setText(i18n("Change clip type"));
}
// virtual
-void ChangeClipTypeCommand::undo() {
+void ChangeClipTypeCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->doChangeClipType(m_pos, m_track, m_originalVideoOnly, m_originalAudioOnly);
}
// virtual
-void ChangeClipTypeCommand::redo() {
+void ChangeClipTypeCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt)
m_view->doChangeClipType(m_pos, m_track, m_videoOnly, m_audioOnly);
class GenTime;
class CustomTrackView;
-class ChangeClipTypeCommand : public QUndoCommand {
+class ChangeClipTypeCommand : public QUndoCommand
+{
public:
ChangeClipTypeCommand(CustomTrackView *view, const int track, const GenTime &pos, bool videoOnly, bool audioOnly, bool originalVideo, bool originalAudio, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-ChangeSpeedCommand::ChangeSpeedCommand(CustomTrackView *view, ItemInfo info, double old_speed, double new_speed, const QString &clipId, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_clipInfo(info), m_old_speed(old_speed), m_new_speed(new_speed), m_clipId(clipId), m_doIt(doIt) {
+ChangeSpeedCommand::ChangeSpeedCommand(CustomTrackView *view, ItemInfo info, double old_speed, double new_speed, const QString &clipId, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_clipInfo(info), m_old_speed(old_speed), m_new_speed(new_speed), m_clipId(clipId), m_doIt(doIt)
+{
setText(i18n("Adjust clip length"));
}
// virtual
-void ChangeSpeedCommand::undo() {
+void ChangeSpeedCommand::undo()
+{
m_view->doChangeClipSpeed(m_clipInfo, m_old_speed, m_new_speed, m_clipId);
}
// virtual
-void ChangeSpeedCommand::redo() {
+void ChangeSpeedCommand::redo()
+{
if (m_doIt) {
m_view->doChangeClipSpeed(m_clipInfo, m_new_speed, m_old_speed, m_clipId);
}
class CustomTrackView;
-class ChangeSpeedCommand : public QUndoCommand {
+class ChangeSpeedCommand : public QUndoCommand
+{
public:
ChangeSpeedCommand(CustomTrackView *view, ItemInfo info, double old_speed, double new_speed, const QString &clipId, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-ChangeTrackCommand::ChangeTrackCommand(CustomTrackView *view, int ix, TrackInfo oldInfo, TrackInfo newInfo, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_ix(ix), m_oldinfo(oldInfo), m_newinfo(newInfo), m_doIt(doIt) {
+ChangeTrackCommand::ChangeTrackCommand(CustomTrackView *view, int ix, TrackInfo oldInfo, TrackInfo newInfo, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_ix(ix), m_oldinfo(oldInfo), m_newinfo(newInfo), m_doIt(doIt)
+{
setText(i18n("Change track type"));
}
// virtual
-void ChangeTrackCommand::undo() {
+void ChangeTrackCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->changeTrack(m_ix, m_oldinfo);
}
// virtual
-void ChangeTrackCommand::redo() {
+void ChangeTrackCommand::redo()
+{
if (m_doIt) m_view->changeTrack(m_ix, m_newinfo);
m_doIt = true;
}
class CustomTrackView;
-class ChangeTrackCommand : public QUndoCommand {
+class ChangeTrackCommand : public QUndoCommand
+{
public:
ChangeTrackCommand(CustomTrackView *view, int ix, TrackInfo oldInfo, TrackInfo newInfo, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <QWheelEvent>
-ClipDurationDialog::ClipDurationDialog(AbstractClipItem *clip, Timecode tc, QWidget * parent): QDialog(parent), m_tc(tc), m_clip(clip) {
+ClipDurationDialog::ClipDurationDialog(AbstractClipItem *clip, Timecode tc, QWidget * parent): QDialog(parent), m_tc(tc), m_clip(clip)
+{
setFont(KGlobalSettings::toolBarFont());
m_fps = m_tc.fps();
m_view.setupUi(this);
adjustSize();
}
-ClipDurationDialog::~ClipDurationDialog() {
+ClipDurationDialog::~ClipDurationDialog()
+{
}
-void ClipDurationDialog::setMargins(GenTime min, GenTime max) {
+void ClipDurationDialog::setMargins(GenTime min, GenTime max)
+{
m_min = min;
m_max = max;
connect(m_view.clip_position, SIGNAL(textChanged(const QString &)), this, SLOT(slotCheckStart()));
connect(m_view.clip_duration, SIGNAL(textChanged(const QString &)), this, SLOT(slotCheckDuration()));
}
-void ClipDurationDialog::slotCheckStart() {
+void ClipDurationDialog::slotCheckStart()
+{
int pos = m_tc.getFrameCount(m_view.clip_position->text(), m_fps);
int dur = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
GenTime start(pos, m_fps);
}
}
-void ClipDurationDialog::slotCheckDuration() {
+void ClipDurationDialog::slotCheckDuration()
+{
int pos = m_tc.getFrameCount(m_view.clip_position->text(), m_fps);
int dur = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
GenTime start(pos, m_fps);
}
}
-void ClipDurationDialog::slotCheckCrop() {
+void ClipDurationDialog::slotCheckCrop()
+{
int dur = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
int crop = m_tc.getFrameCount(m_view.crop_position->text(), m_fps);
GenTime duration(dur, m_fps);
}
}
-void ClipDurationDialog::slotPosUp() {
+void ClipDurationDialog::slotPosUp()
+{
int position = m_tc.getFrameCount(m_view.clip_position->text(), m_fps);
//if (duration >= m_clip->duration().frames(m_fps)) return;
position ++;
m_view.clip_position->setText(m_tc.getTimecode(GenTime(position, m_fps), m_fps));
}
-void ClipDurationDialog::slotPosDown() {
+void ClipDurationDialog::slotPosDown()
+{
int position = m_tc.getFrameCount(m_view.clip_position->text(), m_fps);
//if (duration >= m_clip->duration().frames(m_fps)) return;
position --;
m_view.clip_position->setText(m_tc.getTimecode(GenTime(position, m_fps), m_fps));
}
-void ClipDurationDialog::slotDurUp() {
+void ClipDurationDialog::slotDurUp()
+{
int duration = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
int crop = m_tc.getFrameCount(m_view.crop_position->text(), m_fps);
if (duration + crop > m_clip->maxDuration().frames(m_fps)) return;
m_view.clip_duration->setText(m_tc.getTimecode(GenTime(duration, m_fps), m_fps));
}
-void ClipDurationDialog::slotDurDown() {
+void ClipDurationDialog::slotDurDown()
+{
int duration = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
if (duration <= 0) return;
duration --;
m_view.clip_duration->setText(m_tc.getTimecode(GenTime(duration, m_fps), m_fps));
}
-void ClipDurationDialog::slotCropUp() {
+void ClipDurationDialog::slotCropUp()
+{
int crop = m_tc.getFrameCount(m_view.crop_position->text(), m_fps);
int duration = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
if (duration + crop > m_clip->maxDuration().frames(m_fps)) return;
m_view.crop_position->setText(m_tc.getTimecode(GenTime(crop, m_fps), m_fps));
}
-void ClipDurationDialog::slotCropDown() {
+void ClipDurationDialog::slotCropDown()
+{
int crop = m_tc.getFrameCount(m_view.crop_position->text(), m_fps);
if (crop <= 0) return;
crop --;
m_view.crop_position->setText(m_tc.getTimecode(GenTime(crop, m_fps), m_fps));
}
-GenTime ClipDurationDialog::startPos() const {
+GenTime ClipDurationDialog::startPos() const
+{
int pos = m_tc.getFrameCount(m_view.clip_position->text(), m_fps);
return GenTime(pos, m_fps);
}
-GenTime ClipDurationDialog::cropStart() const {
+GenTime ClipDurationDialog::cropStart() const
+{
int pos = m_tc.getFrameCount(m_view.crop_position->text(), m_fps);
return GenTime(pos, m_fps);
}
-GenTime ClipDurationDialog::duration() const {
+GenTime ClipDurationDialog::duration() const
+{
int pos = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
return GenTime(pos, m_fps);
}
-void ClipDurationDialog::wheelEvent(QWheelEvent * event) {
+void ClipDurationDialog::wheelEvent(QWheelEvent * event)
+{
if (m_view.clip_position->underMouse()) {
if (event->delta() > 0)
slotPosUp();
#include "ui_clipdurationdialog_ui.h"
-class ClipDurationDialog : public QDialog {
+class ClipDurationDialog : public QDialog
+{
Q_OBJECT
public:
#include <QMimeData>
ClipItem::ClipItem(DocClipBase *clip, ItemInfo info, double fps, double speed, bool generateThumbs)
- : AbstractClipItem(info, QRectF(), fps), m_clip(clip), m_resizeMode(NONE), m_grabPoint(0), m_maxTrack(0), m_hasThumbs(false), startThumbTimer(NULL), endThumbTimer(NULL), audioThumbWasDrawn(false), m_opacity(1.0), m_timeLine(0), m_startThumbRequested(false), m_endThumbRequested(false), m_startFade(0), m_endFade(0), m_hover(false), m_selectedEffect(-1), m_speed(speed), framePixelWidth(0), m_startPix(QPixmap()), m_endPix(QPixmap()), m_videoOnly(false), m_audioOnly(false) {
+ : AbstractClipItem(info, QRectF(), fps), m_clip(clip), m_resizeMode(NONE), m_grabPoint(0), m_maxTrack(0), m_hasThumbs(false), startThumbTimer(NULL), endThumbTimer(NULL), audioThumbWasDrawn(false), m_opacity(1.0), m_timeLine(0), m_startThumbRequested(false), m_endThumbRequested(false), m_startFade(0), m_endFade(0), m_hover(false), m_selectedEffect(-1), m_speed(speed), framePixelWidth(0), m_startPix(QPixmap()), m_endPix(QPixmap()), m_videoOnly(false), m_audioOnly(false)
+{
setZValue(1);
setRect(0, 0, (info.endPos - info.startPos).frames(fps) - 0.02, (double)(KdenliveSettings::trackheight() - 2));
setPos(info.startPos.frames(fps), (double)(info.track * KdenliveSettings::trackheight()) + 1);
}
-ClipItem::~ClipItem() {
+ClipItem::~ClipItem()
+{
if (startThumbTimer) delete startThumbTimer;
if (endThumbTimer) delete endThumbTimer;
if (m_timeLine) delete m_timeLine;
}
-ClipItem *ClipItem::clone(ItemInfo info) const {
+ClipItem *ClipItem::clone(ItemInfo info) const
+{
ClipItem *duplicate = new ClipItem(m_clip, info, m_fps, m_speed);
if (info.cropStart == m_cropStart) duplicate->slotSetStartThumb(m_startPix);
if (info.cropStart + (info.endPos - info.startPos) == m_cropStart + m_cropDuration) duplicate->slotSetEndThumb(m_endPix);
return duplicate;
}
-void ClipItem::setEffectList(const EffectsList effectList) {
+void ClipItem::setEffectList(const EffectsList effectList)
+{
m_effectList = effectList;
m_effectNames = m_effectList.effectNames().join(" / ");
}
-const EffectsList ClipItem::effectList() {
+const EffectsList ClipItem::effectList()
+{
return m_effectList;
}
-int ClipItem::selectedEffectIndex() const {
+int ClipItem::selectedEffectIndex() const
+{
return m_selectedEffect;
}
-void ClipItem::initEffect(QDomElement effect) {
+void ClipItem::initEffect(QDomElement effect)
+{
// the kdenlive_ix int is used to identify an effect in mlt's playlist, should
// not be changed
if (effect.attribute("kdenlive_ix").toInt() == 0)
}
}
-bool ClipItem::checkKeyFrames() {
+bool ClipItem::checkKeyFrames()
+{
bool clipEffectsModified = false;
for (int ix = 0; ix < m_effectList.count(); ix ++) {
QString kfr = keyframes(ix);
return clipEffectsModified;
}
-void ClipItem::setKeyframes(const int ix, const QString keyframes) {
+void ClipItem::setKeyframes(const int ix, const QString keyframes)
+{
QDomElement effect = effectAt(ix);
if (effect.attribute("disabled") == "1") return;
QDomNodeList params = effect.elementsByTagName("parameter");
}
-void ClipItem::setSelectedEffect(const int ix) {
+void ClipItem::setSelectedEffect(const int ix)
+{
m_selectedEffect = ix;
QDomElement effect = effectAt(m_selectedEffect);
QDomNodeList params = effect.elementsByTagName("parameter");
}
}
-QString ClipItem::keyframes(const int index) {
+QString ClipItem::keyframes(const int index)
+{
QString result;
QDomElement effect = effectAt(index);
QDomNodeList params = effect.elementsByTagName("parameter");
return result;
}
-void ClipItem::updateKeyframeEffect() {
+void ClipItem::updateKeyframeEffect()
+{
// regenerate xml parameter from the clip keyframes
QDomElement effect = effectAt(m_selectedEffect);
if (effect.attribute("disabled") == "1") return;
}
}
-QDomElement ClipItem::selectedEffect() {
+QDomElement ClipItem::selectedEffect()
+{
if (m_selectedEffect == -1 || m_effectList.isEmpty()) return QDomElement();
return effectAt(m_selectedEffect);
}
-void ClipItem::resetThumbs() {
+void ClipItem::resetThumbs()
+{
m_startPix = QPixmap();
m_endPix = QPixmap();
slotFetchThumbs();
}
-void ClipItem::refreshClip() {
+void ClipItem::refreshClip()
+{
m_maxDuration = m_clip->maxDuration();
if (m_clipType == COLOR) {
QString colour = m_clip->getProperty("colour");
} else slotFetchThumbs();
}
-void ClipItem::slotFetchThumbs() {
+void ClipItem::slotFetchThumbs()
+{
if (m_endPix.isNull() && m_startPix.isNull()) {
m_startThumbRequested = true;
m_endThumbRequested = true;
} else if (m_startPix.isNull()) slotGetStartThumb();*/
}
-void ClipItem::slotGetStartThumb() {
+void ClipItem::slotGetStartThumb()
+{
m_startThumbRequested = true;
emit getThumb((int)cropStart().frames(m_fps), -1);
//videoThumbProducer.setThumbFrames(m_clip->producer(), (int)m_cropStart.frames(m_fps), - 1);
//videoThumbProducer.start(QThread::LowestPriority);
}
-void ClipItem::slotGetEndThumb() {
+void ClipItem::slotGetEndThumb()
+{
m_endThumbRequested = true;
emit getThumb(-1, (int)(cropStart() + cropDuration()).frames(m_fps) - 1);
//videoThumbProducer.setThumbFrames(m_clip->producer(), -1, (int)(m_cropStart + m_cropDuration).frames(m_fps) - 1);
}
-void ClipItem::slotSetStartThumb(QImage img) {
+void ClipItem::slotSetStartThumb(QImage img)
+{
if (!img.isNull() && img.format() == QImage::Format_ARGB32) {
QPixmap pix = QPixmap::fromImage(img);
m_startPix = pix;
}
}
-void ClipItem::slotSetEndThumb(QImage img) {
+void ClipItem::slotSetEndThumb(QImage img)
+{
if (!img.isNull() && img.format() == QImage::Format_ARGB32) {
QPixmap pix = QPixmap::fromImage(img);
m_endPix = pix;
}
}
-void ClipItem::slotThumbReady(int frame, QPixmap pix) {
+void ClipItem::slotThumbReady(int frame, QPixmap pix)
+{
if (scene() == NULL) return;
QRectF r = sceneBoundingRect();
double width = m_startPix.width() / projectScene()->scale();
}
}
-void ClipItem::slotSetStartThumb(const QPixmap pix) {
+void ClipItem::slotSetStartThumb(const QPixmap pix)
+{
m_startPix = pix;
}
-void ClipItem::slotSetEndThumb(const QPixmap pix) {
+void ClipItem::slotSetEndThumb(const QPixmap pix)
+{
m_endPix = pix;
}
-QPixmap ClipItem::startThumb() const {
+QPixmap ClipItem::startThumb() const
+{
return m_startPix;
}
-QPixmap ClipItem::endThumb() const {
+QPixmap ClipItem::endThumb() const
+{
return m_endPix;
}
-void ClipItem::slotGotAudioData() {
+void ClipItem::slotGotAudioData()
+{
audioThumbReady = true;
if (m_clipType == AV) {
QRectF r = boundingRect();
} else update();
}
-int ClipItem::type() const {
+int ClipItem::type() const
+{
return AVWIDGET;
}
-DocClipBase *ClipItem::baseClip() const {
+DocClipBase *ClipItem::baseClip() const
+{
return m_clip;
}
-QDomElement ClipItem::xml() const {
+QDomElement ClipItem::xml() const
+{
QDomElement xml = m_clip->toXML();
if (m_speed != 1.0) xml.setAttribute("speed", m_speed);
return xml;
}
-int ClipItem::clipType() const {
+int ClipItem::clipType() const
+{
return m_clipType;
}
-QString ClipItem::clipName() const {
+QString ClipItem::clipName() const
+{
return m_clipName;
}
-void ClipItem::setClipName(const QString &name) {
+void ClipItem::setClipName(const QString &name)
+{
m_clipName = name;
}
-const QString &ClipItem::clipProducer() const {
+const QString &ClipItem::clipProducer() const
+{
return m_producer;
}
-void ClipItem::flashClip() {
+void ClipItem::flashClip()
+{
if (m_timeLine == 0) {
m_timeLine = new QTimeLine(750, this);
m_timeLine->setCurveShape(QTimeLine::EaseInOutCurve);
m_timeLine->start();
}
-void ClipItem::animate(qreal /*value*/) {
+void ClipItem::animate(qreal /*value*/)
+{
QRectF r = boundingRect();
r.setHeight(20);
update(r);
// virtual
void ClipItem::paint(QPainter *painter,
const QStyleOptionGraphicsItem *option,
- QWidget *) {
+ QWidget *)
+{
/*if (parentItem()) m_opacity = 0.5;
else m_opacity = 1.0;
painter->setOpacity(m_opacity);*/
}
-OPERATIONTYPE ClipItem::operationMode(QPointF pos) {
+OPERATIONTYPE ClipItem::operationMode(QPointF pos)
+{
if (isItemLocked()) return NONE;
if (isSelected()) {
return MOVE;
}
-QList <GenTime> ClipItem::snapMarkers() const {
+QList <GenTime> ClipItem::snapMarkers() const
+{
QList < GenTime > snaps;
QList < GenTime > markers = baseClip()->snapMarkers();
GenTime pos;
return snaps;
}
-QList <CommentedTime> ClipItem::commentedSnapMarkers() const {
+QList <CommentedTime> ClipItem::commentedSnapMarkers() const
+{
QList < CommentedTime > snaps;
QList < CommentedTime > markers = baseClip()->commentedSnapMarkers();
GenTime pos;
return snaps;
}
-void ClipItem::slotPrepareAudioThumb(double pixelForOneFrame, int startpixel, int endpixel, int channels) {
+void ClipItem::slotPrepareAudioThumb(double pixelForOneFrame, int startpixel, int endpixel, int channels)
+{
QRectF re = sceneBoundingRect();
if (m_clipType == AV && !isAudioOnly()) re.setTop(re.y() + re.height() / 2);
//}
}
-uint ClipItem::fadeIn() const {
+uint ClipItem::fadeIn() const
+{
return m_startFade;
}
-uint ClipItem::fadeOut() const {
+uint ClipItem::fadeOut() const
+{
return m_endFade;
}
-void ClipItem::setFadeIn(int pos) {
+void ClipItem::setFadeIn(int pos)
+{
if (pos == m_startFade) return;
int oldIn = m_startFade;
if (pos < 0) pos = 0;
update(rect.x(), rect.y(), qMax(oldIn, pos), rect.height());
}
-void ClipItem::setFadeOut(int pos) {
+void ClipItem::setFadeOut(int pos)
+{
if (pos == m_endFade) return;
int oldOut = m_endFade;
if (pos < 0) pos = 0;
}
// virtual
-void ClipItem::mousePressEvent(QGraphicsSceneMouseEvent * event) {
+void ClipItem::mousePressEvent(QGraphicsSceneMouseEvent * event)
+{
/*m_resizeMode = operationMode(event->pos());
if (m_resizeMode == MOVE) {
m_maxTrack = scene()->sceneRect().height();
}
// virtual
-void ClipItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * event) {
+void ClipItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * event)
+{
m_resizeMode = NONE;
QGraphicsRectItem::mouseReleaseEvent(event);
}
//virtual
-void ClipItem::hoverEnterEvent(QGraphicsSceneHoverEvent */*e*/) {
+void ClipItem::hoverEnterEvent(QGraphicsSceneHoverEvent */*e*/)
+{
//if (e->pos().x() < 20) m_hover = true;
if (isItemLocked()) return;
m_hover = true;
}
//virtual
-void ClipItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *) {
+void ClipItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *)
+{
if (isItemLocked()) return;
m_hover = false;
QRectF r = boundingRect();
update(r.right() - width, r.y() + height, width, height);
}
-void ClipItem::resizeStart(int posx, double /*speed*/) {
+void ClipItem::resizeStart(int posx, double /*speed*/)
+{
const int min = (startPos() - cropStart()).frames(m_fps);
if (posx < min) posx = min;
if (posx == startPos().frames(m_fps)) return;
}
}
-void ClipItem::resizeEnd(int posx, double /*speed*/, bool updateKeyFrames) {
+void ClipItem::resizeEnd(int posx, double /*speed*/, bool updateKeyFrames)
+{
const int max = (startPos() - cropStart() + maxDuration()).frames(m_fps) + 1;
if (posx > max) posx = max;
if (posx == endPos().frames(m_fps)) return;
}
-void ClipItem::checkEffectsKeyframesPos(const int previous, const int current, bool fromStart) {
+void ClipItem::checkEffectsKeyframesPos(const int previous, const int current, bool fromStart)
+{
for (int i = 0; i < m_effectList.size(); i++) {
QDomElement effect = m_effectList.at(i);
QDomNodeList params = effect.elementsByTagName("parameter");
}
//virtual
-QVariant ClipItem::itemChange(GraphicsItemChange change, const QVariant &value) {
+QVariant ClipItem::itemChange(GraphicsItemChange change, const QVariant &value)
+{
if (change == ItemPositionChange && scene()) {
// calculate new position.
//if (parentItem()) return pos();
/*void ClipItem::mouseMoveEvent(QGraphicsSceneMouseEvent * event) {
}*/
-int ClipItem::effectsCounter() {
+int ClipItem::effectsCounter()
+{
return effectsCount() + 1;
}
-int ClipItem::effectsCount() {
+int ClipItem::effectsCount()
+{
return m_effectList.size();
}
-int ClipItem::hasEffect(const QString &tag, const QString &id) const {
+int ClipItem::hasEffect(const QString &tag, const QString &id) const
+{
return m_effectList.hasEffect(tag, id);
}
-QStringList ClipItem::effectNames() {
+QStringList ClipItem::effectNames()
+{
return m_effectList.effectNames();
}
-QDomElement ClipItem::effectAt(int ix) {
+QDomElement ClipItem::effectAt(int ix)
+{
if (ix > m_effectList.count() - 1 || ix < 0) return QDomElement();
return m_effectList.at(ix);
}
-void ClipItem::setEffectAt(int ix, QDomElement effect) {
+void ClipItem::setEffectAt(int ix, QDomElement effect)
+{
kDebug() << "CHange EFFECT AT: " << ix << ", CURR: " << m_effectList.at(ix).attribute("tag") << ", NEW: " << effect.attribute("tag");
effect.setAttribute("kdenlive_ix", ix + 1);
m_effectList.insert(ix, effect);
}
}
-EffectsParameterList ClipItem::addEffect(QDomElement effect, bool animate) {
+EffectsParameterList ClipItem::addEffect(QDomElement effect, bool animate)
+{
bool needRepaint = false;
/*QDomDocument doc;
return parameters;
}
-EffectsParameterList ClipItem::getEffectArgs(QDomElement effect) {
+EffectsParameterList ClipItem::getEffectArgs(QDomElement effect)
+{
EffectsParameterList parameters;
parameters.addParam("tag", effect.attribute("tag"));
parameters.addParam("kdenlive_ix", effect.attribute("kdenlive_ix"));
return parameters;
}
-void ClipItem::deleteEffect(QString index) {
+void ClipItem::deleteEffect(QString index)
+{
bool needRepaint = false;
QString ix;
flashClip();
}
-double ClipItem::speed() const {
+double ClipItem::speed() const
+{
return m_speed;
}
-void ClipItem::setSpeed(const double speed) {
+void ClipItem::setSpeed(const double speed)
+{
m_speed = speed;
if (m_speed == 1.0) m_clipName = baseClip()->name();
else m_clipName = baseClip()->name() + " - " + QString::number(speed * 100, 'f', 0) + '%';
//update();
}
-GenTime ClipItem::maxDuration() const {
+GenTime ClipItem::maxDuration() const
+{
return m_maxDuration / m_speed;
}
-GenTime ClipItem::cropStart() const {
+GenTime ClipItem::cropStart() const
+{
return m_cropStart / m_speed;
}
-GenTime ClipItem::cropDuration() const {
+GenTime ClipItem::cropDuration() const
+{
return m_cropDuration / m_speed;
}
-GenTime ClipItem::endPos() const {
+GenTime ClipItem::endPos() const
+{
return m_startPos + cropDuration();
}
//virtual
-void ClipItem::dropEvent(QGraphicsSceneDragDropEvent * event) {
+void ClipItem::dropEvent(QGraphicsSceneDragDropEvent * event)
+{
QString effects = QString(event->mimeData()->data("kdenlive/effectslist"));
QDomDocument doc;
doc.setContent(effects, true);
}
//virtual
-void ClipItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event) {
+void ClipItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
+{
if (isItemLocked()) event->setAccepted(false);
else event->setAccepted(event->mimeData()->hasFormat("kdenlive/effectslist"));
}
-void ClipItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) {
+void ClipItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
+{
Q_UNUSED(event);
}
-void ClipItem::addTransition(Transition* t) {
+void ClipItem::addTransition(Transition* t)
+{
m_transitionsList.append(t);
//CustomTrackView *view = (CustomTrackView *) scene()->views()[0];
QDomDocument doc;
//if (view) view->slotAddTransition(this, t->toXML() , t->startPos(), track());
}
-void ClipItem::setVideoOnly(bool force) {
+void ClipItem::setVideoOnly(bool force)
+{
m_videoOnly = force;
}
-void ClipItem::setAudioOnly(bool force) {
+void ClipItem::setAudioOnly(bool force)
+{
m_audioOnly = force;
}
-bool ClipItem::isAudioOnly() const {
+bool ClipItem::isAudioOnly() const
+{
return m_audioOnly;
}
-bool ClipItem::isVideoOnly() const {
+bool ClipItem::isVideoOnly() const
+{
return m_videoOnly;
}
class Transition;
-class ClipItem : public AbstractClipItem {
+class ClipItem : public AbstractClipItem
+{
Q_OBJECT
public:
#include <QGraphicsItemGroup>
-ClipManager::ClipManager(KdenliveDoc *doc): m_doc(doc), m_audioThumbsEnabled(false), m_audioThumbsQueue(QList <QString> ()), m_generatingAudioId(QString()) {
+ClipManager::ClipManager(KdenliveDoc *doc): m_doc(doc), m_audioThumbsEnabled(false), m_audioThumbsQueue(QList <QString> ()), m_generatingAudioId(QString())
+{
m_clipIdCounter = 1;
m_folderIdCounter = 1;
}
-ClipManager::~ClipManager() {
+ClipManager::~ClipManager()
+{
qDeleteAll(m_clipList);
}
-void ClipManager::clear() {
+void ClipManager::clear()
+{
qDeleteAll(m_clipList);
m_clipList.clear();
m_clipIdCounter = 1;
m_audioThumbsQueue.clear();
}
-void ClipManager::checkAudioThumbs() {
+void ClipManager::checkAudioThumbs()
+{
if (m_audioThumbsEnabled == KdenliveSettings::audiothumbnails()) return;
m_audioThumbsEnabled = KdenliveSettings::audiothumbnails();
for (int i = 0; i < m_clipList.count(); i++) {
}
}
-void ClipManager::askForAudioThumb(const QString &id) {
+void ClipManager::askForAudioThumb(const QString &id)
+{
DocClipBase *clip = getClipById(id);
if (clip && KdenliveSettings::audiothumbnails()) {
m_audioThumbsQueue.append(id);
}
}
-void ClipManager::startAudioThumbsGeneration() {
+void ClipManager::startAudioThumbsGeneration()
+{
if (!KdenliveSettings::audiothumbnails()) {
m_audioThumbsQueue.clear();
m_generatingAudioId.clear();
}
}
-void ClipManager::endAudioThumbsGeneration(const QString &requestedId) {
+void ClipManager::endAudioThumbsGeneration(const QString &requestedId)
+{
if (!KdenliveSettings::audiothumbnails()) {
m_audioThumbsQueue.clear();
m_generatingAudioId.clear();
}
}
-void ClipManager::setThumbsProgress(const QString &message, int progress) {
+void ClipManager::setThumbsProgress(const QString &message, int progress)
+{
m_doc->setThumbsProgress(message, progress);
}
-QList <DocClipBase*> ClipManager::documentClipList() const {
+QList <DocClipBase*> ClipManager::documentClipList() const
+{
return m_clipList;
}
-QMap <QString, QString> ClipManager::documentFolderList() const {
+QMap <QString, QString> ClipManager::documentFolderList() const
+{
return m_folderList;
}
-void ClipManager::addClip(DocClipBase *clip) {
+void ClipManager::addClip(DocClipBase *clip)
+{
m_clipList.append(clip);
const QString id = clip->getId();
if (id.toInt() >= m_clipIdCounter) m_clipIdCounter = id.toInt() + 1;
if (!gid.isEmpty() && gid.toInt() >= m_folderIdCounter) m_folderIdCounter = gid.toInt() + 1;
}
-void ClipManager::slotDeleteClip(const QString &clipId) {
+void ClipManager::slotDeleteClip(const QString &clipId)
+{
for (int i = 0; i < m_clipList.count(); i++) {
if (m_clipList.at(i)->getId() == clipId) {
AddClipCommand *command = new AddClipCommand(m_doc, m_clipList.at(i)->toXML(), clipId, false);
}
}
-void ClipManager::deleteClip(const QString &clipId) {
+void ClipManager::deleteClip(const QString &clipId)
+{
for (int i = 0; i < m_clipList.count(); i++) {
if (m_clipList.at(i)->getId() == clipId) {
DocClipBase *clip = m_clipList.takeAt(i);
}
}
-DocClipBase *ClipManager::getClipAt(int pos) {
+DocClipBase *ClipManager::getClipAt(int pos)
+{
return m_clipList.at(pos);
}
-DocClipBase *ClipManager::getClipById(QString clipId) {
+DocClipBase *ClipManager::getClipById(QString clipId)
+{
//kDebug() << "++++ CLIP MAN, LOOKING FOR CLIP ID: " << clipId;
clipId = clipId.section('_', 0, 0);
for (int i = 0; i < m_clipList.count(); i++) {
return NULL;
}
-DocClipBase *ClipManager::getClipByResource(QString resource) {
+DocClipBase *ClipManager::getClipByResource(QString resource)
+{
for (int i = 0; i < m_clipList.count(); i++) {
if (m_clipList.at(i)->getProperty("resource") == resource) {
return m_clipList.at(i);
return NULL;
}
-void ClipManager::updatePreviewSettings() {
+void ClipManager::updatePreviewSettings()
+{
for (int i = 0; i < m_clipList.count(); i++) {
if (m_clipList.at(i)->clipType() == AV || m_clipList.at(i)->clipType() == VIDEO) {
if (m_clipList.at(i)->producerProperty("meta.media.0.codec.name") && strcmp(m_clipList.at(i)->producerProperty("meta.media.0.codec.name"), "h264") == 0) {
}
}
-void ClipManager::resetProducersList(QList <Mlt::Producer *> prods) {
+void ClipManager::resetProducersList(QList <Mlt::Producer *> prods)
+{
for (int i = 0; i < m_clipList.count(); i++) {
if (m_clipList.at(i)->numReferences() > 0) {
m_clipList.at(i)->deleteProducers();
}
}
-void ClipManager::slotAddClipList(const KUrl::List urls, const QString group, const QString &groupId) {
+void ClipManager::slotAddClipList(const KUrl::List urls, const QString group, const QString &groupId)
+{
QUndoCommand *addClips = new QUndoCommand();
addClips->setText(i18n("Add clips"));
m_doc->commandStack()->push(addClips);
}
-void ClipManager::slotAddClipFile(const KUrl url, const QString group, const QString &groupId) {
+void ClipManager::slotAddClipFile(const KUrl url, const QString group, const QString &groupId)
+{
kDebug() << "///// CLIP MANAGER, ADDING CLIP: " << url;
QDomDocument doc;
QDomElement prod = doc.createElement("producer");
m_doc->commandStack()->push(command);
}
-void ClipManager::slotAddColorClipFile(const QString name, const QString color, QString duration, const QString group, const QString &groupId) {
+void ClipManager::slotAddColorClipFile(const QString name, const QString color, QString duration, const QString group, const QString &groupId)
+{
QDomDocument doc;
QDomElement prod = doc.createElement("producer");
doc.appendChild(prod);
m_doc->commandStack()->push(command);
}
-void ClipManager::slotAddSlideshowClipFile(const QString name, const QString path, int count, const QString duration, const bool loop, const bool fade, const QString &luma_duration, const QString &luma_file, const int softness, QString group, const QString &groupId) {
+void ClipManager::slotAddSlideshowClipFile(const QString name, const QString path, int count, const QString duration, const bool loop, const bool fade, const QString &luma_duration, const QString &luma_file, const int softness, QString group, const QString &groupId)
+{
QDomDocument doc;
QDomElement prod = doc.createElement("producer");
doc.appendChild(prod);
-void ClipManager::slotAddTextClipFile(const QString titleName, const QString imagePath, const QString xml, const QString group, const QString &groupId) {
+void ClipManager::slotAddTextClipFile(const QString titleName, const QString imagePath, const QString xml, const QString group, const QString &groupId)
+{
QDomDocument doc;
QDomElement prod = doc.createElement("producer");
doc.appendChild(prod);
m_doc->commandStack()->push(command);
}
-int ClipManager::getFreeClipId() {
+int ClipManager::getFreeClipId()
+{
return m_clipIdCounter++;
}
-int ClipManager::getFreeFolderId() {
+int ClipManager::getFreeFolderId()
+{
return m_folderIdCounter++;
}
-int ClipManager::lastClipId() const {
+int ClipManager::lastClipId() const
+{
return m_clipIdCounter - 1;
}
-QString ClipManager::projectFolder() const {
+QString ClipManager::projectFolder() const
+{
return m_doc->projectFolder().path();
}
-void ClipManager::addFolder(const QString &id, const QString &name) {
+void ClipManager::addFolder(const QString &id, const QString &name)
+{
m_folderList.insert(id, name);
}
-void ClipManager::deleteFolder(const QString &id) {
+void ClipManager::deleteFolder(const QString &id)
+{
m_folderList.remove(id);
}
-AbstractGroupItem *ClipManager::createGroup() {
+AbstractGroupItem *ClipManager::createGroup()
+{
AbstractGroupItem *group = new AbstractGroupItem(m_doc->fps());
m_groupsList.append(group);
return group;
}
-void ClipManager::removeGroup(AbstractGroupItem *group) {
+void ClipManager::removeGroup(AbstractGroupItem *group)
+{
m_groupsList.removeAll(group);
}
-QDomElement ClipManager::groupsXml() const {
+QDomElement ClipManager::groupsXml() const
+{
QDomDocument doc;
QDomElement groups = doc.createElement("groups");
doc.appendChild(groups);
class DocClipBase;
class AbstractGroupItem;
-namespace Mlt {
+namespace Mlt
+{
class Producer;
};
-class ClipManager: public QObject {
+class ClipManager: public QObject
+{
Q_OBJECT public:
ClipManager(KdenliveDoc *doc);
static const int TYPE_BMP = 2;
static const int TYPE_GIF = 3;
-ClipProperties::ClipProperties(DocClipBase *clip, Timecode tc, double fps, QWidget * parent): QDialog(parent), m_tc(tc), m_clip(clip), m_fps(fps), m_clipNeedsRefresh(false), m_count(0) {
+ClipProperties::ClipProperties(DocClipBase *clip, Timecode tc, double fps, QWidget * parent): QDialog(parent), m_tc(tc), m_clip(clip), m_fps(fps), m_clipNeedsRefresh(false), m_count(0)
+{
setFont(KGlobalSettings::toolBarFont());
m_view.setupUi(this);
KUrl url = m_clip->fileURL();
adjustSize();
}
-void ClipProperties::slotEnableLuma(int state) {
+void ClipProperties::slotEnableLuma(int state)
+{
bool enable = false;
if (state == Qt::Checked) enable = true;
m_view.luma_duration->setEnabled(enable);
m_view.luma_softness->setEnabled(m_view.label_softness->isEnabled());
}
-void ClipProperties::slotEnableLumaFile(int state) {
+void ClipProperties::slotEnableLumaFile(int state)
+{
bool enable = false;
if (state == Qt::Checked) enable = true;
m_view.luma_file->setEnabled(enable);
m_view.label_softness->setEnabled(enable);
}
-void ClipProperties::slotFillMarkersList() {
+void ClipProperties::slotFillMarkersList()
+{
m_view.markers_list->clear();
QList < CommentedTime > marks = m_clip->commentedSnapMarkers();
for (uint count = 0; count < marks.count(); ++count) {
}
}
-void ClipProperties::slotAddMarker() {
+void ClipProperties::slotAddMarker()
+{
CommentedTime marker(GenTime(), i18n("Marker"));
MarkerDialog d(m_clip, marker, m_tc, i18n("Add Marker"), this);
if (d.exec() == QDialog::Accepted) {
QTimer::singleShot(500, this, SLOT(slotFillMarkersList()));
}
-void ClipProperties::slotEditMarker() {
+void ClipProperties::slotEditMarker()
+{
QList < CommentedTime > marks = m_clip->commentedSnapMarkers();
int pos = m_view.markers_list->currentIndex().row();
if (pos < 0 || pos > marks.count() - 1) return;
QTimer::singleShot(500, this, SLOT(slotFillMarkersList()));
}
-void ClipProperties::slotDeleteMarker() {
+void ClipProperties::slotDeleteMarker()
+{
QList < CommentedTime > marks = m_clip->commentedSnapMarkers();
int pos = m_view.markers_list->currentIndex().row();
if (pos < 0 || pos > marks.count() - 1) return;
QTimer::singleShot(500, this, SLOT(slotFillMarkersList()));
}
-const QString &ClipProperties::clipId() const {
+const QString &ClipProperties::clipId() const
+{
return m_clip->getId();
}
-QMap <QString, QString> ClipProperties::properties() {
+QMap <QString, QString> ClipProperties::properties()
+{
QMap <QString, QString> props;
CLIPTYPE t = m_clip->clipType();
QMap <QString, QString> old_props = m_clip->properties();
return props;
}
-bool ClipProperties::needsTimelineRefresh() const {
+bool ClipProperties::needsTimelineRefresh() const
+{
return m_clipNeedsRefresh;
}
-void ClipProperties::parseFolder() {
+void ClipProperties::parseFolder()
+{
QDir dir(m_view.clip_path->text());
QStringList filters;
m_view.clip_thumb->setPixmap(pix);
}
-void ClipProperties::slotCheckMaxLength() {
+void ClipProperties::slotCheckMaxLength()
+{
int duration = m_tc.getFrameCount(m_view.clip_duration->text(), m_fps);
if (duration > m_clip->maxDuration().frames(m_fps)) {
m_view.clip_duration->setText(m_tc.getTimecode(m_clip->maxDuration(), m_fps));
#include "docclipbase.h"
#include "ui_clipproperties_ui.h"
-class ClipProperties : public QDialog {
+class ClipProperties : public QDialog
+{
Q_OBJECT
public:
#include <QMenu>
ComplexParameter::ComplexParameter(QWidget *parent)
- : QWidget(parent) {
+ : QWidget(parent)
+{
ui.setupUi(this);
//ui.effectlist->horizontalHeader()->setVisible(false);
//ui.effectlist->verticalHeader()->setVisible(false);
-void ComplexParameter::slotSetMoveX() {
+void ComplexParameter::slotSetMoveX()
+{
ui.kplotwidget->setMoveX(!ui.kplotwidget->isMoveX());
updateButtonStatus();
}
-void ComplexParameter::slotSetMoveY() {
+void ComplexParameter::slotSetMoveY()
+{
ui.kplotwidget->setMoveY(!ui.kplotwidget->isMoveY());
updateButtonStatus();
}
-void ComplexParameter::slotSetNew() {
+void ComplexParameter::slotSetNew()
+{
ui.kplotwidget->setNewPoints(!ui.kplotwidget->isNewPoints());
updateButtonStatus();
}
-void ComplexParameter::slotSetHelp() {
+void ComplexParameter::slotSetHelp()
+{
ui.infoBox->setVisible(!ui.infoBox->isVisible());
ui.buttonHelp->setDown(ui.infoBox->isVisible());
}
-void ComplexParameter::slotShowInTimeline() {
+void ComplexParameter::slotShowInTimeline()
+{
ui.kplotwidget->setMoveTimeLine(!ui.kplotwidget->isMoveTimeline());
updateButtonStatus();
}
-void ComplexParameter::updateButtonStatus() {
+void ComplexParameter::updateButtonStatus()
+{
ui.buttonLeftRight->setDown(ui.kplotwidget->isMoveX());
ui.buttonUpDown->setDown(ui.kplotwidget->isMoveY());
ui.buttonNewPoints->setDown(ui.kplotwidget->isNewPoints());
}
-void ComplexParameter::slotParameterChanged(const QString& text) {
+void ComplexParameter::slotParameterChanged(const QString& text)
+{
//ui.buttonNewPoints->setEnabled(text!="all");
ui.kplotwidget->replot(text);
updateButtonStatus();
}
-void ComplexParameter::setupParam(const QDomElement& d, const QString& paramName, int from, int to) {
+void ComplexParameter::setupParam(const QDomElement& d, const QString& paramName, int from, int to)
+{
param = d;
ui.kplotwidget->setPointLists(d, paramName, from, to);
}
-void ComplexParameter::itemSelectionChanged() {
+void ComplexParameter::itemSelectionChanged()
+{
//kDebug() << "drop";
}
-void ComplexParameter::slotUpdateEffectParams(QDomElement e) {
+void ComplexParameter::slotUpdateEffectParams(QDomElement e)
+{
param = e;
emit parameterChanged();
}
-QDomElement ComplexParameter::getParamDesc() {
+QDomElement ComplexParameter::getParamDesc()
+{
return param;
}
-void ComplexParameter::slotUpdateParameterList(QStringList l) {
+void ComplexParameter::slotUpdateParameterList(QStringList l)
+{
kDebug() << l ;
ui.parameterList->clear();
ui.parameterList->addItem("all");
class EffectsList;
class ClipItem;
-class ComplexParameter : public QWidget {
+class ComplexParameter : public QWidget
+{
Q_OBJECT
public:
const int CustomRuler::comboScale[] = { 1, 2, 5, 10, 25, 50, 125, 250, 500, 725, 1500, 3000, 6000, 12000};
CustomRuler::CustomRuler(Timecode tc, CustomTrackView *parent)
- : QWidget(parent), m_timecode(tc), m_view(parent), m_duration(0), m_offset(0) {
+ : QWidget(parent), m_timecode(tc), m_view(parent), m_duration(0), m_offset(0)
+{
setFont(KGlobalSettings::toolBarFont());
m_scale = 3;
m_bgColor = QColor(245, 245, 245);
setMinimumHeight(20);
}
-void CustomRuler::setZone(QPoint p) {
+void CustomRuler::setZone(QPoint p)
+{
int min = qMin(m_zoneStart, p.x());
int max = qMax(m_zoneEnd, p.y());
m_zoneStart = p.x();
}
// virtual
-void CustomRuler::mousePressEvent(QMouseEvent * event) {
+void CustomRuler::mousePressEvent(QMouseEvent * event)
+{
if (event->button() == Qt::RightButton) {
m_contextMenu->exec(event->globalPos());
return;
}
// virtual
-void CustomRuler::mouseMoveEvent(QMouseEvent * event) {
+void CustomRuler::mouseMoveEvent(QMouseEvent * event)
+{
if (event->buttons() == Qt::LeftButton) {
int pos = (int)((event->x() + offset()) / m_factor);
int zoneStart = m_zoneStart;
// virtual
-void CustomRuler::wheelEvent(QWheelEvent * e) {
+void CustomRuler::wheelEvent(QWheelEvent * e)
+{
int delta = 1;
if (e->modifiers() == Qt::ControlModifier) delta = m_timecode.fps();
if (e->delta() < 0) delta = 0 - delta;
m_view->moveCursorPos(delta);
}
-int CustomRuler::inPoint() const {
+int CustomRuler::inPoint() const
+{
return m_zoneStart;
}
-int CustomRuler::outPoint() const {
+int CustomRuler::outPoint() const
+{
return m_zoneEnd;
}
-void CustomRuler::slotMoveRuler(int newPos) {
+void CustomRuler::slotMoveRuler(int newPos)
+{
m_offset = newPos;
update();
}
-int CustomRuler::offset() const {
+int CustomRuler::offset() const
+{
return m_offset;
}
-void CustomRuler::slotCursorMoved(int oldpos, int newpos) {
+void CustomRuler::slotCursorMoved(int oldpos, int newpos)
+{
if (qAbs(oldpos - newpos) * m_factor > 40) {
update(oldpos * m_factor - offset() - 6, 7, 17, 16);
update(newpos * m_factor - offset() - 6, 7, 17, 16);
} else update(qMin(oldpos, newpos) * m_factor - offset() - 6, 7, qAbs(oldpos - newpos) * m_factor + 17, 16);
}
-void CustomRuler::setPixelPerMark(double rate) {
+void CustomRuler::setPixelPerMark(double rate)
+{
int scale = comboScale[(int) rate];
m_factor = 1.0 / (double) scale * FRAME_SIZE;
m_scale = 1.0 / (double) scale;
update();
}
-void CustomRuler::setDuration(int d) {
+void CustomRuler::setDuration(int d)
+{
int oldduration = m_duration;
m_duration = d;
update(qMin(oldduration, m_duration) * m_factor - 1 - offset(), 0, qAbs(oldduration - m_duration) * m_factor + 2, height());
}
// virtual
-void CustomRuler::paintEvent(QPaintEvent *e) {
+void CustomRuler::paintEvent(QPaintEvent *e)
+{
QStylePainter p(this);
p.setClipRect(e->rect());
enum RULER_MOVE { RULER_CURSOR = 0, RULER_START = 1, RULER_MIDDLE = 2, RULER_END = 3 };
-class CustomRuler : public QWidget {
+class CustomRuler : public QWidget
+{
Q_OBJECT
public:
#include <KStandardDirs>
CustomTrackScene::CustomTrackScene(KdenliveDoc *doc, QObject *parent)
- : QGraphicsScene(parent), m_document(doc), m_scale(1.0) {
+ : QGraphicsScene(parent), m_document(doc), m_scale(1.0)
+{
m_transitionPixmap = QPixmap(KStandardDirs::locate("appdata", "transition.png"));
}
-CustomTrackScene::~CustomTrackScene() {
+CustomTrackScene::~CustomTrackScene()
+{
}
-double CustomTrackScene::getSnapPointForPos(double pos, bool doSnap) {
+double CustomTrackScene::getSnapPointForPos(double pos, bool doSnap)
+{
double maximumOffset;
if (doSnap) {
if (m_scale > 3) maximumOffset = 10 / m_scale;
return GenTime(pos, m_document->fps()).frames(m_document->fps());
}
-void CustomTrackScene::setSnapList(QList <GenTime> snaps) {
+void CustomTrackScene::setSnapList(QList <GenTime> snaps)
+{
m_snapPoints = snaps;
}
-GenTime CustomTrackScene::previousSnapPoint(GenTime pos) {
+GenTime CustomTrackScene::previousSnapPoint(GenTime pos)
+{
for (int i = 0; i < m_snapPoints.size(); ++i) {
if (m_snapPoints.at(i) >= pos) {
if (i == 0) i = 1;
return GenTime();
}
-GenTime CustomTrackScene::nextSnapPoint(GenTime pos) {
+GenTime CustomTrackScene::nextSnapPoint(GenTime pos)
+{
for (int i = 0; i < m_snapPoints.size(); ++i) {
if (m_snapPoints.at(i) > pos) {
return m_snapPoints.at(i);
return pos;
}
-void CustomTrackScene::setScale(double scale) {
+void CustomTrackScene::setScale(double scale)
+{
m_scale = scale;
}
-double CustomTrackScene::scale() const {
+double CustomTrackScene::scale() const
+{
return m_scale;
}
-int CustomTrackScene::tracksCount() const {
+int CustomTrackScene::tracksCount() const
+{
return m_document->tracksCount();
}
/** This class holds all properties that need to be used by clip items */
-class CustomTrackScene : public QGraphicsScene {
+class CustomTrackScene : public QGraphicsScene
+{
Q_OBJECT
public:
// const int duration = animate ? 1500 : 1;
CustomTrackView::CustomTrackView(KdenliveDoc *doc, CustomTrackScene* projectscene, QWidget *parent)
- : QGraphicsView(projectscene, parent), m_scene(projectscene), m_cursorPos(0), m_cursorLine(NULL), m_operationMode(NONE), m_dragItem(NULL), m_visualTip(NULL), m_moveOpMode(NONE), m_animation(NULL), m_projectDuration(0), m_clickPoint(QPoint()), m_document(doc), m_autoScroll(KdenliveSettings::autoscroll()), m_tracksHeight(KdenliveSettings::trackheight()), m_tool(SELECTTOOL), m_dragGuide(NULL), m_findIndex(0), m_menuPosition(QPoint()), m_blockRefresh(false), m_selectionGroup(NULL), m_selectedTrack(0), m_copiedItems(QList<AbstractClipItem *> ()), m_scrollOffset(0), m_changeSpeedAction(NULL), m_pasteEffectsAction(NULL), m_ungroupAction(NULL), m_clipDrag(false) {
+ : QGraphicsView(projectscene, parent), m_scene(projectscene), m_cursorPos(0), m_cursorLine(NULL), m_operationMode(NONE), m_dragItem(NULL), m_visualTip(NULL), m_moveOpMode(NONE), m_animation(NULL), m_projectDuration(0), m_clickPoint(QPoint()), m_document(doc), m_autoScroll(KdenliveSettings::autoscroll()), m_tracksHeight(KdenliveSettings::trackheight()), m_tool(SELECTTOOL), m_dragGuide(NULL), m_findIndex(0), m_menuPosition(QPoint()), m_blockRefresh(false), m_selectionGroup(NULL), m_selectedTrack(0), m_copiedItems(QList<AbstractClipItem *> ()), m_scrollOffset(0), m_changeSpeedAction(NULL), m_pasteEffectsAction(NULL), m_ungroupAction(NULL), m_clipDrag(false)
+{
if (doc) m_commandStack = doc->commandStack();
else m_commandStack = NULL;
setMouseTracking(true);
m_scrollTimer.setSingleShot(true);
}
-CustomTrackView::~CustomTrackView() {
+CustomTrackView::~CustomTrackView()
+{
qDeleteAll(m_guides);
}
-void CustomTrackView::setDocumentModified() {
+void CustomTrackView::setDocumentModified()
+{
m_document->setModified(true);
}
-void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition) {
+void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition)
+{
m_timelineContextMenu = timeline;
m_timelineContextClipMenu = clip;
QList <QAction *> list = m_timelineContextClipMenu->actions();
}
}
-void CustomTrackView::checkAutoScroll() {
+void CustomTrackView::checkAutoScroll()
+{
m_autoScroll = KdenliveSettings::autoscroll();
}
return m_scene->m_tracksList;
}*/
-void CustomTrackView::checkTrackHeight() {
+void CustomTrackView::checkTrackHeight()
+{
if (m_tracksHeight == KdenliveSettings::trackheight()) return;
m_tracksHeight = KdenliveSettings::trackheight();
emit trackHeightChanged();
}
// virtual
-void CustomTrackView::resizeEvent(QResizeEvent * event) {
+void CustomTrackView::resizeEvent(QResizeEvent * event)
+{
QGraphicsView::resizeEvent(event);
}
* opposite on up/forward.
*
* See also http://www.kdenlive.org/mantis/view.php?id=265 */
-void CustomTrackView::wheelEvent(QWheelEvent * e) {
+void CustomTrackView::wheelEvent(QWheelEvent * e)
+{
if (e->modifiers() == Qt::ControlModifier) {
if (e->delta() > 0) emit zoomIn();
else emit zoomOut();
}
}
-int CustomTrackView::getPreviousVideoTrack(int track) {
+int CustomTrackView::getPreviousVideoTrack(int track)
+{
track = m_document->tracksCount() - track - 1;
track --;
for (int i = track; i > -1; i--) {
}
-void CustomTrackView::slotCheckMouseScrolling() {
+void CustomTrackView::slotCheckMouseScrolling()
+{
if (m_scrollOffset == 0) {
m_scrollTimer.stop();
return;
m_scrollTimer.start();
}
-void CustomTrackView::slotCheckPositionScrolling() {
+void CustomTrackView::slotCheckPositionScrolling()
+{
// If mouse is at a border of the view, scroll
if (m_moveOpMode != SEEK) return;
int pos = cursorPos();
// virtual
-void CustomTrackView::mouseMoveEvent(QMouseEvent * event) {
+void CustomTrackView::mouseMoveEvent(QMouseEvent * event)
+{
int pos = event->x();
int mappedXPos = (int)(mapToScene(event->pos()).x() + 0.5);
emit mousePosition(mappedXPos);
}
// virtual
-void CustomTrackView::mousePressEvent(QMouseEvent * event) {
+void CustomTrackView::mousePressEvent(QMouseEvent * event)
+{
kDebug() << "mousePressEvent STARTED";
m_menuPosition = QPoint();
m_blockRefresh = true;
//QGraphicsView::mousePressEvent(event);
}
-void CustomTrackView::resetSelectionGroup(bool selectItems) {
+void CustomTrackView::resetSelectionGroup(bool selectItems)
+{
if (m_selectionGroup) {
// delete selection group
bool snap = KdenliveSettings::snaptopoints();
}
}
-void CustomTrackView::groupSelectedItems(bool force, bool createNewGroup) {
+void CustomTrackView::groupSelectedItems(bool force, bool createNewGroup)
+{
if (m_selectionGroup) {
kDebug() << "///// ERROR, TRYING TO OVERRIDE EXISTING GROUP";
return;
} else resetSelectionGroup();
}
-void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event) {
+void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event)
+{
kDebug() << "++++++++++++ DBL CLK";
if (m_dragItem && m_dragItem->hasKeyFrames()) {
if (m_moveOpMode == KEYFRAME) {
}
-void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes) {
+void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes)
+{
ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
if (clip) {
clip->setKeyframes(index, keyframes);
}
-void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip, AbstractGroupItem *group) {
+void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip, AbstractGroupItem *group)
+{
if (clip == NULL) m_timelineContextMenu->popup(pos);
else if (group != NULL) {
m_changeSpeedAction->setEnabled(false);
}
}
-void CustomTrackView::activateMonitor() {
+void CustomTrackView::activateMonitor()
+{
emit activateDocumentMonitor();
}
-void CustomTrackView::dragEnterEvent(QDragEnterEvent * event) {
+void CustomTrackView::dragEnterEvent(QDragEnterEvent * event)
+{
if (event->mimeData()->hasFormat("kdenlive/clip")) {
m_clipDrag = true;
resetSelectionGroup();
}
-bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const {
+bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const
+{
QPolygonF path;
QList<QGraphicsItem *> children = group->childItems();
for (int i = 0; i < children.count(); i++) {
}
-void CustomTrackView::slotRefreshEffects(ClipItem *clip) {
+void CustomTrackView::slotRefreshEffects(ClipItem *clip)
+{
int track = m_document->tracksCount() - clip->track();
GenTime pos = clip->startPos();
if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false, false)) {
m_document->renderer()->doRefresh();
}
-void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect) {
+void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect)
+{
ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
if (clip) {
if (!m_document->renderer()->mltAddEffect(track, pos, clip->addEffect(effect)))
} else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
}
-void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect) {
+void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect)
+{
QString index = effect.attribute("kdenlive_ix");
if (!m_document->renderer()->mltRemoveEffect(track, pos, index, true) && effect.attribute("disabled") != "1") {
kDebug() << "// ERRORÂ REMOVÂ EFFECT: " << index << ", DISABLE: " << effect.attribute("disabled");
}
}
-void CustomTrackView::slotAddGroupEffect(QDomElement effect, AbstractGroupItem *group) {
+void CustomTrackView::slotAddGroupEffect(QDomElement effect, AbstractGroupItem *group)
+{
QList<QGraphicsItem *> itemList = group->childItems();
QUndoCommand *effectCommand = new QUndoCommand();
QString effectName;
} else delete effectCommand;
}
-void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track) {
+void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track)
+{
QList<QGraphicsItem *> itemList;
QUndoCommand *effectCommand = new QUndoCommand();
QString effectName;
} else delete effectCommand;
}
-void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect) {
+void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect)
+{
AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
m_commandStack->push(command);
m_document->setModified(true);
}
-void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser) {
+void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser)
+{
ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
if (clip) {
EffectsParameterList effectParams = clip->getEffectArgs(effect);
m_document->setModified(true);
}
-void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos) {
+void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos)
+{
ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
if (clip) {
m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
m_document->setModified(true);
}
-void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable) {
+void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable)
+{
QDomElement effect = clip->effectAt(effectPos);
QDomElement oldEffect = effect.cloneNode().toElement();
effect.setAttribute("disabled", disable);
m_document->setModified(true);
}
-void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos) {
+void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos)
+{
MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos, true);
m_commandStack->push(command);
m_document->setModified(true);
}
-void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix) {
+void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix)
+{
EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
m_commandStack->push(command);
}
-void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut) {
+void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut)
+{
if (cut) {
// cut clip
ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
}
-void CustomTrackView::slotEnableRefresh() {
+void CustomTrackView::slotEnableRefresh()
+{
m_blockRefresh = false;
}
-void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition) {
+void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition)
+{
QList<QGraphicsItem *> itemList = scene()->selectedItems();
if (itemList.count() == 1) {
if (itemList.at(0)->type() == AVWIDGET) {
}
}
-void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition) {
+void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition)
+{
if (transitionInfo.startPos >= transitionInfo.endPos) {
emit displayMessage(i18n("Invalid transition"), ErrorMessage);
return;
m_document->setModified(true);
}
-void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
+void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params)
+{
Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
//kDebug() << "---- ADDING transition " << params.attribute("value");
if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML())) {
}
}
-void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/) {
+void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/)
+{
Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
if (!item) {
emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
m_document->setModified(true);
}
-void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old) {
+void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old)
+{
kDebug() << "TRANSÂ UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
m_commandStack->push(command);
m_document->setModified(true);
}
-void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget) {
+void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget)
+{
Transition *item = getTransitionItemAt(pos, track);
if (!item) {
kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
m_document->setModified(true);
}
-void CustomTrackView::dragMoveEvent(QDragMoveEvent * event) {
+void CustomTrackView::dragMoveEvent(QDragMoveEvent * event)
+{
event->setDropAction(Qt::IgnoreAction);
const QPointF pos = mapToScene(event->pos());
if (m_selectionGroup && m_clipDrag) {
}
}
-void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event) {
+void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event)
+{
if (m_selectionGroup && m_clipDrag) {
QList<QGraphicsItem *> items = m_selectionGroup->childItems();
qDeleteAll(items);
} else QGraphicsView::dragLeaveEvent(event);
}
-void CustomTrackView::dropEvent(QDropEvent * event) {
+void CustomTrackView::dropEvent(QDropEvent * event)
+{
if (m_selectionGroup && m_clipDrag) {
QList<QGraphicsItem *> items = m_selectionGroup->childItems();
resetSelectionGroup();
}
-QStringList CustomTrackView::mimeTypes() const {
+QStringList CustomTrackView::mimeTypes() const
+{
QStringList qstrList;
// list of accepted mime types for drop
qstrList.append("text/plain");
return qstrList;
}
-Qt::DropActions CustomTrackView::supportedDropActions() const {
+Qt::DropActions CustomTrackView::supportedDropActions() const
+{
// returns what actions are supported when dropping
return Qt::MoveAction;
}
-void CustomTrackView::setDuration(int duration) {
+void CustomTrackView::setDuration(int duration)
+{
int diff = qAbs(duration - sceneRect().width());
if (diff * matrix().m11() > -50) {
if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
m_projectDuration = duration;
}
-int CustomTrackView::duration() const {
+int CustomTrackView::duration() const
+{
return m_projectDuration;
}
-void CustomTrackView::addTrack(TrackInfo type, int ix) {
+void CustomTrackView::addTrack(TrackInfo type, int ix)
+{
if (ix == -1) m_document->insertTrack(ix, type);
else {
m_document->insertTrack(m_document->tracksCount() - ix, type);
//setFixedHeight(50 * m_tracksCount);
}
-void CustomTrackView::removeTrack(int ix) {
+void CustomTrackView::removeTrack(int ix)
+{
// Delete track in MLT playlist
m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
m_document->deleteTrack(m_document->tracksCount() - ix - 1);
viewport()->update();
}
-void CustomTrackView::changeTrack(int ix, TrackInfo type) {
+void CustomTrackView::changeTrack(int ix, TrackInfo type)
+{
int tracknumber = m_document->tracksCount() - ix;
m_document->setTrackType(tracknumber - 1, type);
m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
}
-void CustomTrackView::slotSwitchTrackAudio(int ix) {
+void CustomTrackView::slotSwitchTrackAudio(int ix)
+{
/*for (int i = 0; i < m_document->tracksCount(); i++)
kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
int tracknumber = m_document->tracksCount() - ix;
m_document->setModified(true);
}
-void CustomTrackView::slotSwitchTrackLock(int ix) {
+void CustomTrackView::slotSwitchTrackLock(int ix)
+{
int tracknumber = m_document->tracksCount() - ix - 1;
LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked, true);
m_commandStack->push(command);
}
-void CustomTrackView::lockTrack(int ix, bool lock) {
+void CustomTrackView::lockTrack(int ix, bool lock)
+{
int tracknumber = m_document->tracksCount() - ix - 1;
m_document->switchTrackLock(tracknumber, lock);
emit doTrackLock(ix, lock);
m_document->setModified(true);
}
-void CustomTrackView::slotSwitchTrackVideo(int ix) {
+void CustomTrackView::slotSwitchTrackVideo(int ix)
+{
int tracknumber = m_document->tracksCount() - ix;
m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
m_document->setModified(true);
}
-void CustomTrackView::slotRemoveSpace() {
+void CustomTrackView::slotRemoveSpace()
+{
GenTime pos;
int track = 0;
if (m_menuPosition.isNull()) {
m_commandStack->push(command);
}
-void CustomTrackView::slotInsertSpace() {
+void CustomTrackView::slotInsertSpace()
+{
GenTime pos;
int track = 0;
if (m_menuPosition.isNull()) {
m_commandStack->push(command);
}
-void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset) {
+void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset)
+{
int diff = duration.frames(m_document->fps());
resetSelectionGroup();
m_selectionGroup = new AbstractGroupItem(m_document->fps());
m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
}
-void CustomTrackView::deleteClip(const QString &clipId) {
+void CustomTrackView::deleteClip(const QString &clipId)
+{
resetSelectionGroup();
QList<QGraphicsItem *> itemList = items();
QUndoCommand *deleteCommand = new QUndoCommand();
else m_commandStack->push(deleteCommand);
}
-void CustomTrackView::setCursorPos(int pos, bool seek) {
+void CustomTrackView::setCursorPos(int pos, bool seek)
+{
emit cursorMoved((int)(m_cursorPos), (int)(pos));
m_cursorPos = pos;
m_cursorLine->setPos(pos, 0);
else if (m_autoScroll) checkScrolling();
}
-void CustomTrackView::updateCursorPos() {
+void CustomTrackView::updateCursorPos()
+{
m_cursorLine->setPos(m_cursorPos, 0);
}
-int CustomTrackView::cursorPos() {
+int CustomTrackView::cursorPos()
+{
return (int)(m_cursorPos);
}
-void CustomTrackView::moveCursorPos(int delta) {
+void CustomTrackView::moveCursorPos(int delta)
+{
if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
m_cursorPos += delta;
m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
}
-void CustomTrackView::initCursorPos(int pos) {
+void CustomTrackView::initCursorPos(int pos)
+{
emit cursorMoved((int)(m_cursorPos), (int)(pos));
m_cursorPos = pos;
m_cursorLine->setPos(pos, 0);
checkScrolling();
}
-void CustomTrackView::checkScrolling() {
+void CustomTrackView::checkScrolling()
+{
int vert = verticalScrollBar()->value();
int hor = cursorPos();
ensureVisible(hor, vert + 10, 2, 2, 50, 0);
}
-void CustomTrackView::mouseReleaseEvent(QMouseEvent * event) {
+void CustomTrackView::mouseReleaseEvent(QMouseEvent * event)
+{
if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
QGraphicsView::mouseReleaseEvent(event);
if (m_scrollTimer.isActive()) m_scrollTimer.stop();
m_operationMode = NONE;
}
-void CustomTrackView::deleteClip(ItemInfo info) {
+void CustomTrackView::deleteClip(ItemInfo info)
+{
ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
m_document->renderer()->doRefresh();
}
-void CustomTrackView::deleteSelectedClips() {
+void CustomTrackView::deleteSelectedClips()
+{
resetSelectionGroup();
QList<QGraphicsItem *> itemList = scene()->selectedItems();
if (itemList.count() == 0) {
m_commandStack->push(deleteSelected);
}
-void CustomTrackView::changeClipSpeed() {
+void CustomTrackView::changeClipSpeed()
+{
QList<QGraphicsItem *> itemList = scene()->selectedItems();
if (itemList.count() == 0) {
emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
else delete changeSelected;
}
-void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id) {
+void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id)
+{
DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
if (!item) {
} else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
}
-void CustomTrackView::cutSelectedClips() {
+void CustomTrackView::cutSelectedClips()
+{
QList<QGraphicsItem *> itemList = scene()->selectedItems();
GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
for (int i = 0; i < itemList.count(); i++) {
}
}
-void CustomTrackView::groupClips(bool group) {
+void CustomTrackView::groupClips(bool group)
+{
QList<QGraphicsItem *> itemList = scene()->selectedItems();
QList <ItemInfo> clipInfos;
QList <ItemInfo> transitionInfos;
}
}
-void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group) {
+void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group)
+{
resetSelectionGroup();
m_scene->clearSelection();
if (!group) {
m_document->setModified(true);
}
-void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects) {
+void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects)
+{
DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
if (baseclip == NULL) {
emit displayMessage(i18n("No clip copied"), ErrorMessage);
m_document->renderer()->doRefresh();
}
-void CustomTrackView::slotUpdateClip(const QString &clipId) {
+void CustomTrackView::slotUpdateClip(const QString &clipId)
+{
QList<QGraphicsItem *> list = scene()->items();
ClipItem *clip = NULL;
for (int i = 0; i < list.size(); ++i) {
}
}
-ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track) {
+ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track)
+{
int framepos = (int)(pos.frames(m_document->fps()));
QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
ClipItem *clip = NULL;
return clip;
}
-ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track) {
+ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track)
+{
QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
ClipItem *clip = NULL;
for (int i = 0; i < list.size(); i++) {
return clip;
}
-ClipItem *CustomTrackView::getClipItemAt(int pos, int track) {
+ClipItem *CustomTrackView::getClipItemAt(int pos, int track)
+{
QList<QGraphicsItem *> list = scene()->items(QPointF(pos, track * m_tracksHeight + m_tracksHeight / 2));
ClipItem *clip = NULL;
for (int i = 0; i < list.size(); i++) {
return clip;
}
-ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track) {
+ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track)
+{
int framepos = (int)(pos.frames(m_document->fps()));
return getClipItemAt(framepos, track);
}
-Transition *CustomTrackView::getTransitionItemAt(int pos, int track) {
+Transition *CustomTrackView::getTransitionItemAt(int pos, int track)
+{
QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
Transition *clip = NULL;
for (int i = 0; i < list.size(); i++) {
return clip;
}
-Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track) {
+Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track)
+{
return getTransitionItemAt(pos.frames(m_document->fps()), track);
}
-Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track) {
+Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track)
+{
int framepos = (int)(pos.frames(m_document->fps()));
QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
Transition *clip = NULL;
return clip;
}
-Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track) {
+Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track)
+{
QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
Transition *clip = NULL;
for (int i = 0; i < list.size(); ++i) {
return clip;
}
-void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
+void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end)
+{
if (m_selectionGroup) resetSelectionGroup(false);
ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
if (!item) {
kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
}
-void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove) {
+void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove)
+{
// Group Items
kDebug() << "//GRP MOVE, REVERS:" << reverseMove;
kDebug() << "// GROUP MOV; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;
}
}
-void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
+void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end)
+{
Transition *item = getTransitionItemAt(start.startPos, start.track);
if (!item) {
emit displayMessage(i18n("Cannot move transition at time: %1 on track %2", m_document->timecode().getTimecodeFromFrames(start.startPos.frames(m_document->fps())), start.track), ErrorMessage);
if (m_dragItem && m_dragItem == item) emit transitionItemSelected(item);
}
-void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
+void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end)
+{
bool resizeClipStart = true;
if (start.startPos == end.startPos) resizeClipStart = false;
/*if (resizeClipStart) offset = 1;
KdenliveSettings::setSnaptopoints(snap);
}
-void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
+void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut)
+{
if (!updateFadeOut) {
int end = item->fadeIn();
if (end != 0) {
}
}
-double CustomTrackView::getSnapPointForPos(double pos) {
+double CustomTrackView::getSnapPointForPos(double pos)
+{
return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
}
-void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems) {
+void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems)
+{
QList <GenTime> snaps;
if (selected && offsetList.isEmpty()) offsetList.append(selected->duration());
QList<QGraphicsItem *> itemList = items();
// kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
}
-void CustomTrackView::slotSeekToPreviousSnap() {
+void CustomTrackView::slotSeekToPreviousSnap()
+{
updateSnapPoints(NULL);
GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
setCursorPos((int) res.frames(m_document->fps()));
checkScrolling();
}
-void CustomTrackView::slotSeekToNextSnap() {
+void CustomTrackView::slotSeekToNextSnap()
+{
updateSnapPoints(NULL);
GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
setCursorPos((int) res.frames(m_document->fps()));
checkScrolling();
}
-void CustomTrackView::clipStart() {
+void CustomTrackView::clipStart()
+{
ClipItem *item = getMainActiveClip();
if (item != NULL) {
setCursorPos((int) item->startPos().frames(m_document->fps()));
}
}
-void CustomTrackView::clipEnd() {
+void CustomTrackView::clipEnd()
+{
ClipItem *item = getMainActiveClip();
if (item != NULL) {
setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
}
}
-void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
+void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c)
+{
QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
m_commandStack->push(command);
}
-void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position) {
+void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position)
+{
AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
m_commandStack->push(command);
}
-void CustomTrackView::slotDeleteAllClipMarkers(const QString &id) {
+void CustomTrackView::slotDeleteAllClipMarkers(const QString &id)
+{
DocClipBase *base = m_document->clipManager()->getClipById(id);
QList <CommentedTime> markers = base->commentedSnapMarkers();
m_commandStack->push(deleteMarkers);
}
-void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
+void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment)
+{
DocClipBase *base = m_document->clipManager()->getClipById(id);
if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
else base->deleteSnapMarker(pos);
viewport()->update();
}
-bool sortGuidesList(const Guide *g1 , const Guide *g2) {
+bool sortGuidesList(const Guide *g1 , const Guide *g2)
+{
return (*g1).position() < (*g2).position();
}
-void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
+void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment)
+{
if (oldPos > GenTime() && pos > GenTime()) {
// move guide
for (int i = 0; i < m_guides.count(); i++) {
m_document->syncGuides(m_guides);
}
-bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
+bool CustomTrackView::addGuide(const GenTime pos, const QString &comment)
+{
for (int i = 0; i < m_guides.count(); i++) {
if (m_guides.at(i)->position() == pos) {
emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
return true;
}
-void CustomTrackView::slotAddGuide() {
+void CustomTrackView::slotAddGuide()
+{
CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
if (d.exec() != QDialog::Accepted) return;
}
}
-void CustomTrackView::slotEditGuide() {
+void CustomTrackView::slotEditGuide()
+{
GenTime pos = GenTime(m_cursorPos, m_document->fps());
bool found = false;
for (int i = 0; i < m_guides.count(); i++) {
if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
}
-void CustomTrackView::slotEditGuide(CommentedTime guide) {
+void CustomTrackView::slotEditGuide(CommentedTime guide)
+{
MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
if (d.exec() == QDialog::Accepted) {
EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
}
-void CustomTrackView::slotDeleteGuide() {
+void CustomTrackView::slotDeleteGuide()
+{
GenTime pos = GenTime(m_cursorPos, m_document->fps());
bool found = false;
for (int i = 0; i < m_guides.count(); i++) {
if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
}
-void CustomTrackView::slotDeleteAllGuides() {
+void CustomTrackView::slotDeleteAllGuides()
+{
QUndoCommand *deleteAll = new QUndoCommand();
deleteAll->setText("Delete all guides");
for (int i = 0; i < m_guides.count(); i++) {
m_commandStack->push(deleteAll);
}
-void CustomTrackView::setTool(PROJECTTOOL tool) {
+void CustomTrackView::setTool(PROJECTTOOL tool)
+{
m_tool = tool;
}
-void CustomTrackView::setScale(double scaleFactor) {
+void CustomTrackView::setScale(double scaleFactor)
+{
QMatrix matrix;
matrix = matrix.scale(scaleFactor, 1);
m_scene->setScale(scaleFactor);
//verticalScrollBar()->setValue(vert);*/
}
-void CustomTrackView::slotRefreshGuides() {
+void CustomTrackView::slotRefreshGuides()
+{
if (KdenliveSettings::showmarkers()) {
kDebug() << "// refresh GUIDES";
for (int i = 0; i < m_guides.count(); i++) {
}
}
-void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
+void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect)
+{
QColor base = palette().button().color();
QRectF r = rect;
r.setWidth(r.width() + 1);
painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
}
-bool CustomTrackView::findString(const QString &text) {
+bool CustomTrackView::findString(const QString &text)
+{
QString marker;
for (int i = 0; i < m_searchPoints.size(); ++i) {
marker = m_searchPoints.at(i).comment();
return false;
}
-bool CustomTrackView::findNextString(const QString &text) {
+bool CustomTrackView::findNextString(const QString &text)
+{
QString marker;
for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
marker = m_searchPoints.at(i).comment();
return false;
}
-void CustomTrackView::initSearchStrings() {
+void CustomTrackView::initSearchStrings()
+{
m_searchPoints.clear();
QList<QGraphicsItem *> itemList = items();
for (int i = 0; i < itemList.count(); i++) {
qSort(m_searchPoints);
}
-void CustomTrackView::clearSearchStrings() {
+void CustomTrackView::clearSearchStrings()
+{
m_searchPoints.clear();
m_findIndex = 0;
}
-void CustomTrackView::copyClip() {
+void CustomTrackView::copyClip()
+{
while (m_copiedItems.count() > 0) {
delete m_copiedItems.takeFirst();
}
}
}
-bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
+bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const
+{
QRectF rect((double) info.startPos.frames(m_document->fps()), (double)(info.track * m_tracksHeight + 1), (double)(info.endPos - info.startPos).frames(m_document->fps()), (double)(m_tracksHeight - 1));
QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
for (int i = 0; i < collisions.count(); i++) {
return true;
}
-bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
+bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
+{
for (int i = 0; i < items.count(); i++) {
ItemInfo info = items.at(i)->info();
info.startPos += offset;
return true;
}
-bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
+bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
+{
QPainterPath movePath;
movePath.moveTo(0, 0);
return true;
}
-void CustomTrackView::pasteClip() {
+void CustomTrackView::pasteClip()
+{
if (m_copiedItems.count() == 0) {
emit displayMessage(i18n("No clip copied"), ErrorMessage);
return;
m_commandStack->push(pasteClips);
}
-void CustomTrackView::pasteClipEffects() {
+void CustomTrackView::pasteClipEffects()
+{
if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
return;
}
-ClipItem *CustomTrackView::getClipUnderCursor() const {
+ClipItem *CustomTrackView::getClipUnderCursor() const
+{
QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
for (int i = 0; i < collisions.count(); i++) {
return NULL;
}
-ClipItem *CustomTrackView::getMainActiveClip() const {
+ClipItem *CustomTrackView::getMainActiveClip() const
+{
QList<QGraphicsItem *> clips = scene()->selectedItems();
if (clips.isEmpty()) {
return getClipUnderCursor();
return NULL;
}
-ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const {
+ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const
+{
QList<QGraphicsItem *> clips = scene()->selectedItems();
if (clips.isEmpty()) {
return getClipUnderCursor();
return NULL;
}
-void CustomTrackView::setInPoint() {
+void CustomTrackView::setInPoint()
+{
ClipItem *clip = getActiveClipUnderCursor(true);
if (clip == NULL) {
emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
m_commandStack->push(command);
}
-void CustomTrackView::setOutPoint() {
+void CustomTrackView::setOutPoint()
+{
ClipItem *clip = getActiveClipUnderCursor(true);
if (clip == NULL) {
emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
m_commandStack->push(command);
}
-void CustomTrackView::slotUpdateAllThumbs() {
+void CustomTrackView::slotUpdateAllThumbs()
+{
QList<QGraphicsItem *> itemList = items();
//if (itemList.isEmpty()) return;
ClipItem *item;
viewport()->update();
}
-void CustomTrackView::saveThumbnails() {
+void CustomTrackView::saveThumbnails()
+{
QList<QGraphicsItem *> itemList = items();
ClipItem *item;
QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
}
-void CustomTrackView::slotInsertTrack(int ix) {
+void CustomTrackView::slotInsertTrack(int ix)
+{
kDebug() << "// INSERTING TRK: " << ix;
QDialog d(parentWidget());
Ui::AddTrack_UI view;
}
}
-void CustomTrackView::slotDeleteTrack(int ix) {
+void CustomTrackView::slotDeleteTrack(int ix)
+{
bool ok;
ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
if (ok) {
}
}
-void CustomTrackView::slotChangeTrack(int ix) {
+void CustomTrackView::slotChangeTrack(int ix)
+{
QDialog d(parentWidget());
Ui::AddTrack_UI view;
view.setupUi(&d);
}
-void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo) {
+void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo)
+{
double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
QList<QGraphicsItem *> selection = m_scene->items(r);
m_commandStack->push(deleteTrack);
}
-void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo) {
+void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo)
+{
TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo, true);
m_commandStack->push(changeTrack);
}
-void CustomTrackView::autoTransition() {
+void CustomTrackView::autoTransition()
+{
QList<QGraphicsItem *> itemList = scene()->selectedItems();
if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
}
-QStringList CustomTrackView::getLadspaParams(QDomElement effect) const {
+QStringList CustomTrackView::getLadspaParams(QDomElement effect) const
+{
QStringList result;
QDomNodeList params = effect.elementsByTagName("parameter");
for (int i = 0; i < params.count(); i++) {
return result;
}
-void CustomTrackView::clipNameChanged(const QString id, const QString name) {
+void CustomTrackView::clipNameChanged(const QString id, const QString name)
+{
QList<QGraphicsItem *> list = scene()->items();
ClipItem *clip = NULL;
for (int i = 0; i < list.size(); ++i) {
viewport()->update();
}
-void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
+void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
+{
minimum = GenTime();
maximum = GenTime();
QList<QGraphicsItem *> selection;
}
}
-void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
+void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
+{
minimum = GenTime();
maximum = GenTime();
QList<QGraphicsItem *> selection;
}
-void CustomTrackView::loadGroups(const QDomNodeList groups) {
+void CustomTrackView::loadGroups(const QDomNodeList groups)
+{
for (int i = 0; i < groups.count(); i++) {
QDomNodeList children = groups.at(i).childNodes();
scene()->clearSelection();
}
}
-void CustomTrackView::splitAudio() {
+void CustomTrackView::splitAudio()
+{
resetSelectionGroup();
QList<QGraphicsItem *> selection = scene()->selectedItems();
if (selection.isEmpty()) {
m_commandStack->push(splitCommand);
}
-void CustomTrackView::doSplitAudio(const GenTime &pos, int track, bool split) {
+void CustomTrackView::doSplitAudio(const GenTime &pos, int track, bool split)
+{
ClipItem *clip = getClipItemAt(pos, track);
if (clip == NULL) {
kDebug() << "// Cannot find clip to split!!!";
}
}
-void CustomTrackView::videoOnly() {
+void CustomTrackView::videoOnly()
+{
resetSelectionGroup();
QList<QGraphicsItem *> selection = scene()->selectedItems();
if (selection.isEmpty()) {
m_commandStack->push(videoCommand);
}
-void CustomTrackView::audioOnly() {
+void CustomTrackView::audioOnly()
+{
resetSelectionGroup();
QList<QGraphicsItem *> selection = scene()->selectedItems();
if (selection.isEmpty()) {
m_commandStack->push(videoCommand);
}
-void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly) {
+void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly)
+{
ClipItem *clip = getClipItemAt(pos, track);
if (clip == NULL) {
kDebug() << "// Cannot find clip to split!!!";
class Transition;
class CustomTrackScene;
-class CustomTrackView : public QGraphicsView {
+class CustomTrackView : public QGraphicsView
+{
Q_OBJECT
public:
};
-class EffectParameter {
+class EffectParameter
+{
public:
EffectParameter(const QString name, const QString value): m_name(name), m_value(value) {}
QString name() const {
/** Use our own list for effect parameters so that they are not sorted in any ways, because
some effects like sox need a precise order
*/
-class EffectsParameterList: public QList < EffectParameter > {
+class EffectsParameterList: public QList < EffectParameter >
+{
public:
EffectsParameterList(): QList < EffectParameter >() {}
bool hasParam(const QString name) const {
}
};
-class CommentedTime {
+class CommentedTime
+{
public:
CommentedTime(): t(GenTime(0)) {}
CommentedTime(const GenTime time, QString comment)
#include <QCryptographicHash>
DocClipBase::DocClipBase(ClipManager *clipManager, QDomElement xml, const QString &id):
- m_id(id), m_description(QString()), m_refcount(0), m_audioThumbCreated(false), m_duration(GenTime()), m_thumbProd(NULL), m_audioTimer(NULL), m_properties(QMap <QString, QString> ()), audioFrameChache(QMap<int, QMap<int, QByteArray> > ()), m_baseTrackProducers(QList <Mlt::Producer *>()), m_snapMarkers(QList < CommentedTime > ()), m_videoOnlyProducer(NULL), m_audioTrackProducers(QList <Mlt::Producer *>()) {
+ m_id(id), m_description(QString()), m_refcount(0), m_audioThumbCreated(false), m_duration(GenTime()), m_thumbProd(NULL), m_audioTimer(NULL), m_properties(QMap <QString, QString> ()), audioFrameChache(QMap<int, QMap<int, QByteArray> > ()), m_baseTrackProducers(QList <Mlt::Producer *>()), m_snapMarkers(QList < CommentedTime > ()), m_videoOnlyProducer(NULL), m_audioTrackProducers(QList <Mlt::Producer *>())
+{
int type = xml.attribute("type").toInt();
m_clipType = (CLIPTYPE) type;
return *this;
}*/
-DocClipBase::~DocClipBase() {
+DocClipBase::~DocClipBase()
+{
if (m_thumbProd) {
delete m_thumbProd;
}
m_baseTrackProducers.clear();
}
-void DocClipBase::setZone(QPoint zone) {
+void DocClipBase::setZone(QPoint zone)
+{
m_properties.insert("zone_in", QString::number(zone.x()));
m_properties.insert("zone_out", QString::number(zone.y()));
}
-QPoint DocClipBase::zone() const {
+QPoint DocClipBase::zone() const
+{
QPoint zone;
zone.setX(m_properties.value("zone_in").toInt());
zone.setY(m_properties.value("zone_out", "50").toInt());
return zone;
}
-void DocClipBase::slotCreateAudioTimer() {
+void DocClipBase::slotCreateAudioTimer()
+{
connect(m_thumbProd, SIGNAL(audioThumbReady(QMap <int, QMap <int, QByteArray> >)), this , SLOT(updateAudioThumbnail(QMap <int, QMap <int, QByteArray> >)));
connect(this, SIGNAL(getAudioThumbs()), this , SLOT(slotGetAudioThumbs()));
m_audioTimer = new QTimer(this);
connect(m_audioTimer, SIGNAL(timeout()), this, SLOT(slotGetAudioThumbs()));
}
-void DocClipBase::askForAudioThumbs() {
+void DocClipBase::askForAudioThumbs()
+{
if (m_thumbProd) m_thumbProd->askForAudioThumbs(getId());
}
-void DocClipBase::slotClearAudioCache() {
+void DocClipBase::slotClearAudioCache()
+{
if (m_thumbProd) m_thumbProd->stopAudioThumbs();
if (m_audioTimer != NULL) m_audioTimer->stop();
audioFrameChache.clear();
if (m_thumbProd) m_thumbProd->getMainThumb(m_properties.value("thumbnail").toInt());
}*/
-KThumb *DocClipBase::thumbProducer() {
+KThumb *DocClipBase::thumbProducer()
+{
return m_thumbProd;
}
-bool DocClipBase::audioThumbCreated() const {
+bool DocClipBase::audioThumbCreated() const
+{
return m_audioThumbCreated;
}
-const QString DocClipBase::name() const {
+const QString DocClipBase::name() const
+{
return m_properties.value("name");
}
-const QString &DocClipBase::getId() const {
+const QString &DocClipBase::getId() const
+{
return m_id;
}
-void DocClipBase::setId(const QString &newId) {
+void DocClipBase::setId(const QString &newId)
+{
m_id = newId;
}
-const CLIPTYPE & DocClipBase::clipType() const {
+const CLIPTYPE & DocClipBase::clipType() const
+{
return m_clipType;
}
-void DocClipBase::setClipType(CLIPTYPE type) {
+void DocClipBase::setClipType(CLIPTYPE type)
+{
m_clipType = type;
m_properties.insert("type", QString::number((int) type));
slotCreateAudioTimer();
}
-KUrl DocClipBase::fileURL() const {
+KUrl DocClipBase::fileURL() const
+{
QString res = m_properties.value("resource");
if (m_clipType != COLOR && !res.isEmpty()) return KUrl(res);
return KUrl();
}
-void DocClipBase::setClipThumbFrame(const uint &ix) {
+void DocClipBase::setClipThumbFrame(const uint &ix)
+{
m_properties.insert("thumbnail", QString::number((int) ix));
}
-uint DocClipBase::getClipThumbFrame() const {
+uint DocClipBase::getClipThumbFrame() const
+{
return (uint) m_properties.value("thumbnail").toInt();
}
-const QString DocClipBase::description() const {
+const QString DocClipBase::description() const
+{
return m_properties.value("description");
}
-bool DocClipBase::isTransparent() const {
+bool DocClipBase::isTransparent() const
+{
return (m_properties.value("transparency") == "1");
}
-const QString DocClipBase::getProperty(const QString prop) const {
+const QString DocClipBase::getProperty(const QString prop) const
+{
return m_properties.value(prop);
}
-void DocClipBase::setDuration(GenTime dur) {
+void DocClipBase::setDuration(GenTime dur)
+{
m_duration = dur;
m_properties.insert("duration", QString::number((int) dur.frames(KdenliveSettings::project_fps())));
}
-const GenTime &DocClipBase::duration() const {
+const GenTime &DocClipBase::duration() const
+{
return m_duration;
}
-const GenTime DocClipBase::maxDuration() const {
+const GenTime DocClipBase::maxDuration() const
+{
if (m_clipType == COLOR || m_clipType == IMAGE || m_clipType == TEXT || (m_clipType == SLIDESHOW && m_properties.value("loop") == "1")) {
const GenTime dur(15000, KdenliveSettings::project_fps());
return dur;
return m_duration;
}
-bool DocClipBase::hasFileSize() const {
+bool DocClipBase::hasFileSize() const
+{
return true;
}
// virtual
-QDomElement DocClipBase::toXML() const {
+QDomElement DocClipBase::toXML() const
+{
QDomDocument doc;
QDomElement clip = doc.createElement("producer");
}
-void DocClipBase::setAudioThumbCreated(bool isDone) {
+void DocClipBase::setAudioThumbCreated(bool isDone)
+{
m_audioThumbCreated = isDone;
}
-void DocClipBase::setThumbnail(const QPixmap & pixmap) {
+void DocClipBase::setThumbnail(const QPixmap & pixmap)
+{
m_thumbnail = pixmap;
}
-const QPixmap & DocClipBase::thumbnail() const {
+const QPixmap & DocClipBase::thumbnail() const
+{
return m_thumbnail;
}
-void DocClipBase::updateAudioThumbnail(QMap<int, QMap<int, QByteArray> > data) {
+void DocClipBase::updateAudioThumbnail(QMap<int, QMap<int, QByteArray> > data)
+{
//kDebug() << "CLIPBASE RECIEDVEDÂ AUDIOÂ DATA*********************************************";
audioFrameChache = data;
m_audioThumbCreated = true;
emit gotAudioData();
}
-QList < GenTime > DocClipBase::snapMarkers() const {
+QList < GenTime > DocClipBase::snapMarkers() const
+{
QList < GenTime > markers;
for (uint count = 0; count < m_snapMarkers.count(); ++count) {
return markers;
}
-QList < CommentedTime > DocClipBase::commentedSnapMarkers() const {
+QList < CommentedTime > DocClipBase::commentedSnapMarkers() const
+{
return m_snapMarkers;
}
-void DocClipBase::setSnapMarkers(QList < CommentedTime > markers) {
+void DocClipBase::setSnapMarkers(QList < CommentedTime > markers)
+{
m_snapMarkers = markers;
}
-void DocClipBase::addSnapMarker(const GenTime & time, QString comment) {
+void DocClipBase::addSnapMarker(const GenTime & time, QString comment)
+{
QList < CommentedTime >::Iterator it = m_snapMarkers.begin();
for (it = m_snapMarkers.begin(); it != m_snapMarkers.end(); ++it) {
if ((*it).time() >= time)
}
-void DocClipBase::editSnapMarker(const GenTime & time, QString comment) {
+void DocClipBase::editSnapMarker(const GenTime & time, QString comment)
+{
QList < CommentedTime >::Iterator it;
for (it = m_snapMarkers.begin(); it != m_snapMarkers.end(); ++it) {
if ((*it).time() == time)
}
}
-QString DocClipBase::deleteSnapMarker(const GenTime & time) {
+QString DocClipBase::deleteSnapMarker(const GenTime & time)
+{
QString result = i18n("Marker");
QList < CommentedTime >::Iterator itt = m_snapMarkers.begin();
}
-GenTime DocClipBase::hasSnapMarkers(const GenTime & time) {
+GenTime DocClipBase::hasSnapMarkers(const GenTime & time)
+{
QList < CommentedTime >::Iterator itt = m_snapMarkers.begin();
while (itt != m_snapMarkers.end()) {
return GenTime(0.0);
}
-GenTime DocClipBase::findPreviousSnapMarker(const GenTime & currTime) {
+GenTime DocClipBase::findPreviousSnapMarker(const GenTime & currTime)
+{
int it;
for (it = 0; it < m_snapMarkers.count(); it++) {
if (m_snapMarkers[it].time() >= currTime)
else return m_snapMarkers[it-1].time();
}
-GenTime DocClipBase::findNextSnapMarker(const GenTime & currTime) {
+GenTime DocClipBase::findNextSnapMarker(const GenTime & currTime)
+{
int it;
for (it = 0; it < m_snapMarkers.count(); it++) {
if (m_snapMarkers[it].time() > currTime)
return duration();
}
-QString DocClipBase::markerComment(GenTime t) {
+QString DocClipBase::markerComment(GenTime t)
+{
QList < CommentedTime >::Iterator itt = m_snapMarkers.begin();
while (itt != m_snapMarkers.end()) {
return QString();
}
-void DocClipBase::deleteProducers() {
+void DocClipBase::deleteProducers()
+{
qDeleteAll(m_baseTrackProducers);
m_baseTrackProducers.clear();
if (m_thumbProd) m_thumbProd->clearProducer();
}
-void DocClipBase::setProducer(Mlt::Producer *producer) {
+void DocClipBase::setProducer(Mlt::Producer *producer)
+{
if (producer == NULL) return;
QString id = producer->get("id");
if (id.contains('_')) {
if (m_thumbProd && !m_thumbProd->hasProducer()) m_thumbProd->setProducer(producer);
}
-Mlt::Producer *DocClipBase::audioProducer(int track) {
+Mlt::Producer *DocClipBase::audioProducer(int track)
+{
if (m_audioTrackProducers.count() <= track) {
while (m_audioTrackProducers.count() - 1 < track) {
m_audioTrackProducers.append(NULL);
return m_audioTrackProducers.at(track);
}
-Mlt::Producer *DocClipBase::videoProducer() {
+Mlt::Producer *DocClipBase::videoProducer()
+{
if (m_videoOnlyProducer == NULL) {
int i;
for (i = 0; i < m_baseTrackProducers.count(); i++)
return m_videoOnlyProducer;
}
-Mlt::Producer *DocClipBase::producer(int track) {
+Mlt::Producer *DocClipBase::producer(int track)
+{
/*for (int i = 0; i < m_baseTrackProducers.count(); i++) {
if (m_baseTrackProducers.at(i)) kDebug() << "// PROD: " << i << ", ID: " << m_baseTrackProducers.at(i)->get("id");
}*/
return m_baseTrackProducers.at(track);
}
-void DocClipBase::setProducerProperty(const char *name, int data) {
+void DocClipBase::setProducerProperty(const char *name, int data)
+{
for (int i = 0; i < m_baseTrackProducers.count(); i++) {
if (m_baseTrackProducers.at(i) != NULL)
m_baseTrackProducers[i]->set(name, data);
}
}
-void DocClipBase::setProducerProperty(const char *name, const char *data) {
+void DocClipBase::setProducerProperty(const char *name, const char *data)
+{
for (int i = 0; i < m_baseTrackProducers.count(); i++) {
if (m_baseTrackProducers.at(i) != NULL)
m_baseTrackProducers[i]->set(name, data);
}
}
-const char *DocClipBase::producerProperty(const char *name) const {
+const char *DocClipBase::producerProperty(const char *name) const
+{
for (int i = 0; i < m_baseTrackProducers.count(); i++) {
if (m_baseTrackProducers.at(i) != NULL) {
return m_baseTrackProducers.at(i)->get(name);
}
-void DocClipBase::slotRefreshProducer() {
+void DocClipBase::slotRefreshProducer()
+{
if (m_baseTrackProducers.count() == 0) return;
kDebug() << "//////////// REFRESH CLIP !!!!!!!!!!!!!!!!";
if (m_clipType == SLIDESHOW) {
}
}
-void DocClipBase::setProperties(QMap <QString, QString> properties) {
+void DocClipBase::setProperties(QMap <QString, QString> properties)
+{
// changing clip type is not allowed
properties.remove("type");
QMapIterator<QString, QString> i(properties);
if (refreshProducer) slotRefreshProducer();
}
-void DocClipBase::setMetadata(QMap <QString, QString> properties) {
+void DocClipBase::setMetadata(QMap <QString, QString> properties)
+{
m_metadata = properties;
}
-QMap <QString, QString> DocClipBase::metadata() const {
+QMap <QString, QString> DocClipBase::metadata() const
+{
return m_metadata;
}
-void DocClipBase::clearProperty(const QString &key) {
+void DocClipBase::clearProperty(const QString &key)
+{
m_properties.remove(key);
}
-void DocClipBase::getFileHash(const QString url) {
+void DocClipBase::getFileHash(const QString url)
+{
if (m_clipType == SLIDESHOW) return;
QFile file(url);
if (file.open(QIODevice::ReadOnly)) { // write size and hash only if resource points to a file
}
}
-QString DocClipBase::getClipHash() const {
+QString DocClipBase::getClipHash() const
+{
QString hash;
if (m_clipType == SLIDESHOW) hash = QCryptographicHash::hash(m_properties.value("resource").toAscii().data(), QCryptographicHash::Md5).toHex();
else if (m_clipType == COLOR) hash = QCryptographicHash::hash(m_properties.value("colour").toAscii().data(), QCryptographicHash::Md5).toHex();
return hash;
}
-void DocClipBase::refreshThumbUrl() {
+void DocClipBase::refreshThumbUrl()
+{
if (m_thumbProd) m_thumbProd->updateThumbUrl(m_properties.value("file_hash"));
}
-void DocClipBase::setProperty(const QString &key, const QString &value) {
+void DocClipBase::setProperty(const QString &key, const QString &value)
+{
m_properties.insert(key, value);
if (key == "resource") {
getFileHash(value);
}
}
-QMap <QString, QString> DocClipBase::properties() const {
+QMap <QString, QString> DocClipBase::properties() const
+{
return m_properties;
}
-bool DocClipBase::slotGetAudioThumbs() {
+bool DocClipBase::slotGetAudioThumbs()
+{
if (m_thumbProd == NULL) return false;
if (!KdenliveSettings::audiothumbnails()) {
if (m_audioTimer != NULL) m_audioTimer->stop();
class KThumb;
class ClipManager;
-namespace Mlt {
+namespace Mlt
+{
class Producer;
};
-class DocClipBase: public QObject {
+class DocClipBase: public QObject
+{
Q_OBJECT public:
/** this enum determines the types of "feed" available within this clip. types must be non-exclusive
* - e.g. if you can have audio and video separately, it should be possible to combin the two, as is
#include <QDomDocument>
-DvdWizard::DvdWizard(const QString &url, const QString &profile, QWidget *parent): QWizard(parent), m_profile(profile), m_dvdauthor(NULL), m_mkiso(NULL) {
+DvdWizard::DvdWizard(const QString &url, const QString &profile, QWidget *parent): QWizard(parent), m_profile(profile), m_dvdauthor(NULL), m_mkiso(NULL)
+{
//setPixmap(QWizard::WatermarkPixmap, QPixmap(KStandardDirs::locate("appdata", "banner.png")));
setAttribute(Qt::WA_DeleteOnClose);
m_pageVob = new DvdWizardVob(this);
// connect(m_standard.button_all, SIGNAL(toggled(bool)), this, SLOT(slotCheckStandard()));
}
-DvdWizard::~DvdWizard() {
+DvdWizard::~DvdWizard()
+{
// m_menuFile.remove();
if (m_dvdauthor) {
m_dvdauthor->close();
}
-void DvdWizard::slotPageChanged(int page) {
+void DvdWizard::slotPageChanged(int page)
+{
kDebug() << "//Â PAGEÂ CHGD: " << page;
if (page == 1) {
m_pageMenu->setTargets(m_pageVob->selectedUrls());
-void DvdWizard::generateDvd() {
+void DvdWizard::generateDvd()
+{
KTemporaryFile temp1;
temp1.setSuffix(".png");
//temp1.setAutoRemove(false);
}
-void DvdWizard::slotRenderFinished(int /*exitCode*/, QProcess::ExitStatus status) {
+void DvdWizard::slotRenderFinished(int /*exitCode*/, QProcess::ExitStatus status)
+{
QListWidgetItem *authitem = m_status.job_progress->item(3);
if (status == QProcess::CrashExit) {
QByteArray result = m_dvdauthor->readAllStandardError();
}
-void DvdWizard::slotIsoFinished(int /*exitCode*/, QProcess::ExitStatus status) {
+void DvdWizard::slotIsoFinished(int /*exitCode*/, QProcess::ExitStatus status)
+{
QListWidgetItem *isoitem = m_status.job_progress->item(4);
if (status == QProcess::CrashExit) {
QByteArray result = m_mkiso->readAllStandardError();
}
-void DvdWizard::cleanup() {
+void DvdWizard::cleanup()
+{
m_authorFile.remove();
m_menuFile.remove();
KIO::NetAccess::del(KUrl(m_iso.tmp_folder->url().path() + "/DVD"), this);
#include "ui_dvdwizardiso_ui.h"
#include "ui_dvdwizardstatus_ui.h"
-class DvdWizard : public QWizard {
+class DvdWizard : public QWizard
+{
Q_OBJECT
public:
explicit DvdWizard(const QString &url = QString(), const QString &profile = "dv_pal", QWidget * parent = 0);
#include <KDebug>
-DvdWizardMenu::DvdWizardMenu(const QString &profile, QWidget *parent): QWizardPage(parent) {
+DvdWizardMenu::DvdWizardMenu(const QString &profile, QWidget *parent): QWizardPage(parent)
+{
m_view.setupUi(this);
m_view.play_text->setText(i18n("Play"));
m_scene = new DvdScene(this);
}
-DvdWizardMenu::~DvdWizardMenu() {
+DvdWizardMenu::~DvdWizardMenu()
+{
delete m_color;
delete m_safeRect;
delete m_background;
// virtual
-bool DvdWizardMenu::isComplete() const {
+bool DvdWizardMenu::isComplete() const
+{
if (!m_view.create_menu->isChecked()) return true;
QList <int> targets;
QList<QGraphicsItem *> list = m_scene->items();
return true;
}
-void DvdWizardMenu::setButtonTarget(int ix) {
+void DvdWizardMenu::setButtonTarget(int ix)
+{
QList<QGraphicsItem *> list = m_scene->selectedItems();
for (int i = 0; i < list.count(); i++) {
if (list.at(i)->type() == QGraphicsItem::UserType + 1) {
emit completeChanged();
}
-void DvdWizardMenu::buttonChanged() {
+void DvdWizardMenu::buttonChanged()
+{
QList<QGraphicsItem *> list = m_scene->selectedItems();
bool foundButton = false;
for (int i = 0; i < list.count(); i++) {
if (!foundButton) m_view.tabWidget->widget(0)->setEnabled(false);
}
-void DvdWizardMenu::addButton() {
+void DvdWizardMenu::addButton()
+{
m_scene->clearSelection();
DvdButton *button = new DvdButton(m_view.play_text->text());
QFont font = m_view.font_family->currentFont();
button->setSelected(true);
}
-void DvdWizardMenu::deleteButton() {
+void DvdWizardMenu::deleteButton()
+{
QList<QGraphicsItem *> list = m_scene->selectedItems();
for (int i = 0; i < list.count(); i++) {
if (list.at(i)->type() == QGraphicsItem::UserType + 1) {
}
}
-void DvdWizardMenu::changeProfile(int ix) {
+void DvdWizardMenu::changeProfile(int ix)
+{
switch (ix) {
case 1:
m_width = 720;
}
}
-void DvdWizardMenu::updatePreview() {
+void DvdWizardMenu::updatePreview()
+{
m_scene->setProfile(m_width, m_height);
QMatrix matrix;
matrix.scale(0.5, 0.5);
m_safeRect->setRect(safeW, safeH, m_width - 2 * safeW, m_height - 2 * safeH);
}
-void DvdWizardMenu::setTargets(QStringList /*list*/) {
+void DvdWizardMenu::setTargets(QStringList /*list*/)
+{
m_targets = QStringList() << i18n("Play All");
// TODO: re-enable different targets
/*
m_view.target_list->addItems(m_targets);
}
-void DvdWizardMenu::checkBackgroundType(int ix) {
+void DvdWizardMenu::checkBackgroundType(int ix)
+{
if (ix == 0) {
m_view.background_color->setVisible(true);
m_view.background_image->setVisible(false);
}
}
-void DvdWizardMenu::buildColor() {
+void DvdWizardMenu::buildColor()
+{
m_color->setBrush(m_view.background_color->color());
}
-void DvdWizardMenu::buildImage() {
+void DvdWizardMenu::buildImage()
+{
emit completeChanged();
if (m_view.background_image->url().isEmpty()) {
m_scene->removeItem(m_background);
if (m_view.background_list->currentIndex() == 1) m_scene->addItem(m_background);
}
-void DvdWizardMenu::checkBackground() {
+void DvdWizardMenu::checkBackground()
+{
if (m_view.background_list->currentIndex() != 1) {
m_scene->removeItem(m_background);
} else {
}
}
-void DvdWizardMenu::buildButton() {
+void DvdWizardMenu::buildButton()
+{
DvdButton *button = NULL;
QList<QGraphicsItem *> list = m_scene->selectedItems();
for (int i = 0; i < list.count(); i++) {
button->setDefaultTextColor(m_view.text_color->color());
}
-void DvdWizardMenu::updateColor() {
+void DvdWizardMenu::updateColor()
+{
updateColor(m_view.text_color->color());
m_view.menu_preview->viewport()->update();
}
-void DvdWizardMenu::updateColor(QColor c) {
+void DvdWizardMenu::updateColor(QColor c)
+{
DvdButton *button = NULL;
QList<QGraphicsItem *> list = m_scene->items();
for (int i = 0; i < list.count(); i++) {
}
-void DvdWizardMenu::createButtonImages(const QString &img1, const QString &img2, const QString &img3) {
+void DvdWizardMenu::createButtonImages(const QString &img1, const QString &img2, const QString &img3)
+{
if (m_view.create_menu->isChecked()) {
m_scene->clearSelection();
QImage img(m_width, m_height, QImage::Format_ARGB32);
}
-void DvdWizardMenu::createBackgroundImage(const QString &img1) {
+void DvdWizardMenu::createBackgroundImage(const QString &img1)
+{
QImage img;
if (m_view.background_list->currentIndex() == 0) {
// color background
img.save(img1);
}
-bool DvdWizardMenu::createMenu() const {
+bool DvdWizardMenu::createMenu() const
+{
return m_view.create_menu->isChecked();
}
-bool DvdWizardMenu::menuMovie() const {
+bool DvdWizardMenu::menuMovie() const
+{
return m_view.background_list->currentIndex() == 2;
}
-QString DvdWizardMenu::menuMoviePath() const {
+QString DvdWizardMenu::menuMoviePath() const
+{
return m_view.background_image->url().path();
}
-QMap <int, QRect> DvdWizardMenu::buttonsInfo() {
+QMap <int, QRect> DvdWizardMenu::buttonsInfo()
+{
QMap <int, QRect> info;
QList<QGraphicsItem *> list = m_scene->items();
for (int i = 0; i < list.count(); i++) {
return info;
}
-bool DvdWizardMenu::isPalMenu() const {
+bool DvdWizardMenu::isPalMenu() const
+{
return m_isPal;
}
#include "ui_dvdwizardmenu_ui.h"
-class DvdScene : public QGraphicsScene {
+class DvdScene : public QGraphicsScene
+{
public:
DvdScene(QObject * parent = 0): QGraphicsScene(parent) {}
int m_height;
};
-class DvdButton : public QGraphicsTextItem {
+class DvdButton : public QGraphicsTextItem
+{
public:
DvdButton(const QString & text): QGraphicsTextItem(text), m_target(0) {}
};
-class DvdWizardMenu : public QWizardPage {
+class DvdWizardMenu : public QWizardPage
+{
Q_OBJECT
public:
#include <QHBoxLayout>
-DvdWizardVob::DvdWizardVob(QWidget *parent): QWizardPage(parent) {
+DvdWizardVob::DvdWizardVob(QWidget *parent): QWizardPage(parent)
+{
m_view.setupUi(this);
m_view.intro_vob->setEnabled(false);
m_view.vob_1->setFilter("video/mpeg");
#endif
}
-DvdWizardVob::~DvdWizardVob() {
+DvdWizardVob::~DvdWizardVob()
+{
QList<KUrlRequester *> allUrls = m_view.vob_list->findChildren<KUrlRequester *>();
qDeleteAll(allUrls);
#if KDE_IS_VERSION(4,2,0)
// virtual
-bool DvdWizardVob::isComplete() const {
+bool DvdWizardVob::isComplete() const
+{
if (!m_view.error_message->text().isEmpty()) return false;
if (m_view.vob_1->url().path().isEmpty()) return false;
if (QFile::exists(m_view.vob_1->url().path())) return true;
return false;
}
-void DvdWizardVob::setUrl(const QString &url) {
+void DvdWizardVob::setUrl(const QString &url)
+{
m_view.vob_1->setPath(url);
}
-QStringList DvdWizardVob::selectedUrls() const {
+QStringList DvdWizardVob::selectedUrls() const
+{
QStringList result;
QList<KUrlRequester *> allUrls = m_view.vob_list->findChildren<KUrlRequester *>();
for (int i = 0; i < allUrls.count(); i++) {
return result;
}
-QString DvdWizardVob::introMovie() const {
+QString DvdWizardVob::introMovie() const
+{
if (!m_view.use_intro->isChecked()) return QString();
return m_view.intro_vob->url().path();
}
-void DvdWizardVob::slotCheckVobList(const QString &text) {
+void DvdWizardVob::slotCheckVobList(const QString &text)
+{
emit completeChanged();
QList<KUrlRequester *> allUrls = m_view.vob_list->findChildren<KUrlRequester *>();
int count = allUrls.count();
#include <QWizardPage>
-class DvdWizardVob : public QWizardPage {
+class DvdWizardVob : public QWizardPage
+{
Q_OBJECT
public:
#include <KLocale>
-EditClipCommand::EditClipCommand(ProjectList *list, const QString &id, QMap <QString, QString> oldparams, QMap <QString, QString> newparams, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_list(list), m_id(id), m_oldparams(oldparams), m_newparams(newparams), m_doIt(doIt) {
+EditClipCommand::EditClipCommand(ProjectList *list, const QString &id, QMap <QString, QString> oldparams, QMap <QString, QString> newparams, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_list(list), m_id(id), m_oldparams(oldparams), m_newparams(newparams), m_doIt(doIt)
+{
setText(i18n("Edit clip"));
}
// virtual
-void EditClipCommand::undo() {
+void EditClipCommand::undo()
+{
kDebug() << "---- undoing action";
m_list->slotUpdateClipProperties(m_id, m_oldparams);
}
// virtual
-void EditClipCommand::redo() {
+void EditClipCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt) m_list->slotUpdateClipProperties(m_id, m_newparams);
m_doIt = true;
class ProjectList;
-class EditClipCommand : public QUndoCommand {
+class EditClipCommand : public QUndoCommand
+{
public:
EditClipCommand(ProjectList *list, const QString &id, QMap <QString, QString> oldparams, QMap <QString, QString> newparams, bool doIt, QUndoCommand * parent = 0);
#include <KLocale>
EditEffectCommand::EditEffectCommand(CustomTrackView *view, const int track, GenTime pos, QDomElement oldeffect, QDomElement effect, int stackPos, bool doIt)
- : m_view(view), m_track(track), m_pos(pos), m_oldeffect(oldeffect), m_stackPos(stackPos), m_doIt(doIt) {
+ : m_view(view), m_track(track), m_pos(pos), m_oldeffect(oldeffect), m_stackPos(stackPos), m_doIt(doIt)
+{
m_effect = effect.cloneNode().toElement();
QString effectName;
QDomNode namenode = effect.elementsByTagName("name").item(0);
}
// virtual
-int EditEffectCommand::id() const {
+int EditEffectCommand::id() const
+{
return 1;
}
// virtual
-bool EditEffectCommand::mergeWith(const QUndoCommand * other) {
+bool EditEffectCommand::mergeWith(const QUndoCommand * other)
+{
if (other->id() != id()) return false;
if (m_track != static_cast<const EditEffectCommand*>(other)->m_track) return false;
if (m_pos != static_cast<const EditEffectCommand*>(other)->m_pos) return false;
}
// virtual
-void EditEffectCommand::undo() {
+void EditEffectCommand::undo()
+{
kDebug() << "---- undoing action";
m_view->updateEffect(m_track, m_pos, m_oldeffect, m_stackPos, false);
}
// virtual
-void EditEffectCommand::redo() {
+void EditEffectCommand::redo()
+{
kDebug() << "---- redoing action";
m_view->updateEffect(m_track, m_pos, m_effect, m_stackPos, m_doIt);
m_doIt = false;
class CustomTrackView;
-class EditEffectCommand : public QUndoCommand {
+class EditEffectCommand : public QUndoCommand
+{
public:
EditEffectCommand(CustomTrackView *view, const int track, GenTime pos, QDomElement oldeffect, QDomElement effect, int stackPos, bool doIt);
#include <KLocale>
-EditFolderCommand::EditFolderCommand(ProjectList *view, const QString newfolderName, const QString oldfolderName, const QString &clipId, bool doIt, QUndoCommand *parent) : QUndoCommand(parent), m_view(view), m_name(newfolderName), m_oldname(oldfolderName), m_id(clipId), m_doIt(doIt) {
+EditFolderCommand::EditFolderCommand(ProjectList *view, const QString newfolderName, const QString oldfolderName, const QString &clipId, bool doIt, QUndoCommand *parent) : QUndoCommand(parent), m_view(view), m_name(newfolderName), m_oldname(oldfolderName), m_id(clipId), m_doIt(doIt)
+{
setText(i18n("Rename folder"));
}
// virtual
-void EditFolderCommand::undo() {
+void EditFolderCommand::undo()
+{
m_view->slotAddFolder(m_oldname, m_id, false, true);
}
// virtual
-void EditFolderCommand::redo() {
+void EditFolderCommand::redo()
+{
if (m_doIt) m_view->slotAddFolder(m_name, m_id, false, true);
m_doIt = true;
}
class ProjectList;
-class EditFolderCommand : public QUndoCommand {
+class EditFolderCommand : public QUndoCommand
+{
public:
EditFolderCommand(ProjectList *view, const QString newfolderName, const QString oldfolderName, const QString &clipId, bool doIt, QUndoCommand *parent = 0);
#include <KLocale>
-EditGuideCommand::EditGuideCommand(CustomTrackView *view, const GenTime oldPos, const QString &oldcomment, const GenTime pos, const QString &comment, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_oldPos(oldPos), m_oldcomment(oldcomment), m_pos(pos), m_comment(comment), m_doIt(doIt) {
+EditGuideCommand::EditGuideCommand(CustomTrackView *view, const GenTime oldPos, const QString &oldcomment, const GenTime pos, const QString &comment, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_oldPos(oldPos), m_oldcomment(oldcomment), m_pos(pos), m_comment(comment), m_doIt(doIt)
+{
if (m_oldcomment.isEmpty()) setText(i18n("Add guide"));
else if (m_oldPos == m_pos) setText(i18n("Edit guide"));
else if (m_pos <= GenTime()) setText(i18n("Delete guide"));
// virtual
-void EditGuideCommand::undo() {
+void EditGuideCommand::undo()
+{
m_view->editGuide(m_pos, m_oldPos, m_oldcomment);
}
// virtual
-void EditGuideCommand::redo() {
+void EditGuideCommand::redo()
+{
if (m_doIt) {
m_view->editGuide(m_oldPos, m_pos, m_comment);
}
class CustomTrackView;
-class EditGuideCommand : public QUndoCommand {
+class EditGuideCommand : public QUndoCommand
+{
public:
EditGuideCommand(CustomTrackView *view, const GenTime oldPos, const QString &oldcomment, const GenTime pos, const QString &comment, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-EditKeyFrameCommand::EditKeyFrameCommand(CustomTrackView *view, const int track, GenTime pos, const int effectIndex, const QString& oldkeyframes, const QString& newkeyframes, bool doIt) : m_view(view), m_track(track), m_pos(pos), m_index(effectIndex), m_oldkfr(oldkeyframes), m_newkfr(newkeyframes), m_doIt(doIt) {
+EditKeyFrameCommand::EditKeyFrameCommand(CustomTrackView *view, const int track, GenTime pos, const int effectIndex, const QString& oldkeyframes, const QString& newkeyframes, bool doIt) : m_view(view), m_track(track), m_pos(pos), m_index(effectIndex), m_oldkfr(oldkeyframes), m_newkfr(newkeyframes), m_doIt(doIt)
+{
int prev = m_oldkfr.split(';', QString::SkipEmptyParts).count();
int next = m_newkfr.split(';', QString::SkipEmptyParts).count();
if (prev == next) setText(i18n("Edit keyframe"));
// virtual
-void EditKeyFrameCommand::undo() {
+void EditKeyFrameCommand::undo()
+{
m_view->editKeyFrame(m_pos, m_track, m_index, m_oldkfr);
}
// virtual
-void EditKeyFrameCommand::redo() {
+void EditKeyFrameCommand::redo()
+{
if (m_doIt) {
m_view->editKeyFrame(m_pos, m_track, m_index, m_newkfr);
}
class CustomTrackView;
-class EditKeyFrameCommand : public QUndoCommand {
+class EditKeyFrameCommand : public QUndoCommand
+{
public:
EditKeyFrameCommand(CustomTrackView *view, const int track, GenTime pos, const int effectIndex, const QString& oldkeyframes, const QString& newkeyframes, bool doIt);
virtual void undo();
#include <KLocale>
EditTransitionCommand::EditTransitionCommand(CustomTrackView *view, const int track, GenTime pos, QDomElement oldeffect, QDomElement effect, bool doIt)
- : m_view(view), m_track(track), m_pos(pos), m_oldeffect(oldeffect), m_doIt(doIt) {
+ : m_view(view), m_track(track), m_pos(pos), m_oldeffect(oldeffect), m_doIt(doIt)
+{
m_effect = effect.cloneNode().toElement();
QString effectName;
QDomNode namenode = effect.elementsByTagName("name").item(0);
}
// virtual
-int EditTransitionCommand::id() const {
+int EditTransitionCommand::id() const
+{
return 2;
}
// virtual
-bool EditTransitionCommand::mergeWith(const QUndoCommand * other) {
+bool EditTransitionCommand::mergeWith(const QUndoCommand * other)
+{
if (other->id() != id()) return false;
if (m_track != static_cast<const EditTransitionCommand*>(other)->m_track) return false;
if (m_pos != static_cast<const EditTransitionCommand*>(other)->m_pos) return false;
}
// virtual
-void EditTransitionCommand::undo() {
+void EditTransitionCommand::undo()
+{
m_view->updateTransition(m_track, m_pos, m_effect, m_oldeffect, m_doIt);
}
// virtual
-void EditTransitionCommand::redo() {
+void EditTransitionCommand::redo()
+{
m_view->updateTransition(m_track, m_pos, m_oldeffect, m_effect, m_doIt);
m_doIt = true;
}
class CustomTrackView;
-class EditTransitionCommand : public QUndoCommand {
+class EditTransitionCommand : public QUndoCommand
+{
public:
EditTransitionCommand(CustomTrackView *view, const int track, GenTime pos, QDomElement oldeffect, QDomElement effect, bool doIt);
EffectsList::EffectsList():
- QList < QDomElement > () {
+ QList < QDomElement > ()
+{
}
-EffectsList::~EffectsList() {
+EffectsList::~EffectsList()
+{
}
-QDomElement EffectsList::getEffectByName(const QString & name) const {
+QDomElement EffectsList::getEffectByName(const QString & name) const
+{
QString effectName;
for (int i = 0; i < size(); ++i) {
QDomElement effect = at(i);
return QDomElement();
}
-QDomElement EffectsList::getEffectByTag(const QString & tag, const QString & id) const {
+QDomElement EffectsList::getEffectByTag(const QString & tag, const QString & id) const
+{
if (!id.isEmpty()) for (int i = 0; i < size(); ++i) {
QDomElement effect = at(i);
return QDomElement();
}
-int EffectsList::hasEffect(const QString & tag, const QString & id) const {
+int EffectsList::hasEffect(const QString & tag, const QString & id) const
+{
for (int i = 0; i < size(); ++i) {
QDomElement effect = at(i);
if (!id.isEmpty()) {
return -1;
}
-QStringList EffectsList::effectIdInfo(const int ix) const {
+QStringList EffectsList::effectIdInfo(const int ix) const
+{
QStringList info;
QDomElement effect = at(ix);
QDomNode namenode = effect.elementsByTagName("name").item(0);
return info;
}
-QStringList EffectsList::effectNames() {
+QStringList EffectsList::effectNames()
+{
QStringList list;
for (int i = 0; i < size(); ++i) {
QDomElement effect = at(i);
return list;
}
-QString EffectsList::getInfo(const QString & tag, const QString & id) const {
+QString EffectsList::getInfo(const QString & tag, const QString & id) const
+{
QString info;
QDomElement effect = getEffectByTag(tag, id);
QDomNode namenode = effect.elementsByTagName("description").item(0);
return info;
}
-QString EffectsList::getInfoFromIndex(const int ix) const {
+QString EffectsList::getInfoFromIndex(const int ix) const
+{
QString info;
QDomElement effect = at(ix);
QDomNode namenode = effect.elementsByTagName("description").item(0);
return info;
}
-bool EffectsList::hasKeyFrames(QDomElement effect) {
+bool EffectsList::hasKeyFrames(QDomElement effect)
+{
QDomNodeList params = effect.elementsByTagName("parameter");
for (int i = 0; i < params.count(); i++) {
QDomElement e = params.item(i).toElement();
return false;
}
-EffectsList EffectsList::clone() const {
+EffectsList EffectsList::clone() const
+{
EffectsList list;
for (int i = 0; i < size(); ++i) {
list.append(at(i).cloneNode().toElement());
}
// static
-void EffectsList::setParameter(QDomElement effect, const QString &name, const QString &value) {
+void EffectsList::setParameter(QDomElement effect, const QString &name, const QString &value)
+{
QDomNodeList params = effect.elementsByTagName("parameter");
for (int i = 0; i < params.count(); i++) {
QDomElement e = params.item(i).toElement();
}
// static
-QString EffectsList::parameter(QDomElement effect, const QString &name) {
+QString EffectsList::parameter(QDomElement effect, const QString &name)
+{
QDomNodeList params = effect.elementsByTagName("parameter");
for (int i = 0; i < params.count(); i++) {
QDomElement e = params.item(i).toElement();
*/
-class EffectsList: public QList < QDomElement > {
+class EffectsList: public QList < QDomElement >
+{
public:
EffectsList();
~EffectsList();
#include <QDir>
EffectsListView::EffectsListView(QWidget *parent)
- : QWidget(parent) {
+ : QWidget(parent)
+{
ui.setupUi(this);
QMenu *menu = new QMenu(this);
}
-void EffectsListView::filterList(int pos) {
+void EffectsListView::filterList(int pos)
+{
QListWidgetItem *item;
for (int i = 0; i < m_effectsList->count(); i++) {
item = m_effectsList->item(i);
}
}
-void EffectsListView::showInfoPanel() {
+void EffectsListView::showInfoPanel()
+{
if (ui.infopanel->isVisible()) {
ui.infopanel->setVisible(false);
ui.buttonInfo->setDown(false);
}
}
-void EffectsListView::slotEffectSelected() {
+void EffectsListView::slotEffectSelected()
+{
QDomElement effect = m_effectsList->currentEffect().cloneNode().toElement();
if (!effect.isNull()) emit addEffect(effect);
}
-void EffectsListView::slotUpdateInfo() {
+void EffectsListView::slotUpdateInfo()
+{
ui.infopanel->setText(m_effectsList->currentInfo());
}
-KListWidget *EffectsListView::listView() {
+KListWidget *EffectsListView::listView()
+{
return m_effectsList;
}
-void EffectsListView::reloadEffectList() {
+void EffectsListView::reloadEffectList()
+{
m_effectsList->initList();
}
-void EffectsListView::slotRemoveEffect() {
+void EffectsListView::slotRemoveEffect()
+{
QListWidgetItem *item = m_effectsList->currentItem();
QString effectId = item->text();
QString path = KStandardDirs::locateLocal("appdata", "effects/", true);
class EffectsListWidget;
class KListWidget;
-class EffectsListView : public QWidget {
+class EffectsListView : public QWidget
+{
Q_OBJECT
public:
const int IdRole = TypeRole + 1;
EffectsListWidget::EffectsListWidget(QMenu *menu, QWidget *parent)
- : KListWidget(parent), m_menu(menu) {
+ : KListWidget(parent), m_menu(menu)
+{
//setSelectionMode(QAbstractItemView::ExtendedSelection);
//setDragDropMode(QAbstractItemView::DragDrop);
setDropIndicatorShown(true);
initList();
}
-EffectsListWidget::~EffectsListWidget() {
+EffectsListWidget::~EffectsListWidget()
+{
}
-void EffectsListWidget::initList() {
+void EffectsListWidget::initList()
+{
clear();
QListWidgetItem *item;
QString effectName;
}
}
-QDomElement EffectsListWidget::currentEffect() {
+QDomElement EffectsListWidget::currentEffect()
+{
return itemEffect(currentItem());
}
-QDomElement EffectsListWidget::itemEffect(QListWidgetItem *item) {
+QDomElement EffectsListWidget::itemEffect(QListWidgetItem *item)
+{
QDomElement effect;
if (!item) return effect;
QStringList effectInfo = item->data(IdRole).toStringList();
}
-QString EffectsListWidget::currentInfo() {
+QString EffectsListWidget::currentInfo()
+{
QListWidgetItem *item = currentItem();
if (!item) return QString();
QString info;
}
// virtual
-void EffectsListWidget::mousePressEvent(QMouseEvent *event) {
+void EffectsListWidget::mousePressEvent(QMouseEvent *event)
+{
if (event->button() == Qt::LeftButton) {
m_DragStartPosition = event->pos();
m_dragStarted = true;
}
// virtual
-void EffectsListWidget::mouseMoveEvent(QMouseEvent *event) {
+void EffectsListWidget::mouseMoveEvent(QMouseEvent *event)
+{
if (!m_dragStarted) return;
if ((event->pos() - m_DragStartPosition).manhattanLength()
< QApplication::startDragDistance())
}
}
-void EffectsListWidget::dragMoveEvent(QDragMoveEvent * event) {
+void EffectsListWidget::dragMoveEvent(QDragMoveEvent * event)
+{
event->setDropAction(Qt::IgnoreAction);
//if (item) {
event->setDropAction(Qt::MoveAction);
}
//virtual
-void EffectsListWidget::contextMenuEvent(QContextMenuEvent * event) {
+void EffectsListWidget::contextMenuEvent(QContextMenuEvent * event)
+{
QListWidgetItem *item = itemAt(event->pos());
if (item && item->data(TypeRole).toInt() == EFFECT_CUSTOM) m_menu->popup(event->globalPos());
}
class EffectsList;
-class EffectsListWidget : public KListWidget {
+class EffectsListWidget : public KListWidget
+{
Q_OBJECT
public:
QMap<QString, QImage> EffectStackEdit::iconCache;
-EffectStackEdit::EffectStackEdit(QWidget *parent): QWidget(parent), m_in(0), m_out(0) {
+EffectStackEdit::EffectStackEdit(QWidget *parent): QWidget(parent), m_in(0), m_out(0)
+{
setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
QVBoxLayout *vbox1 = new QVBoxLayout(parent);
vbox1->setContentsMargins(0, 0, 0, 0);
}
-EffectStackEdit::~EffectStackEdit() {
+EffectStackEdit::~EffectStackEdit()
+{
iconCache.clear();
}
-void EffectStackEdit::updateProjectFormat(MltVideoProfile profile, Timecode t) {
+void EffectStackEdit::updateProjectFormat(MltVideoProfile profile, Timecode t)
+{
m_profile = profile;
m_timecode = t;
}
-void EffectStackEdit::updateParameter(const QString &name, const QString &value) {
+void EffectStackEdit::updateParameter(const QString &name, const QString &value)
+{
params.setAttribute(name, value);
}
-void EffectStackEdit::transferParamDesc(const QDomElement& d, int in, int out) {
+void EffectStackEdit::transferParamDesc(const QDomElement& d, int in, int out)
+{
kDebug() << "in";
params = d;
m_in = in;
vbox->addStretch();
}
-void EffectStackEdit::slotSeekToPos(int pos) {
+void EffectStackEdit::slotSeekToPos(int pos)
+{
emit seekTimeline(m_in + pos);
}
-wipeInfo EffectStackEdit::getWipeInfo(QString value) {
+wipeInfo EffectStackEdit::getWipeInfo(QString value)
+{
wipeInfo info;
QString start = value.section(';', 0, 0);
QString end = value.section(';', 1, 1).section('=', 1, 1);
return info;
}
-QString EffectStackEdit::getWipeString(wipeInfo info) {
+QString EffectStackEdit::getWipeString(wipeInfo info)
+{
QString start;
QString end;
return QString(start + ";-1=" + end);
}
-void EffectStackEdit::collectAllParameters() {
+void EffectStackEdit::collectAllParameters()
+{
QDomElement oldparam = params.cloneNode().toElement();
QDomNodeList namenode = params.elementsByTagName("parameter");
emit parameterChanged(oldparam, params);
}
-void EffectStackEdit::createSliderItem(const QString& name, int val , int min, int max) {
+void EffectStackEdit::createSliderItem(const QString& name, int val , int min, int max)
+{
QWidget* toFillin = new QWidget;
Ui::Constval_UI *ctval = new Ui::Constval_UI;
ctval->setupUi(toFillin);
vbox->addWidget(toFillin);
}
-void EffectStackEdit::slotSliderMoved(int) {
+void EffectStackEdit::slotSliderMoved(int)
+{
collectAllParameters();
}
-void EffectStackEdit::clearAllItems() {
+void EffectStackEdit::clearAllItems()
+{
qDeleteAll(items);
foreach(void *p, uiItems) {
delete p;
class QFrame;
-class EffectStackEdit : public QWidget {
+class EffectStackEdit : public QWidget
+{
Q_OBJECT
public:
EffectStackEdit(QWidget *parent);
EffectStackView::EffectStackView(QWidget *parent)
- : QWidget(parent) {
+ : QWidget(parent)
+{
ui.setupUi(this);
effectedit = new EffectStackEdit(ui.frame);
//ui.effectlist->horizontalHeader()->setVisible(false);
setEnabled(false);
}
-void EffectStackView::setMenu(QMenu *menu) {
+void EffectStackView::setMenu(QMenu *menu)
+{
ui.buttonNew->setMenu(menu);
}
-void EffectStackView::updateProjectFormat(MltVideoProfile profile, Timecode t) {
+void EffectStackView::updateProjectFormat(MltVideoProfile profile, Timecode t)
+{
effectedit->updateProjectFormat(profile, t);
}
-void EffectStackView::slotSaveEffect() {
+void EffectStackView::slotSaveEffect()
+{
QString name = QInputDialog::getText(this, i18n("Save Effect"), i18n("Name for saved effect: "));
if (name.isEmpty()) return;
QString path = KStandardDirs::locateLocal("appdata", "effects/", true);
emit reloadEffects();
}
-void EffectStackView::slotUpdateEffectParams(const QDomElement& old, const QDomElement& e) {
+void EffectStackView::slotUpdateEffectParams(const QDomElement& old, const QDomElement& e)
+{
if (clipref)
emit updateClipEffect(clipref, old, e, ui.effectlist->currentRow());
}
-void EffectStackView::slotClipItemSelected(ClipItem* c, int ix) {
+void EffectStackView::slotClipItemSelected(ClipItem* c, int ix)
+{
if (c && c == clipref) {
if (ix == -1) ix = ui.effectlist->currentRow();
} else {
setupListView(ix);
}
-void EffectStackView::slotItemChanged(QListWidgetItem *item) {
+void EffectStackView::slotItemChanged(QListWidgetItem *item)
+{
bool disable = true;
if (item->checkState() == Qt::Checked) disable = false;
ui.buttonReset->setEnabled(!disable);
}
-void EffectStackView::setupListView(int ix) {
+void EffectStackView::setupListView(int ix)
+{
ui.effectlist->clear();
// Issue 238: Add icons for effect type in effectstack.
}
}
-void EffectStackView::slotItemSelectionChanged() {
+void EffectStackView::slotItemSelectionChanged()
+{
bool hasItem = ui.effectlist->currentItem();
int activeRow = ui.effectlist->currentRow();
bool isChecked = false;
ui.buttonDown->setEnabled((activeRow < ui.effectlist->count() - 1) && hasItem);
}
-void EffectStackView::slotItemUp() {
+void EffectStackView::slotItemUp()
+{
int activeRow = ui.effectlist->currentRow();
if (activeRow <= 0) return;
emit changeEffectPosition(clipref, activeRow + 1, activeRow);
}
-void EffectStackView::slotItemDown() {
+void EffectStackView::slotItemDown()
+{
int activeRow = ui.effectlist->currentRow();
if (activeRow >= ui.effectlist->count() - 1) return;
emit changeEffectPosition(clipref, activeRow + 1, activeRow + 2);
}
-void EffectStackView::slotItemDel() {
+void EffectStackView::slotItemDel()
+{
int activeRow = ui.effectlist->currentRow();
if (activeRow >= 0) {
emit removeEffect(clipref, clipref->effectAt(activeRow));
}
}
-void EffectStackView::slotResetEffect() {
+void EffectStackView::slotResetEffect()
+{
int activeRow = ui.effectlist->currentRow();
if (activeRow < 0) return;
QDomElement old = clipref->effectAt(activeRow).cloneNode().toElement();
}
-void EffectStackView::raiseWindow(QWidget* dock) {
+void EffectStackView::raiseWindow(QWidget* dock)
+{
if (clipref && dock)
dock->raise();
}
-void EffectStackView::clear() {
+void EffectStackView::clear()
+{
ui.effectlist->clear();
ui.buttonDel->setEnabled(false);
ui.buttonSave->setEnabled(false);
class ClipItem;
class MltVideoProfile;
-class EffectStackView : public QWidget {
+class EffectStackView : public QWidget
+{
Q_OBJECT
public:
#include "gentime.h"
-class ProgressEvent : public QEvent {
+class ProgressEvent : public QEvent
+{
public:
ProgressEvent(int value, QEvent::Type eventType)
: QEvent(eventType), m_val(value) {};
double GenTime::s_delta = 0.00001;
/** Creates a time object, with a time of 0 seconds. */
-GenTime::GenTime() {
+GenTime::GenTime()
+{
m_time = 0.0;
}
/** Creates a time object, with time given in seconds. */
-GenTime::GenTime(double seconds) {
+GenTime::GenTime(double seconds)
+{
m_time = seconds;
}
/** Creates a time object, by passing number of frames and how many frames per second */
-GenTime::GenTime(int frames, double framesPerSecond) {
+GenTime::GenTime(int frames, double framesPerSecond)
+{
m_time = (double) frames / framesPerSecond;
}
/** Returns the time, in milliseconds */
-double GenTime::ms() const {
+double GenTime::ms() const
+{
return m_time * 1000;
}
/** Returns the time in frames, after being given the number of frames per second */
-double GenTime::frames(double framesPerSecond) const {
+double GenTime::frames(double framesPerSecond) const
+{
return floor(m_time * framesPerSecond + 0.5);
}
-GenTime::~GenTime() {
+GenTime::~GenTime()
+{
}
*@author Jason Wood
*/
-class GenTime {
+class GenTime
+{
public:
/** Creates a time object, with a time of 0 seconds. */
GenTime();
#include <QMenu>
-Geometryval::Geometryval(const MltVideoProfile profile, QWidget* parent): QWidget(parent), m_profile(profile), m_geom(NULL), m_path(NULL), paramRect(NULL), m_fixedMode(false) {
+Geometryval::Geometryval(const MltVideoProfile profile, QWidget* parent): QWidget(parent), m_profile(profile), m_geom(NULL), m_path(NULL), paramRect(NULL), m_fixedMode(false)
+{
ui.setupUi(this);
QVBoxLayout* vbox = new QVBoxLayout(ui.widget);
QGraphicsView *view = new QGraphicsView(this);
connect(scene, SIGNAL(actionFinished()), this, SLOT(slotUpdateTransitionProperties()));
}
-void Geometryval::slotAlignCenter() {
+void Geometryval::slotAlignCenter()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotAlignHCenter() {
+void Geometryval::slotAlignHCenter()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotAlignVCenter() {
+void Geometryval::slotAlignVCenter()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotAlignTop() {
+void Geometryval::slotAlignTop()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotAlignBottom() {
+void Geometryval::slotAlignBottom()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotAlignLeft() {
+void Geometryval::slotAlignLeft()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotAlignRight() {
+void Geometryval::slotAlignRight()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotResize50() {
+void Geometryval::slotResize50()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotResize100() {
+void Geometryval::slotResize100()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotResize200() {
+void Geometryval::slotResize200()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
slotUpdateTransitionProperties();
}
-void Geometryval::slotTransparencyChanged(int transp) {
+void Geometryval::slotTransparencyChanged(int transp)
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->fetch(&item, pos);
emit parameterChanged();
}
-void Geometryval::slotSyncCursor() {
+void Geometryval::slotSyncCursor()
+{
KdenliveSettings::setTransitionfollowcursor(m_syncAction->isChecked());
}
-void Geometryval::slotPositionChanged(int pos, bool seek) {
+void Geometryval::slotPositionChanged(int pos, bool seek)
+{
if (seek && KdenliveSettings::transitionfollowcursor()) emit seekToPos(pos);
ui.spinPos->setValue(pos);
m_helper->setValue(pos);
paramRect->setBrush(QColor(255, 0, 0, item.mix()));
}
-void Geometryval::slotDeleteFrame() {
+void Geometryval::slotDeleteFrame()
+{
// check there is more than one keyframe
Mlt::GeometryItem item;
const int pos = ui.spinPos->value();
emit parameterChanged();
}
-void Geometryval::slotAddFrame() {
+void Geometryval::slotAddFrame()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
item.frame(pos);
emit parameterChanged();
}
-void Geometryval::slotNextFrame() {
+void Geometryval::slotNextFrame()
+{
Mlt::GeometryItem item;
int error = m_geom->next_key(&item, m_helper->value() + 1);
kDebug() << "// SEEK TO NEXT KFR: " << error;
ui.spinPos->setValue(pos);
}
-void Geometryval::slotPreviousFrame() {
+void Geometryval::slotPreviousFrame()
+{
Mlt::GeometryItem item;
int error = m_geom->prev_key(&item, m_helper->value() - 1);
kDebug() << "// SEEK TO NEXT KFR: " << error;
}
-QDomElement Geometryval::getParamDesc() {
+QDomElement Geometryval::getParamDesc()
+{
param.setAttribute("value", m_geom->serialise());
kDebug() << " / / UPDATING TRANSITION VALUE: " << param.attribute("value");
return param;
}
-void Geometryval::setupParam(const QDomElement& par, int minFrame, int maxFrame) {
+void Geometryval::setupParam(const QDomElement& par, int minFrame, int maxFrame)
+{
param = par;
QString val = par.attribute("value");
if (par.attribute("fixed") == "1") {
connect(ui.spinTransp, SIGNAL(valueChanged(int)), this , SLOT(slotTransparencyChanged(int)));
}
-void Geometryval::updateTransitionPath() {
+void Geometryval::updateTransitionPath()
+{
if (m_fixedMode) return;
Mlt::GeometryItem item;
int pos = 0;
m_path->setPath(path);
}
-void Geometryval::slotUpdateTransitionProperties() {
+void Geometryval::slotUpdateTransitionProperties()
+{
int pos = ui.spinPos->value();
Mlt::GeometryItem item;
int error = m_geom->next_key(&item, pos);
class QMouseEvent;
-class Geometryval : public QWidget {
+class Geometryval : public QWidget
+{
Q_OBJECT
public:
explicit Geometryval(const MltVideoProfile profile, QWidget* parent = 0);
#include <QTextBlock>
-GraphicsSceneRectMove::GraphicsSceneRectMove(QObject *parent): QGraphicsScene(parent), m_selectedItem(NULL), resizeMode(NoResize), m_tool(TITLE_RECTANGLE) {
+GraphicsSceneRectMove::GraphicsSceneRectMove(QObject *parent): QGraphicsScene(parent), m_selectedItem(NULL), resizeMode(NoResize), m_tool(TITLE_RECTANGLE)
+{
//grabMouse();
zoom = 1.0;
setBackgroundBrush(QBrush(Qt::transparent));
}
-void GraphicsSceneRectMove::setSelectedItem(QGraphicsItem *item) {
+void GraphicsSceneRectMove::setSelectedItem(QGraphicsItem *item)
+{
clearSelection();
m_selectedItem = item;
item->setSelected(true);
update();
}
-TITLETOOL GraphicsSceneRectMove::tool() {
+TITLETOOL GraphicsSceneRectMove::tool()
+{
return m_tool;
}
-void GraphicsSceneRectMove::setTool(TITLETOOL tool) {
+void GraphicsSceneRectMove::setTool(TITLETOOL tool)
+{
m_tool = tool;
switch (m_tool) {
case TITLE_RECTANGLE:
}
//virtual
-void GraphicsSceneRectMove::keyPressEvent(QKeyEvent * keyEvent) {
+void GraphicsSceneRectMove::keyPressEvent(QKeyEvent * keyEvent)
+{
if (m_selectedItem == NULL) {
QGraphicsScene::keyPressEvent(keyEvent);
return;
}
//virtual
-void GraphicsSceneRectMove::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* e) {
+void GraphicsSceneRectMove::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* e)
+{
QPointF p = e->scenePos();
p += QPoint(-2, -2);
resizeMode = NoResize;
QGraphicsScene::mouseDoubleClickEvent(e);
}
-void GraphicsSceneRectMove::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
+void GraphicsSceneRectMove::mouseReleaseEvent(QGraphicsSceneMouseEvent *e)
+{
if (m_tool == TITLE_RECTANGLE && m_selectedItem) setSelectedItem(m_selectedItem);
QGraphicsScene::mouseReleaseEvent(e);
emit actionFinished();
}
-void GraphicsSceneRectMove::mousePressEvent(QGraphicsSceneMouseEvent* e) {
+void GraphicsSceneRectMove::mousePressEvent(QGraphicsSceneMouseEvent* e)
+{
m_clickPoint = e->screenPos();
QPointF p = e->scenePos();
p += QPoint(-2, -2);
}
-void GraphicsSceneRectMove::clearTextSelection() {
+void GraphicsSceneRectMove::clearTextSelection()
+{
if (m_selectedItem && m_selectedItem->type() == 8) {
//Â disable text editing
QGraphicsTextItem *t = static_cast<QGraphicsTextItem *>(m_selectedItem);
}
//virtual
-void GraphicsSceneRectMove::mouseMoveEvent(QGraphicsSceneMouseEvent* e) {
+void GraphicsSceneRectMove::mouseMoveEvent(QGraphicsSceneMouseEvent* e)
+{
if ((e->screenPos() - m_clickPoint).manhattanLength() < QApplication::startDragDistance()) {
e->accept();
return;
}
}
-void GraphicsSceneRectMove::wheelEvent(QGraphicsSceneWheelEvent * wheelEvent) {
+void GraphicsSceneRectMove::wheelEvent(QGraphicsSceneWheelEvent * wheelEvent)
+{
QList<QGraphicsView*> viewlist = views();
//kDebug() << wheelEvent->delta() << " " << zoom;
if (viewlist.size() > 0) {
}
}
-void GraphicsSceneRectMove::setScale(double s) {
+void GraphicsSceneRectMove::setScale(double s)
+{
if (zoom < 1.0 / 7.0 && s < 1.0) return;
else if (zoom > 10.0 / 7.9 && s > 1.0) return;
QList<QGraphicsView*> viewlist = views();
//kDebug()<<"////////// ZOOM: "<<zoom;
}
-void GraphicsSceneRectMove::setZoom(double s) {
+void GraphicsSceneRectMove::setZoom(double s)
+{
QList<QGraphicsView*> viewlist = views();
if (viewlist.size() > 0) {
viewlist[0]->resetTransform();
//kDebug()<<"////////// ZOOM: "<<zoom;
}
-void GraphicsSceneRectMove::setCursor(QCursor c) {
+void GraphicsSceneRectMove::setCursor(QCursor c)
+{
const QList<QGraphicsView*> l = views();
foreach(QGraphicsView* v, l) {
v->setCursor(c);
enum resizeModes {NoResize, TopLeft, BottomLeft, TopRight, BottomRight, Left, Right, Up, Down};
enum TITLETOOL { TITLE_SELECT = 0, TITLE_RECTANGLE = 1, TITLE_TEXT = 2, TITLE_IMAGE = 3 };
-class GraphicsSceneRectMove: public QGraphicsScene {
+class GraphicsSceneRectMove: public QGraphicsScene
+{
Q_OBJECT
public:
GraphicsSceneRectMove(QObject* parent = 0);
#include <KLocale>
-GroupClipsCommand::GroupClipsCommand(CustomTrackView *view, const QList <ItemInfo> clipInfos, const QList <ItemInfo> transitionInfos, bool group, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_clips(clipInfos), m_transitions(transitionInfos), m_group(group), m_doIt(doIt) {
+GroupClipsCommand::GroupClipsCommand(CustomTrackView *view, const QList <ItemInfo> clipInfos, const QList <ItemInfo> transitionInfos, bool group, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_clips(clipInfos), m_transitions(transitionInfos), m_group(group), m_doIt(doIt)
+{
if (m_group) setText(i18n("Group clips"));
else setText(i18n("Ungroup clips"));
}
// virtual
-void GroupClipsCommand::undo() {
+void GroupClipsCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->doGroupClips(m_clips, m_transitions, !m_group);
}
// virtual
-void GroupClipsCommand::redo() {
+void GroupClipsCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt)
m_view->doGroupClips(m_clips, m_transitions, m_group);
class GenTime;
class CustomTrackView;
-class GroupClipsCommand : public QUndoCommand {
+class GroupClipsCommand : public QUndoCommand
+{
public:
GroupClipsCommand(CustomTrackView *view, const QList <ItemInfo> clipInfos, const QList <ItemInfo> transitionInfos, bool group, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <QBrush>
Guide::Guide(CustomTrackView *view, GenTime pos, QString label, double fps, double height)
- : QGraphicsLineItem(), m_view(view), m_position(pos), m_label(label), m_fps(fps) {
+ : QGraphicsLineItem(), m_view(view), m_position(pos), m_label(label), m_fps(fps)
+{
setFlags(QGraphicsItem::ItemIsMovable);
setToolTip(label);
setLine(0, 0, 0, height);
prepareGeometryChange();
}
-QString Guide::label() const {
+QString Guide::label() const
+{
return m_label;
}
-GenTime Guide::position() const {
+GenTime Guide::position() const
+{
return m_position;
}
-CommentedTime Guide::info() const {
+CommentedTime Guide::info() const
+{
return CommentedTime(m_position, m_label);
}
-void Guide::updateGuide(const GenTime newPos, const QString &comment) {
+void Guide::updateGuide(const GenTime newPos, const QString &comment)
+{
m_position = newPos;
setPos(m_position.frames(m_fps), 0);
if (!comment.isEmpty()) {
}
//virtual
-int Guide::type() const {
+int Guide::type() const
+{
return GUIDEITEM;
}
//virtual
-void Guide::hoverEnterEvent(QGraphicsSceneHoverEvent *) {
+void Guide::hoverEnterEvent(QGraphicsSceneHoverEvent *)
+{
setPen(QPen(QBrush(QColor(200, 0, 0, 180)), 2));
}
//virtual
-void Guide::hoverLeaveEvent(QGraphicsSceneHoverEvent *) {
+void Guide::hoverLeaveEvent(QGraphicsSceneHoverEvent *)
+{
setPen(QPen(QBrush(QColor(0, 0, 200, 180)), 2));
}
//virtual
-QVariant Guide::itemChange(GraphicsItemChange change, const QVariant &value) {
+QVariant Guide::itemChange(GraphicsItemChange change, const QVariant &value)
+{
if (change == ItemPositionChange && scene()) {
// value is the new position.
QPointF newPos = value.toPointF();
}
// virtual
-QRectF Guide::boundingRect() const {
+QRectF Guide::boundingRect() const
+{
if (KdenliveSettings::showmarkers()) {
QRectF rect = QGraphicsLineItem::boundingRect();
rect.setLeft(line().x1());
}
// virtual
-void Guide::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*w*/) {
+void Guide::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*w*/)
+{
painter->setMatrixEnabled(false);
QLineF guideline = painter->matrix().map(line());
painter->setPen(pen());
class CustomTrackView;
-class Guide : public QGraphicsLineItem {
+class Guide : public QGraphicsLineItem
+{
public:
Guide(CustomTrackView *view, GenTime pos, QString label, double fps, double height);
#include <QAction>
HeaderTrack::HeaderTrack(int index, TrackInfo info, QWidget *parent)
- : QWidget(parent), m_index(index), m_type(info.type) {
+ : QWidget(parent), m_index(index), m_type(info.type)
+{
setFixedHeight(KdenliveSettings::trackheight());
view.setupUi(this);
view.track_number->setText(QString::number(m_index));
connect(changeAction, SIGNAL(triggered()), this, SLOT(slotChangeTrack()));
}
-HeaderTrack::~HeaderTrack() {
+HeaderTrack::~HeaderTrack()
+{
if (m_contextMenu) delete m_contextMenu;
}
-void HeaderTrack::switchVideo() {
+void HeaderTrack::switchVideo()
+{
if (view.buttonVideo->isChecked()) {
view.buttonVideo->setIcon(KIcon("kdenlive-show-video"));
} else {
emit switchTrackVideo(m_index);
}
-void HeaderTrack::switchAudio() {
+void HeaderTrack::switchAudio()
+{
if (view.buttonAudio->isChecked()) {
view.buttonAudio->setIcon(KIcon("kdenlive-show-audio"));
} else {
emit switchTrackAudio(m_index);
}
-void HeaderTrack::switchLock(bool emitSignal) {
+void HeaderTrack::switchLock(bool emitSignal)
+{
if (view.buttonLock->isChecked()) {
view.buttonLock->setIcon(KIcon("kdenlive-lock"));
} else {
}
-void HeaderTrack::setLock(bool lock) {
+void HeaderTrack::setLock(bool lock)
+{
view.buttonLock->setChecked(lock);
switchLock(false);
}
-void HeaderTrack::slotDeleteTrack() {
+void HeaderTrack::slotDeleteTrack()
+{
emit deleteTrack(m_index);
}
-void HeaderTrack::slotAddTrack() {
+void HeaderTrack::slotAddTrack()
+{
emit insertTrack(m_index);
}
-void HeaderTrack::slotChangeTrack() {
+void HeaderTrack::slotChangeTrack()
+{
emit changeTrack(m_index);
}
// virtual
-void HeaderTrack::contextMenuEvent(QContextMenuEvent * event) {
+void HeaderTrack::contextMenuEvent(QContextMenuEvent * event)
+{
m_contextMenu->popup(event->globalPos());
}
#include "definitions.h"
#include "ui_trackheader_ui.h"
-class HeaderTrack : public QWidget {
+class HeaderTrack : public QWidget
+{
Q_OBJECT
public:
#include <QDir>
#include <QIcon>
-initEffectsThumbnailer::initEffectsThumbnailer() {
+initEffectsThumbnailer::initEffectsThumbnailer()
+{
}
-void initEffectsThumbnailer::prepareThumbnailsCall(const QStringList& list) {
+void initEffectsThumbnailer::prepareThumbnailsCall(const QStringList& list)
+{
m_list = list;
start();
kDebug() << "done";
}
-void initEffectsThumbnailer::run() {
+void initEffectsThumbnailer::run()
+{
foreach(const QString &entry, m_list) {
kDebug() << entry;
if (!entry.isEmpty() && (entry.endsWith(".png") || entry.endsWith(".pgm"))) {
initEffectsThumbnailer initEffects::thumbnailer;
-initEffects::initEffects() {
+initEffects::initEffects()
+{
}
-initEffects::~initEffects() {
+initEffects::~initEffects()
+{
}
// static
-void initEffects::refreshLumas() {
+void initEffects::refreshLumas()
+{
// Check for Kdenlive installed luma files, add empty string at start for no luma
QStringList imagenamelist = QStringList() << i18n("None");
}
//static
-Mlt::Repository *initEffects::parseEffectFiles() {
+Mlt::Repository *initEffects::parseEffectFiles()
+{
QStringList::Iterator more;
QStringList::Iterator it;
QStringList fileList;
}
// static
-void initEffects::parseCustomEffectsFile() {
+void initEffects::parseCustomEffectsFile()
+{
MainWindow::customEffects.clear();
QString path = KStandardDirs::locateLocal("appdata", "effects/", true);
QDir directory = QDir(path);
}
// static
-void initEffects::parseEffectFile(EffectsList *customEffectList, EffectsList *audioEffectList, EffectsList *videoEffectList, QString name, QStringList filtersList, QStringList producersList) {
+void initEffects::parseEffectFile(EffectsList *customEffectList, EffectsList *audioEffectList, EffectsList *videoEffectList, QString name, QStringList filtersList, QStringList producersList)
+{
QDomDocument doc;
QFile file(name);
doc.setContent(&file, false);
}
//static
-const char* initEffects::ladspaEffectString(int ladspaId, QStringList params) {
+const char* initEffects::ladspaEffectString(int ladspaId, QStringList params)
+{
if (ladspaId == 1433) //Pitch
return ladspaPitchEffectString(params);
else if (ladspaId == 1216) //Room Reverb
}
//static
-void initEffects::ladspaEffectFile(const QString & fname, int ladspaId, QStringList params) {
+void initEffects::ladspaEffectFile(const QString & fname, int ladspaId, QStringList params)
+{
const char *filterString;
switch (ladspaId) {
case 1433: //Pitch
const QString jackString = "<?xml version=\"1.0\"?><!DOCTYPE jackrack SYSTEM \"http://purge.bash.sh/~rah/jack_rack_1.2.dtd\"><jackrack><channels>2</channels><samplerate>48000</samplerate><plugin><id>";
-const char* initEffects::ladspaDeclipEffectString(QStringList) {
+const char* initEffects::ladspaDeclipEffectString(QStringList)
+{
return qstrdup(QString(jackString + "1195</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><lockall>true</lockall></plugin></jackrack>").toUtf8());
}
return qstrdup( QString(jackString + "1441</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><lockall>true</lockall><controlrow><lock>true</lock><value>0.000000</value><value>0.000000</value></controlrow><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow><controlrow><lock>true</lock><value>%2</value><value>%2</value></controlrow><controlrow><lock>true</lock><value>%2</value><value>%2</value></controlrow><controlrow><lock>true</lock><value>%2</value><value>%2</value></controlrow><controlrow><lock>true</lock><value>%2</value><value>%2</value></controlrow><controlrow><lock>true</lock><value>%3</value><value>%3</value></controlrow><controlrow><lock>true</lock><value>%3</value><value>%3</value></controlrow><controlrow><lock>true</lock><value>%3</value><value>%3</value></controlrow><controlrow><lock>true</lock><value>%3</value><value>%3</value></controlrow><controlrow><lock>true</lock><value>%4</value><value>%4</value></controlrow><controlrow><lock>true</lock><value>%4</value><value>%4</value></controlrow><controlrow><lock>true</lock><value>%4</value><value>%4</value></controlrow><controlrow><lock>true</lock><value>%4</value><value>%4</value></controlrow></plugin></jackrack>").arg(params[0]).arg(params[1]).arg(params[2]).arg(params[3]));
}*/
-const char* initEffects::ladspaVinylEffectString(QStringList params) {
+const char* initEffects::ladspaVinylEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1905</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><controlrow><value>%1</value></controlrow><controlrow><value>%2</value></controlrow><controlrow><value>%3</value></controlrow><controlrow><value>%4</value></controlrow><controlrow><value>%5</value></controlrow></plugin></jackrack>").arg(params[0]).arg(params[1]).arg(params[2]).arg(params[3]).arg(params[4]).toUtf8());
}
-const char* initEffects::ladspaPitchEffectString(QStringList params) {
+const char* initEffects::ladspaPitchEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1433</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.0</value><value>1.0</value></wet_dry_values><lockall>true</lockall><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow><controlrow><lock>true</lock><value>4.000000</value><value>4.000000</value></controlrow></plugin></jackrack>").arg(params[0]).toUtf8());
}
-const char* initEffects::ladspaRoomReverbEffectString(QStringList params) {
+const char* initEffects::ladspaRoomReverbEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1216</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><lockall>true</lockall><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow><controlrow><lock>true</lock><value>%2</value><value>%2</value></controlrow><controlrow><lock>true</lock><value>%3</value><value>%3</value></controlrow><controlrow><lock>true</lock><value>0.750000</value><value>0.750000</value></controlrow><controlrow><lock>true</lock><value>-70.000000</value><value>-70.000000</value></controlrow><controlrow><lock>true</lock><value>0.000000</value><value>0.000000</value></controlrow><controlrow><lock>true</lock><value>-17.500000</value><value>-17.500000</value></controlrow></plugin></jackrack>").arg(params[0]).arg(params[1]).arg(params[2]).toUtf8());
}
-const char* initEffects::ladspaReverbEffectString(QStringList params) {
+const char* initEffects::ladspaReverbEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1423</id><enabled>true</enabled> <wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked> <wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values> <lockall>true</lockall><controlrow><lock>true</lock><value>%1</value> <value>%1</value></controlrow><controlrow><lock>true</lock><value>%2</value><value>%2</value></controlrow><controlrow><lock>true</lock><value>0.250000</value><value>0.250000</value></controlrow></plugin></jackrack>").arg(params[0]).arg(params[1]).toUtf8());
}
-const char* initEffects::ladspaEqualizerEffectString(QStringList params) {
+const char* initEffects::ladspaEqualizerEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1901</id><enabled>true</enabled> <wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked> <wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><controlrow><value>%1</value></controlrow><controlrow><value>%2</value></controlrow> <controlrow><value>%3</value></controlrow></plugin></jackrack>").arg(params[0]).arg(params[1]).arg(params[2]).toUtf8());
}
-const char* initEffects::ladspaLimiterEffectString(QStringList params) {
+const char* initEffects::ladspaLimiterEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1913</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><controlrow><value>%1</value></controlrow><controlrow><value>%2</value></controlrow><controlrow><value>%3</value></controlrow></plugin></jackrack>").arg(params[0]).arg(params[1]).arg(params[2]).toUtf8());
}
-const char* initEffects::ladspaPitchShifterEffectString(QStringList params) {
+const char* initEffects::ladspaPitchShifterEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1193</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><lockall>true</lockall><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow></plugin></jackrack>").arg(params[0]).toUtf8());
}
-const char* initEffects::ladspaRateScalerEffectString(QStringList params) {
+const char* initEffects::ladspaRateScalerEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1417</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><lockall>true</lockall><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow></plugin></jackrack>").arg(params[0]).toUtf8());
}
-const char* initEffects::ladspaPhaserEffectString(QStringList params) {
+const char* initEffects::ladspaPhaserEffectString(QStringList params)
+{
return qstrdup(QString(jackString + "1217</id><enabled>true</enabled><wet_dry_enabled>false</wet_dry_enabled><wet_dry_locked>true</wet_dry_locked><wet_dry_values><value>1.000000</value><value>1.000000</value></wet_dry_values><lockall>true</lockall><controlrow><lock>true</lock><value>%1</value><value>%1</value></controlrow><controlrow><lock>true</lock><value>%2</value><value>%2</value></controlrow><controlrow><lock>true</lock><value>%3</value><value>%3</value></controlrow><controlrow><lock>true</lock><value>%4</value><value>%4</value></controlrow></plugin></jackrack>").arg(params[0]).arg(params[1]).arg(params[2]).arg(params[3]).toUtf8());
}
-QDomDocument initEffects::createDescriptionFromMlt(Mlt::Repository* repository, const QString& /*type*/, const QString& filtername) {
+QDomDocument initEffects::createDescriptionFromMlt(Mlt::Repository* repository, const QString& /*type*/, const QString& filtername)
+{
QDomDocument ret;
Mlt::Properties *metadata = repository->metadata(filter_type, filtername.toAscii().data());
return ret;
}
-void initEffects::fillTransitionsList(Mlt::Repository * repository, EffectsList* transitions, QStringList names) {
+void initEffects::fillTransitionsList(Mlt::Repository * repository, EffectsList* transitions, QStringList names)
+{
// remove transitions that are not implemented
int pos = names.indexOf("mix");
if (pos != -1) names.takeAt(pos);
transitions->append(ret2.documentElement());*/
}
-QDomElement initEffects::quickParameterFill(QDomDocument & doc, QString name, QString tag, QString type, QString def, QString min, QString max, QString list, QString listdisplaynames, QString factor, QString namedesc, QString format) {
+QDomElement initEffects::quickParameterFill(QDomDocument & doc, QString name, QString tag, QString type, QString def, QString min, QString max, QString list, QString listdisplaynames, QString factor, QString namedesc, QString format)
+{
QDomElement parameter = doc.createElement("parameter");
parameter.setAttribute("tag", tag);
parameter.setAttribute("default", def);
class EffectsList;
-class initEffectsThumbnailer : public QThread {
+class initEffectsThumbnailer : public QThread
+{
Q_OBJECT
public:
initEffectsThumbnailer();
};
-class initEffects : public QObject {
+class initEffects : public QObject
+{
Q_OBJECT
public:
initEffects();
#include <KLocale>
InsertSpaceCommand::InsertSpaceCommand(CustomTrackView *view, QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime &duration, bool doIt, QUndoCommand * parent)
- : QUndoCommand(parent), m_view(view), m_clipsToMove(clipsToMove), m_transToMove(transToMove), m_track(track), m_duration(duration), m_doIt(doIt) {
+ : QUndoCommand(parent), m_view(view), m_clipsToMove(clipsToMove), m_transToMove(transToMove), m_track(track), m_duration(duration), m_doIt(doIt)
+{
if (duration > GenTime()) setText(i18n("Insert space"));
else setText(i18n("Remove space"));
}
// virtual
-void InsertSpaceCommand::undo() {
+void InsertSpaceCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_view->insertSpace(m_clipsToMove, m_transToMove, m_track, GenTime() - m_duration, m_duration);
}
// virtual
-void InsertSpaceCommand::redo() {
+void InsertSpaceCommand::redo()
+{
// kDebug() << "---- redoing action cut: " << m_cutTime.frames(25);
if (m_doIt) {
m_view->insertSpace(m_clipsToMove, m_transToMove, m_track, m_duration, GenTime());
class CustomTrackView;
-class InsertSpaceCommand : public QUndoCommand {
+class InsertSpaceCommand : public QUndoCommand
+{
public:
InsertSpaceCommand(CustomTrackView *view, QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime &duration, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <QUrl>
#include <QtPlugin>
-class ClipGenerator {
+class ClipGenerator
+{
public:
virtual ~ClipGenerator() {}
#define JOG_STOP 10009
-void ShuttleThread::init(QObject *parent, QString device) {
+void ShuttleThread::init(QObject *parent, QString device)
+{
m_parent = parent;
m_device = device;
stop_me = false;
jogvalue = 0xffff;
}
-bool ShuttleThread::isWorking() {
+bool ShuttleThread::isWorking()
+{
return m_isWorking;
}
-void ShuttleThread::run() {
+void ShuttleThread::run()
+{
kDebug() << "------- STARTING SHUTTLE: " << m_device;
const int fd = KDE_open((char *) m_device.toUtf8().data(), O_RDONLY);
}
-void ShuttleThread::handle_event(EV ev) {
+void ShuttleThread::handle_event(EV ev)
+{
switch (ev.type) {
case KEY :
key(ev.code, ev.value);
}
}
-void ShuttleThread::key(unsigned short code, unsigned int value) {
+void ShuttleThread::key(unsigned short code, unsigned int value)
+{
if (value == 0) {
// Button release (ignored)
return;
}
-void ShuttleThread::shuttle(int value) {
+void ShuttleThread::shuttle(int value)
+{
//gettimeofday( &last_shuttle, 0 );
//need_synthetic_shuttle = value != 0;
}
-void ShuttleThread::jog(unsigned int value) {
+void ShuttleThread::jog(unsigned int value)
+{
// We should generate a synthetic event for the shuttle going
// to the home position if we have not seen one recently
//check_synthetic();
}
-void ShuttleThread::jogshuttle(unsigned short code, unsigned int value) {
+void ShuttleThread::jogshuttle(unsigned short code, unsigned int value)
+{
switch (code) {
case JOG :
jog(value);
}
-JogShuttle::JogShuttle(QString device, QObject *parent): QObject(parent) {
+JogShuttle::JogShuttle(QString device, QObject *parent): QObject(parent)
+{
initDevice(device);
}
-JogShuttle::~JogShuttle() {
+JogShuttle::~JogShuttle()
+{
if (m_shuttleProcess.isRunning()) m_shuttleProcess.exit();
}
-void JogShuttle::initDevice(QString device) {
+void JogShuttle::initDevice(QString device)
+{
if (m_shuttleProcess.isRunning()) return;
m_shuttleProcess.init(this, device);
m_shuttleProcess.start(QThread::LowestPriority);
}
-void JogShuttle::stopDevice() {
+void JogShuttle::stopDevice()
+{
if (m_shuttleProcess.isRunning()) m_shuttleProcess.stop_me = true;
}
-void JogShuttle::customEvent(QEvent* e) {
+void JogShuttle::customEvent(QEvent* e)
+{
switch (e->type()) {
case JOG_BACK1:
emit rewind1();
typedef struct input_event EV;
-class ShuttleThread : public QThread {
+class ShuttleThread : public QThread
+{
public:
virtual void run();
};
-class JogShuttle: public QObject {
+class JogShuttle: public QObject
+{
Q_OBJECT public:
explicit JogShuttle(QString device, QObject * parent = 0);
~JogShuttle();
#include <mlt++/Mlt.h>
-KdenliveDoc::KdenliveDoc(const KUrl &url, const KUrl &projectFolder, QUndoGroup *undoGroup, const QString &profileName, const QPoint tracks, Render *render, MainWindow *parent): QObject(parent), m_render(render), m_url(url), m_projectFolder(projectFolder), m_commandStack(new QUndoStack(undoGroup)), m_modified(false), m_documentLoadingProgress(0), m_documentLoadingStep(0.0), m_startPos(0), m_zoom(7), m_autosave(NULL), m_zoneStart(0), m_zoneEnd(100), m_abortLoading(false) {
+KdenliveDoc::KdenliveDoc(const KUrl &url, const KUrl &projectFolder, QUndoGroup *undoGroup, const QString &profileName, const QPoint tracks, Render *render, MainWindow *parent): QObject(parent), m_render(render), m_url(url), m_projectFolder(projectFolder), m_commandStack(new QUndoStack(undoGroup)), m_modified(false), m_documentLoadingProgress(0), m_documentLoadingStep(0.0), m_startPos(0), m_zoom(7), m_autosave(NULL), m_zoneStart(0), m_zoneEnd(100), m_abortLoading(false)
+{
m_clipManager = new ClipManager(this);
m_autoSaveTimer = new QTimer(this);
m_autoSaveTimer->setSingleShot(true);
}
-KdenliveDoc::~KdenliveDoc() {
+KdenliveDoc::~KdenliveDoc()
+{
delete m_commandStack;
delete m_clipManager;
delete m_autoSaveTimer;
}
}
-void KdenliveDoc::setSceneList() {
+void KdenliveDoc::setSceneList()
+{
m_render->setSceneList(m_document.toString(), m_startPos);
checkProjectClips();
}
-QDomDocument KdenliveDoc::createEmptyDocument(const int videotracks, const int audiotracks) {
+QDomDocument KdenliveDoc::createEmptyDocument(const int videotracks, const int audiotracks)
+{
// Creating new document
QDomDocument doc;
QDomElement westley = doc.createElement("westley");
}
-void KdenliveDoc::syncGuides(QList <Guide *> guides) {
+void KdenliveDoc::syncGuides(QList <Guide *> guides)
+{
m_guidesXml.clear();
QDomElement guideNode = m_guidesXml.createElement("guides");
m_guidesXml.appendChild(guideNode);
emit guidesUpdated();
}
-QDomElement KdenliveDoc::guidesXml() const {
+QDomElement KdenliveDoc::guidesXml() const
+{
return m_guidesXml.documentElement();
}
-void KdenliveDoc::slotAutoSave() {
+void KdenliveDoc::slotAutoSave()
+{
if (m_render && m_autosave) {
if (!m_autosave->isOpen() && !m_autosave->open(QIODevice::ReadWrite)) {
// show error: could not open the autosave file
}
}
-void KdenliveDoc::setZoom(int factor) {
+void KdenliveDoc::setZoom(int factor)
+{
m_zoom = factor;
}
-int KdenliveDoc::zoom() const {
+int KdenliveDoc::zoom() const
+{
return m_zoom;
}
-bool KdenliveDoc::convertDocument(double version) {
+bool KdenliveDoc::convertDocument(double version)
+{
kDebug() << "Opening a document with version " << version;
const double current_version = 0.82;
return true;
}
-QString KdenliveDoc::colorToString(const QColor& c) {
+QString KdenliveDoc::colorToString(const QColor& c)
+{
QString ret = "%1,%2,%3,%4";
ret = ret.arg(c.red()).arg(c.green()).arg(c.blue()).arg(c.alpha());
return ret;
}
-void KdenliveDoc::setZone(int start, int end) {
+void KdenliveDoc::setZone(int start, int end)
+{
m_zoneStart = start;
m_zoneEnd = end;
}
-QPoint KdenliveDoc::zone() const {
+QPoint KdenliveDoc::zone() const
+{
return QPoint(m_zoneStart, m_zoneEnd);
}
-bool KdenliveDoc::saveSceneList(const QString &path, const QString &scene) {
+bool KdenliveDoc::saveSceneList(const QString &path, const QString &scene)
+{
QDomDocument sceneList;
sceneList.setContent(scene, true);
QDomNode wes = sceneList.elementsByTagName("westley").at(0);
return true;
}
-ClipManager *KdenliveDoc::clipManager() {
+ClipManager *KdenliveDoc::clipManager()
+{
return m_clipManager;
}
-KUrl KdenliveDoc::projectFolder() const {
+KUrl KdenliveDoc::projectFolder() const
+{
//if (m_projectFolder.isEmpty()) return KUrl(KStandardDirs::locateLocal("appdata", "/projects/"));
return m_projectFolder;
}
-void KdenliveDoc::setProjectFolder(KUrl url) {
+void KdenliveDoc::setProjectFolder(KUrl url)
+{
if (url == m_projectFolder) return;
setModified(true);
KStandardDirs::makeDir(url.path());
m_projectFolder = url;
}
-void KdenliveDoc::moveProjectData(KUrl url) {
+void KdenliveDoc::moveProjectData(KUrl url)
+{
QList <DocClipBase*> list = m_clipManager->documentClipList();
//TODO: Also move ladspa effects files
for (int i = 0; i < list.count(); i++) {
}
}
-const QString &KdenliveDoc::profilePath() const {
+const QString &KdenliveDoc::profilePath() const
+{
return m_profile.path;
}
-MltVideoProfile KdenliveDoc::mltProfile() const {
+MltVideoProfile KdenliveDoc::mltProfile() const
+{
return m_profile;
}
-void KdenliveDoc::setProfilePath(QString path) {
+void KdenliveDoc::setProfilePath(QString path)
+{
if (path.isEmpty()) path = KdenliveSettings::default_profile();
if (path.isEmpty()) path = "dv_pal";
m_profile = ProfilesDialog::getVideoProfile(path);
else m_timecode.setFormat((int) m_fps);
}
-double KdenliveDoc::dar() {
+double KdenliveDoc::dar()
+{
return (double) m_profile.display_aspect_num / m_profile.display_aspect_den;
}
-void KdenliveDoc::setThumbsProgress(const QString &message, int progress) {
+void KdenliveDoc::setThumbsProgress(const QString &message, int progress)
+{
emit progressInfo(message, progress);
}
-void KdenliveDoc::loadingProgressed() {
+void KdenliveDoc::loadingProgressed()
+{
m_documentLoadingProgress += m_documentLoadingStep;
emit progressInfo(QString(), (int) m_documentLoadingProgress);
}
-QUndoStack *KdenliveDoc::commandStack() {
+QUndoStack *KdenliveDoc::commandStack()
+{
return m_commandStack;
}
emit progressInfo(QString(), -1);
}*/
-void KdenliveDoc::checkProjectClips() {
+void KdenliveDoc::checkProjectClips()
+{
if (m_render == NULL) return;
QList <Mlt::Producer *> prods = m_render->producersList();
QString id ;
}
}
-void KdenliveDoc::updatePreviewSettings() {
+void KdenliveDoc::updatePreviewSettings()
+{
m_clipManager->updatePreviewSettings();
m_render->updatePreviewSettings();
m_clipManager->resetProducersList(m_render->producersList());
}
-Render *KdenliveDoc::renderer() {
+Render *KdenliveDoc::renderer()
+{
return m_render;
}
-void KdenliveDoc::updateClip(const QString &id) {
+void KdenliveDoc::updateClip(const QString &id)
+{
emit updateClipDisplay(id);
}
-int KdenliveDoc::getFramePos(QString duration) {
+int KdenliveDoc::getFramePos(QString duration)
+{
return m_timecode.getFrameCount(duration, m_fps);
}
-QString KdenliveDoc::producerName(const QString &id) {
+QString KdenliveDoc::producerName(const QString &id)
+{
QString result = "unnamed";
QDomNodeList prods = producersList();
int ct = prods.count();
return result;
}
-void KdenliveDoc::setProducerDuration(const QString &id, int duration) {
+void KdenliveDoc::setProducerDuration(const QString &id, int duration)
+{
QDomNodeList prods = producersList();
int ct = prods.count();
for (int i = 0; i < ct ; i++) {
}
}
-int KdenliveDoc::getProducerDuration(const QString &id) {
+int KdenliveDoc::getProducerDuration(const QString &id)
+{
int result = 0;
QDomNodeList prods = producersList();
int ct = prods.count();
return result;
}
-QDomDocument KdenliveDoc::toXml() {
+QDomDocument KdenliveDoc::toXml()
+{
return m_document;
}
-Timecode KdenliveDoc::timecode() const {
+Timecode KdenliveDoc::timecode() const
+{
return m_timecode;
}
-QDomNodeList KdenliveDoc::producersList() {
+QDomNodeList KdenliveDoc::producersList()
+{
return m_document.elementsByTagName("producer");
}
-double KdenliveDoc::projectDuration() const {
+double KdenliveDoc::projectDuration() const
+{
if (m_render)
return GenTime(m_render->getLength(), m_fps).ms() / 1000;
else
return 0;
}
-double KdenliveDoc::fps() const {
+double KdenliveDoc::fps() const
+{
return m_fps;
}
-int KdenliveDoc::width() const {
+int KdenliveDoc::width() const
+{
return m_width;
}
-int KdenliveDoc::height() const {
+int KdenliveDoc::height() const
+{
return m_height;
}
-KUrl KdenliveDoc::url() const {
+KUrl KdenliveDoc::url() const
+{
return m_url;
}
-void KdenliveDoc::setUrl(KUrl url) {
+void KdenliveDoc::setUrl(KUrl url)
+{
m_url = url;
}
-void KdenliveDoc::setModified(bool mod) {
+void KdenliveDoc::setModified(bool mod)
+{
if (!m_url.isEmpty() && mod && KdenliveSettings::crashrecovery()) {
m_autoSaveTimer->start(3000);
}
emit docModified(m_modified);
}
-bool KdenliveDoc::isModified() const {
+bool KdenliveDoc::isModified() const
+{
return m_modified;
}
-const QString KdenliveDoc::description() const {
+const QString KdenliveDoc::description() const
+{
if (m_url.isEmpty())
return i18n("Untitled") + " / " + m_profile.description;
else
return m_url.fileName() + " / " + m_profile.description;
}
-void KdenliveDoc::addClip(QDomElement elem, QString clipId, bool createClipItem) {
+void KdenliveDoc::addClip(QDomElement elem, QString clipId, bool createClipItem)
+{
const QString producerId = clipId.section('_', 0, 0);
DocClipBase *clip = m_clipManager->getClipById(producerId);
if (clip == NULL) {
}
-void KdenliveDoc::setNewClipResource(const QString &id, const QString &path) {
+void KdenliveDoc::setNewClipResource(const QString &id, const QString &path)
+{
QDomNodeList prods = m_document.elementsByTagName("producer");
int maxprod = prods.count();
for (int i = 0; i < maxprod; i++) {
}
}
-QString KdenliveDoc::searchFileRecursively(const QDir &dir, const QString &matchSize, const QString &matchHash) const {
+QString KdenliveDoc::searchFileRecursively(const QDir &dir, const QString &matchSize, const QString &matchHash) const
+{
QString foundFileName;
QByteArray fileData;
QByteArray fileHash;
return foundFileName;
}
-void KdenliveDoc::addClipInfo(QDomElement elem, QDomElement orig, QString clipId) {
+void KdenliveDoc::addClipInfo(QDomElement elem, QDomElement orig, QString clipId)
+{
DocClipBase *clip = m_clipManager->getClipById(clipId);
if (clip == NULL) {
addClip(elem, clipId, false);
}
}
-void KdenliveDoc::deleteProjectClip(QList <QString> ids) {
+void KdenliveDoc::deleteProjectClip(QList <QString> ids)
+{
for (int i = 0; i < ids.size(); ++i) {
emit deleteTimelineClip(ids.at(i));
m_clipManager->slotDeleteClip(ids.at(i));
setModified(true);
}
-void KdenliveDoc::deleteClip(const QString &clipId) {
+void KdenliveDoc::deleteClip(const QString &clipId)
+{
emit signalDeleteProjectClip(clipId);
m_clipManager->deleteClip(clipId);
}
-void KdenliveDoc::slotAddClipList(const KUrl::List urls, const QString group, const QString &groupId) {
+void KdenliveDoc::slotAddClipList(const KUrl::List urls, const QString group, const QString &groupId)
+{
m_clipManager->slotAddClipList(urls, group, groupId);
emit selectLastAddedClip(QString::number(m_clipManager->lastClipId()));
setModified(true);
}
-void KdenliveDoc::slotAddClipFile(const KUrl url, const QString group, const QString &groupId) {
+void KdenliveDoc::slotAddClipFile(const KUrl url, const QString group, const QString &groupId)
+{
//kDebug() << "///////// DOCUM, ADD CLP: " << url;
m_clipManager->slotAddClipFile(url, group, groupId);
emit selectLastAddedClip(QString::number(m_clipManager->lastClipId()));
setModified(true);
}
-const QString KdenliveDoc::getFreeClipId() {
+const QString KdenliveDoc::getFreeClipId()
+{
return QString::number(m_clipManager->getFreeClipId());
}
-DocClipBase *KdenliveDoc::getBaseClip(const QString &clipId) {
+DocClipBase *KdenliveDoc::getBaseClip(const QString &clipId)
+{
return m_clipManager->getClipById(clipId);
}
-void KdenliveDoc::slotCreateTextClip(QString /*group*/, const QString &/*groupId*/) {
+void KdenliveDoc::slotCreateTextClip(QString /*group*/, const QString &/*groupId*/)
+{
QString titlesFolder = projectFolder().path() + "/titles/";
KStandardDirs::makeDir(titlesFolder);
TitleWidget *dia_ui = new TitleWidget(KUrl(), titlesFolder, m_render, kapp->activeWindow());
delete dia_ui;
}
-int KdenliveDoc::tracksCount() const {
+int KdenliveDoc::tracksCount() const
+{
return m_tracksList.count();
}
-TrackInfo KdenliveDoc::trackInfoAt(int ix) const {
+TrackInfo KdenliveDoc::trackInfoAt(int ix) const
+{
return m_tracksList.at(ix);
}
-void KdenliveDoc::switchTrackAudio(int ix, bool hide) {
+void KdenliveDoc::switchTrackAudio(int ix, bool hide)
+{
m_tracksList[ix].isMute = hide; // !m_tracksList.at(ix).isMute;
}
-void KdenliveDoc::switchTrackLock(int ix, bool lock) {
+void KdenliveDoc::switchTrackLock(int ix, bool lock)
+{
m_tracksList[ix].isLocked = lock;
}
-bool KdenliveDoc::isTrackLocked(int ix) const {
+bool KdenliveDoc::isTrackLocked(int ix) const
+{
return m_tracksList[ix].isLocked;
}
-void KdenliveDoc::switchTrackVideo(int ix, bool hide) {
+void KdenliveDoc::switchTrackVideo(int ix, bool hide)
+{
m_tracksList[ix].isBlind = hide; // !m_tracksList.at(ix).isBlind;
}
-void KdenliveDoc::insertTrack(int ix, TrackInfo type) {
+void KdenliveDoc::insertTrack(int ix, TrackInfo type)
+{
if (ix == -1) m_tracksList << type;
else m_tracksList.insert(ix, type);
}
-void KdenliveDoc::deleteTrack(int ix) {
+void KdenliveDoc::deleteTrack(int ix)
+{
m_tracksList.removeAt(ix);
}
-void KdenliveDoc::setTrackType(int ix, TrackInfo type) {
+void KdenliveDoc::setTrackType(int ix, TrackInfo type)
+{
m_tracksList[ix].type = type.type;
m_tracksList[ix].isMute = type.isMute;
m_tracksList[ix].isBlind = type.isBlind;
m_tracksList[ix].isLocked = type.isLocked;
}
-const QList <TrackInfo> KdenliveDoc::tracksList() const {
+const QList <TrackInfo> KdenliveDoc::tracksList() const
+{
return m_tracksList;
}
-QPoint KdenliveDoc::getTracksCount() const {
+QPoint KdenliveDoc::getTracksCount() const
+{
int audio = 0;
int video = 0;
foreach(const TrackInfo &info, m_tracksList) {
return QPoint(video, audio);
}
-void KdenliveDoc::cachePixmap(const QString &fileId, const QPixmap &pix) const {
+void KdenliveDoc::cachePixmap(const QString &fileId, const QPixmap &pix) const
+{
pix.save(m_projectFolder.path() + "/thumbs/" + fileId + ".png");
}
-QString KdenliveDoc::getLadspaFile() const {
+QString KdenliveDoc::getLadspaFile() const
+{
int ct = 0;
QString counter = QString::number(ct).rightJustified(5, '0', false);
while (QFile::exists(m_projectFolder.path() + "/ladspa/" + counter + ".ladspa")) {
class MainWindow;
class TrackInfo;
-class KdenliveDoc: public QObject {
+class KdenliveDoc: public QObject
+{
Q_OBJECT public:
KdenliveDoc(const KUrl &url, const KUrl &projectFolder, QUndoGroup *undoGroup, const QString &profileName, const QPoint tracks, Render *render, MainWindow *parent = 0);
#endif /* NO_JOGSHUTTLE */
-KdenliveSettingsDialog::KdenliveSettingsDialog(QWidget * parent): KConfigDialog(parent, "settings", KdenliveSettings::self()) {
+KdenliveSettingsDialog::KdenliveSettingsDialog(QWidget * parent): KConfigDialog(parent, "settings", KdenliveSettings::self())
+{
QWidget *p1 = new QWidget;
m_configMisc.setupUi(p1);
KdenliveSettingsDialog::~KdenliveSettingsDialog() {}
-void KdenliveSettingsDialog::slotUpdateRmdRegionStatus() {
+void KdenliveSettingsDialog::slotUpdateRmdRegionStatus()
+{
m_configCapture.region_group->setHidden(m_configCapture.kcfg_rmd_capture_type->currentIndex() != 1);
}
-void KdenliveSettingsDialog::checkProfile() {
+void KdenliveSettingsDialog::checkProfile()
+{
m_configMisc.kcfg_profiles_list->clear();
QMap <QString, QString> profilesInfo = ProfilesDialog::getProfilesInfo();
QMapIterator<QString, QString> i(profilesInfo);
}
}
-void KdenliveSettingsDialog::initDevices() {
+void KdenliveSettingsDialog::initDevices()
+{
// Fill audio drivers
m_configSdl.kcfg_audio_driver->addItem(i18n("Automatic"), QString());
m_configSdl.kcfg_audio_driver->addItem(i18n("OSS"), "dsp");
}
-void KdenliveSettingsDialog::slotReadAudioDevices() {
+void KdenliveSettingsDialog::slotReadAudioDevices()
+{
QString result = QString(m_readProcess.readAllStandardOutput());
kDebug() << "// / / / / / READING APLAY: ";
kDebug() << result;
}
}
-void KdenliveSettingsDialog::showPage(int page, int option) {
+void KdenliveSettingsDialog::showPage(int page, int option)
+{
switch (page) {
case 1:
setCurrentPage(page1);
}
}
-void KdenliveSettingsDialog::slotEditVideoApplication() {
+void KdenliveSettingsDialog::slotEditVideoApplication()
+{
KService::Ptr service;
KOpenWithDialog dlg(KUrl::List(), i18n("Select default video player"), m_configEnv.kcfg_defaultplayerapp->text(), this);
if (dlg.exec() != QDialog::Accepted)
m_configEnv.kcfg_defaultplayerapp->setText(service->exec());
}
-void KdenliveSettingsDialog::slotEditAudioApplication() {
+void KdenliveSettingsDialog::slotEditAudioApplication()
+{
KService::Ptr service;
KOpenWithDialog dlg(KUrl::List(), i18n("Select default audio editor"), m_configEnv.kcfg_defaultaudioapp->text(), this);
if (dlg.exec() != QDialog::Accepted)
m_configEnv.kcfg_defaultaudioapp->setText(service->exec());
}
-void KdenliveSettingsDialog::slotEditImageApplication() {
+void KdenliveSettingsDialog::slotEditImageApplication()
+{
KService::Ptr service;
KOpenWithDialog dlg(KUrl::List(), i18n("Select default image editor"), m_configEnv.kcfg_defaultimageapp->text(), this);
if (dlg.exec() != QDialog::Accepted)
}
#ifndef NO_JOGSHUTTLE
-void KdenliveSettingsDialog::slotCheckShuttle(int state) {
+void KdenliveSettingsDialog::slotCheckShuttle(int state)
+{
m_configShuttle.config_group->setEnabled(state);
if (m_configShuttle.shuttledevicelist->count() == 0) {
// parse devices
}
}
-void KdenliveSettingsDialog::slotUpdateShuttleDevice(int ix) {
+void KdenliveSettingsDialog::slotUpdateShuttleDevice(int ix)
+{
QString device = m_configShuttle.shuttledevicelist->itemData(ix).toString();
//KdenliveSettings::setShuttledevice(device);
m_configShuttle.kcfg_shuttledevice->setText(device);
}
#endif /* NO_JOGSHUTTLE */
-void KdenliveSettingsDialog::rebuildVideo4Commands() {
+void KdenliveSettingsDialog::rebuildVideo4Commands()
+{
QString captureCommand;
if (!m_configCapture.kcfg_video4adevice->text().isEmpty()) captureCommand = "-f " + m_configCapture.kcfg_video4aformat->text() + " -i " + m_configCapture.kcfg_video4adevice->text();
}
-void KdenliveSettingsDialog::updateSettings() {
+void KdenliveSettingsDialog::updateSettings()
+{
kDebug() << "// // // KCONFIG UPDATE called";
m_defaultProfile = m_configMisc.kcfg_profiles_list->currentText();
KdenliveSettings::setDefault_profile(m_defaultPath);
if (updatePreview) emit updatePreviewSettings();
}
-void KdenliveSettingsDialog::slotUpdateDisplay() {
+void KdenliveSettingsDialog::slotUpdateDisplay()
+{
QString currentProfile = m_configMisc.kcfg_profiles_list->itemData(m_configMisc.kcfg_profiles_list->currentIndex()).toString();
QMap< QString, QString > values = ProfilesDialog::getSettingsFromFile(currentProfile);
m_configMisc.p_size->setText(values.value("width") + 'x' + values.value("height"));
#include "ui_configjogshuttle_ui.h"
#include "ui_configsdl_ui.h"
-class KdenliveSettingsDialog : public KConfigDialog {
+class KdenliveSettingsDialog : public KConfigDialog
+{
Q_OBJECT
public:
KeyframeHelper::KeyframeHelper(QWidget *parent)
- : QWidget(parent), m_geom(NULL), m_position(0), m_scale(0) {
+ : QWidget(parent), m_geom(NULL), m_position(0), m_scale(0)
+{
setFont(KGlobalSettings::toolBarFont());
}
// virtual
-void KeyframeHelper::mousePressEvent(QMouseEvent * event) {
+void KeyframeHelper::mousePressEvent(QMouseEvent * event)
+{
m_position = event->x() / m_scale;
emit positionChanged(m_position);
update();
}
// virtual
-void KeyframeHelper::mouseMoveEvent(QMouseEvent * event) {
+void KeyframeHelper::mouseMoveEvent(QMouseEvent * event)
+{
m_position = event->x() / m_scale;
m_position = qMax(0, m_position);
m_position = qMin(m_length, m_position);
// virtual
-void KeyframeHelper::wheelEvent(QWheelEvent * e) {
+void KeyframeHelper::wheelEvent(QWheelEvent * e)
+{
if (e->delta() < 0) m_position = m_position - 1;
else m_position = m_position + 1;
m_position = qMax(0, m_position);
}
// virtual
-void KeyframeHelper::paintEvent(QPaintEvent *e) {
+void KeyframeHelper::paintEvent(QPaintEvent *e)
+{
QStylePainter p(this);
const QRectF clipRect = e->rect();
p.setClipRect(clipRect);
}
-int KeyframeHelper::value() const {
+int KeyframeHelper::value() const
+{
return m_position;
}
-void KeyframeHelper::setValue(const int pos) {
+void KeyframeHelper::setValue(const int pos)
+{
if (pos == m_position || m_geom == NULL) return;
m_position = pos;
update();
}
-void KeyframeHelper::setKeyGeometry(Mlt::Geometry *geom, const int length) {
+void KeyframeHelper::setKeyGeometry(Mlt::Geometry *geom, const int length)
+{
m_geom = geom;
m_length = length;
update();
#include "timecode.h"
-class KeyframeHelper : public QWidget {
+class KeyframeHelper : public QWidget
+{
Q_OBJECT
public:
#include <QImage>
#include <QApplication>
-void MyThread::init(QObject *parent, KUrl url, QString target, double frame, double frameLength, int frequency, int channels, int arrayWidth) {
+void MyThread::init(QObject *parent, KUrl url, QString target, double frame, double frameLength, int frequency, int channels, int arrayWidth)
+{
stop_me = false;
m_parent = parent;
m_isWorking = false;
m_arrayWidth = arrayWidth;
}
-bool MyThread::isWorking() {
+bool MyThread::isWorking()
+{
return m_isWorking;
}
-void MyThread::run() {
+void MyThread::run()
+{
if (!f.open(QIODevice::WriteOnly)) {
kDebug() << "++++++++ ERROR WRITING TO FILE: " << f.fileName() << endl;
kDebug() << "++++++++ DISABLING AUDIO THUMBS" << endl;
}
KThumb::KThumb(ClipManager *clipManager, KUrl url, const QString &id, const QString &hash, QObject * parent, const char */*name*/)
- : QObject(parent),
- audioThumbProducer(),
- m_url(url),
- m_thumbFile(),
- m_dar(1),
- m_producer(NULL),
- m_clipManager(clipManager),
- m_id(id),
- m_mainFrame(-1)
+ : QObject(parent),
+ audioThumbProducer(),
+ m_url(url),
+ m_thumbFile(),
+ m_dar(1),
+ m_producer(NULL),
+ m_clipManager(clipManager),
+ m_id(id),
+ m_mainFrame(-1)
{
m_thumbFile = clipManager->projectFolder() + "/thumbs/" + hash + ".thumb";
connect(&audioThumbProducer, SIGNAL(audioThumbProgress(const int)), this, SLOT(slotAudioThumbProgress(const int)));
}
-KThumb::~KThumb() {
+KThumb::~KThumb()
+{
if (audioThumbProducer.isRunning()) {
slotAudioThumbOver();
audioThumbProducer.stop_me = true;
}
}
-void KThumb::setProducer(Mlt::Producer *producer) {
+void KThumb::setProducer(Mlt::Producer *producer)
+{
m_producer = producer;
m_dar = producer->profile()->dar();
}
-void KThumb::clearProducer() {
+void KThumb::clearProducer()
+{
m_producer = NULL;
}
-bool KThumb::hasProducer() const {
+bool KThumb::hasProducer() const
+{
return m_producer != NULL;
}
-void KThumb::updateThumbUrl(const QString &hash) {
+void KThumb::updateThumbUrl(const QString &hash)
+{
m_thumbFile = m_clipManager->projectFolder() + "/thumbs/" + hash + ".thumb";
}
-void KThumb::updateClipUrl(KUrl url, const QString &hash) {
+void KThumb::updateClipUrl(KUrl url, const QString &hash)
+{
m_url = url;
if (m_producer) {
char *tmp = Render::decodedString(url.path());
}
//static
-QPixmap KThumb::getImage(KUrl url, int width, int height) {
+QPixmap KThumb::getImage(KUrl url, int width, int height)
+{
if (url.isEmpty()) return QPixmap();
return getImage(url, 0, width, height);
}
-void KThumb::extractImage(int frame, int frame2) {
+void KThumb::extractImage(int frame, int frame2)
+{
if (m_url.isEmpty() || !KdenliveSettings::videothumbnails() || m_producer == NULL) return;
const int twidth = (int)(KdenliveSettings::trackheight() * m_dar);
}
}
-QPixmap KThumb::extractImage(int frame, int width, int height) {
+QPixmap KThumb::extractImage(int frame, int width, int height)
+{
return getFrame(m_producer, frame, width, height);
}
//static
-QPixmap KThumb::getImage(KUrl url, int frame, int width, int height) {
+QPixmap KThumb::getImage(KUrl url, int frame, int width, int height)
+{
Mlt::Profile profile((char*) KdenliveSettings::current_profile().data());
QPixmap pix(width, height);
if (url.isEmpty()) return pix;
}*/
//static
-QPixmap KThumb::getFrame(Mlt::Producer *producer, int framepos, int width, int height) {
+QPixmap KThumb::getFrame(Mlt::Producer *producer, int framepos, int width, int height)
+{
if (producer == NULL) {
QPixmap p(width, height);
p.fill(Qt::red);
emit thumbReady(endframe, image);
}
*/
-void KThumb::stopAudioThumbs() {
+void KThumb::stopAudioThumbs()
+{
if (audioThumbProducer.isRunning()) audioThumbProducer.stop_me = true;
}
-void KThumb::removeAudioThumb() {
+void KThumb::removeAudioThumb()
+{
if (m_thumbFile.isEmpty()) return;
stopAudioThumbs();
QFile f(m_thumbFile);
f.remove();
}
-void KThumb::getAudioThumbs(int channel, double frame, double frameLength, int arrayWidth) {
+void KThumb::getAudioThumbs(int channel, double frame, double frameLength, int arrayWidth)
+{
if (channel == 0) {
slotAudioThumbOver();
return;
}
}
-void KThumb::slotAudioThumbProgress(const int progress) {
+void KThumb::slotAudioThumbProgress(const int progress)
+{
m_clipManager->setThumbsProgress(i18n("Creating thumbnail for %1", m_url.fileName()), progress);
}
-void KThumb::slotAudioThumbOver() {
+void KThumb::slotAudioThumbOver()
+{
m_clipManager->setThumbsProgress(i18n("Creating thumbnail for %1", m_url.fileName()), -1);
m_clipManager->endAudioThumbsGeneration(m_id);
}
-void KThumb::askForAudioThumbs(const QString &id) {
+void KThumb::askForAudioThumbs(const QString &id)
+{
m_clipManager->askForAudioThumb(id);
}
*/
-namespace Mlt {
+namespace Mlt
+{
class Miracle;
class Consumer;
class Producer;
-class MyThread : public QThread {
+class MyThread : public QThread
+{
Q_OBJECT
public:
virtual void run();
void audioThumbOver();
};
-class KThumb: public QObject {
+class KThumb: public QObject
+{
Q_OBJECT public:
#include <KLocale>
-LockTrackCommand::LockTrackCommand(CustomTrackView *view, int ix, bool lock, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_ix(ix), m_lock(lock), m_doIt(doIt) {
+LockTrackCommand::LockTrackCommand(CustomTrackView *view, int ix, bool lock, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_ix(ix), m_lock(lock), m_doIt(doIt)
+{
if (lock) setText(i18n("Lock track"));
else setText(i18n("Unlock track"));
}
// virtual
-void LockTrackCommand::undo() {
+void LockTrackCommand::undo()
+{
m_view->lockTrack(m_ix, !m_lock);
}
// virtual
-void LockTrackCommand::redo() {
+void LockTrackCommand::redo()
+{
if (m_doIt) {
m_view->lockTrack(m_ix, m_lock);
}
class CustomTrackView;
-class LockTrackCommand : public QUndoCommand {
+class LockTrackCommand : public QUndoCommand
+{
public:
LockTrackCommand(CustomTrackView *view, int ix, bool lock, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
static const char version[] = VERSION;
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
KAboutData aboutData(QByteArray("kdenlive"), QByteArray("kdenlive"),
ki18n("Kdenlive"), QByteArray(version),
ki18n("An open source video editor."),
static const int ID_TIMELINE_POS = 6;
static const int ID_TIMELINE_FORMAT = 7;
-namespace Mlt {
+namespace Mlt
+{
class Producer;
};
#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);
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()) {
}
-void MainWindow::loadPlugins() {
+void MainWindow::loadPlugins()
+{
foreach(QObject *plugin, QPluginLoader::staticInstances())
populateMenus(plugin);
//exit(1);
}
-void MainWindow::populateMenus(QObject *plugin) {
+void MainWindow::populateMenus(QObject *plugin)
+{
QMenu *addMenu = static_cast<QMenu*>(factory()->container("generators", this));
ClipGenerator *iGenerator = qobject_cast<ClipGenerator *>(plugin);
if (iGenerator)
void MainWindow::addToMenu(QObject *plugin, const QStringList &texts,
QMenu *menu, const char *member,
- QActionGroup *actionGroup) {
+ QActionGroup *actionGroup)
+{
kDebug() << "// ADD to MENU" << texts;
foreach(const QString &text, texts) {
QAction *action = new QAction(text, plugin);
}
}
-void MainWindow::aboutPlugins() {
+void MainWindow::aboutPlugins()
+{
//PluginDialog dialog(pluginsDir.path(), m_pluginFileNames, this);
//dialog.exec();
}
-void MainWindow::generateClip() {
+void MainWindow::generateClip()
+{
QAction *action = qobject_cast<QAction *>(sender());
ClipGenerator *iGenerator = qobject_cast<ClipGenerator *>(action->parent());
}
}
-void MainWindow::saveProperties(KConfig*) {
+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_projectMonitor->render);
connect(m_projectList, SIGNAL(receivedClipDuration(const QString &, int)), this, SLOT(slotSetClipDuration(const QString &, int)));
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);
//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");
m_projectList->setHeaderInfo(state);
}
-void MainWindow::slotRunWizard() {
+void MainWindow::slotRunWizard()
+{
Wizard *w = new Wizard(this);
if (w->exec() == QDialog::Accepted && w->isOk()) {
w->adjustSettings();
delete w;
}
-void MainWindow::newFile(bool showProjectSettings) {
+void MainWindow::newFile(bool showProjectSettings)
+{
QString profileName;
KUrl projectFolder;
QPoint projectTracks(KdenliveSettings::videotracks(), KdenliveSettings::audiotracks());
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
}
}
-bool MainWindow::saveFileAs(const QString &outputFileName) {
+bool MainWindow::saveFileAs(const QString &outputFileName)
+{
QString currentSceneList;
if (KdenliveSettings::dropbframes()) {
KdenliveSettings::setDropbframes(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);
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 ?
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) {
+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);
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;
if (w->exec() == QDialog::Accepted) {
KdenliveSettingsDialog* d = static_cast <KdenliveSettingsDialog*>(KConfigDialog::exists("settings"));
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);
delete w;
}
-void MainWindow::slotRenderProject() {
+void MainWindow::slotRenderProject()
+{
if (!m_renderWidget) {
QString projectfolder = m_activeDocument ? m_activeDocument->projectFolder().path() : KdenliveSettings::defaultprojectfolder();
m_renderWidget = new RenderWidget(projectfolder, this);
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, bool resizeProfile, const QString &scriptExport) {
+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 = 0;
}
}
-void MainWindow::setRenderingProgress(const QString &url, int progress) {
+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) {
+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) {
+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);
}
}
-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 ////////////////";
m_buttonSelectTool->setChecked(true);
}
-void MainWindow::slotZoneMoved(int start, int end) {
+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 (page != -1) dialog->showPage(page, option);
}
-void MainWindow::slotUpdatePreviewSettings() {
+void MainWindow::slotUpdatePreviewSettings()
+{
if (m_activeDocument) {
m_clipMonitor->slotSetXml(NULL, 0);
m_activeDocument->updatePreviewSettings();
}
}
-void MainWindow::updateConfiguration() {
+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->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::slotGroupClips() {
+void MainWindow::slotGroupClips()
+{
if (m_activeTimeline) {
m_activeTimeline->projectView()->groupClips();
}
}
-void MainWindow::slotUnGroupClips() {
+void MainWindow::slotUnGroupClips()
+{
if (m_activeTimeline) {
m_activeTimeline->projectView()->groupClips(false);
}
}
-void MainWindow::slotAddProjectClip(KUrl url) {
+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");
}
}
-void MainWindow::customEvent(QEvent* e) {
+void MainWindow::customEvent(QEvent* e)
+{
if (e->type() == QEvent::User) {
// The timeline playing position changed...
kDebug() << "RECEIVEDÂ JOG EVEMNT!!!";
}
}
-void MainWindow::slotActivateEffectStackView() {
+void MainWindow::slotActivateEffectStackView()
+{
effectStack->raiseWindow(effectStackDock);
}
-void MainWindow::slotActivateTransitionView(Transition *t) {
+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;
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.clear();
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 (isMinimized()) {
}
}
-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::slotGetNewLumaStuff() {
+void MainWindow::slotGetNewLumaStuff()
+{
//KNS::Entry::List download();
KNS::Entry::List entries = KNS::Engine::download();
// list of changed entries
initEffects::refreshLumas();
}
-void MainWindow::slotGetNewRenderStuff() {
+void MainWindow::slotGetNewRenderStuff()
+{
//KNS::Entry::List download();
KNS::Engine engine(0);
}
}
-void MainWindow::slotGetNewMltProfileStuff() {
+void MainWindow::slotGetNewMltProfileStuff()
+{
//KNS::Entry::List download();
KNS::Engine engine(0);
}
}
-void MainWindow::slotAutoTransition() {
+void MainWindow::slotAutoTransition()
+{
if (m_activeTimeline) m_activeTimeline->projectView()->autoTransition();
}
-void MainWindow::slotSplitAudio() {
+void MainWindow::slotSplitAudio()
+{
if (m_activeTimeline) m_activeTimeline->projectView()->splitAudio();
}
-void MainWindow::slotAudioOnly() {
+void MainWindow::slotAudioOnly()
+{
if (m_activeTimeline) m_activeTimeline->projectView()->audioOnly();
}
-void MainWindow::slotVideoOnly() {
+void MainWindow::slotVideoOnly()
+{
if (m_activeTimeline) m_activeTimeline->projectView()->videoOnly();
}
-void MainWindow::slotDvdWizard(const QString &url, const QString &profile) {
+void MainWindow::slotDvdWizard(const QString &url, const QString &profile)
+{
DvdWizard *w = new DvdWizard(url, profile, this);
w->exec();
}
-void MainWindow::slotShowTimeline(bool show) {
+void MainWindow::slotShowTimeline(bool show)
+{
if (show == false) {
m_timelineState = saveState();
centralWidget()->setHidden(true);
}
}
-void MainWindow::slotMaximizeCurrent(bool show) {
+void MainWindow::slotMaximizeCurrent(bool show)
+{
//TODO:Â is there a way to maximize current widget?
//if (show == true)
{
class Render;
class Transition;
-class MainWindow : public KXmlGuiWindow {
+class MainWindow : public KXmlGuiWindow
+{
Q_OBJECT
Q_CLASSINFO("D-Bus Interface", "org.kdenlive.MainWindow")
#include <QTimer>
-ManageCapturesDialog::ManageCapturesDialog(KUrl::List files, QWidget * parent): QDialog(parent) {
+ManageCapturesDialog::ManageCapturesDialog(KUrl::List files, QWidget * parent): QDialog(parent)
+{
setFont(KGlobalSettings::toolBarFont());
m_view.setupUi(this);
m_importButton = m_view.buttonBox->button(QDialogButtonBox::Ok);
ManageCapturesDialog::~ManageCapturesDialog() {}
-void ManageCapturesDialog::slotCheckItemIcon() {
+void ManageCapturesDialog::slotCheckItemIcon()
+{
int ct = 0;
int count = m_view.treeWidget->topLevelItemCount();
while (ct < count) {
m_view.treeWidget->setEnabled(true);
}
-void ManageCapturesDialog::slotRefreshButtons() {
+void ManageCapturesDialog::slotRefreshButtons()
+{
int count = m_view.treeWidget->topLevelItemCount();
bool enabled = false;
for (int i = 0; i < count; i++) {
m_importButton->setEnabled(enabled);
}
-void ManageCapturesDialog::slotDeleteCurrent() {
+void ManageCapturesDialog::slotDeleteCurrent()
+{
QTreeWidgetItem *item = m_view.treeWidget->currentItem();
if (!item) return;
int i = m_view.treeWidget->indexOfTopLevelItem(item);
item = NULL;
}
-void ManageCapturesDialog::slotToggle() {
+void ManageCapturesDialog::slotToggle()
+{
int count = m_view.treeWidget->topLevelItemCount();
for (int i = 0; i < count; i++) {
QTreeWidgetItem *item = m_view.treeWidget->topLevelItem(i);
}
}
-KUrl::List ManageCapturesDialog::importFiles() {
+KUrl::List ManageCapturesDialog::importFiles()
+{
KUrl::List result;
int count = m_view.treeWidget->topLevelItemCount();
//#include "docclipbase.h"
#include "ui_managecaptures_ui.h"
-class ManageCapturesDialog : public QDialog {
+class ManageCapturesDialog : public QDialog
+{
Q_OBJECT
public:
#include <KDebug>
-MarkerDialog::MarkerDialog(DocClipBase *clip, CommentedTime t, Timecode tc, const QString &caption, QWidget * parent): QDialog(parent), m_tc(tc), m_clip(clip), m_marker(t), m_producer(NULL), m_profile(NULL) {
+MarkerDialog::MarkerDialog(DocClipBase *clip, CommentedTime t, Timecode tc, const QString &caption, QWidget * parent): QDialog(parent), m_tc(tc), m_clip(clip), m_marker(t), m_producer(NULL), m_profile(NULL)
+{
setFont(KGlobalSettings::toolBarFont());
m_fps = m_tc.fps();
m_view.setupUi(this);
adjustSize();
}
-MarkerDialog::~MarkerDialog() {
+MarkerDialog::~MarkerDialog()
+{
delete m_previewTimer;
if (m_producer) delete m_producer;
if (m_profile) delete m_profile;
}
-void MarkerDialog::slotUpdateThumb() {
+void MarkerDialog::slotUpdateThumb()
+{
m_previewTimer->stop();
int pos = m_tc.getFrameCount(m_view.marker_position->text(), m_fps);
QPixmap p = KThumb::getFrame(m_producer, pos, (int)(100 * m_dar), 100);
else kDebug() << "!!!!!!!!!!! ERROR CREATING THUMB";
}
-void MarkerDialog::slotTimeUp() {
+void MarkerDialog::slotTimeUp()
+{
int duration = m_tc.getFrameCount(m_view.marker_position->text(), m_fps);
if (m_clip && duration >= m_clip->duration().frames(m_fps)) return;
duration ++;
m_view.marker_position->setText(m_tc.getTimecode(GenTime(duration, m_fps), m_fps));
}
-void MarkerDialog::slotTimeDown() {
+void MarkerDialog::slotTimeDown()
+{
int duration = m_tc.getFrameCount(m_view.marker_position->text(), m_fps);
if (duration <= 0) return;
duration --;
m_view.marker_position->setText(m_tc.getTimecode(GenTime(duration, m_fps), m_fps));
}
-CommentedTime MarkerDialog::newMarker() {
+CommentedTime MarkerDialog::newMarker()
+{
return CommentedTime(GenTime(m_tc.getFrameCount(m_view.marker_position->text(), m_fps), m_fps), m_view.marker_comment->text());
}
-void MarkerDialog::wheelEvent(QWheelEvent * event) {
+void MarkerDialog::wheelEvent(QWheelEvent * event)
+{
if (m_view.marker_position->underMouse() || m_view.clip_thumb->underMouse()) {
if (event->delta() > 0)
slotTimeUp();
#include "timecode.h"
#include "ui_markerdialog_ui.h"
-namespace Mlt {
+namespace Mlt
+{
class Producer;
class Profile;
};
-class MarkerDialog : public QDialog {
+class MarkerDialog : public QDialog
+{
Q_OBJECT
public:
Monitor::Monitor(QString name, MonitorManager *manager, QWidget *parent)
- : QWidget(parent), render(NULL), m_monitorManager(manager), m_name(name), m_isActive(false), m_currentClip(NULL), m_dragStarted(false), m_overlay(NULL) {
+ : QWidget(parent), render(NULL), m_monitorManager(manager), m_name(name), m_isActive(false), m_currentClip(NULL), m_dragStarted(false), m_overlay(NULL)
+{
ui.setupUi(this);
m_scale = 1;
m_ruler = new SmallRuler();
kDebug() << "/////// BUILDING MONITOR, ID: " << ui.video_frame->winId();
}
-Monitor::~Monitor() {
+Monitor::~Monitor()
+{
delete m_ruler;
delete m_timePos;
if (m_overlay) delete m_overlay;
delete m_monitorRefresh;
}
-QString Monitor::name() const {
+QString Monitor::name() const
+{
return m_name;
}
-void Monitor::setupMenu(QMenu *goMenu, QAction *playZone, QAction *loopZone, QMenu *markerMenu) {
+void Monitor::setupMenu(QMenu *goMenu, QAction *playZone, QAction *loopZone, QMenu *markerMenu)
+{
m_contextMenu = new QMenu(this);
m_contextMenu->addMenu(m_playMenu);
m_contextMenu->addMenu(goMenu);
}
-void Monitor::slotSetSizeOneToOne() {
+void Monitor::slotSetSizeOneToOne()
+{
QRect r = QApplication::desktop()->screenGeometry();
const int maxWidth = r.width() - 20;
const int maxHeight = r.height() - 20;
emit adjustMonitorSize();
}
-void Monitor::slotSetSizeOneToTwo() {
+void Monitor::slotSetSizeOneToTwo()
+{
QRect r = QApplication::desktop()->screenGeometry();
const int maxWidth = r.width() - 20;
const int maxHeight = r.height() - 20;
emit adjustMonitorSize();
}
-void Monitor::resetSize() {
+void Monitor::resetSize()
+{
ui.video_frame->setMinimumSize(0, 0);
}
-DocClipBase *Monitor::activeClip() {
+DocClipBase *Monitor::activeClip()
+{
return m_currentClip;
}
-void Monitor::slotSeekToPreviousSnap() {
+void Monitor::slotSeekToPreviousSnap()
+{
if (m_currentClip) slotSeek(getSnapForPos(true).frames(m_monitorManager->timecode().fps()));
}
-void Monitor::slotSeekToNextSnap() {
+void Monitor::slotSeekToNextSnap()
+{
if (m_currentClip) slotSeek(getSnapForPos(false).frames(m_monitorManager->timecode().fps()));
}
-GenTime Monitor::position() {
+GenTime Monitor::position()
+{
return GenTime(m_position, m_monitorManager->timecode().fps());
}
-GenTime Monitor::getSnapForPos(bool previous) {
+GenTime Monitor::getSnapForPos(bool previous)
+{
QList <GenTime> snaps;
QList < GenTime > markers = m_currentClip->snapMarkers();
for (int i = 0; i < markers.size(); ++i) {
-void Monitor::slotZoneMoved(int start, int end) {
+void Monitor::slotZoneMoved(int start, int end)
+{
m_ruler->setZone(start, end);
checkOverlay();
setClipZone(m_ruler->zone());
}
-void Monitor::slotSetZoneStart() {
+void Monitor::slotSetZoneStart()
+{
m_ruler->setZone(m_position, -1);
emit zoneUpdated(m_ruler->zone());
checkOverlay();
setClipZone(m_ruler->zone());
}
-void Monitor::slotSetZoneEnd() {
+void Monitor::slotSetZoneEnd()
+{
m_ruler->setZone(-1, m_position);
emit zoneUpdated(m_ruler->zone());
checkOverlay();
}
// virtual
-void Monitor::mousePressEvent(QMouseEvent * event) {
+void Monitor::mousePressEvent(QMouseEvent * event)
+{
if (event->button() != Qt::RightButton) {
if (ui.video_frame->underMouse()) {
m_dragStarted = true;
}
// virtual
-void Monitor::mouseReleaseEvent(QMouseEvent * event) {
+void Monitor::mouseReleaseEvent(QMouseEvent * event)
+{
if (m_dragStarted) {
if (ui.video_frame->underMouse()) {
slotPlay();
// virtual
-void Monitor::mouseMoveEvent(QMouseEvent *event) {
+void Monitor::mouseMoveEvent(QMouseEvent *event)
+{
// kDebug() << "// DRAG STARTED, MOUSE MOVED: ";
if (!m_dragStarted || m_currentClip == NULL) return;
return Qt::MoveAction;
}*/
-QStringList Monitor::mimeTypes() const {
+QStringList Monitor::mimeTypes() const
+{
QStringList qstrList;
// list of accepted mime types for drop
qstrList.append("kdenlive/clip");
* Ctrl+wheel moves single frame, without Ctrl moves a second.
*
* See also http://www.kdenlive.org/mantis/view.php?id=265 */
-void Monitor::wheelEvent(QWheelEvent * event) {
+void Monitor::wheelEvent(QWheelEvent * event)
+{
if (event->modifiers() == Qt::ControlModifier) {
int delta = m_monitorManager->timecode().fps();
if (event->delta() < 0) delta = 0 - delta;
}
}
-void Monitor::slotSetThumbFrame() {
+void Monitor::slotSetThumbFrame()
+{
if (m_currentClip == NULL) {
return;
}
emit refreshClipThumbnail(m_currentClip->getId());
}
-void Monitor::slotExtractCurrentFrame() {
+void Monitor::slotExtractCurrentFrame()
+{
QPixmap frame = render->extractFrame(m_position);
QString outputFile = KFileDialog::getSaveFileName(KUrl(), "image/png");
if (!outputFile.isEmpty()) {
}
}
-bool Monitor::isActive() const {
+bool Monitor::isActive() const
+{
return m_isActive;
}
-void Monitor::activateMonitor() {
+void Monitor::activateMonitor()
+{
if (!m_isActive) m_monitorManager->switchMonitors(); //m_monitorManager->activateMonitor(m_name);
}
-void Monitor::slotSeek() {
+void Monitor::slotSeek()
+{
const int frames = m_monitorManager->timecode().getFrameCount(m_timePos->text(), m_monitorManager->timecode().fps());
slotSeek(frames);
}
-void Monitor::slotSeek(int pos) {
+void Monitor::slotSeek(int pos)
+{
activateMonitor();
if (render == NULL) return;
m_position = pos;
m_timePos->setText(m_monitorManager->timecode().getTimecodeFromFrames(m_position));
}
-void Monitor::checkOverlay() {
+void Monitor::checkOverlay()
+{
if (m_overlay == NULL) return;
QPoint zone = m_ruler->zone();
if (m_position == zone.x()) m_overlay->setOverlayText(i18n("In Point"));
}
}
-void Monitor::slotStart() {
+void Monitor::slotStart()
+{
activateMonitor();
render->play(0);
m_position = 0;
m_timePos->setText(m_monitorManager->timecode().getTimecodeFromFrames(m_position));
}
-void Monitor::slotEnd() {
+void Monitor::slotEnd()
+{
activateMonitor();
render->play(0);
m_position = render->getLength();
m_timePos->setText(m_monitorManager->timecode().getTimecodeFromFrames(m_position));
}
-void Monitor::slotZoneStart() {
+void Monitor::slotZoneStart()
+{
activateMonitor();
render->play(0);
m_position = m_ruler->zone().x();
m_timePos->setText(m_monitorManager->timecode().getTimecodeFromFrames(m_position));
}
-void Monitor::slotZoneEnd() {
+void Monitor::slotZoneEnd()
+{
activateMonitor();
render->play(0);
m_position = m_ruler->zone().y();
m_timePos->setText(m_monitorManager->timecode().getTimecodeFromFrames(m_position));
}
-void Monitor::slotRewind(double speed) {
+void Monitor::slotRewind(double speed)
+{
activateMonitor();
if (speed == 0) {
double currentspeed = render->playSpeed();
m_playAction->setIcon(m_pauseIcon);
}
-void Monitor::slotForward(double speed) {
+void Monitor::slotForward(double speed)
+{
activateMonitor();
if (speed == 0) {
double currentspeed = render->playSpeed();
m_playAction->setIcon(m_pauseIcon);
}
-void Monitor::slotRewindOneFrame(int diff) {
+void Monitor::slotRewindOneFrame(int diff)
+{
activateMonitor();
render->play(0);
if (m_position < 1) return;
checkOverlay();
}
-void Monitor::slotForwardOneFrame(int diff) {
+void Monitor::slotForwardOneFrame(int diff)
+{
activateMonitor();
render->play(0);
if (m_position >= m_length) return;
checkOverlay();
}
-void Monitor::seekCursor(int pos) {
+void Monitor::seekCursor(int pos)
+{
activateMonitor();
checkOverlay();
m_position = pos;
m_ruler->slotNewValue(pos);
}
-void Monitor::rendererStopped(int pos) {
+void Monitor::rendererStopped(int pos)
+{
//int rulerPos = (int)(pos * m_scale);
m_ruler->slotNewValue(pos);
m_position = pos;
m_playAction->setIcon(m_playIcon);
}
-void Monitor::initMonitor() {
+void Monitor::initMonitor()
+{
kDebug() << "/////// INITING MONITOR, ID: " << ui.video_frame->winId();
}
//
}*/
-void Monitor::adjustRulerSize(int length) {
+void Monitor::adjustRulerSize(int length)
+{
if (length > 0) m_length = length;
m_ruler->adjustScale(m_length);
if (m_currentClip != NULL) {
}
}
-void Monitor::stop() {
+void Monitor::stop()
+{
m_isActive = false;
if (render) render->stop();
//kDebug()<<"/// MONITOR RENDER STOP";
}
-void Monitor::start() {
+void Monitor::start()
+{
m_isActive = true;
if (render) render->start();
//kDebug()<<"/// MONITOR RENDER START";
}
-void Monitor::refreshMonitor(bool visible) {
+void Monitor::refreshMonitor(bool visible)
+{
if (visible && render) {
activateMonitor();
render->doRefresh(); //askForRefresh();
}
}
-void Monitor::pause() {
+void Monitor::pause()
+{
if (render == NULL) return;
activateMonitor();
render->pause();
//m_playAction->setIcon(m_pauseIcon);
}
-void Monitor::slotPlay() {
+void Monitor::slotPlay()
+{
if (render == NULL) return;
activateMonitor();
if (render->playSpeed() == 0) {
render->switchPlay();
}
-void Monitor::slotPlayZone() {
+void Monitor::slotPlayZone()
+{
if (render == NULL) return;
activateMonitor();
QPoint p = m_ruler->zone();
m_playAction->setIcon(m_pauseIcon);
}
-void Monitor::slotLoopZone() {
+void Monitor::slotLoopZone()
+{
if (render == NULL) return;
activateMonitor();
QPoint p = m_ruler->zone();
m_playAction->setIcon(m_pauseIcon);
}
-void Monitor::slotSetXml(DocClipBase *clip, const int position) {
+void Monitor::slotSetXml(DocClipBase *clip, const int position)
+{
if (render == NULL) return;
activateMonitor();
if (!clip && m_currentClip != NULL) {
} else if (position != -1) render->seek(GenTime(position, render->fps()));
}
-void Monitor::slotOpenFile(const QString &file) {
+void Monitor::slotOpenFile(const QString &file)
+{
if (render == NULL) return;
activateMonitor();
QDomDocument doc;
render->setSceneList(doc, 0);
}
-void Monitor::slotSaveZone() {
+void Monitor::slotSaveZone()
+{
if (render == NULL) return;
emit saveZone(render, m_ruler->zone());
}
-void Monitor::resetProfile() {
+void Monitor::resetProfile()
+{
if (render == NULL) return;
render->resetProfile();
}
-void Monitor::saveSceneList(QString path, QDomElement info) {
+void Monitor::saveSceneList(QString path, QDomElement info)
+{
if (render == NULL) return;
render->saveSceneList(path, info);
}
-const QString Monitor::sceneList() {
+const QString Monitor::sceneList()
+{
if (render == NULL) return QString();
return render->sceneList();
}
-void Monitor::setClipZone(QPoint pos) {
+void Monitor::setClipZone(QPoint pos)
+{
if (m_currentClip == NULL) return;
m_currentClip->setZone(pos);
}
-void Monitor::slotSwitchMonitorInfo(bool show) {
+void Monitor::slotSwitchMonitorInfo(bool show)
+{
KdenliveSettings::setDisplayMonitorInfo(show);
if (show) {
if (m_overlay) return;
}
}
-MonitorRefresh::MonitorRefresh(QWidget* parent): QWidget(parent), m_renderer(NULL) {
+MonitorRefresh::MonitorRefresh(QWidget* parent): QWidget(parent), m_renderer(NULL)
+{
setAttribute(Qt::WA_PaintOnScreen);
setAttribute(Qt::WA_OpaquePaintEvent); //setAttribute(Qt::WA_NoSystemBackground);
}
-void MonitorRefresh::setRenderer(Render* render) {
+void MonitorRefresh::setRenderer(Render* render)
+{
m_renderer = render;
}
-void MonitorRefresh::paintEvent(QPaintEvent * /*event*/) {
+void MonitorRefresh::paintEvent(QPaintEvent * /*event*/)
+{
if (m_renderer) m_renderer->doRefresh();
}
-Overlay::Overlay(QWidget* parent): QLabel(parent) {
+Overlay::Overlay(QWidget* parent): QLabel(parent)
+{
setAttribute(Qt::WA_TransparentForMouseEvents);
setAttribute(Qt::WA_OpaquePaintEvent);
//setAttribute(Qt::WA_NoSystemBackground);
setAutoFillBackground(false);
}
-void Overlay::paintEvent(QPaintEvent * /*event*/) {
+void Overlay::paintEvent(QPaintEvent * /*event*/)
+{
QPainter painter(this);
QColor col;
painter.setPen(Qt::white);
-void Overlay::setOverlayText(const QString &text, bool isZone) {
+void Overlay::setOverlayText(const QString &text, bool isZone)
+{
setHidden(true);
m_isZone = isZone;
setText(' ' + text + ' ');
class SmallRuler;
class DocClipBase;
-class MonitorRefresh : public QWidget {
+class MonitorRefresh : public QWidget
+{
Q_OBJECT
public:
MonitorRefresh(QWidget* parent);
Render *m_renderer;
};
-class Overlay : public QLabel {
+class Overlay : public QLabel
+{
Q_OBJECT
public:
Overlay(QWidget* parent);
bool m_isZone;
};
-class Monitor : public QWidget {
+class Monitor : public QWidget
+{
Q_OBJECT
public:
MonitorManager::MonitorManager(QWidget *parent)
- : QObject(parent) {
+ : QObject(parent)
+{
}
-Timecode MonitorManager::timecode() {
+Timecode MonitorManager::timecode()
+{
return m_timecode;
}
-void MonitorManager::initMonitors(Monitor *clipMonitor, Monitor *projectMonitor) {
+void MonitorManager::initMonitors(Monitor *clipMonitor, Monitor *projectMonitor)
+{
m_clipMonitor = clipMonitor;
m_projectMonitor = projectMonitor;
}
-void MonitorManager::activateMonitor(QString name) {
+void MonitorManager::activateMonitor(QString name)
+{
if (m_activeMonitor == name) return;
if (name == "clip") {
m_projectMonitor->stop();
m_activeMonitor = name;
}
-void MonitorManager::switchMonitors() {
+void MonitorManager::switchMonitors()
+{
if (m_clipMonitor->isActive()) {
m_clipMonitor->stop();
m_projectMonitor->start();
}
}
-void MonitorManager::stopActiveMonitor() {
+void MonitorManager::stopActiveMonitor()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->pause();
else m_projectMonitor->pause();
}
-void MonitorManager::slotPlay() {
+void MonitorManager::slotPlay()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotPlay();
else m_projectMonitor->slotPlay();
}
-void MonitorManager::slotPlayZone() {
+void MonitorManager::slotPlayZone()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotPlayZone();
else m_projectMonitor->slotPlayZone();
}
-void MonitorManager::slotLoopZone() {
+void MonitorManager::slotLoopZone()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotLoopZone();
else m_projectMonitor->slotLoopZone();
}
-void MonitorManager::slotRewind(double speed) {
+void MonitorManager::slotRewind(double speed)
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotRewind(speed);
else m_projectMonitor->slotRewind(speed);
}
-void MonitorManager::slotForward(double speed) {
+void MonitorManager::slotForward(double speed)
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotForward(speed);
else m_projectMonitor->slotForward(speed);
}
-void MonitorManager::slotRewindOneFrame() {
+void MonitorManager::slotRewindOneFrame()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotRewindOneFrame();
else m_projectMonitor->slotRewindOneFrame();
}
-void MonitorManager::slotForwardOneFrame() {
+void MonitorManager::slotForwardOneFrame()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotForwardOneFrame();
else m_projectMonitor->slotForwardOneFrame();
}
-void MonitorManager::slotRewindOneSecond() {
+void MonitorManager::slotRewindOneSecond()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotRewindOneFrame(m_timecode.fps());
else m_projectMonitor->slotRewindOneFrame(m_timecode.fps());
}
-void MonitorManager::slotForwardOneSecond() {
+void MonitorManager::slotForwardOneSecond()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotForwardOneFrame(m_timecode.fps());
else m_projectMonitor->slotForwardOneFrame(m_timecode.fps());
}
-void MonitorManager::slotStart() {
+void MonitorManager::slotStart()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotStart();
else m_projectMonitor->slotStart();
}
-void MonitorManager::slotEnd() {
+void MonitorManager::slotEnd()
+{
if (m_clipMonitor->isActive()) m_clipMonitor->slotEnd();
else m_projectMonitor->slotEnd();
}
-void MonitorManager::resetProfiles(Timecode tc) {
+void MonitorManager::resetProfiles(Timecode tc)
+{
m_timecode = tc;
QTimer::singleShot(300, this, SLOT(slotResetProfiles()));
}
-void MonitorManager::slotResetProfiles() {
+void MonitorManager::slotResetProfiles()
+{
activateMonitor("clip");
m_clipMonitor->resetProfile();
activateMonitor("project");
class Monitor;
-class MonitorManager : public QObject {
+class MonitorManager : public QObject
+{
Q_OBJECT
public:
#include <KLocale>
-MoveClipCommand::MoveClipCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startPos(start), m_endPos(end), m_doIt(doIt) {
+MoveClipCommand::MoveClipCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startPos(start), m_endPos(end), m_doIt(doIt)
+{
setText(i18n("Move clip"));
}
// virtual
-void MoveClipCommand::undo() {
+void MoveClipCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->moveClip(m_endPos, m_startPos);
}
// virtual
-void MoveClipCommand::redo() {
+void MoveClipCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt)
m_view->moveClip(m_startPos, m_endPos);
class CustomTrackView;
-class MoveClipCommand : public QUndoCommand {
+class MoveClipCommand : public QUndoCommand
+{
public:
MoveClipCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-MoveEffectCommand::MoveEffectCommand(CustomTrackView *view, const int track, GenTime pos, int oldPos, int newPos, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_oldindex(oldPos), m_newindex(newPos), m_doIt(doIt) {
+MoveEffectCommand::MoveEffectCommand(CustomTrackView *view, const int track, GenTime pos, int oldPos, int newPos, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_oldindex(oldPos), m_newindex(newPos), m_doIt(doIt)
+{
/* QString effectName;
QDomNode namenode = effect.elementsByTagName("name").item(0);
if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
}
// virtual
-int MoveEffectCommand::id() const {
+int MoveEffectCommand::id() const
+{
return 2;
}
// virtual
-bool MoveEffectCommand::mergeWith(const QUndoCommand * other) {
+bool MoveEffectCommand::mergeWith(const QUndoCommand * other)
+{
if (other->id() != id()) return false;
if (m_track != static_cast<const MoveEffectCommand*>(other)->m_track) return false;
if (m_pos != static_cast<const MoveEffectCommand*>(other)->m_pos) return false;
}
// virtual
-void MoveEffectCommand::undo() {
+void MoveEffectCommand::undo()
+{
kDebug() << "---- undoing action";
m_view->moveEffect(m_track, m_pos, m_newindex, m_oldindex);
}
// virtual
-void MoveEffectCommand::redo() {
+void MoveEffectCommand::redo()
+{
kDebug() << "---- redoing action";
m_view->moveEffect(m_track, m_pos, m_oldindex, m_newindex);
}
class CustomTrackView;
-class MoveEffectCommand : public QUndoCommand {
+class MoveEffectCommand : public QUndoCommand
+{
public:
MoveEffectCommand(CustomTrackView *view, const int track, GenTime pos, int oldPos, int newPos, bool doIt, QUndoCommand * parent = 0);
#include <KLocale>
-MoveGroupCommand::MoveGroupCommand(CustomTrackView *view, const QList <ItemInfo> startClip, const QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startClip(startClip), m_startTransition(startTransition), m_offset(offset), m_trackOffset(trackOffset), m_doIt(doIt) {
+MoveGroupCommand::MoveGroupCommand(CustomTrackView *view, const QList <ItemInfo> startClip, const QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startClip(startClip), m_startTransition(startTransition), m_offset(offset), m_trackOffset(trackOffset), m_doIt(doIt)
+{
setText(i18n("Move group"));
}
// virtual
-void MoveGroupCommand::undo() {
+void MoveGroupCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->moveGroup(m_startClip, m_startTransition, GenTime() - m_offset, - m_trackOffset, true);
}
// virtual
-void MoveGroupCommand::redo() {
+void MoveGroupCommand::redo()
+{
if (m_doIt)
m_view->moveGroup(m_startClip, m_startTransition, m_offset, m_trackOffset, false);
m_doIt = true;
class GenTime;
class CustomTrackView;
-class MoveGroupCommand : public QUndoCommand {
+class MoveGroupCommand : public QUndoCommand
+{
public:
MoveGroupCommand(CustomTrackView *view, const QList <ItemInfo> startClip, const QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KLocale>
-MoveTransitionCommand::MoveTransitionCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startPos(start), m_endPos(end), m_doIt(doIt) {
+MoveTransitionCommand::MoveTransitionCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startPos(start), m_endPos(end), m_doIt(doIt)
+{
setText(i18n("Move transition"));
}
// virtual
-void MoveTransitionCommand::undo() {
+void MoveTransitionCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->moveTransition(m_endPos, m_startPos);
}
// virtual
-void MoveTransitionCommand::redo() {
+void MoveTransitionCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt) m_view->moveTransition(m_startPos, m_endPos);
m_doIt = true;
class CustomTrackView;
-class MoveTransitionCommand : public QUndoCommand {
+class MoveTransitionCommand : public QUndoCommand
+{
public:
MoveTransitionCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <KDebug>
#include <KPlotPoint>
-ParameterPlotter::ParameterPlotter(QWidget *parent): KPlotWidget(parent) {
+ParameterPlotter::ParameterPlotter(QWidget *parent): KPlotWidget(parent)
+{
setAntialiasing(true);
setLeftPadding(20);
setRightPadding(10);
</effect>
*/
-void ParameterPlotter::setPointLists(const QDomElement& d, const QString& paramName, int startframe, int endframe) {
+void ParameterPlotter::setPointLists(const QDomElement& d, const QString& paramName, int startframe, int endframe)
+{
//QListIterator <QPair <QString, QMap< int , QVariant > > > nameit(params);
m_paramName = paramName;
}
-void ParameterPlotter::createParametersNew() {
+void ParameterPlotter::createParametersNew()
+{
QList<KPlotObject*> plotobjs = plotObjects();
if (plotobjs.size() != parameterNameList.size()) {
kDebug() << "ERROR size not equal";
}
-void ParameterPlotter::mouseMoveEvent(QMouseEvent * event) {
+void ParameterPlotter::mouseMoveEvent(QMouseEvent * event)
+{
if (movepoint != NULL) {
QList<KPlotPoint*> list = pointsUnderPoint(event->pos() - QPoint(leftPadding(), topPadding())) ;
}
}
-void ParameterPlotter::replot(const QString & name) {
+void ParameterPlotter::replot(const QString & name)
+{
//removeAllPlotObjects();
int i = 0;
}
}
-void ParameterPlotter::mousePressEvent(QMouseEvent * event) {
+void ParameterPlotter::mousePressEvent(QMouseEvent * event)
+{
//topPadding and other padding can be wrong and this (i hope) will be correctet in newer kde versions
QPoint inPlot = event->pos() - QPoint(leftPadding(), topPadding());
QList<KPlotPoint*> list = pointsUnderPoint(inPlot) ;
}
}
-void ParameterPlotter::setMoveX(bool b) {
+void ParameterPlotter::setMoveX(bool b)
+{
m_moveX = b;
}
-void ParameterPlotter::setMoveY(bool b) {
+void ParameterPlotter::setMoveY(bool b)
+{
m_moveY = b;
}
-void ParameterPlotter::setMoveTimeLine(bool b) {
+void ParameterPlotter::setMoveTimeLine(bool b)
+{
m_moveTimeline = b;
}
-void ParameterPlotter::setNewPoints(bool b) {
+void ParameterPlotter::setNewPoints(bool b)
+{
m_newPoints = b;
}
-bool ParameterPlotter::isMoveX() {
+bool ParameterPlotter::isMoveX()
+{
return m_moveX;
}
-bool ParameterPlotter::isMoveY() {
+bool ParameterPlotter::isMoveY()
+{
return m_moveY;
}
-bool ParameterPlotter::isMoveTimeline() {
+bool ParameterPlotter::isMoveTimeline()
+{
return m_moveTimeline;
}
-bool ParameterPlotter::isNewPoints() {
+bool ParameterPlotter::isNewPoints()
+{
return m_newPoints;
}
#include <QDomElement>
#include <QMap>
-class ParameterPlotter : public KPlotWidget {
+class ParameterPlotter : public KPlotWidget
+{
Q_OBJECT
public:
ParameterPlotter(QWidget *parent = 0);
#include <QDir>
#include <QCloseEvent>
-ProfilesDialog::ProfilesDialog(QWidget * parent): QDialog(parent), m_isCustomProfile(false), m_profileIsModified(false) {
+ProfilesDialog::ProfilesDialog(QWidget * parent): QDialog(parent), m_isCustomProfile(false), m_profileIsModified(false)
+{
m_view.setupUi(this);
QStringList profilesFilter;
connect(m_view.size_w, SIGNAL(valueChanged(int)), this, SLOT(slotProfileEdited()));
}
-void ProfilesDialog::slotProfileEdited() {
+void ProfilesDialog::slotProfileEdited()
+{
m_profileIsModified = true;
}
-void ProfilesDialog::fillList(const QString selectedProfile) {
+void ProfilesDialog::fillList(const QString selectedProfile)
+{
//Â List the Mlt profiles
m_view.profiles_list->clear();
QMap <QString, QString> profilesInfo = ProfilesDialog::getProfilesInfo();
m_selectedProfileIndex = m_view.profiles_list->currentIndex();
}
-void ProfilesDialog::accept() {
+void ProfilesDialog::accept()
+{
if (askForSave()) QDialog::accept();
}
-void ProfilesDialog::closeEvent(QCloseEvent *event) {
+void ProfilesDialog::closeEvent(QCloseEvent *event)
+{
if (askForSave()) {
event->accept();
} else {
}
}
-bool ProfilesDialog::askForSave() {
+bool ProfilesDialog::askForSave()
+{
if (!m_profileIsModified) return true;
if (KMessageBox::questionYesNo(this, i18n("The custom profile was modified, do you want to save it?")) != KMessageBox::Yes) return true;
return slotSaveProfile();
}
-void ProfilesDialog::slotCreateProfile() {
+void ProfilesDialog::slotCreateProfile()
+{
m_view.button_delete->setEnabled(false);
m_view.button_create->setEnabled(false);
m_view.button_save->setEnabled(true);
m_view.properties->setEnabled(true);
}
-void ProfilesDialog::slotSetDefaultProfile() {
+void ProfilesDialog::slotSetDefaultProfile()
+{
int ix = m_view.profiles_list->currentIndex();
QString path = m_view.profiles_list->itemData(ix).toString();
if (!path.isEmpty()) KdenliveSettings::setDefault_profile(path);
}
-bool ProfilesDialog::slotSaveProfile() {
+bool ProfilesDialog::slotSaveProfile()
+{
const QString profileDesc = m_view.description->text();
int ix = m_view.profiles_list->findText(profileDesc);
if (ix != -1) {
return true;
}
-void ProfilesDialog::saveProfile(const QString path) {
+void ProfilesDialog::saveProfile(const QString path)
+{
QFile file(path);
if (!file.open(QIODevice::WriteOnly)) {
KMessageBox::sorry(this, i18n("Cannot write to file %1", path));
file.close();
}
-void ProfilesDialog::slotDeleteProfile() {
+void ProfilesDialog::slotDeleteProfile()
+{
const QString path = m_view.profiles_list->itemData(m_view.profiles_list->currentIndex()).toString();
if (path.contains('/')) {
KIO::NetAccess::del(KUrl(path), this);
}
// static
-MltVideoProfile ProfilesDialog::getVideoProfile(QString name) {
+MltVideoProfile ProfilesDialog::getVideoProfile(QString name)
+{
MltVideoProfile result;
QStringList profilesNames;
QStringList profilesFiles;
}
// static
-QString ProfilesDialog::getProfileDescription(QString name) {
+QString ProfilesDialog::getProfileDescription(QString name)
+{
QStringList profilesNames;
QStringList profilesFiles;
QStringList profilesFilter;
}
// static
-QMap <QString, QString> ProfilesDialog::getProfilesInfo() {
+QMap <QString, QString> ProfilesDialog::getProfilesInfo()
+{
QMap <QString, QString> result;
QStringList profilesFilter;
profilesFilter << "*";
}
// static
-QMap< QString, QString > ProfilesDialog::getSettingsFromFile(const QString path) {
+QMap< QString, QString > ProfilesDialog::getSettingsFromFile(const QString path)
+{
QStringList profilesNames;
QStringList profilesFiles;
QStringList profilesFilter;
}
// static
-QMap< QString, QString > ProfilesDialog::getSettingsForProfile(const QString profileName) {
+QMap< QString, QString > ProfilesDialog::getSettingsForProfile(const QString profileName)
+{
QStringList profilesNames;
QStringList profilesFiles;
QStringList profilesFilter;
}
// static
-QString ProfilesDialog::getPathFromDescription(const QString profileDesc) {
+QString ProfilesDialog::getPathFromDescription(const QString profileDesc)
+{
QStringList profilesNames;
QStringList profilesFiles;
QStringList profilesFilter;
}
-void ProfilesDialog::slotUpdateDisplay() {
+void ProfilesDialog::slotUpdateDisplay()
+{
if (askForSave() == false) {
m_view.profiles_list->blockSignals(true);
m_view.profiles_list->setCurrentIndex(m_selectedProfileIndex);
#include "definitions.h"
#include "ui_profiledialog_ui.h"
-class ProfilesDialog : public QDialog {
+class ProfilesDialog : public QDialog
+{
Q_OBJECT
public:
// folder
ProjectItem::ProjectItem(QTreeWidget * parent, const QStringList & strings, const QString &clipId)
- : QTreeWidgetItem(parent, strings), m_clipType(FOLDER), m_clipId(clipId), m_clip(NULL), m_groupname(strings.at(1)) {
+ : QTreeWidgetItem(parent, strings), m_clipType(FOLDER), m_clipId(clipId), m_clip(NULL), m_groupname(strings.at(1))
+{
setSizeHint(0, QSize(65, 45));
setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled | Qt::ItemIsEditable);
setIcon(0, KIcon("folder"));
}
ProjectItem::ProjectItem(QTreeWidget * parent, DocClipBase *clip)
- : QTreeWidgetItem(parent) {
+ : QTreeWidgetItem(parent)
+{
setSizeHint(0, QSize(65, 45));
setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled | Qt::ItemIsEditable);
m_clip = clip;
}
ProjectItem::ProjectItem(QTreeWidgetItem * parent, DocClipBase *clip)
- : QTreeWidgetItem(parent) {
+ : QTreeWidgetItem(parent)
+{
setSizeHint(0, QSize(65, 45));
setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled | Qt::ItemIsEditable);
m_clip = clip;
}
-ProjectItem::~ProjectItem() {
+ProjectItem::~ProjectItem()
+{
}
-int ProjectItem::numReferences() const {
+int ProjectItem::numReferences() const
+{
if (!m_clip) return 0;
return m_clip->numReferences();
}
-const QString &ProjectItem::clipId() const {
+const QString &ProjectItem::clipId() const
+{
return m_clipId;
}
-CLIPTYPE ProjectItem::clipType() const {
+CLIPTYPE ProjectItem::clipType() const
+{
return m_clipType;
}
-int ProjectItem::clipMaxDuration() const {
+int ProjectItem::clipMaxDuration() const
+{
return m_clip->getProperty("duration").toInt();
}
-bool ProjectItem::isGroup() const {
+bool ProjectItem::isGroup() const
+{
return m_clipType == FOLDER;
}
-QStringList ProjectItem::names() const {
+QStringList ProjectItem::names() const
+{
QStringList result;
result.append(text(0));
result.append(text(1));
return result;
}
-QDomElement ProjectItem::toXml() const {
+QDomElement ProjectItem::toXml() const
+{
return m_clip->toXML();
}
-const KUrl ProjectItem::clipUrl() const {
+const KUrl ProjectItem::clipUrl() const
+{
if (m_clipType != COLOR && m_clipType != VIRTUAL && m_clipType != UNKNOWN && m_clipType != FOLDER)
return KUrl(m_clip->getProperty("resource"));
else return KUrl();
}
-void ProjectItem::changeDuration(int frames) {
+void ProjectItem::changeDuration(int frames)
+{
setData(1, DurationRole, Timecode::getEasyTimecode(GenTime(frames, KdenliveSettings::project_fps()), KdenliveSettings::project_fps()));
}
-void ProjectItem::setProperties(QMap <QString, QString> props) {
+void ProjectItem::setProperties(QMap <QString, QString> props)
+{
if (m_clip == NULL) return;
m_clip->setProperties(props);
}
-QString ProjectItem::getClipHash() const {
+QString ProjectItem::getClipHash() const
+{
if (m_clip == NULL) return QString();
return m_clip->getClipHash();
}
-void ProjectItem::setProperty(const QString &key, const QString &value) {
+void ProjectItem::setProperty(const QString &key, const QString &value)
+{
if (m_clip == NULL) return;
m_clip->setProperty(key, value);
}
-void ProjectItem::clearProperty(const QString &key) {
+void ProjectItem::clearProperty(const QString &key)
+{
if (m_clip == NULL) return;
m_clip->clearProperty(key);
}
-const QString ProjectItem::groupName() const {
+const QString ProjectItem::groupName() const
+{
return m_groupname;
}
-void ProjectItem::setGroupName(const QString name) {
+void ProjectItem::setGroupName(const QString name)
+{
m_groupname = name;
setText(1, name);
}
-DocClipBase *ProjectItem::referencedClip() {
+DocClipBase *ProjectItem::referencedClip()
+{
return m_clip;
}
-void ProjectItem::slotSetToolTip() {
+void ProjectItem::slotSetToolTip()
+{
QString tip = "<b>";
switch (m_clipType) {
case AUDIO:
}
-void ProjectItem::setProperties(const QMap < QString, QString > &attributes, const QMap < QString, QString > &metadata) {
+void ProjectItem::setProperties(const QMap < QString, QString > &attributes, const QMap < QString, QString > &metadata)
+{
if (m_clip == NULL) return;
//setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled);
if (attributes.contains("duration")) {
/** \brief Represents a clip or a folder in the projecttree
*
* This class represents a clip or folder in the projecttree and in the document(?) */
-class ProjectItem : public QTreeWidgetItem {
+class ProjectItem : public QTreeWidgetItem
+{
public:
/** Create folder item */
ProjectItem(QTreeWidget * parent, const QStringList & strings, const QString &clipId);
#include <QHeaderView>
ProjectList::ProjectList(QWidget *parent)
- : QWidget(parent), m_render(NULL), m_fps(-1), m_commandStack(NULL), m_selectedItem(NULL), m_infoQueue(QMap <QString, QDomElement> ()), m_thumbnailQueue(QList <QString> ()), m_refreshed(false), m_editAction(NULL), m_openAction(NULL), m_deleteAction(NULL), m_reloadAction(NULL) {
+ : QWidget(parent), m_render(NULL), m_fps(-1), m_commandStack(NULL), m_selectedItem(NULL), m_infoQueue(QMap <QString, QDomElement> ()), m_thumbnailQueue(QList <QString> ()), m_refreshed(false), m_editAction(NULL), m_openAction(NULL), m_deleteAction(NULL), m_reloadAction(NULL)
+{
listView = new ProjectListView(this);;
QVBoxLayout *layout = new QVBoxLayout;
}
}
-ProjectList::~ProjectList() {
+ProjectList::~ProjectList()
+{
delete m_menu;
delete m_toolbar;
}
-void ProjectList::setupMenu(QMenu *addMenu, QAction *defaultAction) {
+void ProjectList::setupMenu(QMenu *addMenu, QAction *defaultAction)
+{
QList <QAction *> actions = addMenu->actions();
for (int i = 0; i < actions.count(); i++) {
if (actions.at(i)->data().toString() == "clip_properties") {
m_menu->addActions(addMenu->actions());
}
-void ProjectList::setupGeneratorMenu(QMenu *addMenu) {
+void ProjectList::setupGeneratorMenu(QMenu *addMenu)
+{
if (!addMenu) return;
QMenu *menu = m_addButton->menu();
menu->addMenu(addMenu);
}
-QByteArray ProjectList::headerInfo() {
+QByteArray ProjectList::headerInfo()
+{
return listView->header()->saveState();
}
-void ProjectList::setHeaderInfo(const QByteArray &state) {
+void ProjectList::setHeaderInfo(const QByteArray &state)
+{
listView->header()->restoreState(state);
}
-void ProjectList::slotEditClip() {
+void ProjectList::slotEditClip()
+{
ProjectItem *item = static_cast <ProjectItem*>(listView->currentItem());
if (item && !item->isGroup()) {
emit clipSelected(item->referencedClip());
}
}
-void ProjectList::slotOpenClip() {
+void ProjectList::slotOpenClip()
+{
ProjectItem *item = static_cast <ProjectItem*>(listView->currentItem());
if (item && !item->isGroup()) {
if (item->clipType() == IMAGE) {
}
}
-void ProjectList::slotReloadClip() {
+void ProjectList::slotReloadClip()
+{
ProjectItem *item = static_cast <ProjectItem*>(listView->currentItem());
if (item && !item->isGroup()) {
if (item->clipType() == IMAGE) {
}
}
-void ProjectList::setRenderer(Render *projectRender) {
+void ProjectList::setRenderer(Render *projectRender)
+{
m_render = projectRender;
listView->setIconSize(QSize(40 * m_render->dar(), 40));
}
-void ProjectList::slotClipSelected() {
+void ProjectList::slotClipSelected()
+{
if (listView->currentItem()) {
ProjectItem *clip = static_cast <ProjectItem*>(listView->currentItem());
if (!clip->isGroup()) {
}
}
-void ProjectList::slotPauseMonitor() {
+void ProjectList::slotPauseMonitor()
+{
if (m_render) m_render->pause();
}
-void ProjectList::slotUpdateClipProperties(const QString &id, QMap <QString, QString> properties) {
+void ProjectList::slotUpdateClipProperties(const QString &id, QMap <QString, QString> properties)
+{
ProjectItem *item = getItemById(id);
if (item) {
slotUpdateClipProperties(item, properties);
}
}
-void ProjectList::slotUpdateClipProperties(ProjectItem *clip, QMap <QString, QString> properties) {
+void ProjectList::slotUpdateClipProperties(ProjectItem *clip, QMap <QString, QString> properties)
+{
if (!clip) return;
if (!clip->isGroup()) clip->setProperties(properties);
if (properties.contains("name")) {
}
}
-void ProjectList::slotItemEdited(QTreeWidgetItem *item, int column) {
+void ProjectList::slotItemEdited(QTreeWidgetItem *item, int column)
+{
ProjectItem *clip = static_cast <ProjectItem*>(item);
if (column == 2) {
if (clip->referencedClip()) {
}
}
-void ProjectList::slotContextMenu(const QPoint &pos, QTreeWidgetItem *item) {
+void ProjectList::slotContextMenu(const QPoint &pos, QTreeWidgetItem *item)
+{
bool enable = false;
if (item) {
enable = true;
m_menu->popup(pos);
}
-void ProjectList::slotRemoveClip() {
+void ProjectList::slotRemoveClip()
+{
if (!listView->currentItem()) return;
QList <QString> ids;
QMap <QString, QString> folderids;
}
}
-void ProjectList::selectItemById(const QString &clipId) {
+void ProjectList::selectItemById(const QString &clipId)
+{
ProjectItem *item = getItemById(clipId);
if (item) listView->setCurrentItem(item);
}
-void ProjectList::slotDeleteClip(const QString &clipId) {
+void ProjectList::slotDeleteClip(const QString &clipId)
+{
ProjectItem *item = getItemById(clipId);
if (!item) {
kDebug() << "/// Cannot find clip to delete";
}
-void ProjectList::editFolder(const QString folderName, const QString oldfolderName, const QString &clipId) {
+void ProjectList::editFolder(const QString folderName, const QString oldfolderName, const QString &clipId)
+{
EditFolderCommand *command = new EditFolderCommand(this, folderName, oldfolderName, clipId, false);
m_commandStack->push(command);
m_doc->setModified(true);
}
-void ProjectList::slotAddFolder() {
+void ProjectList::slotAddFolder()
+{
AddFolderCommand *command = new AddFolderCommand(this, i18n("Folder"), QString::number(m_doc->clipManager()->getFreeFolderId()), true);
m_commandStack->push(command);
}
-void ProjectList::slotAddFolder(const QString foldername, const QString &clipId, bool remove, bool edit) {
+void ProjectList::slotAddFolder(const QString foldername, const QString &clipId, bool remove, bool edit)
+{
if (remove) {
ProjectItem *item = getFolderItemById(clipId);
if (item) {
-void ProjectList::deleteProjectFolder(QMap <QString, QString> map) {
+void ProjectList::deleteProjectFolder(QMap <QString, QString> map)
+{
QMapIterator<QString, QString> i(map);
QUndoCommand *delCommand = new QUndoCommand();
delCommand->setText(i18n("Delete Folder"));
m_doc->setModified(true);
}
-void ProjectList::slotAddClip(DocClipBase *clip, bool getProperties) {
+void ProjectList::slotAddClip(DocClipBase *clip, bool getProperties)
+{
if (getProperties) listView->setEnabled(false);
listView->blockSignals(true);
const QString parent = clip->getProperty("groupid");
listView->blockSignals(false);
}
-void ProjectList::slotResetProjectList() {
+void ProjectList::slotResetProjectList()
+{
listView->clear();
emit clipSelected(NULL);
m_thumbnailQueue.clear();
m_refreshed = false;
}
-void ProjectList::requestClipInfo(const QDomElement xml, const QString id) {
+void ProjectList::requestClipInfo(const QDomElement xml, const QString id)
+{
kDebug() << " PRG LISTÂ REQUEST CLP INFO: " << id;
m_infoQueue.insert(id, xml);
listView->setEnabled(false);
if (m_infoQueue.count() == 1) QTimer::singleShot(300, this, SLOT(slotProcessNextClipInQueue()));
}
-void ProjectList::slotProcessNextClipInQueue() {
+void ProjectList::slotProcessNextClipInQueue()
+{
if (m_infoQueue.isEmpty()) {
listView->setEnabled(true);
return;
if (m_infoQueue.isEmpty()) listView->setEnabled(true);
}
-void ProjectList::slotUpdateClip(const QString &id) {
+void ProjectList::slotUpdateClip(const QString &id)
+{
ProjectItem *item = getItemById(id);
listView->blockSignals(true);
if (item) item->setData(1, UsageRole, QString::number(item->numReferences()));
listView->blockSignals(false);
}
-void ProjectList::updateAllClips() {
+void ProjectList::updateAllClips()
+{
QTreeWidgetItemIterator it(listView);
while (*it) {
ProjectItem *item = static_cast <ProjectItem *>(*it);
QTimer::singleShot(500, this, SLOT(slotCheckForEmptyQueue()));
}
-void ProjectList::slotAddClip(const QList <QUrl> givenList, QString group) {
+void ProjectList::slotAddClip(const QList <QUrl> givenList, QString group)
+{
if (!m_commandStack) kDebug() << "!!!!!!!!!!!!!!!! NO CMD STK";
KUrl::List list;
if (givenList.isEmpty()) {
m_doc->slotAddClipList(list, group, groupId);
}
-void ProjectList::slotRemoveInvalidClip(const QString &id) {
+void ProjectList::slotRemoveInvalidClip(const QString &id)
+{
ProjectItem *item = getItemById(id);
if (item) {
const QString path = item->referencedClip()->fileURL().path();
else listView->setEnabled(true);
}
-void ProjectList::slotAddColorClip() {
+void ProjectList::slotAddColorClip()
+{
if (!m_commandStack) kDebug() << "!!!!!!!!!!!!!!!! NO CMD STK";
QDialog *dia = new QDialog(this);
Ui::ColorClip_UI *dia_ui = new Ui::ColorClip_UI();
}
-void ProjectList::slotAddSlideshowClip() {
+void ProjectList::slotAddSlideshowClip()
+{
if (!m_commandStack) kDebug() << "!!!!!!!!!!!!!!!! NO CMD STK";
SlideshowClip *dia = new SlideshowClip(this);
delete dia;
}
-void ProjectList::slotAddTitleClip() {
+void ProjectList::slotAddTitleClip()
+{
QString group;
QString groupId;
ProjectItem *item = static_cast <ProjectItem*>(listView->currentItem());
m_doc->slotCreateTextClip(group, groupId);
}
-void ProjectList::setDocument(KdenliveDoc *doc) {
+void ProjectList::setDocument(KdenliveDoc *doc)
+{
listView->blockSignals(true);
listView->clear();
emit clipSelected(NULL);
m_toolbar->setEnabled(true);
}
-QDomElement ProjectList::producersList() {
+QDomElement ProjectList::producersList()
+{
QDomDocument doc;
QDomElement prods = doc.createElement("producerlist");
doc.appendChild(prods);
return prods;
}
-void ProjectList::slotCheckForEmptyQueue() {
+void ProjectList::slotCheckForEmptyQueue()
+{
if (!m_refreshed && m_thumbnailQueue.isEmpty() && m_infoQueue.isEmpty()) {
m_refreshed = true;
emit loadingIsOver();
} else QTimer::singleShot(500, this, SLOT(slotCheckForEmptyQueue()));
}
-void ProjectList::requestClipThumbnail(const QString &id) {
+void ProjectList::requestClipThumbnail(const QString &id)
+{
m_thumbnailQueue.append(id);
if (m_thumbnailQueue.count() == 1) QTimer::singleShot(300, this, SLOT(slotProcessNextThumbnail()));
}
-void ProjectList::slotProcessNextThumbnail() {
+void ProjectList::slotProcessNextThumbnail()
+{
if (m_thumbnailQueue.isEmpty()) {
return;
}
slotRefreshClipThumbnail(m_thumbnailQueue.takeFirst(), false);
}
-void ProjectList::slotRefreshClipThumbnail(const QString &clipId, bool update) {
+void ProjectList::slotRefreshClipThumbnail(const QString &clipId, bool update)
+{
ProjectItem *item = getItemById(clipId);
if (item) slotRefreshClipThumbnail(item, update);
else slotProcessNextThumbnail();
}
-void ProjectList::slotRefreshClipThumbnail(ProjectItem *item, bool update) {
+void ProjectList::slotRefreshClipThumbnail(ProjectItem *item, bool update)
+{
if (item) {
if (!item->referencedClip()) return;
int height = 50;
}
}
-void ProjectList::slotReplyGetFileProperties(const QString &clipId, Mlt::Producer *producer, const QMap < QString, QString > &properties, const QMap < QString, QString > &metadata, bool replace) {
+void ProjectList::slotReplyGetFileProperties(const QString &clipId, Mlt::Producer *producer, const QMap < QString, QString > &properties, const QMap < QString, QString > &metadata, bool replace)
+{
ProjectItem *item = getItemById(clipId);
if (item && producer) {
listView->blockSignals(true);
else listView->setEnabled(true);
}
-void ProjectList::slotReplyGetImage(const QString &clipId, const QPixmap &pix) {
+void ProjectList::slotReplyGetImage(const QString &clipId, const QPixmap &pix)
+{
ProjectItem *item = getItemById(clipId);
if (item) {
listView->blockSignals(true);
}
}
-ProjectItem *ProjectList::getItemById(const QString &id) {
+ProjectItem *ProjectList::getItemById(const QString &id)
+{
ProjectItem *item;
QTreeWidgetItemIterator it(listView);
while (*it) {
return NULL;
}
-ProjectItem *ProjectList::getFolderItemById(const QString &id) {
+ProjectItem *ProjectList::getFolderItemById(const QString &id)
+{
ProjectItem *item;
QTreeWidgetItemIterator it(listView);
while (*it) {
return NULL;
}
-void ProjectList::slotSelectClip(const QString &ix) {
+void ProjectList::slotSelectClip(const QString &ix)
+{
ProjectItem *clip = getItemById(ix);
if (clip) {
listView->setCurrentItem(clip);
#include "timecode.h"
#include "kdenlivesettings.h"
-namespace Mlt {
+namespace Mlt
+{
class Producer;
};
const int DurationRole = NameRole + 1;
const int UsageRole = NameRole + 2;
-class ItemDelegate: public QItemDelegate {
+class ItemDelegate: public QItemDelegate
+{
public:
ItemDelegate(QAbstractItemView* parent = 0): QItemDelegate(parent) {
}
}
};
-class ProjectList : public QWidget {
+class ProjectList : public QWidget
+{
Q_OBJECT
public:
#include <QAction>
ProjectListView::ProjectListView(QWidget *parent)
- : QTreeWidget(parent), m_dragStarted(false) {
+ : QTreeWidget(parent), m_dragStarted(false)
+{
setSelectionMode(QAbstractItemView::ExtendedSelection);
setDragDropMode(QAbstractItemView::DragDrop);
setDropIndicatorShown(true);
setSortingEnabled(true);
}
-ProjectListView::~ProjectListView() {
+ProjectListView::~ProjectListView()
+{
}
-void ProjectListView::configureColumns(const QPoint& pos) {
+void ProjectListView::configureColumns(const QPoint& pos)
+{
KMenu popup(this);
popup.addTitle(i18nc("@title:menu", "Columns"));
}
// virtual
-void ProjectListView::contextMenuEvent(QContextMenuEvent * event) {
+void ProjectListView::contextMenuEvent(QContextMenuEvent * event)
+{
emit requestMenu(event->globalPos(), itemAt(event->pos()));
}
// virtual
-void ProjectListView::mouseDoubleClickEvent(QMouseEvent * event) {
+void ProjectListView::mouseDoubleClickEvent(QMouseEvent * event)
+{
ProjectItem *item = static_cast <ProjectItem *>(itemAt(event->pos()));
if (!item) emit addClip();
else if (item->isGroup()) {
}
// virtual
-void ProjectListView::dragEnterEvent(QDragEnterEvent *event) {
+void ProjectListView::dragEnterEvent(QDragEnterEvent *event)
+{
if (event->mimeData()->hasUrls() || event->mimeData()->hasText()) {
kDebug() << "//////////////// DRAG ENTR OK";
}
}
// virtual
-void ProjectListView::dropEvent(QDropEvent *event) {
+void ProjectListView::dropEvent(QDropEvent *event)
+{
kDebug() << "//////////////// DROPPED EVENT";
if (event->mimeData()->hasUrls()) {
QTreeWidgetItem *item = itemAt(event->pos());
}
// virtual
-void ProjectListView::mousePressEvent(QMouseEvent *event) {
+void ProjectListView::mousePressEvent(QMouseEvent *event)
+{
if (event->button() == Qt::LeftButton) {
m_DragStartPosition = event->pos();
m_dragStarted = true;
// virtual
-void ProjectListView::mouseMoveEvent(QMouseEvent *event) {
+void ProjectListView::mouseMoveEvent(QMouseEvent *event)
+{
//kDebug() << "// DRAG STARTED, MOUSE MOVED: ";
if (!m_dragStarted) return;
}
// virtual
-void ProjectListView::dragMoveEvent(QDragMoveEvent * event) {
+void ProjectListView::dragMoveEvent(QDragMoveEvent * event)
+{
event->setDropAction(Qt::IgnoreAction);
event->setDropAction(Qt::MoveAction);
if (event->mimeData()->hasText()) {
emit pauseMonitor();
}
-QStringList ProjectListView::mimeTypes() const {
+QStringList ProjectListView::mimeTypes() const
+{
QStringList qstrList;
qstrList << QTreeWidget::mimeTypes();
// list of accepted mime types for drop
}
-Qt::DropActions ProjectListView::supportedDropActions() const {
+Qt::DropActions ProjectListView::supportedDropActions() const
+{
// returns what actions are supported when dropping
return Qt::MoveAction;
}
class KUrl;
-class ProjectListView : public QTreeWidget {
+class ProjectListView : public QTreeWidget
+{
Q_OBJECT
public:
#include <QDir>
-ProjectSettings::ProjectSettings(int videotracks, int audiotracks, const QString projectPath, bool readOnlyTracks, QWidget * parent): QDialog(parent), m_isCustomProfile(false) {
+ProjectSettings::ProjectSettings(int videotracks, int audiotracks, const QString projectPath, bool readOnlyTracks, QWidget * parent): QDialog(parent), m_isCustomProfile(false)
+{
m_view.setupUi(this);
QMap <QString, QString> profilesInfo = ProfilesDialog::getProfilesInfo();
}
-void ProjectSettings::slotUpdateDisplay() {
+void ProjectSettings::slotUpdateDisplay()
+{
QString currentProfile = m_view.profiles_list->itemData(m_view.profiles_list->currentIndex()).toString();
QMap< QString, QString > values = ProfilesDialog::getSettingsFromFile(currentProfile);
m_view.p_size->setText(values.value("width") + 'x' + values.value("height"));
else m_view.p_progressive->setText(i18n("Progressive"));
}
-void ProjectSettings::slotUpdateButton(const QString &path) {
+void ProjectSettings::slotUpdateButton(const QString &path)
+{
if (path.isEmpty()) buttonOk->setEnabled(false);
else buttonOk->setEnabled(true);
}
-QString ProjectSettings::selectedProfile() const {
+QString ProjectSettings::selectedProfile() const
+{
return m_view.profiles_list->itemData(m_view.profiles_list->currentIndex()).toString();
}
-KUrl ProjectSettings::selectedFolder() const {
+KUrl ProjectSettings::selectedFolder() const
+{
return m_view.project_folder->url();
}
-QPoint ProjectSettings::tracks() {
+QPoint ProjectSettings::tracks()
+{
QPoint p;
p.setX(m_view.video_tracks->value());
p.setY(m_view.audio_tracks->value());
return p;
}
-bool ProjectSettings::enableVideoThumbs() const {
+bool ProjectSettings::enableVideoThumbs() const
+{
return m_view.video_thumbs->isChecked();
}
-bool ProjectSettings::enableAudioThumbs() const {
+bool ProjectSettings::enableAudioThumbs() const
+{
return m_view.audio_thumbs->isChecked();
}
#include "ui_projectsettings_ui.h"
-class ProjectSettings : public QDialog {
+class ProjectSettings : public QDialog
+{
Q_OBJECT
public:
#include <KLocale>
-RazorClipCommand::RazorClipCommand(CustomTrackView *view, const ItemInfo info, const GenTime cutTime, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_info(info), m_cutTime(cutTime), m_doIt(doIt) {
+RazorClipCommand::RazorClipCommand(CustomTrackView *view, const ItemInfo info, const GenTime cutTime, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_info(info), m_cutTime(cutTime), m_doIt(doIt)
+{
setText(i18n("Razor clip"));
}
// virtual
-void RazorClipCommand::undo() {
+void RazorClipCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->cutClip(m_info, m_cutTime, false);
}
// virtual
-void RazorClipCommand::redo() {
+void RazorClipCommand::redo()
+{
// kDebug() << "---- redoing action cut: " << m_cutTime.frames(25);
if (m_doIt)
m_view->cutClip(m_info, m_cutTime, true);
class CustomTrackView;
-class RazorClipCommand : public QUndoCommand {
+class RazorClipCommand : public QUndoCommand
+{
public:
RazorClipCommand(CustomTrackView *view, const ItemInfo info, const GenTime cutTime, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
RecMonitor::RecMonitor(QString name, QWidget *parent)
- : QWidget(parent), m_name(name), m_isActive(false), m_isCapturing(false), m_isPlaying(false), m_didCapture(false) {
+ : QWidget(parent), m_name(name), m_isActive(false), m_isCapturing(false), m_isPlaying(false), m_didCapture(false)
+{
ui.setupUi(this);
ui.video_frame->setAttribute(Qt::WA_PaintOnScreen);
kDebug() << "/////// BUILDING MONITOR, ID: " << ui.video_frame->winId();
}
-RecMonitor::~RecMonitor() {
+RecMonitor::~RecMonitor()
+{
delete captureProcess;
delete displayProcess;
}
-QString RecMonitor::name() const {
+QString RecMonitor::name() const
+{
return m_name;
}
-void RecMonitor::slotConfigure() {
+void RecMonitor::slotConfigure()
+{
emit showConfigDialog(4, ui.device_selector->currentIndex());
}
-void RecMonitor::slotUpdateCaptureFolder() {
+void RecMonitor::slotUpdateCaptureFolder()
+{
if (captureProcess) captureProcess->setWorkingDirectory(KdenliveSettings::capturefolder());
slotVideoDeviceChanged(ui.device_selector->currentIndex());
}
-void RecMonitor::slotVideoDeviceChanged(int ix) {
+void RecMonitor::slotVideoDeviceChanged(int ix)
+{
switch (ix) {
case SCREENGRAB:
m_discAction->setEnabled(false);
}
}
-QPixmap RecMonitor::mergeSideBySide(const QPixmap& pix, const QString txt) {
+QPixmap RecMonitor::mergeSideBySide(const QPixmap& pix, const QString txt)
+{
QPainter p;
QRect r = p.fontMetrics().boundingRect(QRect(0, 0, ui.video_frame->width(), ui.video_frame->height()), Qt::AlignLeft, txt);
int strWidth = r.width();
}
-void RecMonitor::checkDeviceAvailability() {
+void RecMonitor::checkDeviceAvailability()
+{
if (!KIO::NetAccess::exists(KUrl(KdenliveSettings::video4vdevice()), KIO::NetAccess::SourceSide , this)) {
m_playAction->setEnabled(false);
m_recAction->setEnabled(false);
ui.video_frame->setPixmap(mergeSideBySide(KIcon("camera-web").pixmap(QSize(50, 50)), i18n("Press play or record button\nto start video capture\nFiles will be saved in:\n%1", KdenliveSettings::capturefolder())));
}
-void RecMonitor::slotDisconnect() {
+void RecMonitor::slotDisconnect()
+{
if (captureProcess->state() == QProcess::NotRunning) {
m_captureTime = KDateTime::currentLocalDateTime();
kDebug() << "CURRENT TIME: " << m_captureTime.toString();
}
}
-void RecMonitor::slotRewind() {
+void RecMonitor::slotRewind()
+{
captureProcess->write("a", 1);
}
-void RecMonitor::slotForward() {
+void RecMonitor::slotForward()
+{
captureProcess->write("z", 1);
}
-void RecMonitor::slotStopCapture() {
+void RecMonitor::slotStopCapture()
+{
// stop capture
switch (ui.device_selector->currentIndex()) {
case FIREWIRE:
}
}
-void RecMonitor::slotStartCapture(bool play) {
+void RecMonitor::slotStartCapture(bool play)
+{
/*
*captureProcess<<"dvgrab";
}
}
-void RecMonitor::slotRecord() {
+void RecMonitor::slotRecord()
+{
if (captureProcess->state() == QProcess::NotRunning && ui.device_selector->currentIndex() == FIREWIRE) {
slotStartCapture();
}
captureProcess->start("ffmpeg", m_captureArgs);
}*/
-void RecMonitor::slotProcessStatus(QProcess::ProcessState status) {
+void RecMonitor::slotProcessStatus(QProcess::ProcessState status)
+{
if (status == QProcess::NotRunning) {
displayProcess->kill();
if (m_isCapturing && ui.device_selector->currentIndex() != FIREWIRE)
}
}
-void RecMonitor::manageCapturedFiles() {
+void RecMonitor::manageCapturedFiles()
+{
QString extension;
switch (KdenliveSettings::firewireformat()) {
case 0:
}
// virtual
-void RecMonitor::mousePressEvent(QMouseEvent * /*event*/) {
+void RecMonitor::mousePressEvent(QMouseEvent * /*event*/)
+{
slotPlay();
}
-void RecMonitor::activateRecMonitor() {
+void RecMonitor::activateRecMonitor()
+{
//if (!m_isActive) m_monitorManager->activateRecMonitor(m_name);
}
-void RecMonitor::stop() {
+void RecMonitor::stop()
+{
m_isActive = false;
}
-void RecMonitor::start() {
+void RecMonitor::start()
+{
m_isActive = true;
}
-void RecMonitor::refreshRecMonitor(bool visible) {
+void RecMonitor::refreshRecMonitor(bool visible)
+{
if (visible) {
//if (!m_isActive) m_monitorManager->activateRecMonitor(m_name);
}
}
-void RecMonitor::slotPlay() {
+void RecMonitor::slotPlay()
+{
//if (!m_isActive) m_monitorManager->activateRecMonitor(m_name);
#include "smallruler.h"
#include "regiongrabber.h"
-class RecMonitor : public QWidget {
+class RecMonitor : public QWidget
+{
Q_OBJECT
public:
TLHandle(0, 0, handleSize, handleSize), TRHandle(0, 0, handleSize, handleSize),
BLHandle(0, 0, handleSize, handleSize), BRHandle(0, 0, handleSize, handleSize),
LHandle(0, 0, handleSize, handleSize), THandle(0, 0, handleSize, handleSize),
- RHandle(0, 0, handleSize, handleSize), BHandle(0, 0, handleSize, handleSize) {
+ RHandle(0, 0, handleSize, handleSize), BHandle(0, 0, handleSize, handleSize)
+{
handles << &TLHandle << &TRHandle << &BLHandle << &BRHandle
<< &LHandle << &THandle << &RHandle << &BHandle;
setMouseTracking(true);
idleTimer.start(3000);
}
-RegionGrabber::~RegionGrabber() {
+RegionGrabber::~RegionGrabber()
+{
}
-void RegionGrabber::init() {
+void RegionGrabber::init()
+{
pixmap = QPixmap::grabWindow(QApplication::desktop()->winId());
showFullScreen();
resize(pixmap.size());
setCursor(Qt::CrossCursor);
}
-void RegionGrabber::displayHelp() {
+void RegionGrabber::displayHelp()
+{
showHelp = true;
update();
}
-void RegionGrabber::paintEvent(QPaintEvent* e) {
+void RegionGrabber::paintEvent(QPaintEvent* e)
+{
Q_UNUSED(e);
if (grabbing) // grabWindow() should just get the background
return;
}
}
-void RegionGrabber::resizeEvent(QResizeEvent* e) {
+void RegionGrabber::resizeEvent(QResizeEvent* e)
+{
Q_UNUSED(e);
if (selection.isNull())
return;
selection = r;
}
-void RegionGrabber::mousePressEvent(QMouseEvent* e) {
+void RegionGrabber::mousePressEvent(QMouseEvent* e)
+{
showHelp = false;
idleTimer.stop();
if (e->button() == Qt::LeftButton) {
update();
}
-void RegionGrabber::mouseMoveEvent(QMouseEvent* e) {
+void RegionGrabber::mouseMoveEvent(QMouseEvent* e)
+{
if (mouseDown) {
if (newSelection) {
QPoint p = e->pos();
}
}
-void RegionGrabber::mouseReleaseEvent(QMouseEvent* e) {
+void RegionGrabber::mouseReleaseEvent(QMouseEvent* e)
+{
mouseDown = false;
newSelection = false;
idleTimer.start();
update();
}
-void RegionGrabber::mouseDoubleClickEvent(QMouseEvent*) {
+void RegionGrabber::mouseDoubleClickEvent(QMouseEvent*)
+{
grabRect();
}
-void RegionGrabber::keyPressEvent(QKeyEvent* e) {
+void RegionGrabber::keyPressEvent(QKeyEvent* e)
+{
if (e->key() == Qt::Key_Escape) {
emit regionGrabbed(QRect());
close();
}
}
-void RegionGrabber::grabRect() {
+void RegionGrabber::grabRect()
+{
QRect r = selection.normalized();
if (!r.isNull() && r.isValid()) {
grabbing = true;
close();
}
-void RegionGrabber::updateHandles() {
+void RegionGrabber::updateHandles()
+{
QRect r = selection.normalized().adjusted(0, 0, -1, -1);
int s2 = handleSize / 2;
BHandle.moveBottomLeft(QPoint(r.x() + r.width() / 2 - s2, r.bottom()));
}
-QRegion RegionGrabber::handleMask() const {
+QRegion RegionGrabber::handleMask() const
+{
// note: not normalized QRects are bad here, since they will not be drawn
QRegion mask;
foreach(const QRect* rect, handles) mask += QRegion(*rect);
return mask;
}
-QPoint RegionGrabber::limitPointToRect(const QPoint &p, const QRect &r) const {
+QPoint RegionGrabber::limitPointToRect(const QPoint &p, const QRect &r) const
+{
QPoint q;
q.setX(p.x() < r.x() ? r.x() : p.x() < r.right() ? p.x() : r.right());
q.setY(p.y() < r.y() ? r.y() : p.y() < r.bottom() ? p.y() : r.bottom());
class QResizeEvent;
class QMouseEvent;
-class RegionGrabber : public QWidget {
+class RegionGrabber : public QWidget
+{
Q_OBJECT
public:
RegionGrabber();
#include <stdlib.h>
-static void consumer_frame_show(mlt_consumer, Render * self, mlt_frame frame_ptr) {
+static void consumer_frame_show(mlt_consumer, Render * self, mlt_frame frame_ptr)
+{
// detect if the producer has finished playing. Is there a better way to do it ?
if (self->m_isBlocked) return;
if (mlt_properties_get_double(MLT_FRAME_PROPERTIES(frame_ptr), "_speed") == 0.0) {
}
}
-Render::Render(const QString & rendererName, int winid, int extid, QWidget *parent): QObject(parent), m_name(rendererName), m_mltConsumer(NULL), m_mltProducer(NULL), m_mltTextProducer(NULL), m_winid(winid), m_externalwinid(extid), m_framePosition(0), m_isBlocked(true), m_blackClip(NULL), m_isSplitView(false), m_isZoneMode(false), m_isLoopMode(false) {
+Render::Render(const QString & rendererName, int winid, int extid, QWidget *parent): QObject(parent), m_name(rendererName), m_mltConsumer(NULL), m_mltProducer(NULL), m_mltTextProducer(NULL), m_winid(winid), m_externalwinid(extid), m_framePosition(0), m_isBlocked(true), m_blackClip(NULL), m_isSplitView(false), m_isZoneMode(false), m_isLoopMode(false)
+{
kDebug() << "////////// USINGÂ PROFILE: " << (char*)KdenliveSettings::current_profile().toUtf8().data();
refreshTimer = new QTimer(this);
connect(refreshTimer, SIGNAL(timeout()), this, SLOT(refresh()));
m_mltProducer->set_speed(0.0);
}
-Render::~Render() {
+Render::~Render()
+{
closeMlt();
}
-void Render::closeMlt() {
+void Render::closeMlt()
+{
delete osdTimer;
delete refreshTimer;
if (m_mltConsumer)
}
-void Render::buildConsumer() {
+void Render::buildConsumer()
+{
char *tmp;
m_activeProfile = KdenliveSettings::current_profile();
tmp = decodedString(m_activeProfile);
}
-int Render::resetProfile() {
+int Render::resetProfile()
+{
if (!m_mltConsumer) return 0;
if (m_activeProfile == KdenliveSettings::current_profile()) {
kDebug() << "reset to same profile, nothing to do";
}
/** Wraps the VEML command of the same name; Seeks the renderer clip to the given time. */
-void Render::seek(GenTime time) {
+void Render::seek(GenTime time)
+{
if (!m_mltProducer)
return;
m_isBlocked = false;
}
//static
-char *Render::decodedString(QString str) {
+char *Render::decodedString(QString str)
+{
/*QCString fn = QFile::encodeName(str);
char *t = new char[fn.length() + 1];
strcpy(t, (const char *)fn);*/
return pix;
}
*/
-int Render::renderWidth() const {
+int Render::renderWidth() const
+{
return (int)(m_mltProfile->height() * m_mltProfile->dar());
}
-int Render::renderHeight() const {
+int Render::renderHeight() const
+{
return m_mltProfile->height();
}
-QPixmap Render::extractFrame(int frame_position, int width, int height) {
+QPixmap Render::extractFrame(int frame_position, int width, int height)
+{
if (width == -1) {
width = renderWidth();
height = renderHeight();
return KThumb::getFrame(m_mltProducer, frame_position, width, height);
}
-QPixmap Render::getImageThumbnail(KUrl url, int /*width*/, int /*height*/) {
+QPixmap Render::getImageThumbnail(KUrl url, int /*width*/, int /*height*/)
+{
QImage im;
QPixmap pixmap;
if (url.fileName().startsWith(".all.")) { // check for slideshow
}*/
-double Render::consumerRatio() const {
+double Render::consumerRatio() const
+{
if (!m_mltConsumer) return 1.0;
return (m_mltConsumer->get_double("aspect_ratio_num") / m_mltConsumer->get_double("aspect_ratio_den"));
}
-int Render::getLength() {
+int Render::getLength()
+{
if (m_mltProducer) {
// kDebug()<<"////// LENGTH: "<<mlt_producer_get_playtime(m_mltProducer->get_producer());
return 0;
}
-bool Render::isValid(KUrl url) {
+bool Render::isValid(KUrl url)
+{
char *tmp = decodedString(url.path());
Mlt::Producer producer(*m_mltProfile, tmp);
delete[] tmp;
return true;
}
-double Render::dar() const {
+double Render::dar() const
+{
return m_mltProfile->dar();
}
-void Render::slotSplitView(bool doit) {
+void Render::slotSplitView(bool doit)
+{
m_isSplitView = doit;
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
}
}
-void Render::getFileProperties(const QDomElement &xml, const QString &clipId, bool replaceProducer) {
+void Render::getFileProperties(const QDomElement &xml, const QString &clipId, bool replaceProducer)
+{
KUrl url = KUrl(xml.attribute("resource", QString()));
Mlt::Producer *producer = NULL;
if (xml.attribute("type").toInt() == TEXT && !QFile::exists(url.path())) {
/** Create the producer from the Westley QDomDocument */
#if 0
-void Render::initSceneList() {
+void Render::initSceneList()
+{
kDebug() << "-------- INIT SCENE LIST ------_";
QDomDocument doc;
QDomElement westley = doc.createElement("westley");
/** Create the producer from the Westley QDomDocument */
-void Render::setProducer(Mlt::Producer *producer, int position) {
+void Render::setProducer(Mlt::Producer *producer, int position)
+{
if (m_winid == -1) return;
if (m_mltConsumer) {
/** Create the producer from the Westley QDomDocument */
-void Render::setSceneList(QDomDocument list, int position) {
+void Render::setSceneList(QDomDocument list, int position)
+{
setSceneList(list.toString(), position);
}
/** Create the producer from the Westley QDomDocument */
-void Render::setSceneList(QString playlist, int position) {
+void Render::setSceneList(QString playlist, int position)
+{
if (m_winid == -1) return;
m_isBlocked = true;
m_slowmotionProducers.clear();
}
/** Create the producer from the Westley QDomDocument */
-const QString Render::sceneList() {
+const QString Render::sceneList()
+{
QString playlist;
Mlt::Consumer westleyConsumer(*m_mltProfile , "westley:kdenlive_playlist");
m_mltProducer->optimise();
return playlist;
}
-bool Render::saveSceneList(QString path, QDomElement kdenliveData) {
+bool Render::saveSceneList(QString path, QDomElement kdenliveData)
+{
QFile file(path);
QDomDocument doc;
doc.setContent(sceneList(), false);
}
-void Render::saveZone(KUrl url, QString desc, QPoint zone) {
+void Render::saveZone(KUrl url, QString desc, QPoint zone)
+{
kDebug() << "// SAVING CLIP ZONE, RENDER: " << m_name;
char *tmppath = decodedString("westley:" + url.path());
Mlt::Consumer westleyConsumer(*m_mltProfile , tmppath);
westleyConsumer.start();
}
-double Render::fps() const {
+double Render::fps() const
+{
return m_fps;
}
-void Render::connectPlaylist() {
+void Render::connectPlaylist()
+{
if (!m_mltConsumer) return;
//m_mltConsumer->set("refresh", "0");
m_mltConsumer->connect(*m_mltProducer);
}*/
}
-void Render::refreshDisplay() {
+void Render::refreshDisplay()
+{
if (!m_mltProducer) return;
//m_mltConsumer->set("refresh", 0);
refresh();
}
-void Render::setVolume(double /*volume*/) {
+void Render::setVolume(double /*volume*/)
+{
if (!m_mltConsumer || !m_mltProducer) return;
/*osdTimer->stop();
m_mltConsumer->set("refresh", 0);
osdTimer->setSingleShot(2500);
}
-void Render::slotOsdTimeout() {
+void Render::slotOsdTimeout()
+{
mlt_properties properties = MLT_PRODUCER_PROPERTIES(m_mltProducer->get_producer());
mlt_properties_set_int(properties, "meta.attr.osdvolume", 0);
mlt_properties_set(properties, "meta.attr.osdvolume.markup", NULL);
refresh();
}
-void Render::start() {
+void Render::start()
+{
kDebug() << "----- STARTING MONITOR: " << m_name;
if (m_winid == -1) {
kDebug() << "----- BROKEN MONITOR: " << m_name << ", RESTART";
m_isBlocked = false;
}
-void Render::clear() {
+void Render::clear()
+{
kDebug() << " ********* RENDER CLEAR";
if (m_mltConsumer) {
//m_mltConsumer->set("refresh", 0);
}
}
-void Render::stop() {
+void Render::stop()
+{
if (m_mltConsumer && !m_mltConsumer->is_stopped()) {
kDebug() << "///////////// RENDER STOPPED: " << m_name;
m_isBlocked = true;
kDebug() << "///////////// RENDER STOP3-------";
}
-void Render::stop(const GenTime & startTime) {
+void Render::stop(const GenTime & startTime)
+{
kDebug() << "///////////// RENDER STOP-------2";
if (m_mltProducer) {
m_mltConsumer->purge();
}
-void Render::pause() {
+void Render::pause()
+{
if (!m_mltProducer || !m_mltConsumer)
return;
if (m_mltProducer->get_speed() == 0.0) return;
m_mltConsumer->purge();
}
-void Render::switchPlay() {
+void Render::switchPlay()
+{
if (!m_mltProducer || !m_mltConsumer)
return;
if (m_isZoneMode) resetZoneMode();
//refresh();
}
-void Render::play(double speed) {
+void Render::play(double speed)
+{
if (!m_mltProducer)
return;
// if (speed == 0.0) m_mltProducer->set("out", m_mltProducer->get_length() - 1);
refresh();
}
-void Render::play(const GenTime & startTime) {
+void Render::play(const GenTime & startTime)
+{
if (!m_mltProducer || !m_mltConsumer)
return;
m_isBlocked = false;
m_mltConsumer->set("refresh", 1);
}
-void Render::loopZone(const GenTime & startTime, const GenTime & stopTime) {
+void Render::loopZone(const GenTime & startTime, const GenTime & stopTime)
+{
if (!m_mltProducer || !m_mltConsumer)
return;
//m_mltProducer->set("eof", "loop");
playZone(startTime, stopTime);
}
-void Render::playZone(const GenTime & startTime, const GenTime & stopTime) {
+void Render::playZone(const GenTime & startTime, const GenTime & stopTime)
+{
if (!m_mltProducer || !m_mltConsumer)
return;
m_isBlocked = false;
m_isZoneMode = true;
}
-void Render::resetZoneMode() {
+void Render::resetZoneMode()
+{
if (!m_isZoneMode && !m_isLoopMode) return;
m_mltProducer->set("out", m_originalOut);
//m_mltProducer->set("eof", "pause");
m_isLoopMode = false;
}
-void Render::seekToFrame(int pos) {
+void Render::seekToFrame(int pos)
+{
//kDebug()<<" ********* RENDER SEEK TO POS";
if (!m_mltProducer)
return;
refresh();
}
-void Render::askForRefresh() {
+void Render::askForRefresh()
+{
// Use a Timer so that we don't refresh too much
refreshTimer->start(200);
}
-void Render::doRefresh() {
+void Render::doRefresh()
+{
// Use a Timer so that we don't refresh too much
if (!m_isBlocked && m_mltConsumer) m_mltConsumer->set("refresh", 1);
}
-void Render::refresh() {
+void Render::refresh()
+{
if (!m_mltProducer || m_isBlocked)
return;
refreshTimer->stop();
}
}
-double Render::playSpeed() {
+double Render::playSpeed()
+{
if (m_mltProducer) return m_mltProducer->get_speed();
return 0.0;
}
-GenTime Render::seekPosition() const {
+GenTime Render::seekPosition() const
+{
if (m_mltProducer) return GenTime((int) m_mltProducer->position(), m_fps);
else return GenTime();
}
-const QString & Render::rendererName() const {
+const QString & Render::rendererName() const
+{
return m_name;
}
-void Render::emitFrameNumber(double position) {
+void Render::emitFrameNumber(double position)
+{
m_framePosition = position;
emit rendererPosition((int) position);
//if (qApp->activeWindow()) QApplication::postEvent(qApp->activeWindow(), new PositionChangeEvent( GenTime((int) position, m_fps), m_monitorId));
}
-void Render::emitConsumerStopped() {
+void Render::emitConsumerStopped()
+{
// This is used to know when the playing stopped
if (m_mltProducer) {
double pos = m_mltProducer->position();
-void Render::exportFileToFirewire(QString /*srcFileName*/, int /*port*/, GenTime /*startTime*/, GenTime /*endTime*/) {
+void Render::exportFileToFirewire(QString /*srcFileName*/, int /*port*/, GenTime /*startTime*/, GenTime /*endTime*/)
+{
KMessageBox::sorry(0, i18n("Firewire is not enabled on your system.\n Please install Libiec61883 and recompile Kdenlive"));
}
-void Render::exportCurrentFrame(KUrl url, bool /*notify*/) {
+void Render::exportCurrentFrame(KUrl url, bool /*notify*/)
+{
if (!m_mltProducer) {
KMessageBox::sorry(qApp->activeWindow(), i18n("There is no clip, cannot extract frame."));
return;
/** MLT PLAYLIST DIRECT MANIPULATON **/
-void Render::mltCheckLength() {
+void Render::mltCheckLength()
+{
//kDebug()<<"checking track length: "<<track<<"..........";
Mlt::Service service(m_mltProducer->get_service());
}
}
-void Render::mltInsertClip(ItemInfo info, QDomElement element, Mlt::Producer *prod) {
+void Render::mltInsertClip(ItemInfo info, QDomElement element, Mlt::Producer *prod)
+{
if (!m_mltProducer) {
kDebug() << "PLAYLISTÂ NOT INITIALISED //////";
return;
}
-void Render::mltCutClip(int track, GenTime position) {
+void Render::mltCutClip(int track, GenTime position)
+{
m_isBlocked = true;
m_isBlocked = false;
}
-void Render::mltUpdateClip(ItemInfo info, QDomElement element, Mlt::Producer *prod) {
+void Render::mltUpdateClip(ItemInfo info, QDomElement element, Mlt::Producer *prod)
+{
// TODO: optimize
mltRemoveClip(info.track, info.startPos);
mltInsertClip(info, element, prod);
}
-bool Render::mltRemoveClip(int track, GenTime position) {
+bool Render::mltRemoveClip(int track, GenTime position)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
if (service.type() != tractor_type) kWarning() << "// TRACTOR PROBLEM";
return true;
}
-int Render::mltGetSpaceLength(const GenTime pos, int track, bool fromBlankStart) {
+int Render::mltGetSpaceLength(const GenTime pos, int track, bool fromBlankStart)
+{
if (!m_mltProducer) {
kDebug() << "PLAYLISTÂ NOT INITIALISED //////";
return -1;
return trackPlaylist.clip_length(clipIndex) + trackPlaylist.clip_start(clipIndex) - insertPos;
}
-int Render::mltTrackDuration(int track) {
+int Render::mltTrackDuration(int track)
+{
if (!m_mltProducer) {
kDebug() << "PLAYLISTÂ NOT INITIALISED //////";
return -1;
return trackProducer.get_playtime() - 1;
}
-void Render::mltInsertSpace(QMap <int, int> trackClipStartList, QMap <int, int> trackTransitionStartList, int track, const GenTime duration, const GenTime timeOffset) {
+void Render::mltInsertSpace(QMap <int, int> trackClipStartList, QMap <int, int> trackTransitionStartList, int track, const GenTime duration, const GenTime timeOffset)
+{
if (!m_mltProducer) {
kDebug() << "PLAYLISTÂ NOT INITIALISED //////";
return;
m_mltConsumer->set("refresh", 1);
}
-int Render::mltChangeClipSpeed(ItemInfo info, double speed, double oldspeed, Mlt::Producer *prod) {
+int Render::mltChangeClipSpeed(ItemInfo info, double speed, double oldspeed, Mlt::Producer *prod)
+{
m_isBlocked = true;
int newLength = 0;
Mlt::Service service(m_mltProducer->parent().get_service());
return newLength;
}
-bool Render::mltRemoveEffect(int track, GenTime position, QString index, bool updateIndex, bool doRefresh) {
+bool Render::mltRemoveEffect(int track, GenTime position, QString index, bool updateIndex, bool doRefresh)
+{
kDebug() << "// TRYing to remove effect at: " << index;
Mlt::Service service(m_mltProducer->parent().get_service());
bool success = false;
}
-bool Render::mltAddEffect(int track, GenTime position, EffectsParameterList params, bool doRefresh) {
+bool Render::mltAddEffect(int track, GenTime position, EffectsParameterList params, bool doRefresh)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
return true;
}
-bool Render::mltEditEffect(int track, GenTime position, EffectsParameterList params) {
+bool Render::mltEditEffect(int track, GenTime position, EffectsParameterList params)
+{
QString index = params.paramValue("kdenlive_ix");
QString tag = params.paramValue("tag");
return true;
}
-void Render::mltMoveEffect(int track, GenTime position, int oldPos, int newPos) {
+void Render::mltMoveEffect(int track, GenTime position, int oldPos, int newPos)
+{
kDebug() << "MOVINGÂ EFFECTÂ FROMÂ " << oldPos << ", TO: " << newPos;
Mlt::Service service(m_mltProducer->parent().get_service());
refresh();
}
-bool Render::mltResizeClipEnd(ItemInfo info, GenTime clipDuration) {
+bool Render::mltResizeClipEnd(ItemInfo info, GenTime clipDuration)
+{
m_isBlocked = true;
Mlt::Service service(m_mltProducer->parent().get_service());
return true;
}
-void Render::mltChangeTrackState(int track, bool mute, bool blind) {
+void Render::mltChangeTrackState(int track, bool mute, bool blind)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
Mlt::Producer trackProducer(tractor.track(track));
}
-bool Render::mltResizeClipCrop(ItemInfo info, GenTime diff) {
+bool Render::mltResizeClipCrop(ItemInfo info, GenTime diff)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
int frameOffset = (int) diff.frames(m_fps);
Mlt::Tractor tractor(service);
return true;
}
-bool Render::mltResizeClipStart(ItemInfo info, GenTime diff) {
+bool Render::mltResizeClipStart(ItemInfo info, GenTime diff)
+{
//kDebug() << "//////// RSIZING CLIP from: "<<info.startPos.frames(25)<<" to "<<diff.frames(25);
Mlt::Service service(m_mltProducer->parent().get_service());
int moveFrame = (int) diff.frames(m_fps);
return true;
}
-bool Render::mltMoveClip(int startTrack, int endTrack, GenTime moveStart, GenTime moveEnd, Mlt::Producer *prod) {
+bool Render::mltMoveClip(int startTrack, int endTrack, GenTime moveStart, GenTime moveEnd, Mlt::Producer *prod)
+{
return mltMoveClip(startTrack, endTrack, (int) moveStart.frames(m_fps), (int) moveEnd.frames(m_fps), prod);
}
-void Render::mltUpdateClipProducer(int track, int pos, Mlt::Producer *prod) {
+void Render::mltUpdateClipProducer(int track, int pos, Mlt::Producer *prod)
+{
if (prod == NULL || !prod->is_valid()) {
kDebug() << "// Warning, CLIP on track " << track << ", at: " << pos << " is invalid, cannot update it!!!";
return;
m_isBlocked = false;
}
-bool Render::mltMoveClip(int startTrack, int endTrack, int moveStart, int moveEnd, Mlt::Producer *prod) {
+bool Render::mltMoveClip(int startTrack, int endTrack, int moveStart, int moveEnd, Mlt::Producer *prod)
+{
m_isBlocked = true;
m_mltConsumer->set("refresh", 0);
return true;
}
-bool Render::mltMoveTransition(QString type, int startTrack, int newTrack, int newTransitionTrack, GenTime oldIn, GenTime oldOut, GenTime newIn, GenTime newOut) {
+bool Render::mltMoveTransition(QString type, int startTrack, int newTrack, int newTransitionTrack, GenTime oldIn, GenTime oldOut, GenTime newIn, GenTime newOut)
+{
int new_in = (int)newIn.frames(m_fps);
int new_out = (int)newOut.frames(m_fps) - 1;
if (new_in >= new_out) return false;
return true;
}
-void Render::mltUpdateTransition(QString oldTag, QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml) {
+void Render::mltUpdateTransition(QString oldTag, QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml)
+{
// kDebug() << "update transition" << tag << " at pos " << in.frames(25);
if (oldTag == tag) mltUpdateTransitionParams(tag, a_track, b_track, in, out, xml);
else {
//mltSavePlaylist();
}
-void Render::mltUpdateTransitionParams(QString type, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml) {
+void Render::mltUpdateTransitionParams(QString type, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml)
+{
m_isBlocked = true;
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
m_mltConsumer->set("refresh", 1);
}
-void Render::mltDeleteTransition(QString tag, int /*a_track*/, int b_track, GenTime in, GenTime out, QDomElement /*xml*/, bool /*do_refresh*/) {
+void Render::mltDeleteTransition(QString tag, int /*a_track*/, int b_track, GenTime in, GenTime out, QDomElement /*xml*/, bool /*do_refresh*/)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
Mlt::Field *field = tractor.field();
//if (do_refresh) m_mltConsumer->set("refresh", 1);
}
-QMap<QString, QString> Render::mltGetTransitionParamsFromXml(QDomElement xml) {
+QMap<QString, QString> Render::mltGetTransitionParamsFromXml(QDomElement xml)
+{
QDomNodeList attribs = xml.elementsByTagName("parameter");
QMap<QString, QString> map;
for (int i = 0;i < attribs.count();i++) {
return map;
}
-void Render::mltAddClipTransparency(ItemInfo info, int transitiontrack, int id) {
+void Render::mltAddClipTransparency(ItemInfo info, int transitiontrack, int id)
+{
kDebug() << "///////// ADDING CLIP TRANSPARENCY AT: " << info.startPos.frames(25);
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
refresh();
}
-void Render::mltDeleteTransparency(int pos, int track, int id) {
+void Render::mltDeleteTransparency(int pos, int track, int id)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
Mlt::Field *field = tractor.field();
//if (do_refresh) m_mltConsumer->set("refresh", 1);
}
-void Render::mltResizeTransparency(int oldStart, int newStart, int newEnd, int track, int id) {
+void Render::mltResizeTransparency(int oldStart, int newStart, int newEnd, int track, int id)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
}
-void Render::mltMoveTransparency(int startTime, int endTime, int startTrack, int endTrack, int id) {
+void Render::mltMoveTransparency(int startTime, int endTime, int startTrack, int endTrack, int id)
+{
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Tractor tractor(service);
}
-bool Render::mltAddTransition(QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml, bool /*do_refresh*/) {
+bool Render::mltAddTransition(QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml, bool /*do_refresh*/)
+{
if (in >= out) return false;
QMap<QString, QString> args = mltGetTransitionParamsFromXml(xml);
Mlt::Service service(m_mltProducer->parent().get_service());
return true;
}
-void Render::mltSavePlaylist() {
+void Render::mltSavePlaylist()
+{
kWarning() << "// UPDATING PLAYLIST TO DISK++++++++++++++++";
Mlt::Consumer fileConsumer(*m_mltProfile, "westley");
fileConsumer.set("resource", "/tmp/playlist.westley");
fileConsumer.start();
}
-QList <Mlt::Producer *> Render::producersList() {
+QList <Mlt::Producer *> Render::producersList()
+{
QList <Mlt::Producer *> prods;
Mlt::Service service(m_mltProducer->parent().get_service());
if (service.type() != tractor_type) return prods;
return prods;
}
-void Render::fillSlowMotionProducers() {
+void Render::fillSlowMotionProducers()
+{
Mlt::Service service(m_mltProducer->parent().get_service());
if (service.type() != tractor_type) return;
}
}
-void Render::mltInsertTrack(int ix, bool videoTrack) {
+void Render::mltInsertTrack(int ix, bool videoTrack)
+{
blockSignals(true);
m_isBlocked = true;
}
-void Render::mltDeleteTrack(int ix) {
+void Render::mltDeleteTrack(int ix)
+{
QDomDocument doc;
doc.setContent(sceneList(), false);
int tracksCount = doc.elementsByTagName("track").count() - 1;
}
-void Render::updatePreviewSettings() {
+void Render::updatePreviewSettings()
+{
kDebug() << "////// RESTARTING CONSUMER";
if (!m_mltConsumer || !m_mltProducer) return;
if (m_mltProducer->get_playtime() == 0) return;
class QTimer;
class QPixmap;
-namespace Mlt {
+namespace Mlt
+{
class Consumer;
class Playlist;
class Tractor;
-class Render: public QObject {
+class Render: public QObject
+{
Q_OBJECT public:
enum FailStates { OK = 0,
const int MetaGroupRole = GroupRole + 6;
const int ExtraRole = GroupRole + 7;
-RenderWidget::RenderWidget(const QString &projectfolder, QWidget * parent): QDialog(parent), m_projectFolder(projectfolder) {
+RenderWidget::RenderWidget(const QString &projectfolder, QWidget * parent): QDialog(parent), m_projectFolder(projectfolder)
+{
m_view.setupUi(this);
setWindowTitle(i18n("Rendering"));
m_view.buttonDelete->setIcon(KIcon("trash-empty"));
focusFirstVisibleItem();
}
-void RenderWidget::slotEditItem(QListWidgetItem *item) {
+void RenderWidget::slotEditItem(QListWidgetItem *item)
+{
QString edit = item->data(EditableRole).toString();
if (edit.isEmpty() || !edit.endsWith("customprofiles.xml")) slotSaveProfile();
else slotEditProfile();
}
-void RenderWidget::showInfoPanel() {
+void RenderWidget::showInfoPanel()
+{
if (m_view.advanced_params->isVisible()) {
m_view.advanced_params->setVisible(false);
m_view.buttonInfo->setDown(false);
}
}
-void RenderWidget::setDocumentPath(const QString path) {
+void RenderWidget::setDocumentPath(const QString path)
+{
m_projectFolder = path;
const QString fileName = m_view.out_file->url().fileName();
m_view.out_file->setUrl(KUrl(m_projectFolder + '/' + fileName));
parseScriptFiles();
}
-void RenderWidget::slotUpdateGuideBox() {
+void RenderWidget::slotUpdateGuideBox()
+{
m_view.guides_box->setVisible(m_view.render_guide->isChecked());
}
-void RenderWidget::slotCheckStartGuidePosition() {
+void RenderWidget::slotCheckStartGuidePosition()
+{
if (m_view.guide_start->currentIndex() > m_view.guide_end->currentIndex())
m_view.guide_start->setCurrentIndex(m_view.guide_end->currentIndex());
}
-void RenderWidget::slotCheckEndGuidePosition() {
+void RenderWidget::slotCheckEndGuidePosition()
+{
if (m_view.guide_end->currentIndex() < m_view.guide_start->currentIndex())
m_view.guide_end->setCurrentIndex(m_view.guide_start->currentIndex());
}
-void RenderWidget::setGuides(QDomElement guidesxml, double duration) {
+void RenderWidget::setGuides(QDomElement guidesxml, double duration)
+{
m_view.guide_start->clear();
m_view.guide_end->clear();
QDomNodeList nodes = guidesxml.elementsByTagName("guide");
// Will be called when the user selects an output file via the file dialog.
// File extension will be added automatically.
-void RenderWidget::slotUpdateButtons(KUrl url) {
+void RenderWidget::slotUpdateButtons(KUrl url)
+{
if (m_view.out_file->url().isEmpty()) m_view.buttonStart->setEnabled(false);
else m_view.buttonStart->setEnabled(true);
if (url != 0) {
// Will be called when the user changes the output file path in the text line.
// File extension must NOT be added, would make editing impossible!
-void RenderWidget::slotUpdateButtons() {
+void RenderWidget::slotUpdateButtons()
+{
if (m_view.out_file->url().isEmpty()) m_view.buttonStart->setEnabled(false);
else m_view.buttonStart->setEnabled(true);
}
-void RenderWidget::slotSaveProfile() {
+void RenderWidget::slotSaveProfile()
+{
//TODO: update to correctly use metagroups
Ui::SaveProfile_UI ui;
QDialog *d = new QDialog(this);
delete d;
}
-void RenderWidget::slotEditProfile() {
+void RenderWidget::slotEditProfile()
+{
QListWidgetItem *item = m_view.size_list->currentItem();
if (!item) return;
QString currentGroup = m_view.format_list->currentItem()->text();
} else delete d;
}
-void RenderWidget::slotDeleteProfile(bool refresh) {
+void RenderWidget::slotDeleteProfile(bool refresh)
+{
//TODO: delete a profile installed by KNewStuff the easy way
/*
QString edit = m_view.size_list->currentItem()->data(EditableRole).toString();
}
}
-void RenderWidget::updateButtons() {
+void RenderWidget::updateButtons()
+{
if (!m_view.size_list->currentItem() || m_view.size_list->currentItem()->isHidden()) {
m_view.buttonSave->setEnabled(false);
m_view.buttonDelete->setEnabled(false);
}
-void RenderWidget::focusFirstVisibleItem() {
+void RenderWidget::focusFirstVisibleItem()
+{
if (m_view.size_list->currentItem() && !m_view.size_list->currentItem()->isHidden()) {
updateButtons();
return;
updateButtons();
}
-void RenderWidget::slotExport(bool scriptExport) {
+void RenderWidget::slotExport(bool scriptExport)
+{
QListWidgetItem *item = m_view.size_list->currentItem();
if (!item) return;
}
}
-void RenderWidget::setProfile(MltVideoProfile profile) {
+void RenderWidget::setProfile(MltVideoProfile profile)
+{
m_profile = profile;
//WARNING: this way to tell the video standard is a bit hackish...
if (m_profile.description.contains("pal", Qt::CaseInsensitive) || m_profile.description.contains("25", Qt::CaseInsensitive) || m_profile.description.contains("50", Qt::CaseInsensitive)) m_view.format_selection->setCurrentIndex(0);
refreshView();
}
-void RenderWidget::refreshView() {
+void RenderWidget::refreshView()
+{
m_view.size_list->blockSignals(true);
QListWidgetItem *sizeItem;
refreshParams();
}
-KUrl RenderWidget::filenameWithExtension(KUrl url, QString extension) {
+KUrl RenderWidget::filenameWithExtension(KUrl url, QString extension)
+{
QString path;
if (!url.isEmpty()) {
path = url.path();
}
-void RenderWidget::refreshParams() {
+void RenderWidget::refreshParams()
+{
QListWidgetItem *item = m_view.size_list->currentItem();
if (!item || item->isHidden()) {
m_view.advanced_params->clear();
m_view.buttonStart->setEnabled(m_view.size_list->currentItem()->flags() & Qt::ItemIsEnabled);
}
-void RenderWidget::reloadProfiles() {
+void RenderWidget::reloadProfiles()
+{
parseProfiles();
}
-void RenderWidget::parseProfiles(QString meta, QString group, QString profile) {
+void RenderWidget::parseProfiles(QString meta, QString group, QString profile)
+{
m_view.size_list->clear();
m_view.format_list->clear();
m_view.destination_list->clear();
if (!child.isEmpty()) m_view.size_list->setCurrentItem(child.at(0));
}
-void RenderWidget::parseFile(QString exportFile, bool editable) {
+void RenderWidget::parseFile(QString exportFile, bool editable)
+{
kDebug() << "// Parsing file: " << exportFile;
kDebug() << "------------------------------";
QDomDocument doc;
}
}
-void RenderWidget::setRenderJob(const QString &dest, int progress) {
+void RenderWidget::setRenderJob(const QString &dest, int progress)
+{
QTreeWidgetItem *item;
QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(dest, Qt::MatchExactly, 1);
if (!existing.isEmpty()) item = existing.at(0);
}
}
-void RenderWidget::setRenderStatus(const QString &dest, int status, const QString &error) {
+void RenderWidget::setRenderStatus(const QString &dest, int status, const QString &error)
+{
QTreeWidgetItem *item;
QList<QTreeWidgetItem *> existing = m_view.running_jobs->findItems(dest, Qt::MatchExactly, 1);
if (!existing.isEmpty()) item = existing.at(0);
slotCheckJob();
}
-void RenderWidget::slotAbortCurrentJob() {
+void RenderWidget::slotAbortCurrentJob()
+{
QTreeWidgetItem *current = m_view.running_jobs->currentItem();
if (current) emit abortProcess(current->text(1));
}
-void RenderWidget::slotCheckJob() {
+void RenderWidget::slotCheckJob()
+{
bool activate = false;
QTreeWidgetItem *current = m_view.running_jobs->currentItem();
if (current) {
m_view.abort_job->setEnabled(activate);
}
-void RenderWidget::parseScriptFiles() {
+void RenderWidget::parseScriptFiles()
+{
QStringList scriptsFilter;
scriptsFilter << "*.sh";
m_view.scripts_list->clear();
m_view.delete_script->setEnabled(activate);
}
-void RenderWidget::slotCheckScript() {
+void RenderWidget::slotCheckScript()
+{
bool activate = false;
QTreeWidgetItemIterator it(m_view.scripts_list);
if (*it) activate = true;
m_view.delete_script->setEnabled(activate);
}
-void RenderWidget::slotStartScript() {
+void RenderWidget::slotStartScript()
+{
QTreeWidgetItem *item = m_view.scripts_list->currentItem();
if (item) {
QString path = item->data(0, Qt::UserRole + 1).toString();
}
}
-void RenderWidget::slotDeleteScript() {
+void RenderWidget::slotDeleteScript()
+{
QTreeWidgetItem *item = m_view.scripts_list->currentItem();
if (item) {
QString path = item->data(0, Qt::UserRole + 1).toString();
}
}
-void RenderWidget::slotGenerateScript() {
+void RenderWidget::slotGenerateScript()
+{
slotExport(true);
}
// RenderViewDelegate is used to draw the progress bars.
-class RenderViewDelegate : public QItemDelegate {
+class RenderViewDelegate : public QItemDelegate
+{
Q_OBJECT
public:
RenderViewDelegate(QWidget *parent) : QItemDelegate(parent) {}
// RenderScriptDelegate is used to draw the script items.
-class RenderScriptDelegate : public QItemDelegate {
+class RenderScriptDelegate : public QItemDelegate
+{
Q_OBJECT
public:
RenderScriptDelegate(QWidget *parent) : QItemDelegate(parent) {}
}
};
-class RenderWidget : public QDialog {
+class RenderWidget : public QDialog
+{
Q_OBJECT
public:
#include <KLocale>
-ResizeClipCommand::ResizeClipCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startPos(start), m_endPos(end), m_doIt(doIt) {
+ResizeClipCommand::ResizeClipCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_startPos(start), m_endPos(end), m_doIt(doIt)
+{
setText(i18n("Resize clip"));
}
// virtual
-void ResizeClipCommand::undo() {
+void ResizeClipCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
if (m_doIt) m_view->resizeClip(m_endPos, m_startPos);
}
// virtual
-void ResizeClipCommand::redo() {
+void ResizeClipCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt) m_view->resizeClip(m_startPos, m_endPos);
m_doIt = true;
class CustomTrackView;
-class ResizeClipCommand : public QUndoCommand {
+class ResizeClipCommand : public QUndoCommand
+{
public:
ResizeClipCommand(CustomTrackView *view, const ItemInfo start, const ItemInfo end, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
#include <QDir>
-SlideshowClip::SlideshowClip(QWidget * parent): QDialog(parent), m_count(0) {
+SlideshowClip::SlideshowClip(QWidget * parent): QDialog(parent), m_count(0)
+{
setFont(KGlobalSettings::toolBarFont());
setWindowTitle(i18n("Add Slideshow Clip"));
m_view.setupUi(this);
adjustSize();
}
-void SlideshowClip::slotEnableLuma(int state) {
+void SlideshowClip::slotEnableLuma(int state)
+{
bool enable = false;
if (state == Qt::Checked) enable = true;
m_view.luma_duration->setEnabled(enable);
m_view.luma_softness->setEnabled(m_view.label_softness->isEnabled());
}
-void SlideshowClip::slotEnableLumaFile(int state) {
+void SlideshowClip::slotEnableLumaFile(int state)
+{
bool enable = false;
if (state == Qt::Checked) enable = true;
m_view.luma_file->setEnabled(enable);
m_view.label_softness->setEnabled(enable);
}
-void SlideshowClip::parseFolder() {
+void SlideshowClip::parseFolder()
+{
m_view.icon_list->clear();
QDir dir(m_view.folder_url->url().path());
m_view.icon_list->setCurrentRow(0);
}
-void SlideshowClip::slotSetItemIcon(int row) {
+void SlideshowClip::slotSetItemIcon(int row)
+{
QListWidgetItem * item = m_view.icon_list->item(row);
if (item) {
QString path = item->data(Qt::UserRole).toString();
}
}
-QString SlideshowClip::selectedPath() const {
+QString SlideshowClip::selectedPath() const
+{
QString extension = "/.all." + m_view.image_type->itemData(m_view.image_type->currentIndex()).toString();
return m_view.folder_url->url().path() + extension;
}
-QString SlideshowClip::clipName() const {
+QString SlideshowClip::clipName() const
+{
return m_view.clip_name->text();
}
-QString SlideshowClip::clipDuration() const {
+QString SlideshowClip::clipDuration() const
+{
return m_view.clip_duration->text();
}
-int SlideshowClip::imageCount() const {
+int SlideshowClip::imageCount() const
+{
return m_count;
}
-int SlideshowClip::softness() const {
+int SlideshowClip::softness() const
+{
return m_view.luma_softness->value();
}
-bool SlideshowClip::loop() const {
+bool SlideshowClip::loop() const
+{
return m_view.slide_loop->isChecked();
}
-bool SlideshowClip::fade() const {
+bool SlideshowClip::fade() const
+{
return m_view.slide_fade->isChecked();
}
-QString SlideshowClip::lumaDuration() const {
+QString SlideshowClip::lumaDuration() const
+{
return m_view.luma_duration->text();
}
-QString SlideshowClip::lumaFile() const {
+QString SlideshowClip::lumaFile() const
+{
if (!m_view.luma_fade->isChecked() || !m_view.luma_file->isEnabled()) return QString();
return m_view.luma_file->itemData(m_view.luma_file->currentIndex()).toString();
}
#include "timecode.h"
#include "ui_slideshowclip_ui.h"
-class SlideshowClip : public QDialog {
+class SlideshowClip : public QDialog
+{
Q_OBJECT
public:
#include <QStylePainter>
SmallRuler::SmallRuler(QWidget *parent)
- : QWidget(parent), m_scale(1), m_maxval(25) {
+ : QWidget(parent), m_scale(1), m_maxval(25)
+{
m_zoneStart = 10;
m_zoneEnd = 60;
m_zoneColor = QColor(133, 255, 143);
}
-void SmallRuler::adjustScale(int maximum) {
+void SmallRuler::adjustScale(int maximum)
+{
m_maxval = maximum;
m_scale = (double) width() / (double) maximum;
if (m_scale == 0) m_scale = 1;
update();
}
-void SmallRuler::setZone(int start, int end) {
+void SmallRuler::setZone(int start, int end)
+{
if (start != -1) {
if (end != -1 && start >= end) {
m_zoneEnd = qMin(m_maxval, end + (start - m_zoneStart));
update();
}
-QPoint SmallRuler::zone() {
+QPoint SmallRuler::zone()
+{
return QPoint(m_zoneStart, m_zoneEnd);
}
// virtual
-void SmallRuler::mousePressEvent(QMouseEvent * event) {
+void SmallRuler::mousePressEvent(QMouseEvent * event)
+{
const int pos = event->x() / m_scale;
if (event->button() == Qt::RightButton) {
// Right button clicked, move selection zone
}
// virtual
-void SmallRuler::mouseMoveEvent(QMouseEvent * event) {
+void SmallRuler::mouseMoveEvent(QMouseEvent * event)
+{
const int pos = event->x() / m_scale;
if (event->buttons() & Qt::LeftButton) emit seekRenderer((int) pos);
}
-void SmallRuler::slotNewValue(int value) {
+void SmallRuler::slotNewValue(int value)
+{
m_cursorFramePosition = value;
int oldPos = m_cursorPosition;
m_cursorPosition = value * m_scale;
}
//virtual
-void SmallRuler::resizeEvent(QResizeEvent *) {
+void SmallRuler::resizeEvent(QResizeEvent *)
+{
adjustScale(m_maxval);
}
// virtual
-void SmallRuler::paintEvent(QPaintEvent *e) {
+void SmallRuler::paintEvent(QPaintEvent *e)
+{
QPainter p(this);
QRect r = e->rect();
#include <QWidget>
-class SmallRuler : public QWidget {
+class SmallRuler : public QWidget
+{
Q_OBJECT
public:
#include <KDebug>
-SpacerDialog::SpacerDialog(const GenTime duration, Timecode tc, int track, int trackNumber, QWidget * parent): QDialog(parent), m_tc(tc) {
+SpacerDialog::SpacerDialog(const GenTime duration, Timecode tc, int track, int trackNumber, QWidget * parent): QDialog(parent), m_tc(tc)
+{
setFont(KGlobalSettings::toolBarFont());
m_fps = m_tc.fps();
m_view.setupUi(this);
adjustSize();
}
-SpacerDialog::~SpacerDialog() {
+SpacerDialog::~SpacerDialog()
+{
}
-void SpacerDialog::slotTimeUp() {
+void SpacerDialog::slotTimeUp()
+{
int duration = m_tc.getFrameCount(m_view.space_duration->text(), m_fps);
duration ++;
m_view.space_duration->setText(m_tc.getTimecode(GenTime(duration, m_fps), m_fps));
}
-void SpacerDialog::slotTimeDown() {
+void SpacerDialog::slotTimeDown()
+{
int duration = m_tc.getFrameCount(m_view.space_duration->text(), m_fps);
if (duration <= 0) return;
duration --;
m_view.space_duration->setText(m_tc.getTimecode(GenTime(duration, m_fps), m_fps));
}
-GenTime SpacerDialog::selectedDuration() {
+GenTime SpacerDialog::selectedDuration()
+{
return GenTime(m_tc.getFrameCount(m_view.space_duration->text(), m_fps), m_fps);
}
-void SpacerDialog::wheelEvent(QWheelEvent * event) {
+void SpacerDialog::wheelEvent(QWheelEvent * event)
+{
if (m_view.space_duration->underMouse()) {
if (event->delta() > 0)
slotTimeUp();
}
}
-int SpacerDialog::selectedTrack() {
+int SpacerDialog::selectedTrack()
+{
return m_view.track_number->currentIndex() - 1;
}
#include "timecode.h"
#include "ui_spacerdialog_ui.h"
-class SpacerDialog : public QDialog {
+class SpacerDialog : public QDialog
+{
Q_OBJECT
public:
#include <KLocale>
-SplitAudioCommand::SplitAudioCommand(CustomTrackView *view, const int track, const GenTime &pos, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_doIt(doIt) {
+SplitAudioCommand::SplitAudioCommand(CustomTrackView *view, const int track, const GenTime &pos, bool doIt, QUndoCommand * parent) : QUndoCommand(parent), m_view(view), m_track(track), m_pos(pos), m_doIt(doIt)
+{
setText(i18n("Split audio"));
}
// virtual
-void SplitAudioCommand::undo() {
+void SplitAudioCommand::undo()
+{
// kDebug()<<"---- undoing action";
m_doIt = true;
m_view->doSplitAudio(m_pos, m_track, false);
}
// virtual
-void SplitAudioCommand::redo() {
+void SplitAudioCommand::redo()
+{
kDebug() << "---- redoing action";
if (m_doIt)
m_view->doSplitAudio(m_pos, m_track, true);
class GenTime;
class CustomTrackView;
-class SplitAudioCommand : public QUndoCommand {
+class SplitAudioCommand : public QUndoCommand
+{
public:
SplitAudioCommand(CustomTrackView *view, const int track, const GenTime &pos, bool doIt, QUndoCommand * parent = 0);
virtual void undo();
m_illumination(0),
m_minTextHeight(-1),
m_timer(0),
- m_closeButton(0) {
+ m_closeButton(0)
+{
setMinimumHeight(KIconLoader::SizeSmall);
QPalette palette;
this, SLOT(closeErrorMessage()));
}
-StatusBarMessageLabel::~StatusBarMessageLabel() {
+StatusBarMessageLabel::~StatusBarMessageLabel()
+{
}
void StatusBarMessageLabel::setMessage(const QString& text,
- MessageType type) {
+ MessageType type)
+{
if ((text == m_text) && (type == m_type)) {
return;
}
show(); //update();
}
-void StatusBarMessageLabel::setMinimumTextHeight(int min) {
+void StatusBarMessageLabel::setMinimumTextHeight(int min)
+{
if (min != m_minTextHeight) {
m_minTextHeight = min;
setMinimumHeight(min);
}
}
-int StatusBarMessageLabel::widthGap() const {
+int StatusBarMessageLabel::widthGap() const
+{
QFontMetrics fontMetrics(font());
const int defaultGap = 10;
return fontMetrics.width(m_text) - availableTextWidth() + defaultGap;
}
-void StatusBarMessageLabel::paintEvent(QPaintEvent* /* event */) {
+void StatusBarMessageLabel::paintEvent(QPaintEvent* /* event */)
+{
QPainter painter(this);
// draw background
painter.end();
}
-void StatusBarMessageLabel::resizeEvent(QResizeEvent* event) {
+void StatusBarMessageLabel::resizeEvent(QResizeEvent* event)
+{
QWidget::resizeEvent(event);
//updateCloseButtonPosition();
//QTimer::singleShot(GeometryTimeout, this, SLOT(assureVisibleText()));
}
-void StatusBarMessageLabel::timerDone() {
+void StatusBarMessageLabel::timerDone()
+{
switch (m_state) {
case Illuminate: {
// increase the illumination
}
}
-void StatusBarMessageLabel::assureVisibleText() {
+void StatusBarMessageLabel::assureVisibleText()
+{
if (m_text.isEmpty()) {
return;
}
//updateCloseButtonPosition();
}
-int StatusBarMessageLabel::availableTextWidth() const {
+int StatusBarMessageLabel::availableTextWidth() const
+{
const int buttonWidth = 0; /*(m_type == ErrorMessage) ?
m_closeButton->width() + BorderGap : 0;*/
return width() - m_pixmap.width() - (BorderGap * 4) - buttonWidth;
}
-void StatusBarMessageLabel::updateCloseButtonPosition() {
+void StatusBarMessageLabel::updateCloseButtonPosition()
+{
const int x = width() - m_closeButton->width() - BorderGap;
const int y = (height() - m_closeButton->height()) / 2;
m_closeButton->move(x, y);
}
-void StatusBarMessageLabel::closeErrorMessage() {
+void StatusBarMessageLabel::closeErrorMessage()
+{
if (!showPendingMessage()) {
reset();
setMessage(m_defaultText, DefaultMessage);
}
}
-bool StatusBarMessageLabel::showPendingMessage() {
+bool StatusBarMessageLabel::showPendingMessage()
+{
if (!m_pendingMessages.isEmpty()) {
reset();
setMessage(m_pendingMessages.takeFirst(), ErrorMessage);
return false;
}
-void StatusBarMessageLabel::reset() {
+void StatusBarMessageLabel::reset()
+{
m_text.clear();
m_pixmap = QPixmap();
m_type = DefaultMessage;
* DolphinStatusBar::Error a dynamic color blending is done to get the
* attention from the user.
*/
-class StatusBarMessageLabel : public QWidget {
+class StatusBarMessageLabel : public QWidget
+{
Q_OBJECT
public:
QPushButton* m_closeButton;
};
-inline MessageType StatusBarMessageLabel::type() const {
+inline MessageType StatusBarMessageLabel::type() const
+{
return m_type;
}
-inline const QString& StatusBarMessageLabel::text() const {
+inline const QString& StatusBarMessageLabel::text() const
+{
return m_text;
}
-inline void StatusBarMessageLabel::setDefaultText(const QString& text) {
+inline void StatusBarMessageLabel::setDefaultText(const QString& text)
+{
m_defaultText = text;
}
-inline const QString& StatusBarMessageLabel::defaultText() const {
+inline const QString& StatusBarMessageLabel::defaultText() const
+{
return m_defaultText;
}
-inline int StatusBarMessageLabel::minimumTextHeight() const {
+inline int StatusBarMessageLabel::minimumTextHeight() const
+{
return m_minTextHeight;
}
Timecode::Timecode(Formats format, int framesPerSecond,
bool dropFrame): m_format(format), m_dropFrame(dropFrame),
- m_displayedFramesPerSecond(framesPerSecond) {
+ m_displayedFramesPerSecond(framesPerSecond)
+{
}
-Timecode::~Timecode() {
+Timecode::~Timecode()
+{
}
-int Timecode::fps() {
+int Timecode::fps()
+{
return m_displayedFramesPerSecond;
}
-int Timecode::getFrameCount(const QString duration, double fps) const {
+int Timecode::getFrameCount(const QString duration, double fps) const
+{
if (m_dropFrame) {
// calculate how many frames need to be dropped every minute.
int frames;
return (int)((duration.section(':', 0, 0).toInt()*3600.0 + duration.section(':', 1, 1).toInt()*60.0 + duration.section(':', 2, 2).toInt()) * fps + duration.section(':', 3, 3).toInt());
}
-QString Timecode::getTimecode(const GenTime & time, double fps) const {
+QString Timecode::getTimecode(const GenTime & time, double fps) const
+{
switch (m_format) {
case HH_MM_SS_FF:
return getTimecodeHH_MM_SS_FF(time, fps);
}
}
-QString Timecode::getTimecodeFromFrames(int frames) {
+QString Timecode::getTimecodeFromFrames(int frames)
+{
return getTimecodeHH_MM_SS_FF(frames);
}
//static
-QString Timecode::getEasyTimecode(const GenTime & time, const double &fps) {
+QString Timecode::getEasyTimecode(const GenTime & time, const double &fps)
+{
// Returns the timecode in an easily read display, like 3 min. 5 sec.
int frames = (int)time.frames(fps);
int seconds = frames / (int) floor(fps + 0.5);
}
-QString Timecode::getTimecodeHH_MM_SS_FF(const GenTime & time, double fps) const {
+QString Timecode::getTimecodeHH_MM_SS_FF(const GenTime & time, double fps) const
+{
if (m_dropFrame)
return getTimecodeDropFrame(time, fps);
return getTimecodeHH_MM_SS_FF((int)time.frames(fps));
}
-QString Timecode::getTimecodeHH_MM_SS_FF(int frames) const {
+QString Timecode::getTimecodeHH_MM_SS_FF(int frames) const
+{
int seconds = frames / m_displayedFramesPerSecond;
frames = frames % m_displayedFramesPerSecond;
return text;
}
-QString Timecode::getTimecodeHH_MM_SS_HH(const GenTime & time) const {
+QString Timecode::getTimecodeHH_MM_SS_HH(const GenTime & time) const
+{
int hundredths = (int)(time.seconds() * 100);
int seconds = hundredths / 100;
hundredths = hundredths % 100;
return text;
}
-QString Timecode::getTimecodeFrames(const GenTime & time, double fps) const {
+QString Timecode::getTimecodeFrames(const GenTime & time, double fps) const
+{
return QString::number(time.frames(fps));
}
-QString Timecode::getTimecodeSeconds(const GenTime & time) const {
+QString Timecode::getTimecodeSeconds(const GenTime & time) const
+{
return QString::number(time.seconds());
}
-QString Timecode::getTimecodeDropFrame(const GenTime & time, double fps) const {
+QString Timecode::getTimecodeDropFrame(const GenTime & time, double fps) const
+{
// Calculate the timecode using dropframes to remove the difference in fps. Note that this algorithm should work
// for NTSC times, but is untested for any others - it is in no way an "official" algorithm, unless it's by fluke.
int frames = (int)time.frames(fps);
@author Jason Wood
*/
-class Timecode {
+class Timecode
+{
public:
enum Formats { HH_MM_SS_FF, HH_MM_SS_HH, Frames, Seconds };
#include <QFile>
-TitleDocument::TitleDocument() {
+TitleDocument::TitleDocument()
+{
scene = NULL;
}
-void TitleDocument::setScene(QGraphicsScene* _scene) {
+void TitleDocument::setScene(QGraphicsScene* _scene)
+{
scene = _scene;
}
-QDomDocument TitleDocument::xml(QGraphicsPolygonItem* startv, QGraphicsPolygonItem* endv) {
+QDomDocument TitleDocument::xml(QGraphicsPolygonItem* startv, QGraphicsPolygonItem* endv)
+{
QDomDocument doc;
QDomElement main = doc.createElement("kdenlivetitle");
/** \brief Get the background color (incl. alpha) from the document, if possibly
* \returns The background color of the document, inclusive alpha. If none found, returns (0,0,0,0) */
-QColor TitleDocument::getBackgroundColor() {
+QColor TitleDocument::getBackgroundColor()
+{
QColor color(0, 0, 0, 0);
if (scene) {
QList<QGraphicsItem *> items = scene->items();
}
-bool TitleDocument::saveDocument(const KUrl& url, QGraphicsPolygonItem* startv, QGraphicsPolygonItem* endv) {
+bool TitleDocument::saveDocument(const KUrl& url, QGraphicsPolygonItem* startv, QGraphicsPolygonItem* endv)
+{
if (!scene)
return false;
return KIO::NetAccess::upload(tmpfile.fileName(), url, 0);
}
-int TitleDocument::loadDocument(const KUrl& url, QGraphicsPolygonItem* startv, QGraphicsPolygonItem* endv) {
+int TitleDocument::loadDocument(const KUrl& url, QGraphicsPolygonItem* startv, QGraphicsPolygonItem* endv)
+{
QString tmpfile;
QDomDocument doc;
if (!scene)
return -1;
}
-int TitleDocument::loadFromXml(QDomDocument doc, QGraphicsPolygonItem* /*startv*/, QGraphicsPolygonItem* /*endv*/) {
+int TitleDocument::loadFromXml(QDomDocument doc, QGraphicsPolygonItem* /*startv*/, QGraphicsPolygonItem* /*endv*/)
+{
QDomNodeList titles = doc.elementsByTagName("kdenlivetitle");
int maxZValue = 0;
if (titles.size()) {
return maxZValue;
}
-QString TitleDocument::colorToString(const QColor& c) {
+QString TitleDocument::colorToString(const QColor& c)
+{
QString ret = "%1,%2,%3,%4";
ret = ret.arg(c.red()).arg(c.green()).arg(c.blue()).arg(c.alpha());
return ret;
}
-QString TitleDocument::rectFToString(const QRectF& c) {
+QString TitleDocument::rectFToString(const QRectF& c)
+{
QString ret = "%1,%2,%3,%4";
ret = ret.arg(c.x()).arg(c.y()).arg(c.width()).arg(c.height());
return ret;
}
-QRectF TitleDocument::stringToRect(const QString & s) {
+QRectF TitleDocument::stringToRect(const QString & s)
+{
QStringList l = s.split(',');
if (l.size() < 4)
return QRectF(l[0].toDouble(), l[1].toDouble(), l[2].toDouble(), l[3].toDouble());
}
-QColor TitleDocument::stringToColor(const QString & s) {
+QColor TitleDocument::stringToColor(const QString & s)
+{
QStringList l = s.split(',');
if (l.size() < 4)
return QColor();
return QColor(l[0].toInt(), l[1].toInt(), l[2].toInt(), l[3].toInt());;
}
-QTransform TitleDocument::stringToTransform(const QString& s) {
+QTransform TitleDocument::stringToTransform(const QString& s)
+{
QStringList l = s.split(',');
if (l.size() < 9)
return QTransform();
class QGraphicsScene;
class QGraphicsPolygonItem;
-class TitleDocument {
+class TitleDocument
+{
QGraphicsScene* scene;
public:
TitleDocument();
int settingUp = false;
-TitleWidget::TitleWidget(KUrl url, QString projectPath, Render *render, QWidget *parent): QDialog(parent), m_render(render), m_count(0), m_projectPath(projectPath), startViewport(NULL), endViewport(NULL) {
+TitleWidget::TitleWidget(KUrl url, QString projectPath, Render *render, QWidget *parent): QDialog(parent), m_render(render), m_count(0), m_projectPath(projectPath), startViewport(NULL), endViewport(NULL)
+{
setupUi(this);
setFont(KGlobalSettings::toolBarFont());
//toolBox->setFont(KGlobalSettings::toolBarFont());
}
}
-TitleWidget::~TitleWidget() {
+TitleWidget::~TitleWidget()
+{
delete m_buttonRect;
delete m_buttonText;
delete m_buttonImage;
}
//static
-QStringList TitleWidget::getFreeTitleInfo(const KUrl &projectUrl) {
+QStringList TitleWidget::getFreeTitleInfo(const KUrl &projectUrl)
+{
QStringList result;
QString titlePath = projectUrl.path() + "/titles/";
KStandardDirs::makeDir(titlePath);
return result;
}
-QString TitleWidget::getTitleResourceFromName(const KUrl &projectUrl, const QString &titleName) {
+QString TitleWidget::getTitleResourceFromName(const KUrl &projectUrl, const QString &titleName)
+{
QStringList result;
QString titlePath = projectUrl.path() + "/titles/";
KStandardDirs::makeDir(titlePath);
}
//virtual
-void TitleWidget::resizeEvent(QResizeEvent * /*event*/) {
+void TitleWidget::resizeEvent(QResizeEvent * /*event*/)
+{
//slotAdjustZoom();
}
-void TitleWidget::slotTextTool() {
+void TitleWidget::slotTextTool()
+{
rect_properties->setHidden(true);
text_properties->setHidden(false);
m_scene->setTool(TITLE_TEXT);
m_buttonCursor->setChecked(false);
}
-void TitleWidget::slotRectTool() {
+void TitleWidget::slotRectTool()
+{
text_properties->setHidden(true);
rect_properties->setHidden(false);
m_scene->setTool(TITLE_RECTANGLE);
m_buttonRect->setChecked(true);
}
-void TitleWidget::slotSelectTool() {
+void TitleWidget::slotSelectTool()
+{
m_scene->setTool(TITLE_SELECT);
m_buttonCursor->setChecked(true);
m_buttonText->setChecked(false);
m_buttonRect->setChecked(false);
}
-void TitleWidget::slotImageTool() {
+void TitleWidget::slotImageTool()
+{
KUrl url = KFileDialog::getOpenUrl(KUrl(), "*.svg *.png *.jpg *.jpeg *.gif *.raw", this, i18n("Load Image"));
if (!url.isEmpty()) {
if (url.path().endsWith(".svg")) {
m_buttonText->setChecked(false);
}
-void TitleWidget::displayBackgroundFrame() {
+void TitleWidget::displayBackgroundFrame()
+{
if (!displayBg->isChecked()) {
QPixmap bg(m_frameWidth / 2, m_frameHeight / 2);
QPixmap pattern(20, 20);
}
}
-void TitleWidget::initViewports() {
+void TitleWidget::initViewports()
+{
startViewport = new QGraphicsPolygonItem(QPolygonF(QRectF(0, 0, 0, 0)));
endViewport = new QGraphicsPolygonItem(QPolygonF(QRectF(0, 0, 0, 0)));
graphicsView->scene()->addItem(endViewport);
}
-void TitleWidget::slotUpdateZoom(int pos) {
+void TitleWidget::slotUpdateZoom(int pos)
+{
m_scene->setZoom((double) pos / 100);
zoom_label->setText(QString::number(pos) + '%');
}
-void TitleWidget::slotZoom(bool up) {
+void TitleWidget::slotZoom(bool up)
+{
int pos = zoom_slider->value();
if (up) pos++;
else pos--;
zoom_slider->setValue(pos);
}
-void TitleWidget::slotAdjustZoom() {
+void TitleWidget::slotAdjustZoom()
+{
/*double scalex = graphicsView->width() / (double)(m_frameWidth * 1.2);
double scaley = graphicsView->height() / (double)(m_frameHeight * 1.2);
if (scalex > scaley) scalex = scaley;
graphicsView->centerOn(m_frameBorder);
}
-void TitleWidget::slotZoomOneToOne() {
+void TitleWidget::slotZoomOneToOne()
+{
zoom_slider->setValue(100);
graphicsView->centerOn(m_frameBorder);
}
-void TitleWidget::slotNewRect(QGraphicsRectItem * rect) {
+void TitleWidget::slotNewRect(QGraphicsRectItem * rect)
+{
QColor f = rectFColor->color();
f.setAlpha(rectFAlpha->value());
QPen penf(f);
//graphicsView->setFocus();
}
-void TitleWidget::slotNewText(QGraphicsTextItem *tt) {
+void TitleWidget::slotNewText(QGraphicsTextItem *tt)
+{
QFont font = font_family->currentFont();
font.setPixelSize(font_size->value());
// mbd: issue 551:
setCurrentItem(tt);
}
-void TitleWidget::setCurrentItem(QGraphicsItem *item) {
+void TitleWidget::setCurrentItem(QGraphicsItem *item)
+{
m_scene->setSelectedItem(item);
}
-void TitleWidget::zIndexChanged(int v) {
+void TitleWidget::zIndexChanged(int v)
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() >= 1) {
l[0]->setZValue(v);
}
}
-void TitleWidget::selectionChanged() {
+void TitleWidget::selectionChanged()
+{
if (m_scene->tool() != TITLE_SELECT) return;
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
//toolBox->setItemEnabled(2, false);
} else frame_properties->setEnabled(false);
}
-void TitleWidget::slotAdjustSelectedItem() {
+void TitleWidget::slotAdjustSelectedItem()
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() >= 1) {
if (l[0]->type() == 3) {
}
}
-void TitleWidget::slotChangeBackground() {
+void TitleWidget::slotChangeBackground()
+{
QColor color = kcolorbutton->color();
color.setAlpha(horizontalSlider->value());
m_frameBorder->setBrush(QBrush(color));
}
-void TitleWidget::textChanged() {
+void TitleWidget::textChanged()
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() == 1 && (l[0])->type() == 8 && !l[0]->hasFocus()) {
//kDebug() << ktextedit->document()->toHtml();
}
}
-void TitleWidget::slotUpdateText() {
+void TitleWidget::slotUpdateText()
+{
QFont font = font_family->currentFont();
font.setPixelSize(font_size->value());
font.setBold(buttonBold->isChecked());
}*/
}
-void TitleWidget::rectChanged() {
+void TitleWidget::rectChanged()
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() == 1 && (l[0])->type() == 3 && !settingUp) {
QGraphicsRectItem *rec = (QGraphicsRectItem*)l[0];
}
}
-void TitleWidget::fontBold() {
+void TitleWidget::fontBold()
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() == 1 && (l[0])->type() == 8 && !l[0]->hasFocus()) {
//ktextedit->document()->setTextOption();
}
}
-void TitleWidget::itemScaled(int val) {
+void TitleWidget::itemScaled(int val)
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() == 1) {
Transform x = transformations[l[0]];
}
}
-void TitleWidget::itemRotate(int val) {
+void TitleWidget::itemRotate(int val)
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() == 1) {
Transform x = transformations[l[0]];
}
}
-void TitleWidget::itemHCenter() {
+void TitleWidget::itemHCenter()
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() == 1) {
QGraphicsItem *item = l[0];
}
}
-void TitleWidget::itemVCenter() {
+void TitleWidget::itemVCenter()
+{
QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
if (l.size() == 1) {
QGraphicsItem *item = l[0];
}
}
-void TitleWidget::setupViewports() {
+void TitleWidget::setupViewports()
+{
double aspect_ratio = 4.0 / 3.0;//read from project
QRectF sp(0, 0, 0, 0);
}
-void TitleWidget::loadTitle() {
+void TitleWidget::loadTitle()
+{
KUrl url = KFileDialog::getOpenUrl(KUrl(m_projectPath), "*.kdenlivetitle", this, i18n("Load Title"));
if (!url.isEmpty()) {
QList<QGraphicsItem *> items = m_scene->items();
}
}
-void TitleWidget::saveTitle(KUrl url) {
+void TitleWidget::saveTitle(KUrl url)
+{
if (url.isEmpty()) url = KFileDialog::getSaveUrl(KUrl(m_projectPath), "*.kdenlivetitle", this, i18n("Save Title"));
if (!url.isEmpty()) {
if (m_titledocument.saveDocument(url, startViewport, endViewport) == false)
}
}
-QDomDocument TitleWidget::xml() {
+QDomDocument TitleWidget::xml()
+{
return m_titledocument.xml(startViewport, endViewport);
}
-void TitleWidget::setXml(QDomDocument doc) {
+void TitleWidget::setXml(QDomDocument doc)
+{
m_count = m_titledocument.loadFromXml(doc, startViewport, endViewport);
// mbd: Update the GUI color selectors to match the stuff from the loaded document
QColor background_color = m_titledocument.getBackgroundColor();
slotSelectTool();
}
-QImage TitleWidget::renderedPixmap() {
+QImage TitleWidget::renderedPixmap()
+{
QImage pix(m_frameWidth, m_frameHeight, QImage::Format_ARGB32);
pix.fill(Qt::transparent);
QPainter painter(&pix);
}
/** \brief Connected to the accepted signal - calls writeChoices */
-void TitleWidget::slotAccepted() {
+void TitleWidget::slotAccepted()
+{
writeChoices();
}
/** \brief Store the current choices of font, background and rect values */
-void TitleWidget::writeChoices() {
+void TitleWidget::writeChoices()
+{
// Get a pointer to a shared configuration instance, then get the TitleWidget group.
KSharedConfigPtr config = KGlobal::config();
KConfigGroup titleConfig(config, "TitleWidget");
}
/** \brief Read the last stored choices into the dialog */
-void TitleWidget::readChoices() {
+void TitleWidget::readChoices()
+{
// Get a pointer to a shared configuration instance, then get the TitleWidget group.
KSharedConfigPtr config = KGlobal::config();
KConfigGroup titleConfig(config, "TitleWidget");
#include <QMap>
-class Transform {
+class Transform
+{
public:
Transform() {
scalex = 1.0;
double rotate;
};
-class TitleWidget : public QDialog , public Ui::TitleWidget_UI {
+class TitleWidget : public QDialog , public Ui::TitleWidget_UI
+{
Q_OBJECT
public:
#include <QScrollBar>
TrackView::TrackView(KdenliveDoc *doc, QWidget *parent)
- : QWidget(parent), m_doc(doc), m_scale(1.0), m_projectTracks(0) {
+ : QWidget(parent), m_doc(doc), m_scale(1.0), m_projectTracks(0)
+{
view = new Ui::TimeLine_UI();
view->setupUi(this);
}
-int TrackView::duration() const {
+int TrackView::duration() const
+{
return m_trackview->duration();
}
-int TrackView::tracksNumber() const {
+int TrackView::tracksNumber() const
+{
return m_projectTracks - 1;
}
-int TrackView::inPoint() const {
+int TrackView::inPoint() const
+{
return m_ruler->inPoint();
}
-int TrackView::outPoint() const {
+int TrackView::outPoint() const
+{
return m_ruler->outPoint();
}
-void TrackView::slotSetZone(QPoint p) {
+void TrackView::slotSetZone(QPoint p)
+{
m_ruler->setZone(p);
}
-void TrackView::slotTransitionItemSelected(Transition *t, bool update) {
+void TrackView::slotTransitionItemSelected(Transition *t, bool update)
+{
emit transitionItemSelected(t, update);
}
-void TrackView::setDuration(int dur) {
+void TrackView::setDuration(int dur)
+{
m_trackview->setDuration(dur);
m_ruler->setDuration(dur);
}
-void TrackView::parseDocument(QDomDocument doc) {
+void TrackView::parseDocument(QDomDocument doc)
+{
//int cursorPos = 0;
m_documentErrors.clear();
// kDebug() << "//// DOCUMENT: " << doc.toString();
//m_scrollBox->setGeometry(0, 0, 300 * zoomFactor(), m_scrollArea->height());
}
-void TrackView::slotDeleteClip(const QString &clipId) {
+void TrackView::slotDeleteClip(const QString &clipId)
+{
m_trackview->deleteClip(clipId);
}
-void TrackView::setCursorPos(int pos) {
+void TrackView::setCursorPos(int pos)
+{
m_trackview->setCursorPos(pos);
}
-void TrackView::moveCursorPos(int pos) {
+void TrackView::moveCursorPos(int pos)
+{
m_trackview->setCursorPos(pos, false);
}
-void TrackView::slotChangeZoom(int factor) {
+void TrackView::slotChangeZoom(int factor)
+{
m_doc->setZoom(factor);
m_ruler->setPixelPerMark(factor);
m_scale = (double) FRAME_SIZE / m_ruler->comboScale[factor]; // m_ruler->comboScale[m_currentZoom] /
m_trackview->setScale(m_scale);
}
-int TrackView::fitZoom() const {
+int TrackView::fitZoom() const
+{
int zoom = (int)((duration() + 20 / m_scale) * FRAME_SIZE / m_trackview->width());
int i;
for (i = 0; i < 13; i++)
return i;
}
-KdenliveDoc *TrackView::document() {
+KdenliveDoc *TrackView::document()
+{
return m_doc;
}
-void TrackView::refresh() {
+void TrackView::refresh()
+{
m_trackview->viewport()->update();
}
-void TrackView::slotRebuildTrackHeaders() {
+void TrackView::slotRebuildTrackHeaders()
+{
QList <TrackInfo> list = m_doc->tracksList();
QList<HeaderTrack *> widgets = findChildren<HeaderTrack *>();
for (int i = 0; i < widgets.count(); i++)
}
-int TrackView::slotAddProjectTrack(int ix, QDomElement xml, bool locked) {
+int TrackView::slotAddProjectTrack(int ix, QDomElement xml, bool locked)
+{
// parse track
int position = 0;
QDomNodeList children = xml.childNodes();
//track->show();
}
-DocClipBase *TrackView::getMissingProducer(const QString id) const {
+DocClipBase *TrackView::getMissingProducer(const QString id) const
+{
QDomElement missingXml;
QDomDocument doc = m_doc->toXml();
QString docRoot = doc.documentElement().attribute("root");
return missingClip;
}
-QGraphicsScene *TrackView::projectScene() {
+QGraphicsScene *TrackView::projectScene()
+{
return m_scene;
}
-CustomTrackView *TrackView::projectView() {
+CustomTrackView *TrackView::projectView()
+{
return m_trackview;
}
-void TrackView::setEditMode(const QString & editMode) {
+void TrackView::setEditMode(const QString & editMode)
+{
m_editMode = editMode;
}
-const QString & TrackView::editMode() const {
+const QString & TrackView::editMode() const
+{
return m_editMode;
}
-void TrackView::slotChangeTrackLock(int ix, bool lock) {
+void TrackView::slotChangeTrackLock(int ix, bool lock)
+{
QList<HeaderTrack *> widgets = findChildren<HeaderTrack *>();
widgets.at(ix)->setLock(lock);
}
class CustomRuler;
class DocClipBase;
-class TrackView : public QWidget {
+class TrackView : public QWidget
+{
Q_OBJECT
public:
#include <QStyleOptionGraphicsItem>
-Transition::Transition(const ItemInfo info, int transitiontrack, double fps, QDomElement params, bool automaticTransition) : AbstractClipItem(info, QRectF(), fps), m_automaticTransition(automaticTransition), m_forceTransitionTrack(false) {
+Transition::Transition(const ItemInfo info, int transitiontrack, double fps, QDomElement params, bool automaticTransition) : AbstractClipItem(info, QRectF(), fps), m_automaticTransition(automaticTransition), m_forceTransitionTrack(false)
+{
setZValue(2);
setRect(0, 0, (info.endPos - info.startPos).frames(fps) - 0.02, (qreal)(KdenliveSettings::trackheight() / 3 * 2 - 1));
setPos(info.startPos.frames(fps), (qreal)(info.track * KdenliveSettings::trackheight() + KdenliveSettings::trackheight() / 3 * 2));
//m_referenceClip->addTransition(this);
}
-Transition::~Transition() {
+Transition::~Transition()
+{
}
-Transition *Transition::clone() {
+Transition *Transition::clone()
+{
QDomElement xml = toXML().cloneNode().toElement();
Transition *tr = new Transition(info(), transitionEndTrack(), m_fps, xml);
return tr;
}
-QString Transition::transitionName() const {
+QString Transition::transitionName() const
+{
return m_name;
}
-QString Transition::transitionTag() const {
+QString Transition::transitionTag() const
+{
return m_parameters.attribute("tag");
}
-bool Transition::isAutomatic() const {
+bool Transition::isAutomatic() const
+{
return m_automaticTransition;
}
-void Transition::setAutomatic(bool automatic) {
+void Transition::setAutomatic(bool automatic)
+{
m_automaticTransition = automatic;
if (automatic) {
m_parameters.setAttribute("automatic", 1);
update();
}
-void Transition::setTransitionParameters(const QDomElement params) {
+void Transition::setTransitionParameters(const QDomElement params)
+{
m_parameters = params;
if (m_parameters.attribute("force_track") == "1") setForcedTrack(true, m_parameters.attribute("transition_btrack").toInt());
else if (m_parameters.attribute("force_track") == "0") setForcedTrack(false, m_parameters.attribute("transition_btrack").toInt());
}
-bool Transition::invertedTransition() const {
+bool Transition::invertedTransition() const
+{
return false; //m_parameters.attribute("reverse").toInt();
}
-QPixmap Transition::transitionPixmap() const {
+QPixmap Transition::transitionPixmap() const
+{
KIcon icon;
QString tag = transitionTag();
if (tag == "luma") {
}
-void Transition::setTransitionDirection(bool /*inv*/) {
+void Transition::setTransitionDirection(bool /*inv*/)
+{
//m_parameters.setAttribute("reverse", inv);
}
-int Transition::transitionEndTrack() const {
+int Transition::transitionEndTrack() const
+{
return m_transitionTrack;
}
-void Transition::updateTransitionEndTrack(int newtrack) {
+void Transition::updateTransitionEndTrack(int newtrack)
+{
if (!m_forceTransitionTrack) m_transitionTrack = newtrack;
}
-void Transition::setForcedTrack(bool force, int track) {
+void Transition::setForcedTrack(bool force, int track)
+{
m_forceTransitionTrack = force;
m_transitionTrack = track;
}
-bool Transition::forcedTrack() const {
+bool Transition::forcedTrack() const
+{
return m_forceTransitionTrack;
}
void Transition::paint(QPainter *painter,
const QStyleOptionGraphicsItem *option,
- QWidget */*widget*/) {
+ QWidget */*widget*/)
+{
const double scale = option->matrix.m11();
QRectF exposed = option->exposedRect;
painter->setClipRect(exposed);
painter->drawRect(br);
}
-int Transition::type() const {
+int Transition::type() const
+{
return TRANSITIONWIDGET;
}
//virtual
-QVariant Transition::itemChange(GraphicsItemChange change, const QVariant &value) {
+QVariant Transition::itemChange(GraphicsItemChange change, const QVariant &value)
+{
if (change == ItemPositionChange && scene()) {
// calculate new position.
QPointF newPos = value.toPointF();
}
-OPERATIONTYPE Transition::operationMode(QPointF pos) {
+OPERATIONTYPE Transition::operationMode(QPointF pos)
+{
if (isItemLocked()) return NONE;
const double scale = projectScene()->scale();
return MOVE;
}
-bool Transition::hasClip(const ClipItem * clip) const {
+bool Transition::hasClip(const ClipItem * clip) const
+{
if (clip == m_secondClip) return true;
return false;
}
-bool Transition::belongsToClip(const ClipItem * clip) const {
+bool Transition::belongsToClip(const ClipItem * clip) const
+{
if (clip == m_referenceClip) return true;
return false;
}
return new Transition::Transition(rect(), clip, toXML(), m_fps, m_referenceClip->startPos());
}*/
-bool Transition::isValid() const {
+bool Transition::isValid() const
+{
return true; //(m_transitionDuration != GenTime());
}
-const ClipItem *Transition::referencedClip() const {
+const ClipItem *Transition::referencedClip() const
+{
return m_referenceClip;
}
-QDomElement Transition::toXML() {
+QDomElement Transition::toXML()
+{
m_parameters.setAttribute("type", transitionTag());
//m_transitionParameters.setAttribute("inverted", invertTransition());
m_parameters.setAttribute("transition_atrack", track());
return m_parameters;
}
-bool Transition::hasGeometry() {
+bool Transition::hasGeometry()
+{
QDomNodeList namenode = m_parameters.elementsByTagName("parameter");
for (int i = 0;i < namenode.count() ;i++) {
QDomElement pa = namenode.item(i).toElement();
class ClipItem;
-class Transition : public AbstractClipItem {
+class Transition : public AbstractClipItem
+{
Q_OBJECT
public:
#include <KDebug>
-TransitionSettings::TransitionSettings(QWidget* parent): QWidget(parent), m_tracksCount(0), m_usedTransition(NULL) {
+TransitionSettings::TransitionSettings(QWidget* parent): QWidget(parent), m_tracksCount(0), m_usedTransition(NULL)
+{
ui.setupUi(this);
effectEdit = new EffectStackEdit(ui.frame);
connect(effectEdit, SIGNAL(seekTimeline(int)), this, SIGNAL(seekTimeline(int)));
connect(effectEdit, SIGNAL(parameterChanged(const QDomElement&, const QDomElement&)), this , SLOT(slotUpdateEffectParams(const QDomElement&, const QDomElement&)));
}
-void TransitionSettings::updateProjectFormat(MltVideoProfile profile, Timecode t, const uint tracksCount) {
+void TransitionSettings::updateProjectFormat(MltVideoProfile profile, Timecode t, const uint tracksCount)
+{
m_tracksCount = tracksCount;
effectEdit->updateProjectFormat(profile, t);
QStringList tracksList;
}
-void TransitionSettings::slotTransitionChanged(bool reinit, bool updateCurrent) {
+void TransitionSettings::slotTransitionChanged(bool reinit, bool updateCurrent)
+{
QDomElement e = m_usedTransition->toXML().cloneNode().toElement();
if (reinit) {
// Reset the transition parameters to the default one
}
}
-void TransitionSettings::slotTransitionTrackChanged() {
+void TransitionSettings::slotTransitionTrackChanged()
+{
if (m_usedTransition == NULL) return;
int ix = 0;
QDomElement oldxml = m_usedTransition->toXML().cloneNode().toElement();
effectEdit->updateParameter("transition_btrack", QString::number(ix));
}
-void TransitionSettings::slotTransitionItemSelected(Transition* t, bool update) {
+void TransitionSettings::slotTransitionItemSelected(Transition* t, bool update)
+{
setEnabled(t != NULL);
if (t == m_usedTransition) {
if (t == NULL) return;
}
-void TransitionSettings::slotUpdateEffectParams(const QDomElement &oldparam, const QDomElement ¶m) {
+void TransitionSettings::slotUpdateEffectParams(const QDomElement &oldparam, const QDomElement ¶m)
+{
if (m_usedTransition) {
m_usedTransition->setTransitionParameters(param);
m_usedTransition->update();
}
}
-void TransitionSettings::raiseWindow(QWidget* dock) {
+void TransitionSettings::raiseWindow(QWidget* dock)
+{
if (dock && m_usedTransition)
dock->raise();
class EffectsList;
class EffectStackEdit;
-class TransitionSettings : public QWidget {
+class TransitionSettings : public QWidget
+{
Q_OBJECT
public:
const double recommendedMltVersion = 36;
-Wizard::Wizard(bool upgrade, QWidget *parent): QWizard(parent) {
+Wizard::Wizard(bool upgrade, QWidget *parent): QWizard(parent)
+{
setPixmap(QWizard::WatermarkPixmap, QPixmap(KStandardDirs::locate("appdata", "banner.png")));
QWizardPage *page1 = new QWizardPage;
}
-void Wizard::checkMltComponents() {
+void Wizard::checkMltComponents()
+{
m_mltCheck.programList->setColumnCount(2);
m_mltCheck.programList->setRootIsDecorated(false);
m_mltCheck.programList->setHeaderHidden(true);
}
}
-void Wizard::slotCheckPrograms() {
+void Wizard::slotCheckPrograms()
+{
m_check.programList->setColumnCount(2);
m_check.programList->setRootIsDecorated(false);
m_check.programList->setHeaderHidden(true);
}
-void Wizard::installExtraMimes(QString baseName, QStringList globs) {
+void Wizard::installExtraMimes(QString baseName, QStringList globs)
+{
QString mimefile = baseName;
mimefile.replace('/', '-');
KMimeType::Ptr mime = KMimeType::mimeType(baseName);
}
}
-void Wizard::runUpdateMimeDatabase() {
+void Wizard::runUpdateMimeDatabase()
+{
const QString localPackageDir = KStandardDirs::locateLocal("xdgdata-mime", QString());
//Q_ASSERT(!localPackageDir.isEmpty());
KProcess proc;
}
}
-void Wizard::slotCheckThumbs() {
+void Wizard::slotCheckThumbs()
+{
QString pixname = "timeline_vthumbs.png";
if (!m_extra.audiothumbs->isChecked() && !m_extra.videothumbs->isChecked()) {
pixname = "timeline_nothumbs.png";
m_extra.timeline_preview->setPixmap(QPixmap(KStandardDirs::locate("appdata", pixname)));
}
-void Wizard::slotCheckStandard() {
+void Wizard::slotCheckStandard()
+{
m_standard.profiles_list->clear();
QStringList profiles;
if (m_standard.button_dv->isChecked()) {
m_standard.profiles_list->setCurrentRow(0);
}
-void Wizard::slotCheckSelectedItem() {
+void Wizard::slotCheckSelectedItem()
+{
// Make sure we always have an item highlighted
m_standard.profiles_list->setCurrentRow(m_standard.profiles_list->currentRow());
}
-void Wizard::adjustSettings() {
+void Wizard::adjustSettings()
+{
if (m_extra.installmimes->isChecked()) {
QStringList globs;
globs << "*.mts" << "*.m2t" << "*.mod" << "*.ts";
}
-void Wizard::slotCheckMlt() {
+void Wizard::slotCheckMlt()
+{
QString errorMessage;
if (KdenliveSettings::rendererpath().isEmpty()) {
errorMessage.append(i18n("your MLT installation cannot be found. Install MLT and restart Kdenlive.\n"));
slotCheckPrograms();
}
-bool Wizard::isOk() const {
+bool Wizard::isOk() const
+{
return m_systemCheckIsOk;
}
#include "ui_wizardcheck_ui.h"
#include "ui_wizardmltcheck_ui.h"
-class WizardDelegate: public QItemDelegate {
+class WizardDelegate: public QItemDelegate
+{
public:
WizardDelegate(QAbstractItemView* parent = 0): QItemDelegate(parent) {
}
};
-class Wizard : public QWizard {
+class Wizard : public QWizard
+{
Q_OBJECT
public:
Wizard(bool upgrade, QWidget * parent = 0);
#define DBG_AREA
//#include "config.h"
-extern "C" {
+extern "C"
+{
KDE_EXPORT ThumbCreator *new_creator() {
return new WestleyPreview;
}
}
WestleyPreview::WestleyPreview()
- : m_rand(0), m_inigoprocess(0) {
+ : m_rand(0), m_inigoprocess(0)
+{
}
-WestleyPreview::~WestleyPreview() {
+WestleyPreview::~WestleyPreview()
+{
delete m_rand;
delete m_inigoprocess;
}
-bool WestleyPreview::startAndWaitProcess(const QStringList &args) {
+bool WestleyPreview::startAndWaitProcess(const QStringList &args)
+{
kDebug(DBG_AREA) << "westleypreview: starting process with args: " << args << endl;
m_inigoprocess->start(args.join(" "));
if (! m_inigoprocess->waitForStarted()) {
return true;
}
-bool WestleyPreview::create(const QString &path, int width, int /*height*/, QImage &img) {
+bool WestleyPreview::create(const QString &path, int width, int /*height*/, QImage &img)
+{
QFileInfo fi(path);
playerBin = KStandardDirs::findExe("inigo");
if (playerBin.isEmpty()) {
return true;
}
-QImage WestleyPreview::getFrame(const QString &path) {
+QImage WestleyPreview::getFrame(const QString &path)
+{
QStringList args;
const int START = 25;
const int RANGE = 500;
}
-uint WestleyPreview::imageVariance(QImage image) {
+uint WestleyPreview::imageVariance(QImage image)
+{
uint delta = 0;
uint avg = 0;
uint bytes = image.numBytes();
return delta / STEPS;
}
-ThumbCreator::Flags WestleyPreview::flags() const {
+ThumbCreator::Flags WestleyPreview::flags() const
+{
return None;
}
class KTempDir;
class KRandomSequence;
-class WestleyPreview : public QObject, public ThumbCreator {
+class WestleyPreview : public QObject, public ThumbCreator
+{
Q_OBJECT
public:
WestleyPreview();
projects / kdenlive / commitdiff