diff --git a/src/timeline2/view/qml/Clip.qml b/src/timeline2/view/qml/Clip.qml
index cfe830aad..01998850f 100644
--- a/src/timeline2/view/qml/Clip.qml
+++ b/src/timeline2/view/qml/Clip.qml
@@ -1,750 +1,759 @@
 /*
  * Copyright (c) 2013-2016 Meltytech, LLC
  * Author: Dan Dennedy <dan@dennedy.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 import QtQuick 2.6
 import QtQuick.Controls 2.2
 import Kdenlive.Controls 1.0
 import QtQml.Models 2.2
 import QtQuick.Window 2.2
 import 'Timeline.js' as Logic
 import com.enums 1.0
 
 Rectangle {
     id: clipRoot
     property real timeScale: 1.0
     property string clipName: ''
     property string clipResource: ''
     property string mltService: ''
     property string effectNames
     property int modelStart
     // Used to store the current frame on move
     property int currentFrame: -1
     property real scrollX: 0
     property int inPoint: 0
     property int outPoint: 0
     property int clipDuration: 0
     property bool isAudio: false
     property int audioChannels
     property bool isComposition: false
     property bool showKeyframes: false
     property bool isGrabbed: false
     property bool grouped: false
     property var audioLevels
     property var markers
     property var keyframeModel
     property var clipStatus: 0
     property var clipType: 0
     property int fadeIn: 0
     property int fadeOut: 0
     property int binId: 0
     property var parentTrack
     property int trackIndex //Index in track repeater
     property int clipId     //Id of the clip in the model
     property int trackId: -1 // Id of the parent track in the model
     property int fakeTid: -1
     property int fakePosition: 0
     property int originalTrackId: -1
     property int originalX: x
     property int originalDuration: clipDuration
     property int lastValidDuration: clipDuration
     property int draggedX: x
     property bool selected: false
+    property bool isLocked: parentTrack && parentTrack.isLocked == true
     property bool hasAudio
     property bool canBeAudio
     property bool canBeVideo
     property string hash: 'ccc' //TODO
     property double speed: 1.0
     property color borderColor: 'black'
     property bool forceReloadThumb: false
     width : clipDuration * timeScale;
     opacity: dragProxyArea.drag.active && dragProxy.draggedItem == clipId ? 0.8 : 1.0
 
     signal trimmingIn(var clip, real newDuration, var mouse, bool shiftTrim)
     signal trimmedIn(var clip, bool shiftTrim)
     signal trimmingOut(var clip, real newDuration, var mouse, bool shiftTrim)
     signal trimmedOut(var clip, bool shiftTrim)
 
     onIsGrabbedChanged: {
         if (clipRoot.isGrabbed) {
             clipRoot.forceActiveFocus();
             mouseArea.focus = true
         }
     }
 
     onInPointChanged: {
         if (parentTrack && parentTrack.isAudio) {
             thumbsLoader.item.reload()
         }
     }
 
     onClipResourceChanged: {
         if (clipType == ProducerType.Color) {
             color: Qt.darker(getColor())
         }
     }
     ToolTip {
         visible: mouseArea.containsMouse && !dragProxyArea.pressed
         font.pixelSize: root.baseUnit
         delay: 1000
         timeout: 5000
         background: Rectangle {
             color: activePalette.alternateBase
             border.color: activePalette.light
         }
         contentItem: Label {
             color: activePalette.text
             text: clipRoot.clipName + ' (' + timeline.timecode(clipRoot.inPoint) + '-' + timeline.timecode(clipRoot.outPoint) + ')'
         }
     }
 
     onKeyframeModelChanged: {
         console.log('keyframe model changed............')
         if (effectRow.keyframecanvas) {
             effectRow.keyframecanvas.requestPaint()
         }
     }
 
     onClipDurationChanged: {
         width = clipDuration * timeScale;
     }
 
     onModelStartChanged: {
         x = modelStart * timeScale;
     }
     onFakePositionChanged: {
         x = fakePosition * timeScale;
     }
     onFakeTidChanged: {
         if (clipRoot.fakeTid > -1 && parentTrack) {
             if (clipRoot.parent != dragContainer) {
                 var pos = clipRoot.mapToGlobal(clipRoot.x, clipRoot.y);
                 clipRoot.parent = dragContainer
                 pos = clipRoot.mapFromGlobal(pos.x, pos.y)
                 clipRoot.x = pos.x
                 clipRoot.y = pos.y
             }
             clipRoot.y = Logic.getTrackById(clipRoot.fakeTid).y
         }
     }
 
     onForceReloadThumbChanged: {
         // TODO: find a way to force reload of clip thumbs
         thumbsLoader.item.reload()
     }
 
     onTimeScaleChanged: {
         x = modelStart * timeScale;
         width = clipDuration * timeScale;
         labelRect.x = scrollX > modelStart * timeScale ? scrollX - modelStart * timeScale : 0
         if (parentTrack && parentTrack.isAudio) {
             thumbsLoader.item.reload();
         }
     }
     onScrollXChanged: {
         labelRect.x = scrollX > modelStart * timeScale ? scrollX - modelStart * timeScale : 0
     }
 
-    color: Qt.darker(getColor())
-
-    border.color: selected? 'red' : grouped ? 'yellowgreen' : borderColor
+    border.color: selected? activePalette.highlight : grouped ? activePalette.midlight : borderColor
     border.width: isGrabbed ? 8 : 1.5
 
     function updateDrag() {
         var itemPos = mapToItem(tracksContainerArea, 0, 0, clipRoot.width, clipRoot.height)
         initDrag(clipRoot, itemPos, clipRoot.clipId, clipRoot.modelStart, clipRoot.trackId, false)
     }
 
     function getColor() {
         if (clipStatus == ClipState.Disabled) {
             return 'grey'
         }
         if (clipType == ProducerType.Color) {
             var color = clipResource.substring(clipResource.length - 9)
             if (color[0] == '#') {
                 return color
             }
             return '#' + color.substring(color.length - 8, color.length - 2)
         }
-        return isAudio? '#445f5a' : '#416e8c'
+        return isAudio? root.audioColor : root.videoColor
     }
 
 /*    function reparent(track) {
         console.log('TrackId: ',trackId)
         parent = track
         height = track.height
         parentTrack = track
         trackId = parentTrack.trackId
         console.log('Reparenting clip to Track: ', trackId)
         //generateWaveform()
     }
 */
     property bool variableThumbs: (isAudio || clipType == ProducerType.Color || mltService === '')
     property bool isImage: clipType == ProducerType.Image
     property string baseThumbPath: variableThumbs ? '' : 'image://thumbnail/' + binId + '/' + (isImage ? '#0' : '#')
     property string inThumbPath: (variableThumbs || isImage ) ? baseThumbPath : baseThumbPath + Math.floor(inPoint * speed)
     property string outThumbPath: (variableThumbs || isImage ) ? baseThumbPath : baseThumbPath + Math.floor(outPoint * speed)
 
     DropArea { //Drop area for clips
         anchors.fill: clipRoot
         keys: 'kdenlive/effect'
         property string dropData
         property string dropSource
         property int dropRow: -1
         onEntered: {
             dropData = drag.getDataAsString('kdenlive/effect')
             dropSource = drag.getDataAsString('kdenlive/effectsource')
         }
         onDropped: {
             console.log("Add effect: ", dropData)
             if (dropSource == '') {
                 // drop from effects list
                 controller.addClipEffect(clipRoot.clipId, dropData);
             } else {
                 controller.copyClipEffect(clipRoot.clipId, dropSource);
             }
             dropSource = ''
             dropRow = -1
             drag.acceptProposedAction
         }
     }
 
     onAudioLevelsChanged: {
         if (parentTrack && parentTrack.isAudio) {
             thumbsLoader.item.reload()
         }
     }
     MouseArea {
         id: mouseArea
         visible: root.activeTool === 0
         anchors.fill: clipRoot
         acceptedButtons: Qt.RightButton
         hoverEnabled: true
         cursorShape: dragProxyArea.drag.active ? Qt.ClosedHandCursor : Qt.OpenHandCursor
         onPressed: {
             root.stopScrolling = true
             if (mouse.button == Qt.RightButton) {
                 if (timeline.selection.indexOf(clipRoot.clipId) == -1) {
                     timeline.addSelection(clipRoot.clipId, true)
                 }
                 clipMenu.clipId = clipRoot.clipId
                 clipMenu.clipStatus = clipRoot.clipStatus
                 clipMenu.grouped = clipRoot.grouped
                 clipMenu.trackId = clipRoot.trackId
                 clipMenu.canBeAudio = clipRoot.canBeAudio
                 clipMenu.canBeVideo = clipRoot.canBeVideo
                 clipMenu.popup()
             }
         }
         Keys.onShortcutOverride: event.accepted = clipRoot.isGrabbed && (event.key === Qt.Key_Left || event.key === Qt.Key_Right || event.key === Qt.Key_Up || event.key === Qt.Key_Down)
         Keys.onLeftPressed: {
             controller.requestClipMove(clipRoot.clipId, clipRoot.trackId, clipRoot.modelStart - 1, true, true, true);
         }
         Keys.onRightPressed: {
             controller.requestClipMove(clipRoot.clipId, clipRoot.trackId, clipRoot.modelStart + 1, true, true, true);
         }
         Keys.onUpPressed: {
             controller.requestClipMove(clipRoot.clipId, controller.getNextTrackId(clipRoot.trackId), clipRoot.modelStart, true, true, true);
         }
         Keys.onDownPressed: {
             controller.requestClipMove(clipRoot.clipId, controller.getPreviousTrackId(clipRoot.trackId), clipRoot.modelStart, true, true, true);
         }
         onPositionChanged: {
             var mapped = parentTrack.mapFromItem(clipRoot, mouse.x, mouse.y).x
             root.mousePosChanged(Math.round(mapped / timeline.scaleFactor))
         }
         onEntered: {
             var itemPos = mapToItem(tracksContainerArea, 0, 0, width, height)
             initDrag(clipRoot, itemPos, clipRoot.clipId, clipRoot.modelStart, clipRoot.trackId, false)
         }
 
         onExited: {
             endDrag()
         }
         onWheel: zoomByWheel(wheel)
     }
 
     Item {
         // Clipping container
         id: container
         anchors.fill: parent
         anchors.margins:1.5
         clip: true
         Loader {
             id: thumbsLoader
             anchors.fill: parent
             source: parentTrack.isAudio ? "ClipAudioThumbs.qml" : clipType == ProducerType.Color ? "" : "ClipThumbs.qml"
         }
 
         Rectangle {
             // text background
             id: labelRect
             color: clipRoot.selected ? 'darkred' : '#66000000'
             width: label.width + 2
             height: label.height
             visible: clipRoot.width > width / 2
             Text {
                 id: label
                 text: clipName + (clipRoot.speed != 1.0 ? ' [' + Math.round(clipRoot.speed*100) + '%]': '')
                 font.pixelSize: root.baseUnit * 1.2
                 anchors {
                     top: labelRect.top
                     left: labelRect.left
                     topMargin: 1
                     leftMargin: 1
                 }
                 color: 'white'
                 style: Text.Outline
                 styleColor: 'black'
             }
         }
         Rectangle {
             // effects
             id: effectsRect
             color: '#555555'
             width: effectLabel.width + 2
             height: effectLabel.height
             x: labelRect.x
             anchors.top: labelRect.bottom
             visible: labelRect.visible && clipRoot.effectNames != ''
             Text {
                 id: effectLabel
                 text: clipRoot.effectNames
                 font.pixelSize: root.baseUnit * 1.2
                 anchors {
                     top: effectsRect.top
                     left: effectsRect.left
                     topMargin: 1
                     leftMargin: 1
                     // + ((isAudio || !settings.timelineShowThumbnails) ? 0 : inThumbnail.width) + 1
                 }
                 color: 'white'
                 //style: Text.Outline
                 styleColor: 'black'
             }
         }
 
         Repeater {
             model: markers
             delegate:
             Item {
                 anchors.fill: parent
                 Rectangle {
                     id: markerBase
                     width: 1
                     height: parent.height
                     x: (model.frame - clipRoot.inPoint) * timeScale;
                     color: model.color
                 }
                 Rectangle {
                     visible: mlabel.visible
                     opacity: 0.7
                     x: markerBase.x
                     radius: 2
                     width: mlabel.width + 4
                     height: mlabel.height
                     anchors {
                         bottom: parent.verticalCenter
                     }
                     color: model.color
                     MouseArea {
                         z: 10
                         anchors.fill: parent
                         acceptedButtons: Qt.LeftButton
                         cursorShape: Qt.PointingHandCursor
                         hoverEnabled: true
                         onDoubleClicked: timeline.editMarker(clipRoot.binId, model.frame)
                         onClicked: timeline.position = (clipRoot.x + markerBase.x) / timeline.scaleFactor
                     }
                 }
                 Text {
                     id: mlabel
                     visible: timeline.showMarkers && parent.width > width * 1.5
                     text: model.comment
                     font.pixelSize: root.baseUnit
                     x: markerBase.x
                     anchors {
                         bottom: parent.verticalCenter
                         topMargin: 2
                         leftMargin: 2
                     }
                     color: 'white'
                 }
             }
         }
 
         KeyframeView {
             id: effectRow
             visible: clipRoot.showKeyframes && clipRoot.keyframeModel
             selected: clipRoot.selected
             inPoint: clipRoot.inPoint
             outPoint: clipRoot.outPoint
             masterObject: clipRoot
         }
     }
 
     states: [
+        State {
+            name: 'locked'
+            when: isLocked
+            PropertyChanges {
+                target: clipRoot
+                color: root.neutralColor
+                opacity: 0.8
+                z: 0
+            }
+        },
         State {
             name: 'normal'
             when: clipRoot.selected === false
             PropertyChanges {
                 target: clipRoot
-                color: Qt.darker(getColor())
+                color: getColor()
                 z: 0
             }
         },
         State {
             name: 'selected'
             when: clipRoot.selected === true
             PropertyChanges {
                 target: clipRoot
-                color: getColor()
+                color: Qt.lighter(getColor(), 1.5)
                 z: 3
             }
         }
     ]
 
 
     TimelineTriangle {
         id: fadeInTriangle
         fillColor: 'green'
         width: Math.min(clipRoot.fadeIn * timeScale, clipRoot.width)
         height: clipRoot.height - clipRoot.border.width * 2
         anchors.left: clipRoot.left
         anchors.top: clipRoot.top
         anchors.margins: clipRoot.border.width
         opacity: 0.3
     }
     Rectangle {
         id: fadeInControl
         anchors.left: fadeInTriangle.width > radius? undefined : fadeInTriangle.left
         anchors.horizontalCenter: fadeInTriangle.width > radius? fadeInTriangle.right : undefined
         anchors.top: fadeInTriangle.top
         anchors.topMargin: -10
         width: root.baseUnit * 2
         height: width
         radius: width / 2
         color: '#FF66FFFF'
         border.width: 2
         border.color: 'green'
         opacity: 0
         Drag.active: fadeInMouseArea.drag.active
         MouseArea {
             id: fadeInMouseArea
             anchors.fill: parent
             hoverEnabled: true
             cursorShape: Qt.PointingHandCursor
             drag.target: parent
             drag.minimumX: -root.baseUnit * 2
             drag.maximumX: container.width
             drag.axis: Drag.XAxis
             property int startX
             property int startFadeIn
             onEntered: parent.opacity = 0.7
             onExited: {
                 if (!pressed) {
                   parent.opacity = 0
                 }
             }
             drag.smoothed: false
             onPressed: {
                 root.stopScrolling = true
                 startX = parent.x
                 startFadeIn = clipRoot.fadeIn
                 parent.anchors.left = undefined
                 parent.anchors.horizontalCenter = undefined
                 parent.opacity = 1
                 fadeInTriangle.opacity = 0.5
                 // parentTrack.clipSelected(clipRoot, parentTrack) TODO
             }
             onReleased: {
                 root.stopScrolling = false
                 fadeInTriangle.opacity = 0.3
                 parent.opacity = 0
                 if (fadeInTriangle.width > parent.radius)
                     parent.anchors.horizontalCenter = fadeInTriangle.right
                 else
                     parent.anchors.left = fadeInTriangle.left
                 console.log('released fade: ', clipRoot.fadeIn)
                 timeline.adjustFade(clipRoot.clipId, 'fadein', clipRoot.fadeIn, startFadeIn)
                 bubbleHelp.hide()
             }
             onPositionChanged: {
                 if (mouse.buttons === Qt.LeftButton) {
                     var delta = Math.round((parent.x - startX) / timeScale)
                     if (delta != 0) {
                         var duration = Math.max(0, startFadeIn + delta)
                         duration = Math.min(duration, clipRoot.clipDuration)
                         if (clipRoot.fadeIn - 1 != duration) {
                             timeline.adjustFade(clipRoot.clipId, 'fadein', duration, -1)
                         }
                         // Show fade duration as time in a "bubble" help.
                         var s = timeline.timecode(Math.max(duration, 0))
                         bubbleHelp.show(clipRoot.x, parentTrack.y + clipRoot.height, s)
                     }
                 }
             }
         }
         SequentialAnimation on scale {
             loops: Animation.Infinite
             running: fadeInMouseArea.containsMouse && !fadeInMouseArea.pressed
             NumberAnimation {
                 from: 1.0
                 to: 0.7
                 duration: 250
                 easing.type: Easing.InOutQuad
             }
             NumberAnimation {
                 from: 0.7
                 to: 1.0
                 duration: 250
                 easing.type: Easing.InOutQuad
             }
         }
     }
 
     TimelineTriangle {
         id: fadeOutCanvas
         fillColor: 'red'
         width: Math.min(clipRoot.fadeOut * timeScale, clipRoot.width)
         height: clipRoot.height - clipRoot.border.width * 2
         anchors.right: clipRoot.right
         anchors.top: clipRoot.top
         anchors.margins: clipRoot.border.width
         opacity: 0.3
         transform: Scale { xScale: -1; origin.x: fadeOutCanvas.width / 2}
     }
     Rectangle {
         id: fadeOutControl
         anchors.right: fadeOutCanvas.width > radius? undefined : fadeOutCanvas.right
         anchors.horizontalCenter: fadeOutCanvas.width > radius? fadeOutCanvas.left : undefined
         anchors.top: fadeOutCanvas.top
         anchors.topMargin: -10
         width: root.baseUnit * 2
         height: width
         radius: width / 2
         color: '#66FFFFFF'
         border.width: 2
         border.color: 'red'
         opacity: 0
         Drag.active: fadeOutMouseArea.drag.active
         MouseArea {
             id: fadeOutMouseArea
             anchors.fill: parent
             hoverEnabled: true
             cursorShape: Qt.PointingHandCursor
             drag.target: parent
             drag.axis: Drag.XAxis
             drag.minimumX: -root.baseUnit * 2
             drag.maximumX: container.width
             property int startX
             property int startFadeOut
             onEntered: parent.opacity = 0.7
             onExited: {
                 if (!pressed) {
                   parent.opacity = 0
                 }
             }
             drag.smoothed: false
             onPressed: {
                 root.stopScrolling = true
                 startX = parent.x
                 startFadeOut = clipRoot.fadeOut
                 parent.anchors.right = undefined
                 parent.anchors.horizontalCenter = undefined
                 parent.opacity = 1
                 fadeOutCanvas.opacity = 0.5
             }
             onReleased: {
                 fadeOutCanvas.opacity = 0.3
                 parent.opacity = 0
                 root.stopScrolling = false
                 if (fadeOutCanvas.width > parent.radius)
                     parent.anchors.horizontalCenter = fadeOutCanvas.left
                 else
                     parent.anchors.right = fadeOutCanvas.right
                 timeline.adjustFade(clipRoot.clipId, 'fadeout', clipRoot.fadeOut, startFadeOut)
                 bubbleHelp.hide()
             }
             onPositionChanged: {
                 if (mouse.buttons === Qt.LeftButton) {
                     var delta = Math.round((startX - parent.x) / timeScale)
                     if (delta != 0) {
                         var duration = Math.max(0, startFadeOut + delta)
                         duration = Math.min(duration, clipRoot.clipDuration)
                         if (clipRoot.fadeOut - 1 != duration) {
                             timeline.adjustFade(clipRoot.clipId, 'fadeout', duration, -1)
                         }
                         // Show fade duration as time in a "bubble" help.
                         var s = timeline.timecode(Math.max(duration, 0))
                         bubbleHelp.show(clipRoot.x + clipRoot.width, parentTrack.y + clipRoot.height, s)
                     }
                 }
             }
         }
         SequentialAnimation on scale {
             loops: Animation.Infinite
             running: fadeOutMouseArea.containsMouse && !fadeOutMouseArea.pressed
             NumberAnimation {
                 from: 1.0
                 to: 0.7
                 duration: 250
                 easing.type: Easing.InOutQuad
             }
             NumberAnimation {
                 from: 0.7
                 to: 1.0
                 duration: 250
                 easing.type: Easing.InOutQuad
             }
         }
     }
 
     Rectangle {
         id: trimIn
         anchors.left: clipRoot.left
         anchors.leftMargin: 0
         height: parent.height
         width: 5
         color: isAudio? 'green' : 'lawngreen'
         opacity: 0
         Drag.active: trimInMouseArea.drag.active
         Drag.proposedAction: Qt.MoveAction
         visible: root.activeTool === 0 && !mouseArea.drag.active
 
         MouseArea {
             id: trimInMouseArea
             anchors.fill: parent
             hoverEnabled: true
             drag.target: parent
             drag.axis: Drag.XAxis
             drag.smoothed: false
             property bool shiftTrim: false
             property bool sizeChanged: false
             cursorShape: (containsMouse ? Qt.SizeHorCursor : Qt.ClosedHandCursor);
             onPressed: {
                 root.stopScrolling = true
                 clipRoot.originalX = clipRoot.x
                 clipRoot.originalDuration = clipDuration
                 parent.anchors.left = undefined
                 shiftTrim = mouse.modifiers & Qt.ShiftModifier
                 parent.opacity = 0
             }
             onReleased: {
                 root.stopScrolling = false
                 parent.anchors.left = clipRoot.left
                 if (sizeChanged) {
                     clipRoot.trimmedIn(clipRoot, shiftTrim)
                     sizeChanged = false
                 }
             }
             onPositionChanged: {
                 if (mouse.buttons === Qt.LeftButton) {
                     var delta = Math.round((trimIn.x) / timeScale)
                     if (delta !== 0) {
                         if (delta < -modelStart) {
                             delta = -modelStart
                         }
                         var newDuration =  clipDuration - delta
                         sizeChanged = true
                         clipRoot.trimmingIn(clipRoot, newDuration, mouse, shiftTrim)
                     }
                 }
             }
             onEntered: {
                 if (!pressed) {
                     parent.opacity = 0.5
                 }
             }
             onExited: {
                 parent.opacity = 0
             }
         }
     }
     Rectangle {
         id: trimOut
         anchors.right: clipRoot.right
         anchors.rightMargin: 0
         height: parent.height
         width: 5
         color: 'red'
         opacity: 0
         Drag.active: trimOutMouseArea.drag.active
         Drag.proposedAction: Qt.MoveAction
         visible: root.activeTool === 0 && !mouseArea.drag.active
 
         MouseArea {
             id: trimOutMouseArea
             anchors.fill: parent
             hoverEnabled: true
             property bool shiftTrim: false
             property bool sizeChanged: false
             cursorShape: (containsMouse ? Qt.SizeHorCursor : Qt.ClosedHandCursor);
             drag.target: parent
             drag.axis: Drag.XAxis
             drag.smoothed: false
 
             onPressed: {
                 root.stopScrolling = true
                 clipRoot.originalDuration = clipDuration
                 parent.anchors.right = undefined
                 shiftTrim = mouse.modifiers & Qt.ShiftModifier
                 parent.opacity = 0
             }
             onReleased: {
                 root.stopScrolling = false
                 parent.anchors.right = clipRoot.right
                 if (sizeChanged) {
                     clipRoot.trimmedOut(clipRoot, shiftTrim)
                     sizeChanged = false
                 }
             }
             onPositionChanged: {
                 if (mouse.buttons === Qt.LeftButton) {
                     var newDuration = Math.round((parent.x + parent.width) / timeScale)
                     if (newDuration != clipDuration) {
                         sizeChanged = true
                         clipRoot.trimmingOut(clipRoot, newDuration, mouse, shiftTrim)
                     }
                 }
             }
             onEntered: {
                 if (!pressed) {
                     parent.opacity = 0.5
                 }
             }
             onExited: parent.opacity = 0
         }
     }
 
         /*MenuItem {
             id: mergeItem
             text: i18n('Merge with next clip')
             onTriggered: timeline.mergeClipWithNext(trackIndex, index, false)
         }
         MenuItem {
             text: i18n('Rebuild Audio Waveform')
             onTriggered: timeline.remakeAudioLevels(trackIndex, index)
         }*/
         /*onPopupVisibleChanged: {
             if (visible && application.OS !== 'OS X' && __popupGeometry.height > 0) {
                 // Try to fix menu running off screen. This only works intermittently.
                 menu.__yOffset = Math.min(0, Screen.height - (__popupGeometry.y + __popupGeometry.height + 40))
                 menu.__xOffset = Math.min(0, Screen.width - (__popupGeometry.x + __popupGeometry.width))
             }
         }*/
 }
diff --git a/src/timeline2/view/qml/ClipAudioThumbs.qml b/src/timeline2/view/qml/ClipAudioThumbs.qml
index d84952ee9..62d718fa3 100644
--- a/src/timeline2/view/qml/ClipAudioThumbs.qml
+++ b/src/timeline2/view/qml/ClipAudioThumbs.qml
@@ -1,53 +1,54 @@
 import QtQuick 2.6
 import QtQuick.Controls 2.2
 import Kdenlive.Controls 1.0
 import QtQml.Models 2.2
 import com.enums 1.0
 
 Row {
     id: waveform
     visible: clipStatus != ClipState.VideoOnly && parentTrack.isAudio && timeline.showAudioThumbnails  && !parentTrack.isMute
     opacity: clipStatus == ClipState.Disabled ? 0.2 : 1
     property int maxWidth: 1500
     property int innerWidth: clipRoot.width - clipRoot.border.width * 2
     anchors.fill: parent
     property int scrollStart: scrollView.flickableItem.contentX - clipRoot.modelStart * timeline.scaleFactor
     property int scrollEnd: scrollStart + scrollView.viewport.width
     property int scrollMin: scrollView.flickableItem.contentX / timeline.scaleFactor
     property int scrollMax: scrollMin + scrollView.viewport.width / timeline.scaleFactor
 
     onScrollStartChanged: {
         reload()
     }
 
     function reload() {
         // This is needed to make the model have the correct count.
         // Model as a property expression is not working in all cases.
             if (!timeline.showAudioThumbnails || (waveform.scrollMin > clipRoot.modelStart + clipRoot.clipDuration) || (clipRoot.modelStart > waveform.scrollMax) || clipRoot.audioLevels == '') {
                 return;
             }
             //var t0 = new Date();
             waveformRepeater.model = Math.ceil(waveform.innerWidth / waveform.maxWidth)
             var firstWaveRepeater = Math.max(0, Math.floor((waveform.scrollMin - clipRoot.modelStart) / (waveform.maxWidth / timeline.scaleFactor)))
             var lastWaveRepeater = Math.min(waveformRepeater.count - 1, firstWaveRepeater + Math.ceil((waveform.scrollMax - waveform.scrollMin) / (waveform.maxWidth / timeline.scaleFactor)))
             for (var i = firstWaveRepeater; i <= lastWaveRepeater; i++) {
                 waveformRepeater.itemAt(i).update();
             }
             /*var t1 = new Date();
             console.log("Took: " + (t1.valueOf() - t0.valueOf()) + " millisecs for " + waveformRepeater.count + " iterations");*/
     }
 
     Repeater {
         id: waveformRepeater
         TimelineWaveform {
             width: Math.min(waveform.innerWidth, waveform.maxWidth)
             height: waveform.height
             channels: clipRoot.audioChannels
             showItem: waveform.visible && (index * width) < waveform.scrollEnd && (index * width + width) > waveform.scrollStart
             format: timeline.audioThumbFormat
             inPoint: Math.round((clipRoot.inPoint + (index * waveform.maxWidth / clipRoot.timeScale)) * clipRoot.speed) * channels
             outPoint: inPoint + Math.round(width / clipRoot.timeScale * clipRoot.speed) * channels
             levels: clipRoot.audioLevels
+            fillColor: activePalette.text
         }
     }
 }
diff --git a/src/timeline2/view/qml/timeline.qml b/src/timeline2/view/qml/timeline.qml
index a4091bf7e..8fcdc6dcb 100644
--- a/src/timeline2/view/qml/timeline.qml
+++ b/src/timeline2/view/qml/timeline.qml
@@ -1,1306 +1,1309 @@
 import QtQuick 2.6
 import QtQml.Models 2.2
 import QtQuick.Controls 1.4 as OLD
 import QtQuick.Controls 2.2
 import QtQuick.Layouts 1.3
 import QtQuick.Dialogs 1.2
 import Kdenlive.Controls 1.0
 import QtQuick.Window 2.2
 import 'Timeline.js' as Logic
 
 Rectangle {
     id: root
     objectName: "timelineview"
 
     SystemPalette { id: activePalette }
     color: activePalette.window
     property bool validMenu: false
+    property color textColor: activePalette.text
 
     signal clipClicked()
     signal mousePosChanged(int position)
     signal zoomIn(bool onMouse)
     signal zoomOut(bool onMouse)
 
     FontMetrics {
         id: fontMetrics
         font.family: "Arial"
     }
     ClipMenu {
         id: clipMenu
     }
     CompositionMenu {
         id: compositionMenu
     }
 
     function updatePalette() {
         root.color = activePalette.window
-        cursor.color = activePalette.text
+        root.textColor = activePalette.text
         playhead.fillColor = activePalette.windowText
         ruler.repaintRuler()
     }
 
     function moveSelectedTrack(offset) {
         var cTrack = Logic.getTrackIndexFromId(timeline.activeTrack)
         var newTrack = cTrack + offset
         var max = tracksRepeater.count;
         if (newTrack < 0) {
             newTrack = max - 1;
         } else if (newTrack >= max) {
             newTrack = 0;
         }
         console.log('Setting curr tk: ', newTrack, 'MAX: ',max)
         timeline.activeTrack = tracksRepeater.itemAt(newTrack).trackInternalId
     }
 
     function zoomByWheel(wheel) {
         if (wheel.modifiers & Qt.AltModifier) {
             if (wheel.angleDelta.x > 0) {
                 timeline.triggerAction('monitor_seek_snap_backward')
             } else {
                 timeline.triggerAction('monitor_seek_snap_forward')
             }
         } else if (wheel.modifiers & Qt.ControlModifier) {
             if (wheel.angleDelta.y > 0) {
                 root.zoomIn(true);
             } else {
                 root.zoomOut(true);
             }
         } else {
             var newScroll = Math.min(scrollView.flickableItem.contentX - wheel.angleDelta.y, timeline.fullDuration * root.timeScale - (scrollView.width - scrollView.__verticalScrollBar.width))
             scrollView.flickableItem.contentX = Math.max(newScroll, 0)
         }
         wheel.accepted = true
     }
 
     function continuousScrolling(x) {
         // This provides continuous scrolling at the left/right edges.
         if (x > scrollView.flickableItem.contentX + scrollView.width - 50) {
             scrollTimer.item = clip
             scrollTimer.backwards = false
             scrollTimer.start()
         } else if (x < 50) {
             scrollView.flickableItem.contentX = 0;
             scrollTimer.stop()
         } else if (x < scrollView.flickableItem.contentX + 50) {
             scrollTimer.item = clip
             scrollTimer.backwards = true
             scrollTimer.start()
         } else {
             scrollTimer.stop()
         }
 
     }
     function getTrackYFromId(a_track) {
         return Logic.getTrackYFromId(a_track)
     }
 
     function getTrackYFromMltIndex(a_track) {
         return Logic.getTrackYFromMltIndex(a_track)
     }
 
     function getTracksCount() {
         return Logic.getTracksList()
     }
 
     function getMousePos() {
         return (scrollView.flickableItem.contentX + tracksArea.mouseX) / timeline.scaleFactor
     }
 
     function getScrollPos() {
         return scrollView.flickableItem.contentX
     }
 
     function setScrollPos(pos) {
         return scrollView.flickableItem.contentX = pos
     }
 
     function getCopiedItemId() {
         return copiedClip
     }
 
     function getMouseTrack() {
         return Logic.getTrackIdFromPos(tracksArea.mouseY - ruler.height + scrollView.flickableItem.contentY)
     }
 
     function getTrackColor(audio, header) {
         var col = activePalette.alternateBase
         if (audio) {
             col = Qt.tint(col, "#1000cc00")
         }
         if (header) {
             col = Qt.darker(col, 1.05)
         }
         return col
     }
 
     function clearDropData() {
         clipBeingDroppedId = -1
         droppedPosition = -1
         droppedTrack = -1
         scrollTimer.running = false
         scrollTimer.stop()
     }
 
     function initDrag(itemObject, itemCoord, itemId, itemPos, itemTrack, isComposition) {
         dragProxy.x = itemObject.modelStart * timeScale
         dragProxy.y = itemCoord.y
         dragProxy.width = itemObject.clipDuration * timeScale
         dragProxy.height = itemCoord.height
         dragProxy.masterObject = itemObject
         dragProxy.draggedItem = itemId
         dragProxy.sourceTrack = itemTrack
         dragProxy.sourceFrame = itemPos
         dragProxy.isComposition = isComposition
     }
     function endDrag() {
         dragProxy.draggedItem = -1
         dragProxy.x = 0
         dragProxy.y = 0
         dragProxy.width = 0
         dragProxy.height = 0
     }
 
     property int headerWidth: timeline.headerWidth()
     property int activeTool: 0
     property real baseUnit: fontMetrics.font.pointSize
     property color selectedTrackColor: Qt.rgba(activePalette.highlight.r, activePalette.highlight.g, activePalette.highlight.b, 0.4)
     property bool stopScrolling: false
     property int duration: timeline.duration
-    property color shotcutBlue: Qt.rgba(23/255, 92/255, 118/255, 1.0)
+    property color audioColor: timeline.audioColor
+    property color videoColor: timeline.videoColor
+    property color neutralColor: timeline.neutralColor
     property int clipBeingDroppedId: -1
     property string clipBeingDroppedData
     property int droppedPosition: -1
     property int droppedTrack: -1
     property int clipBeingMovedId: -1
     property int spacerGroup: -1
     property int spacerFrame: -1
     property int spacerClickFrame: -1
     property real timeScale: timeline.scaleFactor
     property real snapping: timeline.snap ? 10 / Math.sqrt(timeScale) : -1
     property var timelineSelection: timeline.selection
     property int trackHeight
     property int copiedClip: -1
     property int zoomOnMouse: -1
     property int viewActiveTrack: timeline.activeTrack
 
     //onCurrentTrackChanged: timeline.selection = []
     onTimeScaleChanged: {
         if (root.zoomOnMouse >= 0) {
             scrollView.flickableItem.contentX = Math.max(0, root.zoomOnMouse * timeline.scaleFactor - tracksArea.mouseX)
             root.zoomOnMouse = -1
         } else {
             scrollView.flickableItem.contentX = Math.max(0, (timeline.seekPosition > -1 ? timeline.seekPosition : timeline.position) * timeline.scaleFactor - (scrollView.width / 2))
         }
         root.snapping = timeline.snap ? 10 / Math.sqrt(root.timeScale) : -1
         ruler.adjustStepSize()
         if (dragProxy.draggedItem > -1 && dragProxy.masterObject) {
             // update dragged item pos
             dragProxy.masterObject.updateDrag()
         }
     }
 
     onViewActiveTrackChanged: {
         var tk = Logic.getTrackById(timeline.activeTrack)
         if (tk.y < scrollView.flickableItem.contentY) {
             scrollView.flickableItem.contentY = Math.max(0, tk.y - scrollView.height / 3)
         } else if (tk.y + tk.height > scrollView.flickableItem.contentY + scrollView.viewport.height) {
             scrollView.flickableItem.contentY = Math.min(scrollView.flickableItem.height, tk.y - scrollView.height / 3)
         }
     }
 
     DropArea { //Drop area for compositions
         width: root.width - headerWidth
         height: root.height - ruler.height
         y: ruler.height
         x: headerWidth
         keys: 'kdenlive/composition'
         onEntered: {
             console.log("Trying to drop composition")
             if (clipBeingMovedId == -1) {
                 console.log("No clip being moved")
                 var track = Logic.getTrackIdFromPos(drag.y + scrollView.flickableItem.contentY)
                 var frame = Math.round((drag.x + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                 droppedPosition = frame
                 if (track >= 0) {
                     clipBeingDroppedData = drag.getDataAsString('kdenlive/composition')
                     console.log("Trying to insert",track, frame, clipBeingDroppedData)
                     clipBeingDroppedId = timeline.insertComposition(track, frame, clipBeingDroppedData, false)
                     console.log("id",clipBeingDroppedId)
                     continuousScrolling(drag.x + scrollView.flickableItem.contentX)
                     drag.acceptProposedAction()
                 } else {
                     drag.accepted = false
                 }
             }
         }
         onPositionChanged: {
             if (clipBeingMovedId == -1) {
                 var track = Logic.getTrackIdFromPos(drag.y + scrollView.flickableItem.contentY)
                 if (track !=-1) {
                     var frame = Math.round((drag.x + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                     frame = controller.suggestSnapPoint(frame, root.snapping)
                     if (clipBeingDroppedId >= 0){
                         controller.requestCompositionMove(clipBeingDroppedId, track, frame, true, false)
                         continuousScrolling(drag.x + scrollView.flickableItem.contentX)
                     } else {
                         clipBeingDroppedData = drag.getDataAsString('kdenlive/composition')
                         clipBeingDroppedId = timeline.insertComposition(track, frame, clipBeingDroppedData , false)
                         continuousScrolling(drag.x + scrollView.flickableItem.contentX)
                     }
                 }
             }
         }
         onExited:{
             if (clipBeingDroppedId != -1) {
                 controller.requestItemDeletion(clipBeingDroppedId, false)
             }
             clearDropData()
         }
         onDropped: {
             if (clipBeingDroppedId != -1) {
                 var frame = controller.getCompositionPosition(clipBeingDroppedId)
                 var track = controller.getCompositionTrackId(clipBeingDroppedId)
                 // we simulate insertion at the final position so that stored undo has correct value
                 controller.requestItemDeletion(clipBeingDroppedId, false)
                 timeline.insertNewComposition(track, frame, clipBeingDroppedData, true)
             }
             clearDropData()
         }
     }
     DropArea { //Drop area for bin/clips
         /** @brief local helper function to handle the insertion of multiple dragged items */
         function insertAndMaybeGroup(track, frame, droppedData) {
             var binIds = droppedData.split(";")
             if (binIds.length == 0) {
                 return -1
             }
 
             var id = -1
             if (binIds.length == 1) {
                 id = timeline.insertClip(timeline.activeTrack, frame, clipBeingDroppedData, false, true, false)
             } else {
                 var ids = timeline.insertClips(timeline.activeTrack, frame, binIds, false, true, false)
 
                 // if the clip insertion succeeded, request the clips to be grouped
                 if (ids.length > 0) {
                     timeline.groupClips(ids)
                     id = ids[0]
                 }
             }
             return id
         }
 
         width: root.width - headerWidth
         height: root.height - ruler.height
         y: ruler.height
         x: headerWidth
         keys: 'kdenlive/producerslist'
         onEntered: {
             if (clipBeingMovedId == -1) {
                 //var track = Logic.getTrackIdFromPos(drag.y)
                 var track = Logic.getTrackIndexFromPos(drag.y + scrollView.flickableItem.contentY)
                 if (track >= 0  && track < tracksRepeater.count) {
                     var frame = Math.round((drag.x + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                     droppedPosition = frame
                     timeline.activeTrack = tracksRepeater.itemAt(track).trackInternalId
                     //drag.acceptProposedAction()
                     clipBeingDroppedData = drag.getDataAsString('kdenlive/producerslist')
                     console.log('dropped data: ', clipBeingDroppedData)
                     clipBeingDroppedId = insertAndMaybeGroup(timeline.activeTrack, frame, clipBeingDroppedData)
                     continuousScrolling(drag.x + scrollView.flickableItem.contentX)
                 } else {
                     drag.accepted = false
                 }
             }
         }
         onExited:{
             if (clipBeingDroppedId != -1) {
                 controller.requestItemDeletion(clipBeingDroppedId, false)
             }
             clearDropData()
         }
         onPositionChanged: {
             if (clipBeingMovedId == -1) {
                 var track = Logic.getTrackIndexFromPos(drag.y + scrollView.flickableItem.contentY)
                 if (track >= 0  && track < tracksRepeater.count) {
                     timeline.activeTrack = tracksRepeater.itemAt(track).trackInternalId
                     var frame = Math.round((drag.x + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                     frame = controller.suggestSnapPoint(frame, root.snapping)
                     if (clipBeingDroppedId >= 0){
                         controller.requestClipMove(clipBeingDroppedId, timeline.activeTrack, frame, true, false, false)
                         continuousScrolling(drag.x + scrollView.flickableItem.contentX)
                     } else {
                         clipBeingDroppedId = insertAndMaybeGroup(timeline.activeTrack, frame, drag.getDataAsString('kdenlive/producerslist'), false, true)
                         continuousScrolling(drag.x + scrollView.flickableItem.contentX)
                     }
                 }
             }
         }
         onDropped: {
             if (clipBeingDroppedId != -1) {
                 var frame = controller.getClipPosition(clipBeingDroppedId)
                 var track = controller.getClipTrackId(clipBeingDroppedId)
                 /* We simulate insertion at the final position so that stored undo has correct value
                  * NOTE: even if dropping multiple clips, requesting the deletion of the first one is
                  * enough as internally it will request the group deletion
                  */
                 controller.requestItemDeletion(clipBeingDroppedId, false)
 
                 var binIds = clipBeingDroppedData.split(";")
                 if (binIds.length == 1) {
                     timeline.insertClip(track, frame, clipBeingDroppedData, true, true, false)
                 } else {
                     timeline.insertClips(track, frame, binIds, true, true)
                 }
             }
             clearDropData()
         }
     }
     OLD.Menu {
         id: menu
         property int clickedX
         property int clickedY
         onAboutToHide: {
             timeline.ungrabHack()
         }
         OLD.MenuItem {
             text: i18n('Paste')
             iconName: 'edit-paste'
             visible: copiedClip != -1
             onTriggered: {
                 timeline.pasteItem()
             }
         }
         OLD.MenuItem {
             text: i18n('Insert Space')
             onTriggered: {
                 var track = Logic.getTrackIdFromPos(menu.clickedY - ruler.height + scrollView.flickableItem.contentY)
                 var frame = Math.floor((menu.clickedX + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                 timeline.insertSpace(track, frame);
             }
         }
         OLD.MenuItem {
             text: i18n('Remove Space On Active Track')
             onTriggered: {
                 var track = Logic.getTrackIdFromPos(menu.clickedY - ruler.height + scrollView.flickableItem.contentY)
                 var frame = Math.floor((menu.clickedX + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                 timeline.removeSpace(track, frame);
             }
         }
         OLD.MenuItem {
             text: i18n('Remove Space')
             onTriggered: {
                 var track = Logic.getTrackIdFromPos(menu.clickedY - ruler.height + scrollView.flickableItem.contentY)
                 var frame = Math.floor((menu.clickedX + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                 timeline.removeSpace(track, frame, true);
             }
         }
         OLD.MenuItem {
             id: addGuideMenu
             text: i18n('Add Guide')
             onTriggered: {
                 timeline.switchGuide(timeline.position);
             }
         }
         OLD.MenuItem {
             id: editGuideMenu
             text: i18n('Edit Guide')
             visible: false
             onTriggered: {
                 timeline.editGuide(timeline.position);
             }
         }
         AssetMenu {
             title: i18n('Insert a composition...')
             menuModel: transitionModel
             isTransition: true
             onAssetSelected: {
                 var track = Logic.getTrackIdFromPos(menu.clickedY - ruler.height + scrollView.flickableItem.contentY)
                 var frame = Math.round((menu.clickedX + scrollView.flickableItem.contentX) / timeline.scaleFactor)
                 var id = timeline.insertComposition(track, frame, assetId, true)
                 if (id == -1) {
                     compositionFail.open()
                 }
             }
         }
         onAboutToShow: {
             if (guidesModel.hasMarker(timeline.position)) {
                 // marker at timeline position
                 addGuideMenu.text = i18n('Remove Guide')
                 editGuideMenu.visible = true
             } else {
                 addGuideMenu.text = i18n('Add Guide')
                 editGuideMenu.visible = false
             }
             console.log("pop menu")
         }
     }
     OLD.Menu {
         id: rulermenu
         property int clickedX
         property int clickedY
         OLD.MenuItem {
             id: addGuideMenu2
             text: i18n('Add Guide')
             onTriggered: {
                 timeline.switchGuide(timeline.position);
             }
         }
         OLD.MenuItem {
             id: editGuideMenu2
             text: i18n('Edit Guide')
             visible: false
             onTriggered: {
                 timeline.editGuide(timeline.position);
             }
         }
         OLD.MenuItem {
             id: addProjectNote
             text: i18n('Add Project Note')
             onTriggered: {
                 timeline.triggerAction('add_project_note')
             }
         }
         onAboutToShow: {
             if (guidesModel.hasMarker(timeline.position)) {
                 // marker at timeline position
                 addGuideMenu2.text = i18n('Remove Guide')
                 editGuideMenu2.visible = true
             } else {
                 addGuideMenu2.text = i18n('Add Guide')
                 editGuideMenu2.visible = false
             }
             console.log("pop menu")
         }
     }
     MessageDialog {
         id: compositionFail
         title: i18n("Timeline error")
         icon: StandardIcon.Warning
         text: i18n("Impossible to add a composition at that position. There might not be enough space")
         standardButtons: StandardButton.Ok
     }
     OLD.Menu {
         id: headerMenu
         OLD.MenuItem {
             text: i18n('Add Track')
             onTriggered: {
                 timeline.addTrack(timeline.activeTrack)
                 timeline.ungrabHack()
             }
         }
         OLD.MenuItem {
             text: i18n('Delete Track')
             onTriggered: {
                 timeline.deleteTrack(timeline.activeTrack)
                 timeline.ungrabHack()
             }
         }
     }
 
     Row {
         Column {
             z: 1
             Rectangle {
                 id: cornerstone
                 property bool selected: false
                 // Padding between toolbar and track headers.
                 width: headerWidth
                 height: ruler.height
                 color: 'transparent' //selected? shotcutBlue : activePalette.window
                 border.color: selected? 'red' : 'transparent'
                 border.width: selected? 1 : 0
                 z: 1
                 MouseArea {
                     anchors.fill: parent
                     acceptedButtons: Qt.LeftButton
                     onClicked: {
                         //timeline.selectMultitrack()
                     }
                 }
             }
             Flickable {
                 // Non-slider scroll area for the track headers.
                 id: headerFlick
                 contentY: scrollView.flickableItem.contentY
                 width: headerWidth
                 height: 100
                 interactive: false
 
                 MouseArea {
                     width: trackHeaders.width
                     height: trackHeaders.height
                     acceptedButtons: Qt.NoButton
                     onWheel: {
                         var newScroll = Math.min(scrollView.flickableItem.contentY - wheel.angleDelta.y, height - headerFlick.height - cornerstone.height)
                         scrollView.flickableItem.contentY = Math.max(newScroll, 0)
                     }
                 }
                 Column {
                     id: trackHeaders
                     spacing: 0
                     Repeater {
                         id: trackHeaderRepeater
                         model: multitrack
                         TrackHead {
                             trackName: model.name
                             thumbsFormat: model.thumbsFormat
                             trackTag: model.trackTag
                             isDisabled: model.disabled
                             isComposite: model.composite
                             isLocked: model.locked
                             isAudio: model.audio
                             effectNames: model.effectNames
                             isStackEnabled: model.isStackEnabled
                             width: headerWidth
                             height: model.trackHeight
                             selected: false
                             current: item === timeline.activeTrack
                             trackId: item
                             onIsLockedChanged: tracksRepeater.itemAt(index).isLocked = isLocked
                             collapsed: height <= collapsedHeight
                             onMyTrackHeightChanged: {
                                 trackBaseRepeater.itemAt(index).height = myTrackHeight
                                 tracksRepeater.itemAt(index).height = myTrackHeight
                                 height = myTrackHeight
                                 collapsed = height <= collapsedHeight
                                 if (!collapsed) {
                                     controller.setTrackProperty(trackId, "kdenlive:trackheight", myTrackHeight)
                                     controller.setTrackProperty(trackId, "kdenlive:collapsed", "0")
                                 } else {
                                     controller.setTrackProperty(trackId, "kdenlive:collapsed", collapsedHeight)
                                 }
                                 // hack: change property to trigger transition adjustment
                                 root.trackHeight = root.trackHeight === 1 ? 0 : 1
                             }
                             onClicked: {
                                 timeline.activeTrack = tracksRepeater.itemAt(index).trackInternalId
                                 console.log('track name: ',index, ' = ', model.name,'/',tracksRepeater.itemAt(index).trackInternalId)
                                 //timeline.selectTrackHead(currentTrack)
                             }
                         }
                     }
                 }
                 Column {
                     id: trackHeadersResizer
                     spacing: 0
                     width: 5
                     Rectangle {
                         id: resizer
                         height: trackHeaders.height
                         width: 3
                         x: root.headerWidth - 2
                         color: 'red'
                         opacity: 0
                         Drag.active: headerMouseArea.drag.active
                         Drag.proposedAction: Qt.MoveAction
 
                         MouseArea {
                             id: headerMouseArea
                             anchors.fill: parent
                             hoverEnabled: true
                             cursorShape: Qt.SizeHorCursor
                             drag.target: parent
                             drag.axis: Drag.XAxis
                             drag.minimumX: 2 * baseUnit
                             property double startX
                             property double originalX
                             drag.smoothed: false
 
                             onPressed: {
                                 root.stopScrolling = true
                             }
                             onReleased: {
                                 root.stopScrolling = false
                                 parent.opacity = 0
                             }
                             onEntered: parent.opacity = 0.5
                             onExited: parent.opacity = 0
                             onPositionChanged: {
                                 if (mouse.buttons === Qt.LeftButton) {
                                     parent.opacity = 0.5
                                     headerWidth = Math.max(10, mapToItem(null, x, y).x + 2)
                                     timeline.setHeaderWidth(headerWidth)
                                 }
                             }
                         }
                     }
                 }
             }
         }
         MouseArea {
             id: tracksArea
             property real clickX
             property real clickY
             width: root.width - headerWidth
             height: root.height
             Keys.onDownPressed: {
                 root.moveSelectedTrack(1)
             }
             Keys.onUpPressed: {
                 root.moveSelectedTrack(-1)
             }
             // This provides continuous scrubbing and scimming at the left/right edges.
             hoverEnabled: true
             acceptedButtons: Qt.RightButton | Qt.LeftButton | Qt.MidButton
             cursorShape: tracksArea.mouseY < ruler.height || root.activeTool === 0 ? Qt.ArrowCursor : root.activeTool === 1 ? Qt.IBeamCursor : Qt.SplitHCursor
             onWheel: {
                 if (wheel.modifiers & Qt.AltModifier) {
                     // Alt + wheel = seek to next snap point
                     if (wheel.angleDelta.x > 0) {
                         timeline.triggerAction('monitor_seek_snap_backward')
                     } else {
                         timeline.triggerAction('monitor_seek_snap_forward')
                     }
                 } else {
                     var delta = wheel.modifiers & Qt.ShiftModifier ? timeline.fps() : 1
                     if (timeline.seekPosition > -1) {
                         timeline.seekPosition = Math.min(timeline.seekPosition - (wheel.angleDelta.y > 0 ? delta : -delta), timeline.fullDuration - 1)
                     } else {
                         timeline.seekPosition = Math.min(timeline.position - (wheel.angleDelta.y > 0 ? delta : -delta), timeline.fullDuration - 1)
                     }
                     timeline.position = timeline.seekPosition
                 }
             }
             onPressed: {
                 focus = true
                 if (mouse.buttons === Qt.MidButton || (root.activeTool == 0 && mouse.modifiers & Qt.ControlModifier)) {
                     clickX = mouseX
                     clickY = mouseY
                     return
                 }
                 if (mouse.modifiers & Qt.ShiftModifier) {
                         // rubber selection
                         rubberSelect.x = mouse.x + tracksArea.x
                         rubberSelect.y = mouse.y
                         rubberSelect.originX = mouse.x
                         rubberSelect.originY = rubberSelect.y
                         rubberSelect.width = 0
                         rubberSelect.height = 0
                 } else if (mouse.button & Qt.LeftButton) {
                     if (dragProxy.draggedItem > -1) {
                         mouse.accepted = false
                         return
                     }
                     if (root.activeTool === 2 && mouse.y > ruler.height) {
                         // spacer tool
                         var y = mouse.y - ruler.height + scrollView.flickableItem.contentY
                         var frame = (scrollView.flickableItem.contentX + mouse.x) / timeline.scaleFactor
                         var track = (mouse.modifiers & Qt.ControlModifier) ? tracksRepeater.itemAt(Logic.getTrackIndexFromPos(y)).trackInternalId : -1
                         spacerGroup = timeline.requestSpacerStartOperation(track, frame)
                         if (spacerGroup > -1) {
                             drag.axis = Drag.XAxis
                             Drag.active = true
                             Drag.proposedAction = Qt.MoveAction
                             spacerClickFrame = frame
                             spacerFrame = controller.getClipPosition(spacerGroup)
                         }
                     } else if (root.activeTool === 0 || mouse.y <= ruler.height) {
                         if (mouse.y > ruler.height) {
                             timeline.selection = []
                         }
                         timeline.seekPosition = Math.min((scrollView.flickableItem.contentX + mouse.x) / timeline.scaleFactor, timeline.fullDuration - 1)
                         timeline.position = timeline.seekPosition
                     } else if (root.activeTool === 1) {
                         // razor tool
                         var y = mouse.y - ruler.height + scrollView.flickableItem.contentY
                         timeline.cutClipUnderCursor((scrollView.flickableItem.contentX + mouse.x) / timeline.scaleFactor, tracksRepeater.itemAt(Logic.getTrackIndexFromPos(y)).trackInternalId)
                     }
                 } else if (mouse.button & Qt.RightButton) {
                     menu.clickedX = mouse.x
                     menu.clickedY = mouse.y
                     if (mouse.y > ruler.height) {
                         timeline.activeTrack = tracksRepeater.itemAt(Logic.getTrackIndexFromPos(mouse.y - ruler.height + scrollView.flickableItem.contentY)).trackInternalId
                         menu.popup()
                     } else {
                         // ruler menu
                         rulermenu.popup()
                     }
                 }
             }
             property bool scim: false
             onExited: {
                 scim = false
             }
             onPositionChanged: {
                 if (pressed && ((mouse.buttons === Qt.MidButton) || (mouse.buttons === Qt.LeftButton && root.activeTool == 0 && mouse.modifiers & Qt.ControlModifier))) {
                     var newScroll = Math.min(scrollView.flickableItem.contentX - (mouseX - clickX), timeline.fullDuration * root.timeScale - (scrollView.width - scrollView.__verticalScrollBar.width))
                     var vertScroll = Math.min(scrollView.flickableItem.contentY - (mouseY - clickY), trackHeaders.height - scrollView.height + scrollView.__horizontalScrollBar.height)
                     scrollView.flickableItem.contentX = Math.max(newScroll, 0)
                     scrollView.flickableItem.contentY = Math.max(vertScroll, 0)
                     clickX = mouseX
                     clickY = mouseY
                     return
                 }
                 if (dragProxy.draggedItem > -1) {
                     mouse.accepted = false
                     return
                 }
                 root.mousePosChanged(Math.max(0, Math.round((mouse.x + scrollView.flickableItem.contentX) / timeline.scaleFactor)))
                 ruler.showZoneLabels = mouse.y < ruler.height
                 if ((mouse.modifiers & Qt.ShiftModifier) && mouse.buttons === Qt.LeftButton && !rubberSelect.visible) {
                     // rubber selection
                     rubberSelect.visible = true
                 }
                 if (rubberSelect.visible) {
                     var newX = mouse.x
                     var newY = mouse.y
                     if (newX < rubberSelect.originX) {
                         rubberSelect.x = newX + tracksArea.x
                         rubberSelect.width = rubberSelect.originX - newX
                     } else {
                         rubberSelect.x = rubberSelect.originX + tracksArea.x
                         rubberSelect.width = newX - rubberSelect.originX
                     }
                     if (newY < rubberSelect.originY) {
                         rubberSelect.y = newY
                         rubberSelect.height = rubberSelect.originY - newY
                     } else {
                         rubberSelect.y = rubberSelect.originY
                         rubberSelect.height= newY - rubberSelect.originY
                     }
                 } else if (mouse.buttons === Qt.LeftButton) {
                     if (root.activeTool === 0 || mouse.y < ruler.height) {
                         timeline.seekPosition = Math.max(0, Math.min((scrollView.flickableItem.contentX + mouse.x) / timeline.scaleFactor, timeline.fullDuration - 1))
                         timeline.position = timeline.seekPosition
                     } else if (root.activeTool === 2 && spacerGroup > -1) {
                         // Move group
                         var track = controller.getItemTrackId(spacerGroup)
                         var frame = Math.round((mouse.x + scrollView.flickableItem.contentX) / timeline.scaleFactor) + spacerFrame - spacerClickFrame
                         frame = controller.suggestItemMove(spacerGroup, track, frame, root.snapping)
                         continuousScrolling(mouse.x + scrollView.flickableItem.contentX)
                     }
                     scim = true
                 } else {
                     scim = false
                     if (root.activeTool === 1) {
                         cutLine.x = Math.floor((scrollView.flickableItem.contentX + mouse.x) / timeline.scaleFactor) * timeline.scaleFactor - scrollView.flickableItem.contentX
                     }
                 }
             }
             onReleased: {
                 if (rubberSelect.visible) {
                     rubberSelect.visible = false
                     var y = rubberSelect.y - ruler.height + scrollView.flickableItem.contentY
                     var topTrack = Logic.getTrackIndexFromPos(Math.max(0, y))
                     var bottomTrack = Logic.getTrackIndexFromPos(y + rubberSelect.height)
                     if (bottomTrack >= topTrack) {
                         var t = []
                         for (var i = topTrack; i <= bottomTrack; i++) {
                             t.push(tracksRepeater.itemAt(i).trackInternalId)
                         }
                         var startFrame = (scrollView.flickableItem.contentX - tracksArea.x + rubberSelect.x) / timeline.scaleFactor
                         var endFrame = (scrollView.flickableItem.contentX - tracksArea.x + rubberSelect.x + rubberSelect.width) / timeline.scaleFactor
                         timeline.selectItems(t, startFrame, endFrame, mouse.modifiers & Qt.ControlModifier);
                     }
                 } else if (mouse.modifiers & Qt.ShiftModifier) {
                     // Shift click, process seek
                     timeline.seekPosition = Math.min((scrollView.flickableItem.contentX + mouse.x) / timeline.scaleFactor, timeline.fullDuration - 1)
                     timeline.position = timeline.seekPosition
                 }
                 if (spacerGroup > -1) {
                     var frame = controller.getItemPosition(spacerGroup)
                     timeline.requestSpacerEndOperation(spacerGroup, spacerFrame, frame);
                     spacerClickFrame = -1
                     spacerFrame = -1
                     spacerGroup = -1
                 }
                 scim = false
             }
             Timer {
                 id: scrubTimer
                 interval: 25
                 repeat: true
                 running: parent.scim && parent.containsMouse
                          && (parent.mouseX < 50 || parent.mouseX > parent.width - 50)
                          && (timeline.position * timeline.scaleFactor >= 50)
                 onTriggered: {
                     if (parent.mouseX < 50)
                         timeline.seekPosition = Math.max(0, timeline.position - 10)
                     else
                         timeline.seekPosition = Math.min(timeline.position + 10, timeline.fullDuration - 1)
                 }
             }
 
             Column {
                 Flickable {
                     // Non-slider scroll area for the Ruler.
                     id: rulercontainer
                     width: root.width - headerWidth
                     height: fontMetrics.font.pixelSize * 2
                     contentX: scrollView.flickableItem.contentX
                     contentWidth: Math.max(parent.width, timeline.fullDuration * timeScale)
                     interactive: false
                     clip: true
                     Ruler {
                         id: ruler
                         width: rulercontainer.contentWidth
                         height: parent.height
                         Rectangle {
                             id: seekCursor
                             visible: timeline.seekPosition > -1
                             color: activePalette.highlight
                             width: 4
                             height: ruler.height
                             opacity: 0.5
                             x: timeline.seekPosition * timeline.scaleFactor
                         }
                         TimelinePlayhead {
                             id: playhead
                             visible: timeline.position > -1
                             height: baseUnit
                             width: baseUnit * 1.5
                             fillColor: activePalette.windowText
                             anchors.bottom: parent.bottom
                             x: timeline.position * timeline.scaleFactor - (width / 2)
                         }
                     }
                 }
                 OLD.ScrollView {
                     id: scrollView
                     width: root.width - headerWidth
                     height: root.height - ruler.height
                     y: ruler.height
                     // Click and drag should seek, not scroll the timeline view
                     flickableItem.interactive: false
                     clip: true
                     Rectangle {
                         id: tracksContainerArea
                         width: Math.max(scrollView.width - scrollView.__verticalScrollBar.width, timeline.fullDuration * timeScale)
                         height: Math.max(trackHeaders.height, scrollView.height - scrollView.__horizontalScrollBar.height)
                         color: root.color
                         Rectangle {
                             // Drag proxy, responsible for clip / composition move
                             id: dragProxy
                             x: 0
                             y: 0
                             width: 0
                             height: 0
                             property int draggedItem: -1
                             property int sourceTrack
                             property int sourceFrame
                             property bool isComposition
                             property var masterObject
                             color: 'green'
                             opacity: 0.8
                             MouseArea {
                                 id: dragProxyArea
                                 anchors.fill: parent
                                 drag.target: parent
                                 drag.axis: Drag.XAxis
                                 drag.smoothed: false
                                 drag.minimumX: 0
                                 property int dragFrame
                                 property bool shiftClick: false
                                 cursorShape: pressed ? Qt.ClosedHandCursor : Qt.OpenHandCursor
                                 onPressed: {
                                     if (mouse.modifiers & Qt.ControlModifier) {
                                         mouse.accepted = false
                                         return
                                     }
                                     dragFrame = -1
                                     timeline.activeTrack = dragProxy.sourceTrack
                                     if (mouse.modifiers & Qt.ShiftModifier) {
                                         if (timeline.selection.indexOf(dragProxy.draggedItem) == -1) {
                                             timeline.addSelection(dragProxy.draggedItem)
                                         } else {
                                             timeline.removeSelection(dragProxy.draggedItem)
                                             endDrag()
                                             shiftClick = true
                                             return
                                         }
                                         shiftClick = true
                                     } else {
                                         if (timeline.selection.indexOf(dragProxy.draggedItem) == -1) {
                                             timeline.selection = [ dragProxy.draggedItem ]
                                         }
                                         shiftClick = false
                                     }
                                     timeline.showAsset(dragProxy.draggedItem)
                                     root.stopScrolling = true
                                     clipBeingMovedId = dragProxy.draggedItem
                                     if (dragProxy.draggedItem > -1) {
                                         var tk = controller.getItemTrackId(dragProxy.draggedItem)
                                         var x = controller.getItemPosition(dragProxy.draggedItem)
                                         var posx = Math.round((parent.x)/ root.timeScale)
                                         var clickAccepted = true
                                         if (controller.normalEdit() && (tk != Logic.getTrackIdFromPos(parent.y) || x != posx)) {
                                             console.log('INCORRECT DRAG, Trying to recover item: ', parent.y,' XPOS: ',x,'=',posx,'\n!!!!!!!!!!')
                                             // Try to find correct item
                                             var track = Logic.getTrackById(tk)
                                             var container = track.children[0].children[0].children[0]
                                             var tentativeClip = container.childAt(mouseX + parent.x, 5)
                                             if (tentativeClip && tentativeClip.clipId) {
                                                 clickAccepted = true
                                                 dragProxy.draggedItem = tentativeClip.clipId
                                                 dragProxy.x = tentativeClip.x
                                                 dragProxy.y = tentativeClip.y
                                                 dragProxy.width = tentativeClip.width
                                                 dragProxy.height = tentativeClip.height
                                                 dragProxy.masterObject = tentativeClip
                                                 dragProxy.sourceTrack = tk
                                                 dragProxy.sourceFrame = tentativeClip.modelStart
                                                 dragProxy.isComposition = tentativeClip.isComposition
                                             } else {
                                                 clickAccepted = false
                                                 mouse.accepted = false
                                                 dragProxy.draggedItem = -1
                                                 dragProxy.masterObject = undefined
                                                 parent.x = 0
                                                 parent.y = 0
                                                 parent.width = 0
                                                 parent.height = 0
                                             }
                                         }
                                         if (clickAccepted && dragProxy.draggedItem != -1) {
                                             focus = true;
                                             dragProxy.masterObject.originalX = dragProxy.masterObject.x
                                             dragProxy.masterObject.originalTrackId = dragProxy.masterObject.trackId
                                             dragProxy.masterObject.forceActiveFocus();
                                             if (!dragProxy.masterObject.selected) {
                                                 dragProxy.masterObject.clicked(dragProxy.masterObject, mouse.modifiers == Qt.ShiftModifier)
                                             }
                                         }
                                     } else {
                                         mouse.accepted = false
                                         parent.x = 0
                                         parent.y = 0
                                         parent.width = 0
                                         parent.height = 0
                                     }
                                 }
                                 onPositionChanged: {
                                     if (!shiftClick && dragProxy.draggedItem > -1 && mouse.buttons === Qt.LeftButton) {
                                         continuousScrolling(mouse.x + parent.x)
                                         var mapped = tracksContainerArea.mapFromItem(dragProxy, mouse.x, mouse.y).x
                                         root.mousePosChanged(Math.round(mapped / timeline.scaleFactor))
                                         var posx = Math.round((parent.x)/ root.timeScale)
                                         var posy = Math.min(Math.max(0, mouse.y + parent.y), tracksContainerArea.height)
                                         var tId = Logic.getTrackIdFromPos(posy)
                                         timeline.activeTrack = tId
                                         if (dragProxy.isComposition) {
                                             dragFrame = controller.suggestCompositionMove(dragProxy.draggedItem, tId, posx, root.snapping)
                                         } else {
                                             if (!controller.normalEdit() && dragProxy.masterObject.parent != dragContainer) {
                                                 var pos = dragProxy.masterObject.mapToGlobal(dragProxy.masterObject.x, dragProxy.masterObject.y);
                                                 dragProxy.masterObject.parent = dragContainer
                                                 pos = dragProxy.masterObject.mapFromGlobal(pos.x, pos.y)
                                                 dragProxy.masterObject.x = pos.x
                                                 dragProxy.masterObject.y = pos.y
                                                 console.log('bringing item to front')
                                             }
                                             dragFrame = controller.suggestClipMove(dragProxy.draggedItem, tId, posx, root.snapping)
                                         }
                                         var delta = dragFrame - dragProxy.sourceFrame
                                         if (delta != 0) {
                                             var s = timeline.timecode(Math.abs(delta))
                                             // remove leading zeroes
                                             if (s.substring(0, 3) === '00:')
                                                 s = s.substring(3)
                                             s = ((delta < 0)? '-' : (delta > 0)? '+' : '') + s
                                             bubbleHelp.show(parent.x, ruler.height, s)
                                         } else bubbleHelp.hide()
                                     }
                                 }
                                 onReleased: {
                                     clipBeingMovedId = -1
                                     if (!shiftClick && dragProxy.draggedItem > -1 && dragFrame > -1) {
                                         var tId = controller.getItemTrackId(dragProxy.draggedItem)
                                         if (dragProxy.isComposition) {
                                             controller.requestCompositionMove(dragProxy.draggedItem, dragProxy.sourceTrack, dragProxy.sourceFrame, true, false, false)
                                             controller.requestCompositionMove(dragProxy.draggedItem, tId, dragFrame , true, true, true)
                                         } else {
                                             if (controller.normalEdit()) {
                                                 controller.requestClipMove(dragProxy.draggedItem, dragProxy.sourceTrack, dragProxy.sourceFrame, true, false, false)
                                                 controller.requestClipMove(dragProxy.draggedItem, tId, dragFrame , true, true, true)
                                             } else {
                                                 // Fake move, only process final move
                                                 timeline.endFakeMove(dragProxy.draggedItem, dragFrame , true, true, true)
                                             }
                                         }
                                         dragProxy.x = controller.getItemPosition(dragProxy.draggedItem) * timeline.scaleFactor
                                         dragProxy.sourceFrame = dragFrame
                                         bubbleHelp.hide()
                                     }
                                 }
                                 onDoubleClicked: {
                                     if (dragProxy.masterObject.keyframeModel) {
                                         var newVal = (dragProxy.height - mouseY) / dragProxy.height
                                         var newPos = Math.round(mouseX / timeScale) + dragProxy.masterObject.inPoint
                                         timeline.addEffectKeyframe(dragProxy.draggedItem, newPos, newVal)
                                     }
                                 }
                             }
                         }
                         MouseArea {
                             anchors.fill: parent
                             acceptedButtons: Qt.NoButton
                             onWheel: zoomByWheel(wheel)
                             cursorShape: dragProxyArea.drag.active ? Qt.ClosedHandCursor : tracksArea.cursorShape
                         }
                         Column {
                             // These make the striped background for the tracks.
                             // It is important that these are not part of the track visual hierarchy;
                             // otherwise, the clips will be obscured by the Track's background.
                             Repeater {
                                 model: multitrack
                                 id: trackBaseRepeater
                                 delegate: Rectangle {
                                     width: tracksContainerArea.width
                                     border.width: 1
                                     border.color: Qt.rgba(activePalette.windowText.r, activePalette.windowText.g, activePalette.windowText.b, 0.1)
                                     height: model.trackHeight
                                     color: tracksRepeater.itemAt(index) ? ((tracksRepeater.itemAt(index).trackInternalId === timeline.activeTrack) ? Qt.tint(getTrackColor(tracksRepeater.itemAt(index).isAudio, false), selectedTrackColor) : getTrackColor(tracksRepeater.itemAt(index).isAudio, false)) : 'red'
                                 }
                             }
                         }
                         Column {
                             id: tracksContainer
                             Repeater { id: tracksRepeater; model: trackDelegateModel }
                             Item {
                                 id: dragContainer
                             }
                             Repeater { id: guidesRepeater; model: guidesDelegateModel }
                         }
                         Rectangle {
                             id: cursor
                             visible: timeline.position > -1
-                            color: activePalette.text
+                            color: root.textColor
                             width: Math.max(1, 1 * timeline.scaleFactor)
                             opacity: (width > 2) ? 0.5 : 1
                             height: parent.height
                             x: timeline.position * timeline.scaleFactor
                         }
                     }
                 }
             }
             /*CornerSelectionShadow {
                 y: tracksRepeater.count ? tracksRepeater.itemAt(currentTrack).y + ruler.height - scrollView.flickableItem.contentY : 0
                 clip: timeline.selection.length ?
                         tracksRepeater.itemAt(currentTrack).clipAt(timeline.selection[0]) : null
                 opacity: clip && clip.x + clip.width < scrollView.flickableItem.contentX ? 1 : 0
             }
 
             CornerSelectionShadow {
                 y: tracksRepeater.count ? tracksRepeater.itemAt(currentTrack).y + ruler.height - scrollView.flickableItem.contentY : 0
                 clip: timeline.selection.length ?
                         tracksRepeater.itemAt(currentTrack).clipAt(timeline.selection[timeline.selection.length - 1]) : null
                 opacity: clip && clip.x > scrollView.flickableItem.contentX + scrollView.width ? 1 : 0
                 anchors.right: parent.right
                 mirrorGradient: true
             }*/
             Rectangle {
                 id: cutLine
                 visible: root.activeTool == 1 && tracksArea.mouseY > ruler.height
                 color: 'red'
                 width: Math.max(1, 1 * timeline.scaleFactor)
                 opacity: (width > 2) ? 0.5 : 1
                 height: root.height - scrollView.__horizontalScrollBar.height - ruler.height
                 x: 0
                 //x: timeline.position * timeline.scaleFactor - scrollView.flickableItem.contentX
                 y: ruler.height
             }
         }
     }
 
     Rectangle {
         id: bubbleHelp
         property alias text: bubbleHelpLabel.text
         color: root.color //application.toolTipBaseColor
         width: bubbleHelpLabel.width + 8
         height: bubbleHelpLabel.height + 8
         radius: 4
         states: [
             State { name: 'invisible'; PropertyChanges { target: bubbleHelp; opacity: 0} },
             State { name: 'visible'; PropertyChanges { target: bubbleHelp; opacity: 0.8} }
         ]
         state: 'invisible'
         transitions: [
             Transition {
                 from: 'invisible'
                 to: 'visible'
                 OpacityAnimator { target: bubbleHelp; duration: 200; easing.type: Easing.InOutQuad }
             },
             Transition {
                 from: 'visible'
                 to: 'invisible'
                 OpacityAnimator { target: bubbleHelp; duration: 200; easing.type: Easing.InOutQuad }
             }
         ]
         Label {
             id: bubbleHelpLabel
             color: activePalette.text //application.toolTipTextColor
             anchors.centerIn: parent
             font.pixelSize: root.baseUnit
         }
         function show(x, y, text) {
             bubbleHelp.x = x + tracksArea.x - scrollView.flickableItem.contentX - bubbleHelpLabel.width
             bubbleHelp.y = y + tracksArea.y - scrollView.flickableItem.contentY - bubbleHelpLabel.height
             bubbleHelp.text = text
             if (bubbleHelp.state !== 'visible')
                 bubbleHelp.state = 'visible'
         }
         function hide() {
             bubbleHelp.state = 'invisible'
             bubbleHelp.opacity = 0
         }
     }
 
     Rectangle {
         id: rubberSelect
         property int originX
         property int originY
         color: Qt.rgba(activePalette.highlight.r, activePalette.highlight.g, activePalette.highlight.b, 0.4)
         border.color: activePalette.highlight
         border.width: 1
         visible: false
     }
     /*DropShadow {
         source: bubbleHelp
         anchors.fill: bubbleHelp
         opacity: bubbleHelp.opacity
         horizontalOffset: 3
         verticalOffset: 3
         radius: 8
         color: '#80000000'
         transparentBorder: true
         fast: true
     }*/
 
     DelegateModel {
         id: trackDelegateModel
         model: multitrack
         delegate: Track {
             trackModel: multitrack
             trackRootIndex: trackDelegateModel.modelIndex(index)
             height: trackHeight
             timeScale: timeline.scaleFactor
             width: tracksContainerArea.width
             isAudio: audio
             trackThumbsFormat: thumbsFormat
             isCurrentTrack: item === timeline.activeTrack
             trackInternalId: item
             /*Rectangle {
                 anchors.right: parent.right
                 anchors.left: parent.left
                 height: parent.height
                 //source: "qrc:///pics/kdenlive-lock.svgz"
                 //fillMode: Image.Tile
                 opacity: parent.isLocked
                 color: '#33ff3300'
                 visible: opacity
                 Behavior on opacity { NumberAnimation {} }
                 MouseArea {
                     anchors.fill: parent
                     onPressed: {
                         mouse.accepted = true;
                         trackHeaderRepeater.itemAt(index).pulseLockButton()
                     }
                 }
             }*/
         }
     }
 
 
     DelegateModel {
         id: guidesDelegateModel
         model: guidesModel
             Item {
                 id: guideRoot
                 Rectangle {
                     id: guideBase
                     width: 1
                     height: tracksContainer.height
                     x: model.frame * timeScale;
                     color: model.color
                 }
                 Rectangle {
                     visible: mlabel.visible
                     opacity: 0.7
                     x: guideBase.x
                     y: mlabel.y
                     radius: 2
                     width: mlabel.width + 4
                     height: mlabel.height
                     color: model.color
                     MouseArea {
                         z: 10
                         anchors.fill: parent
                         acceptedButtons: Qt.LeftButton
                         cursorShape: Qt.PointingHandCursor
                         hoverEnabled: true
                         property int startX
                         drag.axis: Drag.XAxis
                         drag.target: guideRoot
                         onPressed: {
                             drag.target = guideRoot
                             startX = guideRoot.x
                         }
                         onReleased: {
                             if (startX != guideRoot.x) {
                                 timeline.moveGuide(model.frame,  model.frame + guideRoot.x / timeline.scaleFactor)
                             }
                             drag.target = undefined
                         }
                         onPositionChanged: {
                             if (pressed) {
                                 var frame = Math.round(model.frame + guideRoot.x / timeline.scaleFactor)
                                 frame = controller.suggestSnapPoint(frame, root.snapping)
                                 guideRoot.x = (frame - model.frame) * timeline.scaleFactor
                             }
                         }
                         drag.smoothed: false
                         onDoubleClicked: {
                             timeline.editGuide(model.frame)
                             drag.target = undefined
                         }
                         onClicked: timeline.position = guideBase.x / timeline.scaleFactor
                     }
                 }
                 Text {
                     id: mlabel
                     visible: timeline.showMarkers
                     text: model.comment
                     font.pixelSize: root.baseUnit
                     x: guideBase.x + 2
                     y: scrollView.flickableItem.contentY
                     color: 'white'
                 }
             }
         }
 
 
     Connections {
         target: timeline
         onPositionChanged: if (!stopScrolling) Logic.scrollIfNeeded()
         onFrameFormatChanged: ruler.adjustFormat()
         onSelectionChanged: {
             //cornerstone.selected = timeline.isMultitrackSelected()
             if (dragProxy.draggedItem > -1 && timeline.selection.indexOf(dragProxy.draggedItem) == -1) {
                 endDrag()
             }
             var selectedTrack = timeline.selectedTrack()
             for (var i = 0; i < trackHeaderRepeater.count; i++) {
                 trackHeaderRepeater.itemAt(i).selected = (i === selectedTrack)
             }
         }
     }
 
     // This provides continuous scrolling at the left/right edges.
     Timer {
         id: scrollTimer
         interval: 25
         repeat: true
         triggeredOnStart: true
         property var item
         property bool backwards
         onTriggered: {
             var delta = backwards? -10 : 10
             if (item) item.x += delta
             scrollView.flickableItem.contentX += delta
             if (scrollView.flickableItem.contentX <= 0 || clipBeingMovedId == -1)
                 stop()
         }
     }
 }
 
diff --git a/src/timeline2/view/qml/timelineitems.cpp b/src/timeline2/view/qml/timelineitems.cpp
index 129e680fa..0b6e61bcf 100644
--- a/src/timeline2/view/qml/timelineitems.cpp
+++ b/src/timeline2/view/qml/timelineitems.cpp
@@ -1,187 +1,189 @@
 
 
 #include "kdenlivesettings.h"
 #include <QLinearGradient>
 #include <QPainter>
 #include <QPainterPath>
 #include <QPalette>
 #include <QQuickPaintedItem>
 
 class TimelineTriangle : public QQuickPaintedItem
 {
     Q_OBJECT
     Q_PROPERTY(QColor fillColor MEMBER m_color)
 public:
     TimelineTriangle() { setAntialiasing(true); }
     void paint(QPainter *painter) override
     {
         QPainterPath path;
         path.moveTo(0, 0);
         path.lineTo(width(), 0);
         path.lineTo(0, height());
         painter->fillPath(path, m_color);
         painter->setPen(Qt::white);
         painter->drawLine(width(), 0, 0, height());
     }
 
 private:
     QColor m_color;
 };
 
 class TimelinePlayhead : public QQuickPaintedItem
 {
     Q_OBJECT
     Q_PROPERTY(QColor fillColor MEMBER m_color NOTIFY colorChanged)
 
 public:
     TimelinePlayhead()
     {
         connect(this, SIGNAL(colorChanged(QColor)), this, SLOT(update()));
     }
 
     void paint(QPainter *painter) override
     {
         QPainterPath path;
         path.moveTo(width(), 0);
         path.lineTo(width() / 2.0, height());
         path.lineTo(0, 0);
         painter->fillPath(path, m_color);
     }
 signals:
     void colorChanged(const QColor&);
 private:
     QColor m_color;
 };
 
 class TimelineWaveform : public QQuickPaintedItem
 {
     Q_OBJECT
     Q_PROPERTY(QVariant levels MEMBER m_audioLevels NOTIFY propertyChanged)
     Q_PROPERTY(QColor fillColor MEMBER m_color NOTIFY propertyChanged)
     Q_PROPERTY(int inPoint MEMBER m_inPoint NOTIFY inPointChanged)
     Q_PROPERTY(int channels MEMBER m_channels NOTIFY audioChannelsChanged)
     Q_PROPERTY(int outPoint MEMBER m_outPoint NOTIFY outPointChanged)
     Q_PROPERTY(bool format MEMBER m_format NOTIFY propertyChanged)
     Q_PROPERTY(bool showItem MEMBER m_showItem)
 
 public:
     TimelineWaveform()
     {
         setAntialiasing(false);
         setClip(true);
         setEnabled(false);
         setRenderTarget(QQuickPaintedItem::FramebufferObject);
         setMipmap(true);
         setTextureSize(QSize(width(), height()));
         connect(this, SIGNAL(propertyChanged()), this, SLOT(update()));
         // Fill gradient
-        m_gradient.setStart(0, 0);
+        /*m_gradient.setStart(0, 0);
         m_gradient.setFinalStop(0, height());
         m_gradient.setColorAt(1, QColor(129, 233, 139));
         m_gradient.setColorAt(0.4, QColor(129, 233, 139));
         m_gradient.setColorAt(0.2, QColor(233, 215, 129));
         m_gradient.setColorAt(0.1, QColor(255, 0, 0));
-        m_gradient.setSpread(QGradient::ReflectSpread);
+        m_gradient.setSpread(QGradient::ReflectSpread);*/
     }
 
     void paint(QPainter *painter) override
     {
         if (!m_showItem) return;
         QVariantList data = m_audioLevels.toList();
         if (data.isEmpty()) return;
 
         const qreal indicesPrPixel = qreal(m_outPoint - m_inPoint) / width();
         QPen pen = painter->pen();
         pen.setWidthF(0.5);
         pen.setColor(Qt::black);
         if (!KdenliveSettings::displayallchannels()) {
-            m_gradient.setFinalStop(0, height());
-            painter->setBrush(m_gradient);
+            //m_gradient.setFinalStop(0, height());
+            //painter->setBrush(m_gradient);
+            painter->setBrush(m_color);
 
             // Draw merged channels
             QPainterPath path;
             path.moveTo(-1, height());
             double i = 0;
             double increment = qMax(1., 1 / indicesPrPixel);
             int lastIdx = -1;
             for (; i <= width(); i += increment) {
                 int idx = m_inPoint + int(i * indicesPrPixel);
                 if (lastIdx == idx) {
                     continue;
                 }
                 lastIdx = idx;
                 if (idx + m_channels >= data.length()) break;
                 double level = data.at(idx).toDouble() / 256;
                 for (int j = 1; j < m_channels; j++) {
                     level = qMax(level, data.at(idx + j).toDouble() / 256);
                 }
                 path.lineTo(i, height() - level * height());
             }
             path.lineTo(i, height());
             painter->drawPath(path);
         } else {
             // Fill gradient
             int channelHeight = height() / (2 * m_channels);
-            m_gradient.setFinalStop(0, channelHeight);
-            painter->setBrush(m_gradient);
+            //m_gradient.setFinalStop(0, channelHeight);
+            //painter->setBrush(m_gradient);
+            painter->setBrush(m_color);
 
             // Draw separate channels
             QMap<int, QPainterPath> positiveChannelPaths;
             QMap<int, QPainterPath> negativeChannelPaths;
             // TODO: get channels count
             double i = 0;
             double increment = qMax(1., 1 / indicesPrPixel);
             for (int channel = 0; channel < m_channels; channel++) {
                 int y = height() - (2 * channel + 1) * channelHeight;
                 positiveChannelPaths[channel].moveTo(-1, y);
                 negativeChannelPaths[channel].moveTo(-1, y);
                 // Draw channel median line
                 painter->drawLine(0, y, width(), y);
                 int lastIdx = -1;
                 for (i = 0; i <= width(); i += increment) {
                     int idx = m_inPoint + int(i * indicesPrPixel);
                     if (lastIdx == idx) {
                         continue;
                     }
                     lastIdx = idx;
                     if (idx + channel >= data.length()) break;
                     qreal level = data.at(idx + channel).toReal() / 256;
                     positiveChannelPaths[channel].lineTo(i, y - level * channelHeight);
                     negativeChannelPaths[channel].lineTo(i, y + level * channelHeight);
                 }
             }
             for (int channel = 0; channel < m_channels; channel++) {
                 int y = height() - (2 * channel + 1) * channelHeight;
                 positiveChannelPaths[channel].lineTo(i, y);
                 negativeChannelPaths[channel].lineTo(i, y);
                 painter->drawPath(positiveChannelPaths.value(channel));
                 painter->drawPath(negativeChannelPaths.value(channel));
             }
         }
     }
 
 signals:
     void propertyChanged();
     void inPointChanged();
     void outPointChanged();
     void audioChannelsChanged();
 
 private:
     QVariant m_audioLevels;
     int m_inPoint;
     int m_outPoint;
     QColor m_color;
     bool m_format;
     QLinearGradient m_gradient;
     bool m_showItem;
     int m_channels;
 };
 
 void registerTimelineItems()
 {
     qmlRegisterType<TimelineTriangle>("Kdenlive.Controls", 1, 0, "TimelineTriangle");
     qmlRegisterType<TimelinePlayhead>("Kdenlive.Controls", 1, 0, "TimelinePlayhead");
     qmlRegisterType<TimelineWaveform>("Kdenlive.Controls", 1, 0, "TimelineWaveform");
 }
 
 #include "timelineitems.moc"
diff --git a/src/timeline2/view/timelinecontroller.cpp b/src/timeline2/view/timelinecontroller.cpp
index 32ba645ce..d2d76e37b 100644
--- a/src/timeline2/view/timelinecontroller.cpp
+++ b/src/timeline2/view/timelinecontroller.cpp
@@ -1,2319 +1,2340 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Jean-Baptiste Mardelle                                  *
  *   This file is part of Kdenlive. See www.kdenlive.org.                  *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) version 3 or any later version accepted by the       *
  *   membership of KDE e.V. (or its successor approved  by the membership  *
  *   of KDE e.V.), which shall act as a proxy defined in Section 14 of     *
  *   version 3 of the license.                                             *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "timelinecontroller.h"
 #include "../model/timelinefunctions.hpp"
 #include "bin/bin.h"
 #include "bin/model/markerlistmodel.hpp"
 #include "bin/projectclip.h"
 #include "bin/projectitemmodel.h"
 #include "core.h"
 #include "dialogs/spacerdialog.h"
 #include "doc/kdenlivedoc.h"
 #include "effects/effectstack/model/effectstackmodel.hpp"
 #include "assets/keyframes/model/keyframemodellist.hpp"
 #include "kdenlivesettings.h"
 #include "previewmanager.h"
 #include "project/projectmanager.h"
 #include "timeline2/model/clipmodel.hpp"
 #include "timeline2/model/compositionmodel.hpp"
 #include "timeline2/model/groupsmodel.hpp"
 #include "timeline2/model/timelineitemmodel.hpp"
 #include "timeline2/model/trackmodel.hpp"
 #include "timeline2/view/dialogs/clipdurationdialog.h"
 #include "timeline2/view/dialogs/trackdialog.h"
 #include "transitions/transitionsrepository.hpp"
 #include "lib/audio/audioEnvelope.h"
 #include "effects/effectsrepository.hpp"
 
 #include <KActionCollection>
+#include <KColorScheme>
 #include <QApplication>
 #include <QInputDialog>
 #include <QQuickItem>
 
 int TimelineController::m_duration = 0;
 
 TimelineController::TimelineController(QObject *parent)
     : QObject(parent)
     , m_root(nullptr)
     , m_usePreview(false)
     , m_position(0)
     , m_seekPosition(-1)
     , m_activeTrack(0)
     , m_audioRef(-1)
     , m_zone(-1, -1)
     , m_scale( QFontMetrics(QApplication::font()).maxWidth() / 250)
     , m_timelinePreview(nullptr)
 {
     m_disablePreview = pCore->currentDoc()->getAction(QStringLiteral("disable_preview"));
     connect(m_disablePreview, &QAction::triggered, this, &TimelineController::disablePreview);
     connect(this, &TimelineController::selectionChanged, this, &TimelineController::updateClipActions);
     m_disablePreview->setEnabled(false);
 }
 
 TimelineController::~TimelineController()
 {
     delete m_timelinePreview;
     m_timelinePreview = nullptr;
 }
 
 void TimelineController::setModel(std::shared_ptr<TimelineItemModel> model)
 {
     delete m_timelinePreview;
     m_zone = QPoint(-1, -1);
     m_timelinePreview = nullptr;
     m_model = std::move(model);
     m_selection.selectedItems.clear();
     m_selection.selectedTrack = -1;
     connect(m_model.get(), &TimelineItemModel::requestClearAssetView, [&](int id) { pCore->clearAssetPanel(id); });
     connect(m_model.get(), &TimelineItemModel::requestMonitorRefresh, [&]() { pCore->requestMonitorRefresh(); });
     connect(m_model.get(), &TimelineModel::invalidateZone, this, &TimelineController::invalidateZone, Qt::DirectConnection);
     connect(m_model.get(), &TimelineModel::durationUpdated, this, &TimelineController::checkDuration);
     connect(m_model.get(), &TimelineModel::removeFromSelection, this, &TimelineController::slotUpdateSelection);
 }
 
 void TimelineController::setTargetTracks(QPair<int, int> targets)
 {
     setVideoTarget(targets.first >= 0 && targets.first < m_model->getTracksCount() ? m_model->getTrackIndexFromPosition(targets.first) : -1);
     setAudioTarget(targets.second >= 0 && targets.second < m_model->getTracksCount() ? m_model->getTrackIndexFromPosition(targets.second) : -1);
 }
 
 std::shared_ptr<TimelineItemModel> TimelineController::getModel() const
 {
     return m_model;
 }
 
 void TimelineController::setRoot(QQuickItem *root)
 {
     m_root = root;
 }
 
 Mlt::Tractor *TimelineController::tractor()
 {
     return m_model->tractor();
 }
 
 void TimelineController::removeSelection(int newSelection)
 {
     if (!m_selection.selectedItems.contains(newSelection)) {
         return;
     }
     m_selection.selectedItems.removeAll(newSelection);
     std::unordered_set<int> ids;
     ids.insert(m_selection.selectedItems.cbegin(), m_selection.selectedItems.cend());
     if (ids.size() > 1) {
         m_model->m_temporarySelectionGroup = m_model->requestClipsGroup(ids, true,
                                                                         GroupType::Selection);
     } else if (m_model->m_temporarySelectionGroup > -1) {
         m_model->m_groups->destructGroupItem(m_model->m_temporarySelectionGroup);
         m_model->m_temporarySelectionGroup = -1;
     }
 
     std::unordered_set<int> newIds;
     if (m_model->m_temporarySelectionGroup >= 0) {
         // new items were selected, inform model to prepare for group drag
         newIds = m_model->getGroupElements(m_selection.selectedItems.constFirst());
     }
     emit selectionChanged();
     if (!m_selection.selectedItems.isEmpty())
         emitSelectedFromSelection();
     else
         emit selected(nullptr);
 }
 
 void TimelineController::addSelection(int newSelection, bool clear)
 {
     if (m_selection.selectedItems.contains(newSelection)) {
         return;
     }
     if (clear) {
         if (m_model->m_temporarySelectionGroup >= 0) {
             m_model->m_groups->destructGroupItem(m_model->m_temporarySelectionGroup);
             m_model->m_temporarySelectionGroup = -1;
         }
         m_selection.selectedItems.clear();
     }
     m_selection.selectedItems << newSelection;
     std::unordered_set<int> ids;
     ids.insert(m_selection.selectedItems.cbegin(), m_selection.selectedItems.cend());
     m_model->m_temporarySelectionGroup = m_model->requestClipsGroup(ids, true, GroupType::Selection);
 
     std::unordered_set<int> newIds;
     if (m_model->m_temporarySelectionGroup >= 0) {
         // new items were selected, inform model to prepare for group drag
         newIds = m_model->getGroupElements(m_selection.selectedItems.constFirst());
     }
     emit selectionChanged();
     if (!m_selection.selectedItems.isEmpty())
         emitSelectedFromSelection();
     else
         emit selected(nullptr);
 }
 
 int TimelineController::getCurrentItem()
 {
     // TODO: if selection is empty, return topmost clip under timeline cursor
     if (m_selection.selectedItems.isEmpty()) {
         return -1;
     }
     // TODO: if selection contains more than 1 clip, return topmost clip under timeline cursor in selection
     return m_selection.selectedItems.constFirst();
 }
 
 double TimelineController::scaleFactor() const
 {
     return m_scale;
 }
 
 const QString TimelineController::getTrackNameFromMltIndex(int trackPos)
 {
     if (trackPos == -1) {
         return i18n("unknown");
     }
     if (trackPos == 0) {
         return i18n("Black");
     }
     return m_model->getTrackTagById(m_model->getTrackIndexFromPosition(trackPos - 1));
 }
 
 const QString TimelineController::getTrackNameFromIndex(int trackIndex)
 {
     QString trackName = m_model->getTrackFullName(trackIndex);
     return trackName.isEmpty() ? m_model->getTrackTagById(trackIndex) : trackName;
 }
 
 QMap<int, QString> TimelineController::getTrackNames(bool videoOnly)
 {
     QMap<int, QString> names;
     for (const auto &track : m_model->m_iteratorTable) {
         if (videoOnly && m_model->getTrackById_const(track.first)->isAudioTrack()) {
             continue;
         }
         QString trackName = m_model->getTrackFullName(track.first);
         names[m_model->getTrackMltIndex(track.first)] = trackName;
     }
     return names;
 }
 
 void TimelineController::setScaleFactorOnMouse(double scale, bool zoomOnMouse)
 {
     /*if (m_duration * scale < width() - 160) {
         // Don't allow scaling less than full project's width
         scale = (width() - 160.0) / m_duration;
     }*/
     if (m_root) {
         m_root->setProperty("zoomOnMouse", zoomOnMouse ? qMin(getMousePos(), duration()) : -1);
         m_scale = scale;
         emit scaleFactorChanged();
     } else {
         qWarning("Timeline root not created, impossible to zoom in");
     }
 }
 
 void TimelineController::setScaleFactor(double scale)
 {
     m_scale = scale;
     // Update mainwindow's zoom slider
     emit updateZoom(scale);
     // inform qml
     emit scaleFactorChanged();
 }
 
 int TimelineController::duration() const
 {
     return m_duration;
 }
 
 int TimelineController::fullDuration() const
 {
     return m_duration + TimelineModel::seekDuration;
 }
 
 void TimelineController::checkDuration()
 {
     int currentLength = m_model->duration();
     if (currentLength != m_duration) {
         m_duration = currentLength;
         emit durationChanged();
     }
 }
 
 std::unordered_set<int> TimelineController::getCurrentSelectionIds() const
 {
     std::unordered_set<int> selection;
     if (m_model->m_temporarySelectionGroup >= 0 ||
         (!m_selection.selectedItems.isEmpty() && m_model->m_groups->isInGroup(m_selection.selectedItems.constFirst()))) {
         selection = m_model->getGroupElements(m_selection.selectedItems.constFirst());
     } else {
         for (int i : m_selection.selectedItems) {
             selection.insert(i);
         }
     }
     return selection;
 }
 
 void TimelineController::selectCurrentItem(ObjectType type, bool select, bool addToCurrent)
 {
     QList<int> toSelect;
     int currentClip = type == ObjectType::TimelineClip ? m_model->getClipByPosition(m_activeTrack, timelinePosition())
                                                        : m_model->getCompositionByPosition(m_activeTrack, timelinePosition());
     if (currentClip == -1) {
         pCore->displayMessage(i18n("No item under timeline cursor in active track"), InformationMessage, 500);
         return;
     }
     if (addToCurrent || !select) {
         toSelect = m_selection.selectedItems;
     }
     if (select) {
         if (!toSelect.contains(currentClip)) {
             toSelect << currentClip;
             setSelection(toSelect);
         }
     } else if (toSelect.contains(currentClip)) {
         toSelect.removeAll(currentClip);
         setSelection(toSelect);
     }
 }
 
 void TimelineController::setSelection(const QList<int> &newSelection, int trackIndex, bool isMultitrack)
 {
     qDebug() << "Changing selection to" << newSelection << " trackIndex" << trackIndex << "isMultitrack" << isMultitrack;
     if (newSelection != selection() || trackIndex != m_selection.selectedTrack || isMultitrack != m_selection.isMultitrackSelected) {
         m_selection.selectedItems = newSelection;
         m_selection.selectedTrack = trackIndex;
         m_selection.isMultitrackSelected = isMultitrack;
         if (m_model->m_temporarySelectionGroup > -1) {
             // Clear current selection
             m_model->requestClipUngroup(m_model->m_temporarySelectionGroup, false);
         }
         std::unordered_set<int> newIds;
         if (m_selection.selectedItems.size() > 0) {
             std::unordered_set<int> ids;
             ids.insert(m_selection.selectedItems.cbegin(), m_selection.selectedItems.cend());
             m_model->m_temporarySelectionGroup = m_model->requestClipsGroup(ids, true, GroupType::Selection);
             if (m_model->m_temporarySelectionGroup >= 0 ||
                 (!m_selection.selectedItems.isEmpty() && m_model->m_groups->isInGroup(m_selection.selectedItems.constFirst()))) {
                 newIds = m_model->getGroupElements(m_selection.selectedItems.constFirst());
             } else {
                 qDebug() << "// NON GROUPED SELCTUIIN: " << m_selection.selectedItems << " !!!!!!";
             }
             emitSelectedFromSelection();
         } else {
             // Empty selection
             emit selected(nullptr);
             emit showItemEffectStack(QString(), nullptr, QSize(), false);
         }
         emit selectionChanged();
     }
 }
 
 void TimelineController::emitSelectedFromSelection()
 {
     /*if (!m_model.trackList().count()) {
         if (m_model.tractor())
             selectMultitrack();
         else
             emit selected(0);
         return;
     }
 
     int trackIndex = currentTrack();
     int clipIndex = selection().isEmpty()? 0 : selection().first();
     Mlt::ClipInfo* info = getClipInfo(trackIndex, clipIndex);
     if (info && info->producer && info->producer->is_valid()) {
         delete m_updateCommand;
         m_updateCommand = new Timeline::UpdateCommand(*this, trackIndex, clipIndex, info->start);
         // We need to set these special properties so time-based filters
         // can get information about the cut while still applying filters
         // to the cut parent.
         info->producer->set(kFilterInProperty, info->frame_in);
         info->producer->set(kFilterOutProperty, info->frame_out);
         if (MLT.isImageProducer(info->producer))
             info->producer->set("out", info->cut->get_int("out"));
         info->producer->set(kMultitrackItemProperty, 1);
         m_ignoreNextPositionChange = true;
         emit selected(info->producer);
         delete info;
     }*/
 }
 
 QList<int> TimelineController::selection() const
 {
     if (!m_root) return QList<int>();
     return m_selection.selectedItems;
 }
 
 void TimelineController::setScrollPos(int pos)
 {
     if (pos > 0 && m_root) {
         QMetaObject::invokeMethod(m_root, "setScrollPos", Qt::QueuedConnection, Q_ARG(QVariant, pos));
     }
 }
 
 void TimelineController::selectMultitrack()
 {
     setSelection(QList<int>(), -1, true);
     QMetaObject::invokeMethod(m_root, "selectMultitrack");
     // emit selected(m_model.tractor());
 }
 
 void TimelineController::resetView()
 {
     m_model->_resetView();
     if (m_root) {
         QMetaObject::invokeMethod(m_root, "updatePalette");
     }
+    emit colorsChanged();
 }
 
 bool TimelineController::snap()
 {
     return KdenliveSettings::snaptopoints();
 }
 
 void TimelineController::snapChanged(bool snap)
 {
     m_root->setProperty("snapping", snap ? 10 / std::sqrt(m_scale) : -1);
 }
 
 bool TimelineController::ripple()
 {
     return false;
 }
 
 bool TimelineController::scrub()
 {
     return false;
 }
 
 int TimelineController::insertClip(int tid, int position, const QString &data_str, bool logUndo, bool refreshView, bool useTargets)
 {
     int id;
     if (tid == -1) {
         tid = m_activeTrack;
     }
     if (position == -1) {
         position = timelinePosition();
     }
     if (!m_model->requestClipInsertion(data_str, tid, position, id, logUndo, refreshView, useTargets)) {
         id = -1;
     }
     return id;
 }
 
 QList<int> TimelineController::insertClips(int tid, int position, const QStringList &binIds, bool logUndo, bool refreshView)
 {
     QList<int> clipIds;
     if (tid == -1) {
         tid = m_activeTrack;
     }
     if (position == -1) {
         position = timelinePosition();
     }
     TimelineFunctions::requestMultipleClipsInsertion(m_model, binIds, tid, position, clipIds, logUndo, refreshView);
     // we don't need to check the return value of the above function, in case of failure it will return an empty list of ids.
     return clipIds;
 }
 
 int TimelineController::insertNewComposition(int tid, int position, const QString &transitionId, bool logUndo)
 {
     int id;
     //int duration = pCore->currentDoc()->getFramePos(KdenliveSettings::transition_duration());
     int duration = m_model->getTrackById_const(tid)->suggestCompositionLength(position);
     int lowerVideoTrackId = m_model->getPreviousVideoTrackIndex(tid);
     if (lowerVideoTrackId > 0) {
         int duration2 = m_model->getTrackById_const(lowerVideoTrackId)->suggestCompositionLength(position);
         if (duration2 > 0) {
             duration = (duration > 0) ? qMin(duration, duration2) : duration2;
         }
     }
     if (duration <= 4) {
         // if suggested composition duration is lower than 4 frames, use default
         duration = pCore->currentDoc()->getFramePos(KdenliveSettings::transition_duration());
     }
     if (!m_model->requestCompositionInsertion(transitionId, tid, position, duration, nullptr, id, logUndo)) {
         id = -1;
     }
     return id;
 }
 
 int TimelineController::insertComposition(int tid, int position, const QString &transitionId, bool logUndo)
 {
     int id;
     int duration = pCore->currentDoc()->getFramePos(KdenliveSettings::transition_duration());
     if (!m_model->requestCompositionInsertion(transitionId, tid, position, duration, nullptr, id, logUndo)) {
         id = -1;
     }
     return id;
 }
 
 void TimelineController::deleteSelectedClips()
 {
     if (m_selection.selectedItems.isEmpty()) {
         return;
     }
     if (m_model->m_temporarySelectionGroup != -1) {
         // selection is grouped, delete group only
         m_model->requestGroupDeletion(m_model->m_temporarySelectionGroup);
     } else {
         for (int cid : m_selection.selectedItems) {
             m_model->requestItemDeletion(cid);
         }
     }
     m_selection.selectedItems.clear();
     emit selectionChanged();
 }
 
 void TimelineController::slotUpdateSelection(int itemId)
 {
     if (m_selection.selectedItems.contains(itemId)) {
         m_selection.selectedItems.removeAll(itemId);
         emit selectionChanged();
     }
 }
 
 void TimelineController::copyItem()
 {
     int clipId = -1;
     int masterTrack = -1;
     if (!m_selection.selectedItems.isEmpty()) {
         clipId = m_selection.selectedItems.first();
         // Check grouped clips
         QList <int> extraClips = m_selection.selectedItems;
         masterTrack = m_model->getItemTrackId(m_selection.selectedItems.first());
         std::unordered_set<int> groupRoots;
         for (int id : m_selection.selectedItems) {
             if (m_model->m_groups->isInGroup(id)) {
                 int gid = m_model->m_groups->getRootId(id);
                 qDebug()<<" * ** ITEM "<<id<<" IS IN GROUP: "<<gid;
                 if (gid != m_model->m_temporarySelectionGroup) {
                     qDebug()<<" * ** TRYING TO INSERT GP: "<<gid;
                     if (groupRoots.find(gid) == groupRoots.end()) {
                         groupRoots.insert(gid);
                     }
                 } else {
                     qDebug()<<" * ** TRYING TO INSERT SELECTION CHILD";
                     std::unordered_set<int> selection = m_model->m_groups->getDirectChildren(gid);
                     for (int j : selection) {
                         if (groupRoots.find(j) == groupRoots.end()) {
                             groupRoots.insert(j);
                         }
                     }
                 }
                 std::unordered_set<int> selection = m_model->getGroupElements(id);
                 for (int j : selection) {
                     if (!extraClips.contains(j)) {
                         extraClips << j;
                     }
                 }
             }
         }
         qDebug()<<"==============\n GROUP ROOTS: ";
         for (int gp : groupRoots) {
             qDebug()<<"GROUP: "<<gp;
         }
         qDebug()<<"\n=======";
         m_copiedItems.clear();
         int offset = -1;
         QDomElement container = m_copiedItems.createElement(QStringLiteral("list"));
         m_copiedItems.appendChild(container);
         for (int id : extraClips) {
             if (offset == -1 || m_model->getItemPosition(id) < offset) {
                 offset = m_model->getItemPosition(id);
             }
             if (m_model->isClip(id)) {
                 container.appendChild(m_model->m_allClips[id]->toXml(m_copiedItems));
             } else if (m_model->isComposition(id)) {
                 container.appendChild(m_model->m_allCompositions[id]->toXml(m_copiedItems));
             }
         }
         container.setAttribute(QStringLiteral("offset"), offset);
         container.setAttribute(QStringLiteral("masterTrack"), masterTrack);
         QDomElement grp = m_copiedItems.createElement(QStringLiteral("groups"));
         container.appendChild(grp);
         grp.appendChild(m_copiedItems.createTextNode(m_model->m_groups->toJson(groupRoots)));
         //TODO: groups
         qDebug()<<" / // / PASTED DOC: \n\n"<<m_copiedItems.toString()<<"\n\n------------";
     } else {
         return;
     }
     m_root->setProperty("copiedClip", clipId);
 }
 
 bool TimelineController::pasteItem()
 {
     int tid = getMouseTrack();
     int position = getMousePos();
     if (tid == -1) {
         tid = m_activeTrack;
     }
     if (position == -1) {
         position = timelinePosition();
     }
     QDomNodeList clips = m_copiedItems.documentElement().elementsByTagName(QStringLiteral("clip"));
     QDomNodeList compositions = m_copiedItems.documentElement().elementsByTagName(QStringLiteral("composition"));
     int offset = m_copiedItems.documentElement().attribute(QStringLiteral("offset")).toInt();
     int masterTrack = m_copiedItems.documentElement().attribute(QStringLiteral("masterTrack")).toInt();
     int trackOffset = TimelineFunctions::getTrackOffset(m_model, masterTrack, tid);
     bool masterIsAudio = m_model->isAudioTrack(masterTrack);
     // find paste tracks
     QMap <int, int> tracksMap;
     for (int i = 0; i < clips.count(); i++) {
         QDomElement prod = clips.at(i).toElement();
         int trackId = prod.attribute(QStringLiteral("track")).toInt();
         if (tracksMap.contains(trackId)) {
             // Track already processed, skip
             continue;
         }
         if (trackOffset == 0) {
             tracksMap.insert(trackId, trackId);
             continue;
         }
         tracksMap.insert(trackId, TimelineFunctions::getOffsetTrackId(m_model, trackId, trackOffset, masterIsAudio));
     }
     for (int i = 0; i < compositions.count(); i++) {
         QDomElement prod = compositions.at(i).toElement();
         int trackId = prod.attribute(QStringLiteral("track")).toInt();
         if (!tracksMap.contains(trackId)) {
             tracksMap.insert(trackId, TimelineFunctions::getOffsetTrackId(m_model, trackId, trackOffset, masterIsAudio));
         }
         int atrackId = prod.attribute(QStringLiteral("a_track")).toInt();
         if (atrackId == 0) {
             continue;
         }
         atrackId = m_model->getTrackIndexFromPosition(atrackId);
         if (!tracksMap.contains(atrackId)) {
             tracksMap.insert(atrackId, TimelineFunctions::getOffsetTrackId(m_model, atrackId, trackOffset, masterIsAudio));
         }
     }
 
     std::function<bool(void)> undo = []() { return true; };
     std::function<bool(void)> redo = []() { return true; };
     bool res = true;
     QMap <int, int> correspondingIds;
     for (int i = 0; res && i < clips.count(); i++) {
         QDomElement prod = clips.at(i).toElement();
         QString originalId = prod.attribute(QStringLiteral("binid"));
         int in = prod.attribute(QStringLiteral("in")).toInt();
         int out = prod.attribute(QStringLiteral("out")).toInt();
         int trackId = prod.attribute(QStringLiteral("track")).toInt();
         int pos = prod.attribute(QStringLiteral("position")).toInt() - offset;
         int newId;
         res = m_model->requestClipCreation(originalId, newId, m_model->getTrackById_const(trackId)->trackType(), undo, redo);
         if(m_model->m_allClips[newId]->m_endlessResize) {
             out = out - in;
             in = 0;
             m_model->m_allClips[newId]->m_producer->set("length", out + 1);
         }
         m_model->m_allClips[newId]->setInOut(in, out);
         correspondingIds.insert(prod.attribute(QStringLiteral("id")).toInt(), newId);
         res = res & m_model->getTrackById(tracksMap.value(trackId))->requestClipInsertion(newId, position + pos, true, true, undo, redo);
         // paste effects
         if (res) {
             std::shared_ptr<EffectStackModel> destStack = m_model->getClipEffectStackModel(newId);
             destStack->fromXml(prod.firstChildElement(QStringLiteral("effects")), undo, redo);
         }
     }
 
     // Compositions
     for (int i = 0; res && i < compositions.count(); i++) {
         QDomElement prod = compositions.at(i).toElement();
         QString originalId = prod.attribute(QStringLiteral("composition"));
         int in = prod.attribute(QStringLiteral("in")).toInt();
         int out = prod.attribute(QStringLiteral("out")).toInt();
         int trackId = prod.attribute(QStringLiteral("track")).toInt();
         int aTrackId = prod.attribute(QStringLiteral("a_track")).toInt();
         if (aTrackId > 0) {
             aTrackId = tracksMap.value(m_model->getTrackIndexFromPosition(aTrackId));
         }
         int pos = prod.attribute(QStringLiteral("position")).toInt() - offset;
         int newId;
         Mlt::Properties transProps;
         QDomNodeList props = prod.elementsByTagName(QStringLiteral("property"));
         for (int j = 0; j < props.count(); j++) {
             transProps.set(props.at(j).toElement().attribute(QStringLiteral("name")).toUtf8().constData(), props.at(j).toElement().text().toUtf8().constData());
         }
         res = m_model->requestCompositionInsertion(originalId, tracksMap.value(trackId), aTrackId, position + pos, out - in, &transProps, newId, undo, redo);
     }
     if (!res) {
         undo();
         return false;
     }
     const QString groupsData = m_copiedItems.documentElement().firstChildElement(QStringLiteral("groups")).text();
     qDebug()<<"************** GRP DATA ********\n"<<groupsData<<"\n******";
     m_model->m_groups->fromJsonWithOffset(groupsData, tracksMap, position - offset);
     pCore->pushUndo(undo, redo, i18n("Paste clips"));
     return true;
 }
 
 void TimelineController::triggerAction(const QString &name)
 {
     pCore->triggerAction(name);
 }
 
 QString TimelineController::timecode(int frames)
 {
     return KdenliveSettings::frametimecode() ? QString::number(frames) : m_model->tractor()->frames_to_time(frames, mlt_time_smpte_df);
 }
 
 bool TimelineController::showThumbnails() const
 {
     return KdenliveSettings::videothumbnails();
 }
 
 bool TimelineController::showAudioThumbnails() const
 {
     return KdenliveSettings::audiothumbnails();
 }
 
 bool TimelineController::showMarkers() const
 {
     return KdenliveSettings::showmarkers();
 }
 
 bool TimelineController::audioThumbFormat() const
 {
     return KdenliveSettings::displayallchannels();
 }
 
 bool TimelineController::showWaveforms() const
 {
     return KdenliveSettings::audiothumbnails();
 }
 
 void TimelineController::addTrack(int tid)
 {
     if (tid == -1) {
         tid = m_activeTrack;
     }
     QPointer<TrackDialog> d = new TrackDialog(m_model, tid, qApp->activeWindow());
     if (d->exec() == QDialog::Accepted) {
         int newTid;
         m_model->requestTrackInsertion(d->selectedTrackPosition(), newTid, d->trackName(), d->addAudioTrack());
         m_model->buildTrackCompositing(true);
         m_model->_resetView();
     }
 }
 
 void TimelineController::deleteTrack(int tid)
 {
     if (tid == -1) {
         tid = m_activeTrack;
     }
     QPointer<TrackDialog> d = new TrackDialog(m_model, tid, qApp->activeWindow(), true);
     if (d->exec() == QDialog::Accepted) {
         int selectedTrackIx = d->selectedTrackId();
         m_model->requestTrackDeletion(selectedTrackIx);
         m_model->buildTrackCompositing(true);
         if (m_activeTrack == selectedTrackIx) {
             setActiveTrack(m_model->getTrackIndexFromPosition(m_model->getTracksCount() - 1));
         }
     }
 }
 
 void TimelineController::gotoNextSnap()
 {
     setPosition(m_model->requestNextSnapPos(timelinePosition()));
 }
 
 void TimelineController::gotoPreviousSnap()
 {
     setPosition(m_model->requestPreviousSnapPos(timelinePosition()));
 }
 
 void TimelineController::groupSelection()
 {
     if (m_selection.selectedItems.size() < 2) {
         pCore->displayMessage(i18n("Select at least 2 items to group"), InformationMessage, 500);
         return;
     }
     std::unordered_set<int> clips;
     for (int id : m_selection.selectedItems) {
         clips.insert(id);
     }
     m_model->requestClipsGroup(clips);
     emit selectionChanged();
 }
 
 void TimelineController::unGroupSelection(int cid)
 {
     if (cid == -1 && m_selection.selectedItems.isEmpty()) {
         pCore->displayMessage(i18n("Select at least 1 item to ungroup"), InformationMessage, 500);
         return;
     }
     if (cid == -1) {
         if (m_model->m_temporarySelectionGroup >= 0) {
             cid = m_model->m_temporarySelectionGroup;
         } else {
             for (int id : m_selection.selectedItems) {
                 if (m_model->m_groups->getRootId(id)) {
                     cid = id;
                     break;
                 }
             }
         }
     }
     int tmpGroup = m_model->m_temporarySelectionGroup;
     if (tmpGroup >= 0) {
         m_model->requestClipUngroup(m_model->m_temporarySelectionGroup, false);
     }
     if (cid > -1) {
         if (cid != tmpGroup) {
             cid = m_model->m_groups->getDirectAncestor(cid);
         } else {
             cid = -1;
             for (int id : m_selection.selectedItems) {
                 if (m_model->m_groups->getRootId(id)) {
                     cid = id;
                     break;
                 }
             }
         }
         if (cid > -1) {
             m_model->requestClipUngroup(cid);
         }
     }
     m_selection.selectedItems.clear();
     emit selectionChanged();
 }
 
 void TimelineController::setInPoint()
 {
     int cursorPos = timelinePosition();
     if (!m_selection.selectedItems.isEmpty()) {
         for (int id : m_selection.selectedItems) {
             int start = m_model->getItemPosition(id);
             if (start == cursorPos) {
                 continue;
             }
             int size = start + m_model->getItemPlaytime(id) - cursorPos;
             m_model->requestItemResize(id, size, false, true, 0, false);
         }
     }
 }
 
 int TimelineController::timelinePosition() const
 {
     return m_seekPosition >= 0 ? m_seekPosition : m_position;
 }
 
 void TimelineController::setOutPoint()
 {
     int cursorPos = timelinePosition();
     if (!m_selection.selectedItems.isEmpty()) {
         for (int id : m_selection.selectedItems) {
             int start = m_model->getItemPosition(id);
             if (start + m_model->getItemPlaytime(id) == cursorPos) {
                 continue;
             }
             int size = cursorPos - start;
             m_model->requestItemResize(id, size, true, true, 0, false);
         }
     }
 }
 
 void TimelineController::editMarker(const QString &cid, int frame)
 {
     std::shared_ptr<ProjectClip> clip = pCore->bin()->getBinClip(cid);
     GenTime pos(frame, pCore->getCurrentFps());
     clip->getMarkerModel()->editMarkerGui(pos, qApp->activeWindow(), false, clip.get());
 }
 
 void TimelineController::editGuide(int frame)
 {
     if (frame == -1) {
         frame = timelinePosition();
     }
     auto guideModel = pCore->projectManager()->current()->getGuideModel();
     GenTime pos(frame, pCore->getCurrentFps());
     guideModel->editMarkerGui(pos, qApp->activeWindow(), false);
 }
 
 void TimelineController::moveGuide(int frame, int newFrame)
 {
     auto guideModel = pCore->projectManager()->current()->getGuideModel();
     GenTime pos(frame, pCore->getCurrentFps());
     GenTime newPos(newFrame, pCore->getCurrentFps());
     guideModel->editMarker(pos, newPos);
 }
 
 void TimelineController::switchGuide(int frame, bool deleteOnly)
 {
     bool markerFound = false;
     if (frame == -1) {
         frame = timelinePosition();
     }
     CommentedTime marker = pCore->projectManager()->current()->getGuideModel()->getMarker(GenTime(frame, pCore->getCurrentFps()), &markerFound);
     if (!markerFound) {
         if (deleteOnly) {
             pCore->displayMessage(i18n("No guide found at current position"), InformationMessage, 500);
             return;
         }
         GenTime pos(frame, pCore->getCurrentFps());
         pCore->projectManager()->current()->getGuideModel()->addMarker(pos, i18n("guide"));
     } else {
         pCore->projectManager()->current()->getGuideModel()->removeMarker(marker.time());
     }
 }
 
 void TimelineController::addAsset(const QVariantMap data)
 {
     QString effect = data.value(QStringLiteral("kdenlive/effect")).toString();
     if (!m_selection.selectedItems.isEmpty()) {
         QList<int> effectSelection;
         for (int id : m_selection.selectedItems) {
             if (m_model->isClip(id)) {
                 effectSelection << id;
                 int partner = m_model->getClipSplitPartner(id);
                 if (partner > -1 && !effectSelection.contains(partner)) {
                     effectSelection << partner;
                 }
             }
         }
         bool foundMatch = false;
         for (int id : effectSelection) {
             if (m_model->addClipEffect(id, effect, false)) {
                 foundMatch = true;
             }
         }
         if (!foundMatch) {
             QString effectName = EffectsRepository::get()->getName(effect);
             pCore->displayMessage(i18n("Cannot add effect %1 to selected clip", effectName), InformationMessage, 500);
         }
     } else {
         pCore->displayMessage(i18n("Select a clip to apply an effect"), InformationMessage, 500);
     }
 }
 
 void TimelineController::requestRefresh()
 {
     pCore->requestMonitorRefresh();
 }
 
 void TimelineController::showAsset(int id)
 {
     if (m_model->isComposition(id)) {
         emit showTransitionModel(id, m_model->getCompositionParameterModel(id));
     } else if (m_model->isClip(id)) {
         QModelIndex clipIx = m_model->makeClipIndexFromID(id);
         QString clipName = m_model->data(clipIx, Qt::DisplayRole).toString();
         bool showKeyframes = m_model->data(clipIx, TimelineModel::ShowKeyframesRole).toInt();
         qDebug() << "-----\n// SHOW KEYFRAMES: " << showKeyframes;
         emit showItemEffectStack(clipName, m_model->getClipEffectStackModel(id), m_model->getClipFrameSize(id), showKeyframes);
     }
 }
 
 void TimelineController::showTrackAsset(int trackId)
 {
     emit showItemEffectStack(getTrackNameFromIndex(trackId), m_model->getTrackEffectStackModel(trackId), pCore->getCurrentFrameSize(), false);
 }
 
 void TimelineController::setPosition(int position)
 {
     setSeekPosition(position);
     emit seeked(position);
 }
 
 void TimelineController::setAudioTarget(int track)
 {
     m_model->m_audioTarget = track;
     emit audioTargetChanged();
 }
 
 void TimelineController::setVideoTarget(int track)
 {
     m_model->m_videoTarget = track;
     emit videoTargetChanged();
 }
 
 void TimelineController::setActiveTrack(int track)
 {
     m_activeTrack = track;
     emit activeTrackChanged();
 }
 
 void TimelineController::setSeekPosition(int position)
 {
     m_seekPosition = position;
     emit seekPositionChanged();
 }
 
 void TimelineController::onSeeked(int position)
 {
     m_position = position;
     emit positionChanged();
     if (m_seekPosition > -1 && position == m_seekPosition) {
         m_seekPosition = -1;
         emit seekPositionChanged();
     }
 }
 
 void TimelineController::setZone(const QPoint &zone)
 {
     if (m_zone.x() > 0) {
         m_model->removeSnap(m_zone.x());
     }
     if (m_zone.y() > 0) {
         m_model->removeSnap(m_zone.y() - 1);
     }
     if (zone.x() > 0) {
         m_model->addSnap(zone.x());
     }
     if (zone.y() > 0) {
         m_model->addSnap(zone.y() - 1);
     }
     m_zone = zone;
     emit zoneChanged();
 }
 
 void TimelineController::setZoneIn(int inPoint)
 {
     if (m_zone.x() > 0) {
         m_model->removeSnap(m_zone.x());
     }
     if (inPoint > 0) {
         m_model->addSnap(inPoint);
     }
     m_zone.setX(inPoint);
     emit zoneMoved(m_zone);
 }
 
 void TimelineController::setZoneOut(int outPoint)
 {
     if (m_zone.y() > 0) {
         m_model->removeSnap(m_zone.y() - 1);
     }
     if (outPoint > 0) {
         m_model->addSnap(outPoint - 1);
     }
     m_zone.setY(outPoint);
     emit zoneMoved(m_zone);
 }
 
 void TimelineController::selectItems(QVariantList arg, int startFrame, int endFrame, bool addToSelect)
 {
     std::unordered_set<int> previousSelection = getCurrentSelectionIds();
     std::unordered_set<int> itemsToSelect;
     if (addToSelect) {
         for (int cid : m_selection.selectedItems) {
             itemsToSelect.insert(cid);
         }
     }
     m_selection.selectedItems.clear();
     for (int i = 0; i < arg.count(); i++) {
         auto currentClips = m_model->getItemsInRange(arg.at(i).toInt(), startFrame, endFrame, true);
         itemsToSelect.insert(currentClips.begin(), currentClips.end());
     }
     if (itemsToSelect.size() > 0) {
         for (int x : itemsToSelect) {
             m_selection.selectedItems << x;
         }
         qDebug() << "// GROUPING ITEMS: " << m_selection.selectedItems;
         m_model->m_temporarySelectionGroup = m_model->requestClipsGroup(itemsToSelect, true, GroupType::Selection);
         qDebug() << "// GROUPING ITEMS DONE";
     } else if (m_model->m_temporarySelectionGroup > -1) {
         m_model->requestClipUngroup(m_model->m_temporarySelectionGroup, false);
     }
     std::unordered_set<int> newIds;
     if (m_model->m_temporarySelectionGroup >= 0) {
         newIds = m_model->getGroupElements(m_selection.selectedItems.constFirst());
         for (int child : newIds) {
             QModelIndex ix;
             if (m_model->isClip(child)) {
                 ix = m_model->makeClipIndexFromID(child);
             } else if (m_model->isComposition(child)) {
                 ix = m_model->makeCompositionIndexFromID(child);
             }
             if (ix.isValid()) {
                 m_model->dataChanged(ix, ix, {TimelineModel::GroupedRole});
             }
         }
     }
     emit selectionChanged();
 }
 
 void TimelineController::requestClipCut(int clipId, int position)
 {
     if (position == -1) {
         position = timelinePosition();
     }
     TimelineFunctions::requestClipCut(m_model, clipId, position);
 }
 
 void TimelineController::cutClipUnderCursor(int position, int track)
 {
     if (position == -1) {
         position = timelinePosition();
     }
     bool foundClip = false;
     for (int cid : m_selection.selectedItems) {
         if (m_model->isClip(cid)) {
             if (TimelineFunctions::requestClipCut(m_model, cid, position)) {
                 foundClip = true;
             }
         } else {
             qDebug() << "//// TODO: COMPOSITION CUT!!!";
         }
     }
     if (!foundClip) {
         if (track == -1) {
             track = m_activeTrack;
         }
         if (track >= 0) {
             int cid = m_model->getClipByPosition(track, position);
             if (cid >= 0 && TimelineFunctions::requestClipCut(m_model, cid, position)) {
                 foundClip = true;
             }
         }
     }
     if (!foundClip) {
         pCore->displayMessage(i18n("No clip to cut"), InformationMessage, 500);
     }
 }
 
 int TimelineController::requestSpacerStartOperation(int trackId, int position)
 {
     return TimelineFunctions::requestSpacerStartOperation(m_model, trackId, position);
 }
 
 bool TimelineController::requestSpacerEndOperation(int clipId, int startPosition, int endPosition)
 {
     return TimelineFunctions::requestSpacerEndOperation(m_model, clipId, startPosition, endPosition);
 }
 
 void TimelineController::seekCurrentClip(bool seekToEnd)
 {
     for (int cid : m_selection.selectedItems) {
         int start = m_model->getItemPosition(cid);
         if (seekToEnd) {
             start += m_model->getItemPlaytime(cid);
         }
         setPosition(start);
         break;
     }
 }
 
 void TimelineController::seekToClip(int cid, bool seekToEnd)
 {
     int start = m_model->getItemPosition(cid);
     if (seekToEnd) {
         start += m_model->getItemPlaytime(cid);
     }
     setPosition(start);
 }
 
 void TimelineController::seekToMouse()
 {
     QVariant returnedValue;
     QMetaObject::invokeMethod(m_root, "getMousePos", Q_RETURN_ARG(QVariant, returnedValue));
     int mousePos = returnedValue.toInt();
     setPosition(mousePos);
 }
 
 int TimelineController::getMousePos()
 {
     QVariant returnedValue;
     QMetaObject::invokeMethod(m_root, "getMousePos", Q_RETURN_ARG(QVariant, returnedValue));
     return returnedValue.toInt();
 }
 
 int TimelineController::getMouseTrack()
 {
     QVariant returnedValue;
     QMetaObject::invokeMethod(m_root, "getMouseTrack", Q_RETURN_ARG(QVariant, returnedValue));
     return returnedValue.toInt();
 }
 
 void TimelineController::refreshItem(int id)
 {
     int in = m_model->getItemPosition(id);
     if (in > m_position || m_model->m_allClips[id]->isAudioOnly()) {
         return;
     }
     if (m_position <= in + m_model->getItemPlaytime(id)) {
         pCore->requestMonitorRefresh();
     }
 }
 
 QPoint TimelineController::getTracksCount() const
 {
     QVariant returnedValue;
     QMetaObject::invokeMethod(m_root, "getTracksCount", Q_RETURN_ARG(QVariant, returnedValue));
     QVariantList tracks = returnedValue.toList();
     QPoint p(tracks.at(0).toInt(), tracks.at(1).toInt());
     return p;
 }
 
 QStringList TimelineController::extractCompositionLumas() const
 {
     return m_model->extractCompositionLumas();
 }
 
 void TimelineController::addEffectToCurrentClip(const QStringList &effectData)
 {
     QList<int> activeClips;
     for (int track = m_model->getTracksCount() - 1; track >= 0; track--) {
         int trackIx = m_model->getTrackIndexFromPosition(track);
         int cid = m_model->getClipByPosition(trackIx, timelinePosition());
         if (cid > -1) {
             activeClips << cid;
         }
     }
     if (!activeClips.isEmpty()) {
         if (effectData.count() == 4) {
             QString effectString = effectData.at(1) + QStringLiteral("-") + effectData.at(2) + QStringLiteral("-") + effectData.at(3);
             m_model->copyClipEffect(activeClips.first(), effectString);
         } else {
             m_model->addClipEffect(activeClips.first(), effectData.constFirst());
         }
     }
 }
 
 void TimelineController::adjustFade(int cid, const QString &effectId, int duration, int initialDuration)
 {
     if (duration <= 0) {
         // remove fade
         m_model->removeFade(cid, effectId == QLatin1String("fadein"));
     } else {
         m_model->adjustEffectLength(cid, effectId, duration, initialDuration);
     }
 }
 
 QPair<int, int> TimelineController::getCompositionATrack(int cid) const
 {
     QPair<int, int> result;
     std::shared_ptr<CompositionModel> compo = m_model->getCompositionPtr(cid);
     if (compo) {
         result = QPair<int, int>(compo->getATrack(), m_model->getTrackMltIndex(compo->getCurrentTrackId()));
     }
     return result;
 }
 
 void TimelineController::setCompositionATrack(int cid, int aTrack)
 {
     TimelineFunctions::setCompositionATrack(m_model, cid, aTrack);
 }
 
 bool TimelineController::compositionAutoTrack(int cid) const
 {
     std::shared_ptr<CompositionModel> compo = m_model->getCompositionPtr(cid);
     return compo && compo->getForcedTrack() == -1;
 }
 
 const QString TimelineController::getClipBinId(int clipId) const
 {
     return m_model->getClipBinId(clipId);
 }
 
 void TimelineController::focusItem(int itemId)
 {
     int start = m_model->getItemPosition(itemId);
     setPosition(start);
 }
 
 int TimelineController::headerWidth() const
 {
     return qMax(10, KdenliveSettings::headerwidth());
 }
 
 void TimelineController::setHeaderWidth(int width)
 {
     KdenliveSettings::setHeaderwidth(width);
 }
 
 bool TimelineController::createSplitOverlay(Mlt::Filter *filter)
 {
     if (m_timelinePreview && m_timelinePreview->hasOverlayTrack()) {
         return true;
     }
     int clipId = getCurrentItem();
     if (clipId == -1) {
         pCore->displayMessage(i18n("Select a clip to compare effect"), InformationMessage, 500);
         return false;
     }
     std::shared_ptr<ClipModel> clip = m_model->getClipPtr(clipId);
     const QString binId = clip->binId();
 
     // Get clean bin copy of the clip
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(binId);
     std::shared_ptr<Mlt::Producer> binProd(binClip->masterProducer()->cut(clip->getIn(), clip->getOut()));
 
     // Get copy of timeline producer
     std::shared_ptr<Mlt::Producer> clipProducer(new Mlt::Producer(*clip));
 
     // Built tractor and compositing
     Mlt::Tractor trac(*m_model->m_tractor->profile());
     Mlt::Playlist play(*m_model->m_tractor->profile());
     Mlt::Playlist play2(*m_model->m_tractor->profile());
     play.append(*clipProducer.get());
     play2.append(*binProd);
     trac.set_track(play, 0);
     trac.set_track(play2, 1);
     play2.attach(*filter);
     QString splitTransition = TransitionsRepository::get()->getCompositingTransition();
     Mlt::Transition t(*m_model->m_tractor->profile(), splitTransition.toUtf8().constData());
     t.set("always_active", 1);
     trac.plant_transition(t, 0, 1);
     int startPos = m_model->getClipPosition(clipId);
 
     // plug in overlay playlist
     Mlt::Playlist *overlay = new Mlt::Playlist(*m_model->m_tractor->profile());
     overlay->insert_blank(0, startPos);
     Mlt::Producer split(trac.get_producer());
     overlay->insert_at(startPos, &split, 1);
 
     // insert in tractor
     if (!m_timelinePreview) {
         initializePreview();
     }
     m_timelinePreview->setOverlayTrack(overlay);
     m_model->m_overlayTrackCount = m_timelinePreview->addedTracks();
     return true;
 }
 
 void TimelineController::removeSplitOverlay()
 {
     if (m_timelinePreview && !m_timelinePreview->hasOverlayTrack()) {
         return;
     }
     // disconnect
     m_timelinePreview->removeOverlayTrack();
     m_model->m_overlayTrackCount = m_timelinePreview->addedTracks();
 }
 
 void TimelineController::addPreviewRange(bool add)
 {
     if (m_zone.isNull()) {
         return;
     }
     if (!m_timelinePreview) {
         initializePreview();
     }
     if (m_timelinePreview) {
         m_timelinePreview->addPreviewRange(m_zone, add);
     }
 }
 
 void TimelineController::clearPreviewRange()
 {
     if (m_timelinePreview) {
         m_timelinePreview->clearPreviewRange();
     }
 }
 
 void TimelineController::startPreviewRender()
 {
     // Timeline preview stuff
     if (!m_timelinePreview) {
         initializePreview();
     } else if (m_disablePreview->isChecked()) {
         m_disablePreview->setChecked(false);
         disablePreview(false);
     }
     if (m_timelinePreview) {
         if (!m_usePreview) {
             m_timelinePreview->buildPreviewTrack();
             m_usePreview = true;
             m_model->m_overlayTrackCount = m_timelinePreview->addedTracks();
         }
         m_timelinePreview->startPreviewRender();
     }
 }
 
 void TimelineController::stopPreviewRender()
 {
     if (m_timelinePreview) {
         m_timelinePreview->abortRendering();
     }
 }
 
 void TimelineController::initializePreview()
 {
     if (m_timelinePreview) {
         // Update parameters
         if (!m_timelinePreview->loadParams()) {
             if (m_usePreview) {
                 // Disconnect preview track
                 m_timelinePreview->disconnectTrack();
                 m_usePreview = false;
             }
             delete m_timelinePreview;
             m_timelinePreview = nullptr;
         }
     } else {
         m_timelinePreview = new PreviewManager(this, m_model->m_tractor.get());
         if (!m_timelinePreview->initialize()) {
             // TODO warn user
             delete m_timelinePreview;
             m_timelinePreview = nullptr;
         } else {
         }
     }
     QAction *previewRender = pCore->currentDoc()->getAction(QStringLiteral("prerender_timeline_zone"));
     if (previewRender) {
         previewRender->setEnabled(m_timelinePreview != nullptr);
     }
     m_disablePreview->setEnabled(m_timelinePreview != nullptr);
     m_disablePreview->blockSignals(true);
     m_disablePreview->setChecked(false);
     m_disablePreview->blockSignals(false);
 }
 
 void TimelineController::disablePreview(bool disable)
 {
     if (disable) {
         m_timelinePreview->deletePreviewTrack();
         m_usePreview = false;
         m_model->m_overlayTrackCount = m_timelinePreview->addedTracks();
     } else {
         if (!m_usePreview) {
             if (!m_timelinePreview->buildPreviewTrack()) {
                 // preview track already exists, reconnect
                 m_model->m_tractor->lock();
                 m_timelinePreview->reconnectTrack();
                 m_model->m_tractor->unlock();
             }
             m_timelinePreview->loadChunks(QVariantList(), QVariantList(), QDateTime());
             m_usePreview = true;
         }
     }
     m_model->m_overlayTrackCount = m_timelinePreview->addedTracks();
 }
 
 QVariantList TimelineController::dirtyChunks() const
 {
     return m_timelinePreview ? m_timelinePreview->m_dirtyChunks : QVariantList();
 }
 
 QVariantList TimelineController::renderedChunks() const
 {
     return m_timelinePreview ? m_timelinePreview->m_renderedChunks : QVariantList();
 }
 
 int TimelineController::workingPreview() const
 {
     return m_timelinePreview ? m_timelinePreview->workingPreview : -1;
 }
 
 bool TimelineController::useRuler() const
 {
     return pCore->currentDoc()->getDocumentProperty(QStringLiteral("enableTimelineZone")).toInt() == 1;
 }
 
 void TimelineController::resetPreview()
 {
     if (m_timelinePreview) {
         m_timelinePreview->clearPreviewRange();
         initializePreview();
     }
 }
 
 void TimelineController::loadPreview(QString chunks, QString dirty, const QDateTime &documentDate, int enable)
 {
     if (chunks.isEmpty() && dirty.isEmpty()) {
         return;
     }
     if (!m_timelinePreview) {
         initializePreview();
     }
     QVariantList renderedChunks;
     QVariantList dirtyChunks;
     QStringList chunksList = chunks.split(QLatin1Char(','), QString::SkipEmptyParts);
     QStringList dirtyList = dirty.split(QLatin1Char(','), QString::SkipEmptyParts);
     for (const QString &frame : chunksList) {
         renderedChunks << frame.toInt();
     }
     for (const QString &frame : dirtyList) {
         dirtyChunks << frame.toInt();
     }
     m_disablePreview->blockSignals(true);
     m_disablePreview->setChecked(enable);
     m_disablePreview->blockSignals(false);
     if (!enable) {
         m_timelinePreview->buildPreviewTrack();
         m_usePreview = true;
         m_model->m_overlayTrackCount = m_timelinePreview->addedTracks();
     }
     m_timelinePreview->loadChunks(renderedChunks, dirtyChunks, documentDate);
 }
 
 QMap<QString, QString> TimelineController::documentProperties()
 {
     QMap<QString, QString> props = pCore->currentDoc()->documentProperties();
     int audioTarget = m_model->m_audioTarget == -1 ? -1 : m_model->getTrackPosition(m_model->m_audioTarget);
     int videoTarget = m_model->m_videoTarget == -1 ? -1 : m_model->getTrackPosition(m_model->m_videoTarget);
     int activeTrack = m_activeTrack == -1 ? -1 : m_model->getTrackPosition(m_activeTrack);
     props.insert(QStringLiteral("audioTarget"), QString::number(audioTarget));
     props.insert(QStringLiteral("videoTarget"), QString::number(videoTarget));
     props.insert(QStringLiteral("activeTrack"), QString::number(activeTrack));
     props.insert(QStringLiteral("position"), QString::number(timelinePosition()));
     QVariant returnedValue;
     QMetaObject::invokeMethod(m_root, "getScrollPos", Q_RETURN_ARG(QVariant, returnedValue));
     int scrollPos = returnedValue.toInt();
     props.insert(QStringLiteral("scrollPos"), QString::number(scrollPos));
     props.insert(QStringLiteral("zonein"), QString::number(m_zone.x()));
     props.insert(QStringLiteral("zoneout"), QString::number(m_zone.y()));
     if (m_timelinePreview) {
         QPair<QStringList, QStringList> chunks = m_timelinePreview->previewChunks();
         props.insert(QStringLiteral("previewchunks"), chunks.first.join(QLatin1Char(',')));
         props.insert(QStringLiteral("dirtypreviewchunks"), chunks.second.join(QLatin1Char(',')));
     }
     props.insert(QStringLiteral("disablepreview"), QString::number((int)m_disablePreview->isChecked()));
     return props;
 }
 
 void TimelineController::insertSpace(int trackId, int frame)
 {
     if (frame == -1) {
         frame = timelinePosition();
     }
     if (trackId == -1) {
         trackId = m_activeTrack;
     }
     QPointer<SpacerDialog> d = new SpacerDialog(GenTime(65, pCore->getCurrentFps()), pCore->currentDoc()->timecode(), qApp->activeWindow());
     if (d->exec() != QDialog::Accepted) {
         delete d;
         return;
     }
     int cid = requestSpacerStartOperation(d->affectAllTracks() ? -1 : trackId, frame);
     int spaceDuration = d->selectedDuration().frames(pCore->getCurrentFps());
     delete d;
     if (cid == -1) {
         pCore->displayMessage(i18n("No clips found to insert space"), InformationMessage, 500);
         return;
     }
     int start = m_model->getItemPosition(cid);
     requestSpacerEndOperation(cid, start, start + spaceDuration);
 }
 
 void TimelineController::removeSpace(int trackId, int frame, bool affectAllTracks)
 {
     if (frame == -1) {
         frame = timelinePosition();
     }
     if (trackId == -1) {
         trackId = m_activeTrack;
     }
     // find blank duration
     int spaceDuration = m_model->getTrackById_const(trackId)->getBlankSizeAtPos(frame);
     int cid = requestSpacerStartOperation(affectAllTracks ? -1 : trackId, frame);
     if (cid == -1) {
         pCore->displayMessage(i18n("No clips found to insert space"), InformationMessage, 500);
         return;
     }
     int start = m_model->getItemPosition(cid);
     requestSpacerEndOperation(cid, start, start - spaceDuration);
 }
 
 void TimelineController::invalidateItem(int cid)
 {
     if (!m_timelinePreview || m_model->getItemTrackId(cid) == -1  ) {
         return;
     }
     int start = m_model->getItemPosition(cid);
     int end = start + m_model->getItemPlaytime(cid);
     m_timelinePreview->invalidatePreview(start, end);
 }
 
 void TimelineController::invalidateZone(int in, int out)
 {
     if (!m_timelinePreview) {
         return;
     }
     m_timelinePreview->invalidatePreview(in, out);
 }
 
 void TimelineController::changeItemSpeed(int clipId, double speed)
 {
     if (qFuzzyCompare(speed, -1)) {
         speed = 100 * m_model->getClipSpeed(clipId);
         bool ok = false;
         double duration = m_model->getItemPlaytime(clipId);
         // this is the max speed so that the clip is at least one frame long
         double maxSpeed = 100. * duration * qAbs(m_model->getClipSpeed(clipId));
         // this is the min speed so that the clip doesn't bump into the next one on track
         double minSpeed = 100. * duration * qAbs(m_model->getClipSpeed(clipId)) / (duration + double(m_model->getBlankSizeNearClip(clipId, true)) - 1);
 
         // if there is a split partner, we must also take it into account
         int partner = m_model->getClipSplitPartner(clipId);
         if (partner != -1) {
             double duration2 = m_model->getItemPlaytime(partner);
             double maxSpeed2 = 100. * duration2 * qAbs(m_model->getClipSpeed(partner));
             double minSpeed2 = 100. * duration2 * qAbs(m_model->getClipSpeed(partner)) / (duration2 + double(m_model->getBlankSizeNearClip(partner, true)) - 1);
             minSpeed = std::max(minSpeed, minSpeed2);
             maxSpeed = std::min(maxSpeed, maxSpeed2);
         }
         speed = QInputDialog::getDouble(QApplication::activeWindow(), i18n("Clip Speed"), i18n("Percentage"), speed, minSpeed, maxSpeed, 2, &ok);
         if (!ok) {
             return;
         }
     }
     m_model->requestClipTimeWarp(clipId, speed);
 }
 
 void TimelineController::switchCompositing(int mode)
 {
     // m_model->m_tractor->lock();
     QScopedPointer<Mlt::Service> service(m_model->m_tractor->field());
     Mlt::Field *field = m_model->m_tractor->field();
     field->lock();
     while ((service != nullptr) && service->is_valid()) {
         if (service->type() == transition_type) {
             Mlt::Transition t((mlt_transition)service->get_service());
             QString serviceName = t.get("mlt_service");
             if (t.get_int("internal_added") == 237 && serviceName != QLatin1String("mix")) {
                 // remove all compositing transitions
                 field->disconnect_service(t);
             }
         }
         service.reset(service->producer());
     }
     if (mode > 0) {
         const QString compositeGeometry =
             QStringLiteral("0=0/0:%1x%2").arg(m_model->m_tractor->profile()->width()).arg(m_model->m_tractor->profile()->height());
 
         // Loop through tracks
         for (int track = 1; track < m_model->getTracksCount(); track++) {
             if (m_model->getTrackById(m_model->getTrackIndexFromPosition(track))->getProperty("kdenlive:audio_track").toInt() == 0) {
                 // This is a video track
                 Mlt::Transition t(*m_model->m_tractor->profile(),
                                   mode == 1 ? "composite" : TransitionsRepository::get()->getCompositingTransition().toUtf8().constData());
                 t.set("always_active", 1);
                 t.set("a_track", 0);
                 t.set("b_track", track + 1);
                 if (mode == 1) {
                     t.set("valign", "middle");
                     t.set("halign", "centre");
                     t.set("fill", 1);
                     t.set("geometry", compositeGeometry.toUtf8().constData());
                 }
                 t.set("internal_added", 237);
                 field->plant_transition(t, 0, track + 1);
             }
         }
     }
     field->unlock();
     delete field;
     pCore->requestMonitorRefresh();
 }
 
 void TimelineController::extractZone(QPoint zone, bool liftOnly)
 {
     QVector<int> tracks;
     if (audioTarget() >= 0) {
         tracks << audioTarget();
     }
     if (videoTarget() >= 0) {
         tracks << videoTarget();
     }
     if (tracks.isEmpty()) {
         tracks << m_activeTrack;
     }
     if (m_zone == QPoint()) {
         // Use current timeline position and clip zone length
         zone.setY(timelinePosition() + zone.y() - zone.x());
         zone.setX(timelinePosition());
     }
     TimelineFunctions::extractZone(m_model, tracks, m_zone == QPoint() ? zone : m_zone, liftOnly);
 }
 
 void TimelineController::extract(int clipId)
 {
     // TODO: grouped clips?
     int in = m_model->getClipPosition(clipId);
     QPoint zone(in, in + m_model->getClipPlaytime(clipId));
     int track = m_model->getClipTrackId(clipId);
     TimelineFunctions::extractZone(m_model, QVector<int>() << track, zone, false);
 }
 
 int TimelineController::insertZone(const QString &binId, QPoint zone, bool overwrite)
 {
     std::shared_ptr<ProjectClip> clip = pCore->bin()->getBinClip(binId);
     int aTrack = -1;
     int vTrack = -1;
     if (clip->hasAudio()) {
         aTrack = audioTarget();
     }
     if (clip->hasVideo()) {
         vTrack = videoTarget();
     }
     if (aTrack == -1 && vTrack == -1) {
         // No target tracks defined, use active track
         if (m_model->getTrackById_const(m_activeTrack)->isAudioTrack()) {
             aTrack = m_activeTrack;
             vTrack = m_model->getMirrorVideoTrackId(aTrack);
         } else {
             vTrack = m_activeTrack;
             aTrack = m_model->getMirrorAudioTrackId(vTrack);
         }
     }
     int insertPoint;
     QPoint sourceZone;
     if (useRuler() && m_zone != QPoint()) {
         // We want to use timeline zone for in/out insert points
         insertPoint = m_zone.x();
         sourceZone = QPoint(zone.x(), zone.x() + m_zone.y() - m_zone.x());
     } else {
         // Use curent timeline pos and clip zone for in/out
         insertPoint = timelinePosition();
         sourceZone = zone;
     }
     QList <int> target_tracks;
     if (vTrack > -1) {
         target_tracks << vTrack;
     }
     if (aTrack > -1) {
         target_tracks << aTrack;
     }
     return TimelineFunctions::insertZone(m_model, target_tracks, binId, insertPoint, sourceZone, overwrite) ? insertPoint + (sourceZone.y() - sourceZone.x()) : -1;
 }
 
 void TimelineController::updateClip(int clipId, QVector<int> roles)
 {
     QModelIndex ix = m_model->makeClipIndexFromID(clipId);
     if (ix.isValid()) {
         m_model->dataChanged(ix, ix, roles);
     }
 }
 
 void TimelineController::showClipKeyframes(int clipId, bool value)
 {
     TimelineFunctions::showClipKeyframes(m_model, clipId, value);
 }
 
 void TimelineController::showCompositionKeyframes(int clipId, bool value)
 {
     TimelineFunctions::showCompositionKeyframes(m_model, clipId, value);
 }
 
 void TimelineController::switchEnableState(int clipId)
 {
     TimelineFunctions::switchEnableState(m_model, clipId);
 }
 
 void TimelineController::addCompositionToClip(const QString &assetId, int clipId)
 {
     int position = m_model->getClipPosition(clipId);
     int track = m_model->getClipTrackId(clipId);
     insertNewComposition(track, position, assetId, true);
 }
 
 void TimelineController::addEffectToClip(const QString &assetId, int clipId)
 {
     m_model->addClipEffect(clipId, assetId);
 }
 
 bool TimelineController::splitAV()
 {
     int cid = m_selection.selectedItems.first();
     if (m_model->isClip(cid)) {
         std::shared_ptr<ClipModel> clip = m_model->getClipPtr(cid);
         if (clip->clipState() == PlaylistState::AudioOnly) {
             return TimelineFunctions::requestSplitVideo(m_model, cid, videoTarget());
         } else {
             return TimelineFunctions::requestSplitAudio(m_model, cid, audioTarget());
         }
     }
     pCore->displayMessage(i18n("No clip found to perform AV split operation"), InformationMessage, 500);
     return false;
 }
 
 void TimelineController::splitAudio(int clipId)
 {
     TimelineFunctions::requestSplitAudio(m_model, clipId, audioTarget());
 }
 
 void TimelineController::splitVideo(int clipId)
 {
     TimelineFunctions::requestSplitVideo(m_model, clipId, videoTarget());
 }
 
 void TimelineController::setAudioRef(int clipId)
 {
     m_audioRef = clipId;
     std::unique_ptr<AudioEnvelope> envelope(new AudioEnvelope(getClipBinId(clipId), clipId));
     m_audioCorrelator.reset(new AudioCorrelation(std::move(envelope)));
     connect(m_audioCorrelator.get(), &AudioCorrelation::gotAudioAlignData, [&] (int cid, int shift) {
         int pos = m_model->getClipPosition(m_audioRef) + shift + m_model->getClipIn(m_audioRef);
         bool result = m_model->requestClipMove(cid, m_model->getClipTrackId(cid), pos, true, true);
         if (!result) {
             pCore->displayMessage(i18n("Cannot move clip to frame %1.", (pos + shift)), InformationMessage, 500);
         }
     });
     connect(m_audioCorrelator.get(), &AudioCorrelation::displayMessage, pCore.get(), &Core::displayMessage);
 }
 
 void TimelineController::alignAudio(int clipId)
 {
     // find other clip
     if (m_audioRef == -1 || m_audioRef == clipId) {
         pCore->displayMessage(i18n("Set audio reference before attempting to align"), InformationMessage, 500);
         return;
     }
     const QString masterBinClipId = getClipBinId(m_audioRef);
     if (m_model->m_groups->isInGroup(clipId)) {
         std::unordered_set<int> groupIds = m_model->getGroupElements(clipId);
         // Check that no item is grouped with our audioRef item
         // TODO
         clearSelection();
     }
     const QString otherBinId = getClipBinId(clipId);
     if (otherBinId == masterBinClipId) {
         // easy, same clip.
         int newPos = m_model->getClipPosition(m_audioRef) - m_model->getClipIn(m_audioRef) + m_model->getClipIn(clipId);
         if (newPos) {
             bool result = m_model->requestClipMove(clipId, m_model->getClipTrackId(clipId), newPos, true, true);
             if (!result) {
                 pCore->displayMessage(i18n("Cannot move clip to frame %1.", newPos), InformationMessage, 500);
             }
             return;
         }
     }
     // Perform audio calculation
     AudioEnvelope *envelope = new AudioEnvelope(getClipBinId(clipId), clipId, m_model->getClipIn(clipId),  m_model->getClipPlaytime(clipId), m_model->getClipPosition(clipId));
     m_audioCorrelator->addChild(envelope);
 }
 
 void TimelineController::switchTrackLock(bool applyToAll)
 {
     if (!applyToAll) {
         // apply to active track only
         bool locked = m_model->getTrackById_const(m_activeTrack)->getProperty("kdenlive:locked_track").toInt() == 1;
         m_model->setTrackProperty(m_activeTrack, QStringLiteral("kdenlive:locked_track"), locked ? QStringLiteral("0") : QStringLiteral("1"));
     } else {
         // Invert track lock
         // Get track states first
         QMap<int, bool> trackLockState;
         int unlockedTracksCount = 0;
         int tracksCount = m_model->getTracksCount();
         for (int track = tracksCount - 1; track >= 0; track--) {
             int trackIx = m_model->getTrackIndexFromPosition(track);
             bool isLocked = m_model->getTrackById_const(trackIx)->getProperty("kdenlive:locked_track").toInt() == 1;
             if (!isLocked) {
                 unlockedTracksCount++;
             }
             trackLockState.insert(trackIx, isLocked);
         }
         if (unlockedTracksCount == tracksCount) {
             // do not lock all tracks, leave active track unlocked
             trackLockState.insert(m_activeTrack, true);
         }
         QMapIterator<int, bool> i(trackLockState);
         while (i.hasNext()) {
             i.next();
             m_model->setTrackProperty(i.key(), QStringLiteral("kdenlive:locked_track"), i.value() ? QStringLiteral("0") : QStringLiteral("1"));
         }
     }
 }
 
 void TimelineController::switchTargetTrack()
 {
     bool isAudio = m_model->getTrackById_const(m_activeTrack)->getProperty("kdenlive:audio_track").toInt() == 1;
     if (isAudio) {
         setAudioTarget(audioTarget() == m_activeTrack ? -1 : m_activeTrack);
     } else {
         setVideoTarget(videoTarget() == m_activeTrack ? -1 : m_activeTrack);
     }
 }
 
 int TimelineController::audioTarget() const
 {
     return m_model->m_audioTarget;
 }
 
 int TimelineController::videoTarget() const
 {
     return m_model->m_videoTarget;
 }
 
 void TimelineController::resetTrackHeight()
 {
     int tracksCount = m_model->getTracksCount();
     for (int track = tracksCount - 1; track >= 0; track--) {
         int trackIx = m_model->getTrackIndexFromPosition(track);
         m_model->getTrackById(trackIx)->setProperty(QStringLiteral("kdenlive:trackheight"), QString::number(KdenliveSettings::trackheight()));
     }
     QModelIndex modelStart = m_model->makeTrackIndexFromID(m_model->getTrackIndexFromPosition(0));
     QModelIndex modelEnd = m_model->makeTrackIndexFromID(m_model->getTrackIndexFromPosition(tracksCount - 1));
     m_model->dataChanged(modelStart, modelEnd, {TimelineModel::HeightRole});
 }
 
 int TimelineController::groupClips(const QList<int> &clipIds)
 {
     std::unordered_set<int> theSet(clipIds.begin(), clipIds.end());
     return m_model->requestClipsGroup(theSet, false, GroupType::Selection);
 }
 
 bool TimelineController::ungroupClips(int clipId)
 {
     return m_model->requestClipUngroup(clipId);
 }
 
 void TimelineController::clearSelection()
 {
     if (m_model->m_temporarySelectionGroup >= 0) {
         m_model->m_groups->destructGroupItem(m_model->m_temporarySelectionGroup);
         m_model->m_temporarySelectionGroup = -1;
     }
     m_selection.selectedItems.clear();
     emit selectionChanged();
 }
 
 void TimelineController::selectAll()
 {
     QList<int> ids;
     for (auto clp : m_model->m_allClips) {
         ids << clp.first;
     }
     for (auto clp : m_model->m_allCompositions) {
         ids << clp.first;
     }
     setSelection(ids);
 }
 
 void TimelineController::selectCurrentTrack()
 {
     QList<int> ids;
     for (auto clp : m_model->getTrackById_const(m_activeTrack)->m_allClips) {
         ids << clp.first;
     }
     for (auto clp : m_model->getTrackById_const(m_activeTrack)->m_allCompositions) {
         ids << clp.first;
     }
     setSelection(ids);
 }
 
 void TimelineController::pasteEffects(int targetId)
 {
     QVariant returnedValue;
     QMetaObject::invokeMethod(m_root, "getCopiedItemId", Q_RETURN_ARG(QVariant, returnedValue));
     int sourceId = returnedValue.toInt();
     if (targetId == -1 && !m_selection.selectedItems.isEmpty()) {
         targetId = m_selection.selectedItems.constFirst();
     }
     if (!m_model->isClip(targetId) || !m_model->isClip(sourceId)) {
         return;
     }
     std::function<bool(void)> undo = []() { return true; };
     std::function<bool(void)> redo = []() { return true; };
     std::shared_ptr<EffectStackModel> sourceStack = m_model->getClipEffectStackModel(sourceId);
     std::shared_ptr<EffectStackModel> destStack = m_model->getClipEffectStackModel(targetId);
     bool result = destStack->importEffects(sourceStack, m_model->m_allClips[targetId]->clipState(), undo, redo);
     if (result) {
         pCore->pushUndo(undo, redo, i18n("Paste effects"));
     } else {
         pCore->displayMessage(i18n("Cannot paste effect on selected clip"), InformationMessage, 500);
         undo();
     }
 }
 
 double TimelineController::fps() const
 {
     return pCore->getCurrentFps();
 }
 
 void TimelineController::editItemDuration(int id)
 {
     int start = m_model->getItemPosition(id);
     int in = 0;
     int duration = m_model->getItemPlaytime(id);
     int maxLength = -1;
     bool isComposition = false;
     if (m_model->isClip(id)) {
         in = m_model->getClipIn(id);
         std::shared_ptr<ProjectClip> clip = pCore->bin()->getBinClip(getClipBinId(id));
         if (clip && clip->hasLimitedDuration()) {
             maxLength = clip->getProducerDuration();
         }
     } else if (m_model->isComposition(id)) {
         // nothing to do
         isComposition = true;
     } else {
         pCore->displayMessage(i18n("No item to edit"), InformationMessage, 500);
         return;
     }
     int trackId = m_model->getItemTrackId(id);
     int maxFrame = qMax(0, start + duration + (isComposition ? m_model->getTrackById(trackId)->getBlankSizeNearComposition(id, true) : m_model->getTrackById(trackId)->getBlankSizeNearClip(id, true)));
     int minFrame = qMax(0, in - (isComposition ? m_model->getTrackById(trackId)->getBlankSizeNearComposition(id, false) : m_model->getTrackById(trackId)->getBlankSizeNearClip(id, false)));
     int partner = isComposition ? -1 : m_model->getClipSplitPartner(id);
     QPointer<ClipDurationDialog> dialog =
         new ClipDurationDialog(id, pCore->currentDoc()->timecode(), start, minFrame, in, in + duration, maxLength, maxFrame, qApp->activeWindow());
     if (dialog->exec() == QDialog::Accepted) {
         std::function<bool(void)> undo = []() { return true; };
         std::function<bool(void)> redo = []() { return true; };
         int newPos = dialog->startPos().frames(pCore->getCurrentFps());
         int newIn = dialog->cropStart().frames(pCore->getCurrentFps());
         int newDuration = dialog->duration().frames(pCore->getCurrentFps());
         bool result = true;
         if (newPos < start) {
             if (!isComposition) {
                 result = m_model->requestClipMove(id, trackId, newPos, true, true, undo, redo);
                 if (result && partner > -1) {
                     result = m_model->requestClipMove(partner, m_model->getItemTrackId(partner), newPos, true, true, undo, redo);
                 }
             } else {
                 result = m_model->requestCompositionMove(id, trackId, newPos, m_model->m_allCompositions[id]->getForcedTrack(), true, true, undo, redo);
             }
             if (result && newIn != in) {
                 m_model->requestItemResize(id, duration + (in - newIn), false, true, undo, redo);
                 if (result && partner > -1) {
                     result = m_model->requestItemResize(partner, duration + (in - newIn), false, true, undo, redo);
                 }
             }
             if (newDuration != duration + (in - newIn)) {
                 result = result && m_model->requestItemResize(id, newDuration, true, true, undo, redo);
                 if (result && partner > -1) {
                     result = m_model->requestItemResize(partner, newDuration, false, true, undo, redo);
                 }
             }
         } else {
             // perform resize first
             if (newIn != in) {
                 result = m_model->requestItemResize(id, duration + (in - newIn), false, true, undo, redo);
                 if (result && partner > -1) {
                     result = m_model->requestItemResize(partner, duration + (in - newIn), false, true, undo, redo);
                 }
             }
             if (newDuration != duration + (in - newIn)) {
                 result = result && m_model->requestItemResize(id, newDuration, start == newPos, true, undo, redo);
                 if (result && partner > -1) {
                     result = m_model->requestItemResize(partner, newDuration, start == newPos, true, undo, redo);
                 }
             }
             if (start != newPos || newIn != in) {
                 if (!isComposition) {
                     result = result && m_model->requestClipMove(id, trackId, newPos, true, true, undo, redo);
                     if (result && partner > -1) {
                         result = m_model->requestClipMove(partner, m_model->getItemTrackId(partner), newPos, true, true, undo, redo);
                     }
                 } else {
                     result = result && m_model->requestCompositionMove(id, trackId, newPos, m_model->m_allCompositions[id]->getForcedTrack(), true, true, undo, redo);
                 }
             }
         }
         if (result) {
             pCore->pushUndo(undo, redo, i18n("Edit item"));
         } else {
             undo();
         }
     }
 }
 
 void TimelineController::updateClipActions()
 {
     if (m_selection.selectedItems.isEmpty()) {
         for(QAction *act : clipActions) {
             act->setEnabled(false);
         }
         emit timelineClipSelected(false);
         return;
     }
     std::shared_ptr<ClipModel> clip(nullptr);
     int item = m_selection.selectedItems.first();
     if (m_model->isClip(item)) {
         clip = m_model->getClipPtr(item);
     }
     for(QAction *act : clipActions) {
         bool enableAction = true;
         const QChar actionData = act->data().toChar();
         if (actionData == QLatin1Char('G')) {
             enableAction = m_model->isInMultiSelection(item);
         } else if (actionData == QLatin1Char('U')) {
             enableAction = m_model->m_groups->isInGroup(item) && !m_model->isInMultiSelection(item);
         } else if (actionData == QLatin1Char('A')) {
             enableAction = clip && clip->clipState() == PlaylistState::AudioOnly;
         } else if (actionData == QLatin1Char('V')) {
             enableAction = clip && clip->clipState() == PlaylistState::VideoOnly;
         } else if (actionData == QLatin1Char('D')) {
             enableAction = clip && clip->clipState() == PlaylistState::Disabled;
         } else if (actionData == QLatin1Char('E')) {
             enableAction = clip && clip->clipState() != PlaylistState::Disabled;
         } else if (actionData == QLatin1Char('X') || actionData == QLatin1Char('S')) {
             enableAction = clip && clip->canBeVideo() && clip->canBeAudio();
             if (enableAction && actionData == QLatin1Char('S')) {
                 act->setText(clip->clipState() == PlaylistState::AudioOnly ? i18n("Split video") : i18n("Split audio"));
             }
         } else if (actionData == QLatin1Char('C') && clip == nullptr) {
             enableAction = false;
         }
         act->setEnabled(enableAction);
     }
     emit timelineClipSelected(clip != nullptr);
 }
 
 const QString TimelineController::getAssetName(const QString &assetId, bool isTransition)
 {
     return isTransition ? TransitionsRepository::get()->getName(assetId) : EffectsRepository::get()->getName(assetId);
 }
 
 void TimelineController::grabCurrent()
 {
     if (m_selection.selectedItems.isEmpty()) {
         //TODO: error displayMessage
         return;
     }
     int id = m_selection.selectedItems.constFirst();
     if (m_model->isClip(id)) {
         std::shared_ptr<ClipModel> clip = m_model->getClipPtr(id);
         clip->setGrab(!clip->isGrabbed());
         QModelIndex ix = m_model->makeClipIndexFromID(id);
         if (ix.isValid()) {
             m_model->dataChanged(ix, ix, {TimelineItemModel::GrabbedRole});
         }
     } else if (m_model->isComposition(id)) {
         std::shared_ptr<CompositionModel> clip = m_model->getCompositionPtr(id);
         clip->setGrab(!clip->isGrabbed());
         QModelIndex ix = m_model->makeCompositionIndexFromID(id);
         if (ix.isValid()) {
             m_model->dataChanged(ix, ix, {TimelineItemModel::GrabbedRole});
         }
     }
 }
 
 bool TimelineController::endFakeMove(int clipId, int position, bool updateView, bool logUndo, bool invalidateTimeline)
 {
     Q_ASSERT(m_model->m_allClips.count(clipId) > 0);
     int trackId = m_model->m_allClips[clipId]->getFakeTrackId();
     if (m_model->getClipPosition(clipId) == position && m_model->getClipTrackId(clipId) == trackId) {
         qDebug()<<"* * ** END FAKE; NO MOVE RQSTED";
         return true;
     }
     if (m_model->m_groups->isInGroup(clipId)) {
         // element is in a group.
         int old_trackId = m_model->getItemTrackId(clipId);
         int groupId = m_model->m_groups->getRootId(clipId);
         int current_trackId = m_model->getClipTrackId(clipId);
         int track_pos1 = m_model->getTrackPosition(trackId);
         int track_pos2 = m_model->getTrackPosition(current_trackId);
         int delta_track = track_pos1 - track_pos2;
         int delta_pos = position - m_model->m_allClips[clipId]->getPosition();
         return endFakeGroupMove(clipId, groupId, delta_track, delta_pos, updateView, logUndo);
     }
     qDebug()<<"//////\n//////\nENDING FAKE MNOVE: "<<trackId<<", POS: "<<position;
     std::function<bool(void)> undo = []() { return true; };
     std::function<bool(void)> redo = []() { return true; };
     int duration = m_model->getClipPlaytime(clipId);
     int currentTrack = m_model->m_allClips[clipId]->getCurrentTrackId();
     bool res = true;
     if (currentTrack > -1) {
         res = res & m_model->getTrackById(currentTrack)->requestClipDeletion(clipId, updateView, invalidateTimeline, undo, redo);
     }
     if (m_model->m_editMode == TimelineMode::OverwriteEdit) {
         res = res & TimelineFunctions::liftZone(m_model, trackId, QPoint(position, position + duration), undo, redo);
     } else if (m_model->m_editMode == TimelineMode::InsertEdit) {
         int startClipId = m_model->getClipByPosition(trackId, position);
         if (startClipId > -1) {
             // There is a clip, cut
             res = res & TimelineFunctions::requestClipCut(m_model, startClipId, position, undo, redo);
         }
         res = res & TimelineFunctions::insertSpace(m_model, trackId, QPoint(position, position + duration), undo, redo);
     }
     res = res & m_model->getTrackById(trackId)->requestClipInsertion(clipId, position, updateView, invalidateTimeline, undo, redo);
     if (res) {
         if (logUndo) {
             pCore->pushUndo(undo, redo, i18n("Move item"));
         }
     } else {
         qDebug()<<"//// FAKE FAILED";
         undo();
     }
     return res;
 }
 
 bool TimelineController::endFakeGroupMove(int clipId, int groupId, int delta_track, int delta_pos, bool updateView, bool logUndo)
 {
     std::function<bool(void)> undo = []() { return true; };
     std::function<bool(void)> redo = []() { return true; };
     bool res = endFakeGroupMove(clipId, groupId, delta_track, delta_pos, updateView, logUndo, undo, redo);
     if (res && logUndo) {
         pCore->pushUndo(undo, redo, i18n("Move group"));
     }
     return res;
 }
 
 bool TimelineController::endFakeGroupMove(int clipId, int groupId, int delta_track, int delta_pos, bool updateView, bool finalMove, Fun &undo, Fun &redo)
 {
     Q_ASSERT(m_model->m_allGroups.count(groupId) > 0);
     bool ok = true;
     auto all_items = m_model->m_groups->getLeaves(groupId);
     Q_ASSERT(all_items.size() > 1);
     Fun local_undo = []() { return true; };
     Fun local_redo = []() { return true; };
 
     // Sort clips. We need to delete from right to left to avoid confusing the view
     std::vector<int> sorted_clips(all_items.begin(), all_items.end());
     std::sort(sorted_clips.begin(), sorted_clips.end(), [this](int clipId1, int clipId2) {
         int p1 = m_model->isClip(clipId1) ? m_model->m_allClips[clipId1]->getPosition() : m_model->m_allCompositions[clipId1]->getPosition();
         int p2 = m_model->isClip(clipId2) ? m_model->m_allClips[clipId2]->getPosition() : m_model->m_allCompositions[clipId2]->getPosition();
         return p2 <= p1;
     });
 
     // Moving groups is a two stage process: first we remove the clips from the tracks, and then try to insert them back at their calculated new positions.
     // This way, we ensure that no conflict will arise with clips inside the group being moved
 
     // First, remove clips
     int audio_delta, video_delta;
     audio_delta = video_delta = delta_track;
     int master_trackId = m_model->getItemTrackId(clipId);
     if (m_model->getTrackById_const(master_trackId)->isAudioTrack()) {
         // Master clip is audio, so reverse delta for video clips
         video_delta = -delta_track;
     } else {
         audio_delta = -delta_track;
     }
     int min = -1;
     int max = -1;
     std::unordered_map<int, int> old_track_ids, old_position, old_forced_track, new_track_ids;
     for (int item : sorted_clips) {
         int old_trackId = m_model->getItemTrackId(item);
         old_track_ids[item] = old_trackId;
         if (old_trackId != -1) {
             bool updateThisView = true;
             if (m_model->isClip(item)) {
                 int current_track_position = m_model->getTrackPosition(old_trackId);
                 int d = m_model->getTrackById_const(old_trackId)->isAudioTrack() ? audio_delta : video_delta;
                 int target_track_position = current_track_position + d;
                 auto it = m_model->m_allTracks.cbegin();
                 std::advance(it, target_track_position);
                 int target_track = (*it)->getId();
                 new_track_ids[item] = target_track;
                 old_position[item] = m_model->m_allClips[item]->getPosition();
                 int duration = m_model->m_allClips[item]->getPlaytime();
                 min = min < 0 ? old_position[item] + delta_pos : qMin(min, old_position[item] + delta_pos);
                 max = max < 0 ? old_position[item] + delta_pos + duration : qMax(max, old_position[item] + delta_pos + duration);
                 ok = ok && m_model->getTrackById(old_trackId)->requestClipDeletion(item, updateThisView, finalMove, undo, redo);
             } else {
                 //ok = ok && getTrackById(old_trackId)->requestCompositionDeletion(item, updateThisView, local_undo, local_redo);
                 old_position[item] = m_model->m_allCompositions[item]->getPosition();
                 old_forced_track[item] = m_model->m_allCompositions[item]->getForcedTrack();
             }
             if (!ok) {
                 bool undone = undo();
                 Q_ASSERT(undone);
                 return false;
             }
         }
     }
     bool res = true;
     if (m_model->m_editMode == TimelineMode::OverwriteEdit) {
         for (int item : sorted_clips) {
             if (m_model->isClip(item) && new_track_ids.count(item) > 0) {
                 int target_track = new_track_ids[item];
                 int target_position = old_position[item] + delta_pos;
                 int duration = m_model->m_allClips[item]->getPlaytime();
                 res = res & TimelineFunctions::liftZone(m_model, target_track, QPoint(target_position, target_position + duration), undo, redo);
             }
         }
     } else if (m_model->m_editMode == TimelineMode::InsertEdit) {
         QList <int> processedTracks;
         for (int item : sorted_clips) {
             int target_track = new_track_ids[item];
             if (processedTracks.contains(target_track)) {
                 // already processed
                 continue;
             }
             processedTracks << target_track;
             int target_position = min;
             int startClipId = m_model->getClipByPosition(target_track, target_position);
             if (startClipId > -1) {
                 // There is a clip, cut
                 res = res & TimelineFunctions::requestClipCut(m_model, startClipId, target_position, undo, redo);
             }
         }
         res = res & TimelineFunctions::insertSpace(m_model, -1, QPoint(min, max), undo, redo);
     }
     for (int item : sorted_clips) {
         if (m_model->isClip(item)) {
             int target_track = new_track_ids[item];
             int target_position = old_position[item] + delta_pos;
             ok = ok && m_model->requestClipMove(item, target_track, target_position, updateView, finalMove, undo, redo);
         } else {
             //ok = ok && requestCompositionMove(item, target_track, old_forced_track[item], target_position, updateThisView, local_undo, local_redo);
         }
         if (!ok) {
             bool undone = undo();
             Q_ASSERT(undone);
             return false;
         }
     }
     return true;
 }
 
 QStringList TimelineController::getThumbKeys()
 {
     QStringList result;
     for (auto clp : m_model->m_allClips) {
         const QString binId = getClipBinId(clp.first);
         std::shared_ptr<ProjectClip> binClip = pCore->bin()->getBinClip(binId);
         result << binClip->hash() + QLatin1Char('#') + QString::number(clp.second->getIn()) + QStringLiteral(".png");
         result << binClip->hash() + QLatin1Char('#') + QString::number(clp.second->getOut()) + QStringLiteral(".png");
     }
     result.removeDuplicates();
     return result;
 }
 
 bool TimelineController::isInSelection(int itemId)
 {
     return m_model->isInMultiSelection(itemId);
 }
 
 void TimelineController::slotMultitrackView(bool enable)
 {
     TimelineFunctions::enableMultitrackView(m_model, enable);
 }
 
 void TimelineController::saveTimelineSelection(QDir targetDir)
 {
     TimelineFunctions::saveTimelineSelection(m_model, m_selection.selectedItems, targetDir);
 }
 
 void TimelineController::addEffectKeyframe(int cid, int frame, double val)
 {
     if (m_model->isClip(cid)) {
         std::shared_ptr<EffectStackModel> destStack = m_model->getClipEffectStackModel(cid);
         destStack->addEffectKeyFrame(frame, val);
     } else if (m_model->isComposition(cid)) {
         std::shared_ptr<KeyframeModelList> listModel = m_model->m_allCompositions[cid]->getKeyframeModel();
         listModel->addKeyframe(frame, val);
     }
 }
 
 void TimelineController::removeEffectKeyframe(int cid, int frame)
 {
     if (m_model->isClip(cid)) {
         std::shared_ptr<EffectStackModel> destStack = m_model->getClipEffectStackModel(cid);
         destStack->removeKeyFrame(frame);
     } else if (m_model->isComposition(cid)) {
         std::shared_ptr<KeyframeModelList> listModel = m_model->m_allCompositions[cid]->getKeyframeModel();
         listModel->removeKeyframe(GenTime(frame, pCore->getCurrentFps()));
     }
 }
 
 void TimelineController::updateEffectKeyframe(int cid, int oldFrame, int newFrame, double normalizedValue)
 {
     if (m_model->isClip(cid)) {
         std::shared_ptr<EffectStackModel> destStack = m_model->getClipEffectStackModel(cid);
         destStack->updateKeyFrame(oldFrame, newFrame, normalizedValue);
     } else if (m_model->isComposition(cid)) {
         std::shared_ptr<KeyframeModelList> listModel = m_model->m_allCompositions[cid]->getKeyframeModel();
         listModel->updateKeyframe(GenTime(oldFrame, pCore->getCurrentFps()), GenTime(newFrame, pCore->getCurrentFps()), normalizedValue);
     }
 }
 
+QColor TimelineController::videoColor() const
+{
+    KColorScheme scheme(QApplication::palette().currentColorGroup(), KColorScheme::View);
+    return scheme.background(KColorScheme::LinkBackground).color();
+}
+
+
+QColor TimelineController::audioColor() const
+{
+    KColorScheme scheme(QApplication::palette().currentColorGroup(), KColorScheme::View);
+    return scheme.background(KColorScheme::NegativeBackground).color();
+}
+
+QColor TimelineController::neutralColor() const
+{
+    KColorScheme scheme(QApplication::palette().currentColorGroup(), KColorScheme::View);
+    return scheme.background(KColorScheme::VisitedBackground).color();
+}
+
diff --git a/src/timeline2/view/timelinecontroller.h b/src/timeline2/view/timelinecontroller.h
index c3b2df7c1..9196cd135 100644
--- a/src/timeline2/view/timelinecontroller.h
+++ b/src/timeline2/view/timelinecontroller.h
@@ -1,518 +1,525 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Jean-Baptiste Mardelle                          *
  *   This file is part of Kdenlive. See www.kdenlive.org.                  *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) version 3 or any later version accepted by the       *
  *   membership of KDE e.V. (or its successor approved  by the membership  *
  *   of KDE e.V.), which shall act as a proxy defined in Section 14 of     *
  *   version 3 of the license.                                             *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef TIMELINECONTROLLER_H
 #define TIMELINECONTROLLER_H
 
 #include "definitions.h"
 #include "timeline2/model/timelineitemmodel.hpp"
 #include "lib/audio/audioCorrelation.h"
 
 #include <KActionCollection>
 #include <QDir>
 
 class PreviewManager;
 class QAction;
 class QQuickItem;
 
 // see https://bugreports.qt.io/browse/QTBUG-57714, don't expose a QWidget as a context property
 class TimelineController : public QObject
 {
     Q_OBJECT
     /* @brief holds a list of currently selected clips (list of clipId's)
      */
     Q_PROPERTY(QList<int> selection READ selection WRITE setSelection NOTIFY selectionChanged)
     /* @brief holds the timeline zoom factor
      */
     Q_PROPERTY(double scaleFactor READ scaleFactor WRITE setScaleFactor NOTIFY scaleFactorChanged)
     /* @brief holds the current project duration
      */
     Q_PROPERTY(int duration READ duration NOTIFY durationChanged)
     Q_PROPERTY(int fullDuration READ fullDuration NOTIFY durationChanged)
     Q_PROPERTY(bool audioThumbFormat READ audioThumbFormat NOTIFY audioThumbFormatChanged)
     /* @brief holds the current timeline position
      */
     Q_PROPERTY(int position READ position WRITE setPosition NOTIFY positionChanged)
     Q_PROPERTY(int zoneIn READ zoneIn WRITE setZoneIn NOTIFY zoneChanged)
     Q_PROPERTY(int zoneOut READ zoneOut WRITE setZoneOut NOTIFY zoneChanged)
     Q_PROPERTY(int seekPosition READ seekPosition WRITE setSeekPosition NOTIFY seekPositionChanged)
     Q_PROPERTY(bool ripple READ ripple NOTIFY rippleChanged)
     Q_PROPERTY(bool scrub READ scrub NOTIFY scrubChanged)
     Q_PROPERTY(bool showThumbnails READ showThumbnails NOTIFY showThumbnailsChanged)
     Q_PROPERTY(bool showMarkers READ showMarkers NOTIFY showMarkersChanged)
     Q_PROPERTY(bool showAudioThumbnails READ showAudioThumbnails NOTIFY showAudioThumbnailsChanged)
     Q_PROPERTY(QVariantList dirtyChunks READ dirtyChunks NOTIFY dirtyChunksChanged)
     Q_PROPERTY(QVariantList renderedChunks READ renderedChunks NOTIFY renderedChunksChanged)
     Q_PROPERTY(int workingPreview READ workingPreview NOTIFY workingPreviewChanged)
     Q_PROPERTY(bool useRuler READ useRuler NOTIFY useRulerChanged)
     Q_PROPERTY(int activeTrack READ activeTrack WRITE setActiveTrack NOTIFY activeTrackChanged)
     Q_PROPERTY(int audioTarget READ audioTarget WRITE setAudioTarget NOTIFY audioTargetChanged)
     Q_PROPERTY(int videoTarget READ videoTarget WRITE setVideoTarget NOTIFY videoTargetChanged)
+    Q_PROPERTY(QColor videoColor READ videoColor NOTIFY colorsChanged)
+    Q_PROPERTY(QColor audioColor READ audioColor NOTIFY colorsChanged)
+    Q_PROPERTY(QColor neutralColor READ neutralColor NOTIFY colorsChanged)
 
 public:
     TimelineController(QObject *parent);
     virtual ~TimelineController();
     /** @brief Sets the model that this widgets displays */
     void setModel(std::shared_ptr<TimelineItemModel> model);
     std::shared_ptr<TimelineItemModel> getModel() const;
     void setRoot(QQuickItem *root);
 
     Q_INVOKABLE bool isMultitrackSelected() const { return m_selection.isMultitrackSelected; }
     Q_INVOKABLE int selectedTrack() const { return m_selection.selectedTrack; }
     /** @brief Remove a clip id from current selection
      */
     Q_INVOKABLE void removeSelection(int newSelection);
     /** @brief Add a clip id to current selection
      */
     Q_INVOKABLE void addSelection(int newSelection, bool clear = false);
     /** @brief Edit an item's in/out points with a dialog
      */
     Q_INVOKABLE void editItemDuration(int itemId);
     /** @brief Clear current selection and inform the view
      */
     void clearSelection();
     /** @brief Select all timeline items
      */
     void selectAll();
     /* @brief Select all items in one track
      */
     void selectCurrentTrack();
     /* @brief returns current timeline's zoom factor
      */
     Q_INVOKABLE double scaleFactor() const;
     /* @brief set current timeline's zoom factor
      */
     void setScaleFactorOnMouse(double scale, bool zoomOnMouse);
     void setScaleFactor(double scale);
     /* @brief Returns the project's duration (tractor)
      */
     Q_INVOKABLE int duration() const;
     Q_INVOKABLE int fullDuration() const;
     /* @brief Returns the current cursor position (frame currently displayed by MLT)
      */
     Q_INVOKABLE int position() const { return m_position; }
     /* @brief Returns the seek request position (-1 = no seek pending)
      */
     Q_INVOKABLE int seekPosition() const { return m_seekPosition; }
     Q_INVOKABLE int audioTarget() const;
     Q_INVOKABLE int videoTarget() const;
     Q_INVOKABLE int activeTrack() const { return m_activeTrack; }
+    Q_INVOKABLE QColor videoColor() const;
+    Q_INVOKABLE QColor audioColor() const;
+    Q_INVOKABLE QColor neutralColor() const;
     /* @brief Request a seek operation
        @param position is the desired new timeline position
      */
     Q_INVOKABLE int zoneIn() const { return m_zone.x(); }
     Q_INVOKABLE int zoneOut() const { return m_zone.y(); }
     Q_INVOKABLE void setZoneIn(int inPoint);
     Q_INVOKABLE void setZoneOut(int outPoint);
     void setZone(const QPoint &zone);
     /* @brief Request a seek operation
        @param position is the desired new timeline position
      */
     Q_INVOKABLE void setPosition(int position);
     Q_INVOKABLE bool snap();
     Q_INVOKABLE bool ripple();
     Q_INVOKABLE bool scrub();
     Q_INVOKABLE QString timecode(int frames);
     /* @brief Request inserting a new clip in timeline (dragged from bin or monitor)
        @param tid is the destination track
        @param position is the timeline position
        @param xml is the data describing the dropped clip
        @param logUndo if set to false, no undo object is stored
        @return the id of the inserted clip
      */
     Q_INVOKABLE int insertClip(int tid, int position, const QString &xml, bool logUndo, bool refreshView, bool useTargets);
     /* @brief Request inserting multiple clips into the timeline (dragged from bin or monitor)
      * @param tid is the destination track
      * @param position is the timeline position
      * @param binIds the IDs of the bins being dropped
      * @param logUndo if set to false, no undo object is stored
      * @return the ids of the inserted clips
      */
     Q_INVOKABLE QList<int> insertClips(int tid, int position, const QStringList &binIds, bool logUndo, bool refreshView);
     /* @brief Request the grouping of the given clips
      * @param clipIds the ids to be grouped
      * @return the group id or -1 in case of faiure
      */
     Q_INVOKABLE int groupClips(const QList<int> &clipIds);
     /* @brief Request the ungrouping of clips
      * @param clipId the id of a clip belonging to the group
      * @return true in case of success, false otherwise
      */
     Q_INVOKABLE bool ungroupClips(int clipId);
     Q_INVOKABLE void copyItem();
     Q_INVOKABLE bool pasteItem();
     /* @brief Request inserting a new composition in timeline (dragged from compositions list)
        @param tid is the destination track
        @param position is the timeline position
        @param transitionId is the data describing the dropped composition
        @param logUndo if set to false, no undo object is stored
        @return the id of the inserted composition
     */
     Q_INVOKABLE int insertComposition(int tid, int position, const QString &transitionId, bool logUndo);
     /* @brief Request inserting a new composition in timeline (dragged from compositions list)
        this function will check if there is a clip at insert point and
        adjust the composition length accordingly
        @param tid is the destination track
        @param position is the timeline position
        @param transitionId is the data describing the dropped composition
        @param logUndo if set to false, no undo object is stored
        @return the id of the inserted composition
     */
     Q_INVOKABLE int insertNewComposition(int tid, int position, const QString &transitionId, bool logUndo);
 
     /* @brief Request deletion of the currently selected clips
      */
     Q_INVOKABLE void deleteSelectedClips();
 
     Q_INVOKABLE void triggerAction(const QString &name);
 
     /* @brief Do we want to display video thumbnails
      */
     bool showThumbnails() const;
     bool showAudioThumbnails() const;
     bool showMarkers() const;
     bool audioThumbFormat() const;
     /* @brief Do we want to display audio thumbnails
      */
     Q_INVOKABLE bool showWaveforms() const;
     /* @brief Insert a timeline track
      */
     Q_INVOKABLE void addTrack(int tid);
     /* @brief Remove a timeline track
      */
     Q_INVOKABLE void deleteTrack(int tid);
     /* @brief Group selected items in timeline
      */
     Q_INVOKABLE void groupSelection();
     /* @brief Ungroup selected items in timeline
      */
     Q_INVOKABLE void unGroupSelection(int cid = -1);
     /* @brief Ask for edit marker dialog
      */
     Q_INVOKABLE void editMarker(const QString &cid, int frame);
     /* @brief Ask for edit timeline guide dialog
      */
     Q_INVOKABLE void editGuide(int frame = -1);
     Q_INVOKABLE void moveGuide(int frame, int newFrame);
     /* @brief Add a timeline guide
      */
     Q_INVOKABLE void switchGuide(int frame = -1, bool deleteOnly = false);
     /* @brief Request monitor refresh
      */
     Q_INVOKABLE void requestRefresh();
 
     /* @brief Show the asset of the given item in the AssetPanel
        If the id corresponds to a clip, we show the corresponding effect stack
        If the id corresponds to a composition, we show its properties
     */
     Q_INVOKABLE void showAsset(int id);
     Q_INVOKABLE void showTrackAsset(int trackId);
 
     Q_INVOKABLE void selectItems(QVariantList arg, int startFrame, int endFrame, bool addToSelect);
     /* @brief Returns true is item is selected as well as other items */
     Q_INVOKABLE bool isInSelection(int itemId);
 
     Q_INVOKABLE int headerWidth() const;
     Q_INVOKABLE void setHeaderWidth(int width);
 
     /* @brief Seek to next snap point
      */
     void gotoNextSnap();
     /* @brief Seek to previous snap point
      */
     void gotoPreviousSnap();
     /* @brief Set current item's start point to cursor position
      */
     void setInPoint();
     /* @brief Set current item's end point to cursor position
      */
     void setOutPoint();
     /* @brief Return the project's tractor
      */
     Mlt::Tractor *tractor();
     /* @brief Sets the list of currently selected clips
        @param selection is the list of id's
        @param trackIndex is current clip's track
        @param isMultitrack is true if we want to select the whole tractor (currently unused)
      */
     void setSelection(const QList<int> &selection = QList<int>(), int trackIndex = -1, bool isMultitrack = false);
     /* @brief Get the list of currenly selected clip id's
      */
     QList<int> selection() const;
 
     /* @brief Add an asset (effect, composition)
      */
     void addAsset(const QVariantMap data);
 
     /* @brief Cuts the clip on current track at timeline position
      */
     Q_INVOKABLE void cutClipUnderCursor(int position = -1, int track = -1);
     /* @brief Request a spacer operation
      */
     Q_INVOKABLE int requestSpacerStartOperation(int trackId, int position);
     /* @brief Request a spacer operation
      */
     Q_INVOKABLE bool requestSpacerEndOperation(int clipId, int startPosition, int endPosition);
     /* @brief Request a Fade in effect for clip
      */
     Q_INVOKABLE void adjustFade(int cid, const QString &effectId, int duration, int initialDuration);
 
     Q_INVOKABLE const QString getTrackNameFromMltIndex(int trackPos);
     /* @brief Request inserting space in a track
      */
     Q_INVOKABLE void insertSpace(int trackId = -1, int frame = -1);
     Q_INVOKABLE void removeSpace(int trackId = -1, int frame = -1, bool affectAllTracks = false);
     /* @brief If clip is enabled, disable, otherwise enable
      */
     Q_INVOKABLE void switchEnableState(int clipId);
     Q_INVOKABLE void addCompositionToClip(const QString &assetId, int clipId);
     Q_INVOKABLE void addEffectToClip(const QString &assetId, int clipId);
 
     Q_INVOKABLE void requestClipCut(int clipId, int position);
 
     Q_INVOKABLE void extract(int clipId);
 
     Q_INVOKABLE void splitAudio(int clipId);
     Q_INVOKABLE void splitVideo(int clipId);
     Q_INVOKABLE void setAudioRef(int clipId);
     Q_INVOKABLE void alignAudio(int clipId);
 
     Q_INVOKABLE bool endFakeMove(int clipId, int position, bool updateView, bool logUndo, bool invalidateTimeline);
     bool endFakeGroupMove(int clipId, int groupId, int delta_track, int delta_pos, bool updateView, bool logUndo);
     bool endFakeGroupMove(int clipId, int groupId, int delta_track, int delta_pos, bool updateView, bool finalMove, Fun &undo, Fun &redo);
 
     bool splitAV();
 
     /* @brief Seeks to selected clip start / end
      */
     Q_INVOKABLE void pasteEffects(int targetId = -1);
     Q_INVOKABLE double fps() const;
     Q_INVOKABLE void addEffectKeyframe(int cid, int frame, double val);
     Q_INVOKABLE void removeEffectKeyframe(int cid, int frame);
     Q_INVOKABLE void updateEffectKeyframe(int cid, int oldFrame, int newFrame, double normalizedValue);
 
     void switchTrackLock(bool applyToAll = false);
     void switchTargetTrack();
 
     const QString getTrackNameFromIndex(int trackIndex);
     /* @brief Seeks to selected clip start / end
      */
     void seekCurrentClip(bool seekToEnd = false);
     /* @brief Seeks to a clip start (or end) based on it's clip id
      */
     void seekToClip(int cid, bool seekToEnd);
     /* @brief Returns the number of tracks (audioTrakcs, videoTracks)
      */
     QPoint getTracksCount() const;
     /* @brief Request monitor refresh if item (clip or composition) is under timeline cursor
      */
     void refreshItem(int id);
     /* @brief Seek timeline to mouse position
      */
     void seekToMouse();
 
     /* @brief User enabled / disabled snapping, update timeline behavior
      */
     void snapChanged(bool snap);
 
     /* @brief Returns a list of all luma files used in the project
      */
     QStringList extractCompositionLumas() const;
     /* @brief Get the frame where mouse is positionned
      */
     int getMousePos();
     /* @brief Get the frame where mouse is positionned
      */
     int getMouseTrack();
     /* @brief Returns a map of track ids/track names
      */
     QMap<int, QString> getTrackNames(bool videoOnly);
     /* @brief Returns the transition a track index for a composition (MLT index / Track id)
      */
     QPair<int, int> getCompositionATrack(int cid) const;
     void setCompositionATrack(int cid, int aTrack);
     /* @brief Return true if composition's a_track is automatic (no forced track)
      */
     bool compositionAutoTrack(int cid) const;
     const QString getClipBinId(int clipId) const;
     void focusItem(int itemId);
     /* @brief Create and display a split clip view to compare effect
      */
     bool createSplitOverlay(Mlt::Filter *filter);
     /* @brief Delete the split clip view to compare effect
      */
     void removeSplitOverlay();
     /* @brief Add current timeline zone to preview rendering
      */
     void addPreviewRange(bool add);
     /* @brief Clear current timeline zone from preview rendering
      */
     void clearPreviewRange();
     void startPreviewRender();
     void stopPreviewRender();
     QVariantList dirtyChunks() const;
     QVariantList renderedChunks() const;
     /* @brief returns the frame currently processed by timeline preview, -1 if none
      */
     int workingPreview() const;
 
     /** @brief Return true if we want to use timeline ruler zone for editing */
     bool useRuler() const;
     /* @brief Load timeline preview from saved doc
      */
     void loadPreview(QString chunks, QString dirty, const QDateTime &documentDate, int enable);
     /* @brief Return document properties with added settings from timeline
      */
     QMap<QString, QString> documentProperties();
 
     /** @brief Change track compsiting mode */
     void switchCompositing(int mode);
 
     /** @brief Change a clip item's speed in timeline */
     Q_INVOKABLE void changeItemSpeed(int clipId, double speed);
     /** @brief Delete selected zone and fill gap by moving following clips
      *  @param lift if true, the zone will simply be deleted but clips won't be moved
      */
     void extractZone(QPoint zone, bool liftOnly = false);
     /** @brief Insert clip monitor into timeline
      *  @returns the zone end position or -1 on fail
      */
     int insertZone(const QString &binId, QPoint zone, bool overwrite);
     void updateClip(int clipId, QVector<int> roles);
     void showClipKeyframes(int clipId, bool value);
     void showCompositionKeyframes(int clipId, bool value);
     /** @brief Returns last usable timeline position (seek request or current pos) */
     int timelinePosition() const;
     /** @brief Adjust all timeline tracks height */
     void resetTrackHeight();
     /** @brief timeline preview params changed, reset */
     void resetPreview();
     /** @brief Select the clip in active track under cursor */
     void selectCurrentItem(ObjectType type, bool select, bool addToCurrent = false);
     /** @brief Set target tracks (video, audio) */
     void setTargetTracks(QPair<int, int> targets);
     /** @brief Return asset's display name from it's id (effect or composition) */
     Q_INVOKABLE const QString getAssetName(const QString &assetId, bool isTransition);
     /** @brief Set keyboard grabbing on current selection */
     void grabCurrent();
     /** @brief Returns keys for all used thumbnails */
     QStringList getThumbKeys();
 
 public slots:
     void selectMultitrack();
     void resetView();
     Q_INVOKABLE void setSeekPosition(int position);
     Q_INVOKABLE void setAudioTarget(int track);
     Q_INVOKABLE void setVideoTarget(int track);
     Q_INVOKABLE void setActiveTrack(int track);
     void onSeeked(int position);
     void addEffectToCurrentClip(const QStringList &effectData);
     /** @brief Dis / enable timeline preview. */
     void disablePreview(bool disable);
     void invalidateItem(int cid);
     void invalidateZone(int in, int out);
     void checkDuration();
     /** @brief Dis / enable multi track view. */
     void slotMultitrackView(bool enable);
     /** @brief Save timeline selcted clips to target folder. */
     void saveTimelineSelection(QDir targetDir);
     /** @brief Restore timeline scroll pos on open. */
     void setScrollPos(int pos);
 
 private slots:
     void slotUpdateSelection(int itemId);
     void updateClipActions();
 
 public:
     /** @brief a list of actions that have to be enabled/disabled depending on the timeline selection */
     QList <QAction *>clipActions;
 
 private:
     QQuickItem *m_root;
     KActionCollection *m_actionCollection;
     std::shared_ptr<TimelineItemModel> m_model;
     bool m_usePreview;
     struct Selection
     {
         QList<int> selectedItems;
         int selectedTrack;
         bool isMultitrackSelected;
     };
     int m_position;
     int m_seekPosition;
     int m_audioTarget;
     int m_videoTarget;
     int m_activeTrack;
     int m_audioRef;
     QPoint m_zone;
     double m_scale;
     static int m_duration;
     Selection m_selection;
     Selection m_savedSelection;
     PreviewManager *m_timelinePreview;
     QAction *m_disablePreview;
     std::shared_ptr<AudioCorrelation> m_audioCorrelator;
 
     void emitSelectedFromSelection();
     int getCurrentItem();
     void initializePreview();
     // Get a list of currently selected items, including clips grouped with selection
     std::unordered_set<int> getCurrentSelectionIds() const;
     QDomDocument m_copiedItems;
 
 signals:
     void selected(Mlt::Producer *producer);
     void selectionChanged();
     void frameFormatChanged();
     void trackHeightChanged();
     void scaleFactorChanged();
     void audioThumbFormatChanged();
     void durationChanged();
     void positionChanged();
     void seekPositionChanged();
     void audioTargetChanged();
     void videoTargetChanged();
     void activeTrackChanged();
+    void colorsChanged();
     void showThumbnailsChanged();
     void showAudioThumbnailsChanged();
     void showMarkersChanged();
     void rippleChanged();
     void scrubChanged();
     void seeked(int position);
     void zoneChanged();
     void zoneMoved(const QPoint &zone);
     /* @brief Requests that a given parameter model is displayed in the asset panel */
     void showTransitionModel(int tid, std::shared_ptr<AssetParameterModel>);
     void showItemEffectStack(const QString &clipName, std::shared_ptr<EffectStackModel>, QSize frameSize, bool showKeyframes);
     /* @brief notify of chunks change
      */
     void dirtyChunksChanged();
     void renderedChunksChanged();
     void workingPreviewChanged();
     void useRulerChanged();
     void updateZoom(double);
     /* @brief emitted when timeline selection changes, true if a clip is selected
      */
     void timelineClipSelected(bool);
     Q_INVOKABLE void ungrabHack();
 };
 
 #endif