Adds feature to edit tangents of Cubic Hermite progressions

data/themes/classic/style.css

@@ -22,6 +22,7 @@ lmms--gui--AutomationEditor {
 	qproperty-backgroundShade: rgba(255, 255, 255, 15);
 	qproperty-nodeInValueColor: rgba(255, 119, 175, 150);
 	qproperty-nodeOutValueColor: rgba(129, 231, 181, 150);
+	qproperty-nodeTangentLineColor: rgba(200, 200, 200, 255);
 	qproperty-crossColor: rgb( 255, 51, 51 );
 	/* Grid colors */
 	qproperty-lineColor: rgba(128, 128, 128, 80);

data/themes/default/style.css

@@ -57,6 +57,7 @@ lmms--gui--AutomationEditor {
 	qproperty-backgroundShade: rgba(255, 255, 255, 15);
 	qproperty-nodeInValueColor: rgba(103, 73, 194, 150);
 	qproperty-nodeOutValueColor: rgba(125, 40, 40, 150);
+	qproperty-nodeTangentLineColor: rgba(200, 200, 200, 255);
 	qproperty-crossColor: rgba(215, 210, 254, 150);
 	/* Grid colors */
 	qproperty-lineColor: #292929;

include/AutomationClip.h

@@ -46,6 +46,7 @@ class TimePos;
 namespace gui
 {
 class AutomationClipView;
+class AutomationEditor;
 } // namespace gui
 
 
@@ -111,6 +112,8 @@ class LMMS_EXPORT AutomationClip : public Clip
 
 	void resetNodes(const int tick0, const int tick1);
 
+	void resetTangents(const int tick0, const int tick1);
+
 	void recordValue(TimePos time, float value);
 
 	TimePos setDragValue( const TimePos & time,
@@ -151,6 +154,17 @@ class LMMS_EXPORT AutomationClip : public Clip
 		return m_timeMap.isEmpty() == false;
 	}
 
+	static bool supportsTangentEditing(ProgressionType pType)
+	{
+		// Update function if we have new progression types that support tangent editing
+		return pType == ProgressionType::CubicHermite;
+	}
+
+	inline bool canEditTangents() const
+	{
+		return supportsTangentEditing(m_progressionType);
+	}
+
 	float valueAt( const TimePos & _time ) const;
 	float *valuesAfter( const TimePos & _time ) const;
 
@@ -219,6 +233,9 @@ public slots:
 	bool m_dragging;
 	bool m_dragKeepOutValue; // Should we keep the current dragged node's outValue?
 	float m_dragOutValue; // The outValue of the dragged node's
+	bool m_dragLockedTan; // If the dragged node has it's tangents locked
+	float m_dragInTan; // The dragged node's inTangent
+	float m_dragOutTan; // The dragged node's outTangent
 
 	bool m_isRecording;
 	float m_lastRecordedValue;
@@ -230,6 +247,7 @@ public slots:
 
 	friend class gui::AutomationClipView;
 	friend class AutomationNode;
+	friend class gui::AutomationEditor;
 
 } ;
 
@@ -261,6 +279,11 @@ inline float OUTTAN(AutomationClip::TimemapIterator it)
 	return it->getOutTangent();
 }
 
+inline float LOCKEDTAN(AutomationClip::TimemapIterator it)
+{
+	return it->lockedTangents();
+}
+
 inline int POS(AutomationClip::TimemapIterator it)
 {
 	return it.key();

include/AutomationEditor.h

@@ -63,6 +63,7 @@ class AutomationEditor : public QWidget, public JournallingObject
 	Q_PROPERTY(QColor lineColor MEMBER m_lineColor)
 	Q_PROPERTY(QColor nodeInValueColor MEMBER m_nodeInValueColor)
 	Q_PROPERTY(QColor nodeOutValueColor MEMBER m_nodeOutValueColor)
+	Q_PROPERTY(QColor nodeTangentLineColor MEMBER m_nodeTangentLineColor)
 	Q_PROPERTY(QBrush scaleColor MEMBER m_scaleColor)
 	Q_PROPERTY(QBrush graphColor MEMBER m_graphColor)
 	Q_PROPERTY(QColor crossColor MEMBER m_crossColor)
@@ -91,7 +92,8 @@ class AutomationEditor : public QWidget, public JournallingObject
 	{
 		Draw,
 		Erase,
-		DrawOutValues
+		DrawOutValues,
+		EditTangents
 	};
 
 public slots:
@@ -118,6 +120,8 @@ public slots:
 	inline void drawLevelTick(QPainter & p, int tick, float value);
 
 	timeMap::iterator getNodeAt(int x, int y, bool outValue = false, int r = 5);
+	// Get the closest node to the x position (for the drag tangent)
+	timeMap::iterator getClosestNode(int x);
 
 	void drawLine( int x0, float y0, int x1, float y1 );
 	bool fineTuneValue(timeMap::iterator node, bool editingOutValue);
@@ -153,7 +157,9 @@ protected slots:
 		EraseValues,
 		MoveOutValue,
 		ResetOutValues,
-		DrawLine
+		DrawLine,
+		MoveTangent,
+		ResetTangents
 	} ;
 
 	// some constants...
@@ -173,6 +179,7 @@ protected slots:
 	static QPixmap * s_toolDraw;
 	static QPixmap * s_toolErase;
 	static QPixmap * s_toolDrawOut;
+	static QPixmap * s_toolEditTangents;
 	static QPixmap * s_toolMove;
 	static QPixmap * s_toolYFlip;
 	static QPixmap * s_toolXFlip;
@@ -215,6 +222,11 @@ protected slots:
 	// Time position (key) of automation node whose outValue is being dragged
 	int m_draggedOutValueKey;
 
+	// The tick from the node whose tangent is being dragged
+	int m_draggedTangentTick;
+	// Whether the tangent being dragged is the InTangent or OutTangent
+	bool m_draggedOutTangent;
+
 	EditMode m_editMode;
 
 	bool m_mouseDownLeft;
@@ -225,6 +237,7 @@ protected slots:
 
 	void drawCross(QPainter & p );
 	void drawAutomationPoint( QPainter & p, timeMap::iterator it );
+	void drawAutomationTangents(QPainter & p, timeMap::iterator it);
 	bool inPatternEditor();
 
 	QColor m_barLineColor;
@@ -233,6 +246,7 @@ protected slots:
 	QBrush m_graphColor;
 	QColor m_nodeInValueColor;
 	QColor m_nodeOutValueColor;
+	QColor m_nodeTangentLineColor;
 	QBrush m_scaleColor;
 	QColor m_crossColor;
 	QColor m_backgroundShade;
@@ -285,8 +299,14 @@ protected slots:
 
 private slots:
 	void updateWindowTitle();
+	void setProgressionType(int progType);
 
 private:
+	QAction* m_drawAction;
+	QAction* m_eraseAction;
+	QAction* m_drawOutAction;
+	QAction* m_editTanAction;
+
 	QAction* m_discreteAction;
 	QAction* m_linearAction;
 	QAction* m_cubicHermiteAction;

include/AutomationNode.h

@@ -125,6 +125,22 @@ class AutomationNode
 		m_outTangent = tangent;
 	}
 
+	/**
+	 * @brief Checks if the tangents from the node are locked
+	 */
+	inline const bool lockedTangents() const
+	{
+		return m_lockedTangents;
+	}
+
+	/**
+	 * @brief Locks or Unlocks the tangents from this node
+	 */
+	inline void setLockedTangents(bool b)
+	{
+		m_lockedTangents = b;
+	}
+
 	/**
 	 * @brief Sets the clip this node belongs to
 	 * @param AutomationClip* clip that m_clip will be
@@ -152,6 +168,11 @@ class AutomationNode
 	// outValue are equal, inTangent and outTangent are equal too.
 	float m_inTangent;
 	float m_outTangent;
+
+	// If the tangents were edited manually, this will be true. That way
+	// the tangents from this node will not be recalculated. It's set back
+	// to false if the tangents are reset.
+	bool m_lockedTangents;
 };
 
 } // namespace lmms

src/core/AutomationClip.cpp

@@ -422,6 +422,37 @@ void AutomationClip::resetNodes(const int tick0, const int tick1)
 
 
 
+/**
+ * @brief Resets the tangents from the nodes between the given ticks
+ * @param Int first tick of the range
+ * @param Int second tick of the range
+ */
+void AutomationClip::resetTangents(const int tick0, const int tick1)
+{
+	if (tick0 == tick1)
+	{
+		auto it = m_timeMap.find(TimePos(tick0));
+		if (it != m_timeMap.end())
+		{
+			it.value().setLockedTangents(false);
+			generateTangents(it, 1);
+		}
+		return;
+	}
+
+	TimePos start = TimePos(qMin(tick0, tick1));
+	TimePos end = TimePos(qMax(tick0, tick1));
+
+	for (auto it = m_timeMap.lowerBound(start), endIt = m_timeMap.upperBound(end); it != endIt; ++it)
+	{
+		it.value().setLockedTangents(false);
+		generateTangents(it, 1);
+	}
+}
+
+
+
+
 void AutomationClip::recordValue(TimePos time, float value)
 {
 	QMutexLocker m(&m_clipMutex);
@@ -467,16 +498,31 @@ TimePos AutomationClip::setDragValue(
 		// inValue
 		m_dragKeepOutValue = false;
 
+		// We will set the tangents back to what they were if the node had
+		// its tangents locked
+		m_dragLockedTan = false;
+
 		// Check if we already have a node on the position we are dragging
 		// and if we do, store the outValue so the discrete jump can be kept
+		// and information about the tangents
 		timeMap::iterator it = m_timeMap.find(newTime);
 		if (it != m_timeMap.end())
 		{
+			// If we don't have a discrete jump, the outValue will be the
+			// same as the inValue
 			if (OFFSET(it) != 0)
 			{
 				m_dragKeepOutValue = true;
 				m_dragOutValue = OUTVAL(it);
 			}
+			// For the tangents, we will only keep them if the tangents were
+			// locked
+			if (LOCKEDTAN(it))
+			{
+				m_dragLockedTan = true;
+				m_dragInTan = INTAN(it);
+				m_dragOutTan = OUTTAN(it);
+			}
 		}
 
 		this->removeNode(newTime);
@@ -489,12 +535,31 @@ TimePos AutomationClip::setDragValue(
 
 	generateTangents();
 
+	TimePos returnedPos;
+
 	if (m_dragKeepOutValue)
 	{
-		return this->putValues(time, value, m_dragOutValue, quantPos, controlKey);
+		returnedPos = this->putValues(time, value, m_dragOutValue, quantPos, controlKey);
+	}
+	else
+	{
+		returnedPos = this->putValue(time, value, quantPos, controlKey);
 	}
 
-	return this->putValue(time, value, quantPos, controlKey);
+	// Set the tangents on the newly created node if they were locked
+	// before dragging
+	if (m_dragLockedTan)
+	{
+		timeMap::iterator it = m_timeMap.find(returnedPos);
+		if (it != m_timeMap.end())
+		{
+			it.value().setInTangent(m_dragInTan);
+			it.value().setOutTangent(m_dragOutTan);
+			it.value().setLockedTangents(true);
+		}
+	}
+
+	return returnedPos;
 }
 
 
@@ -783,6 +848,9 @@ void AutomationClip::saveSettings( QDomDocument & _doc, QDomElement & _this )
 		element.setAttribute("pos", POS(it));
 		element.setAttribute("value", INVAL(it));
 		element.setAttribute("outValue", OUTVAL(it));
+		element.setAttribute("inTan", INTAN(it));
+		element.setAttribute("outTan", OUTTAN(it));
+		element.setAttribute("lockedTan", static_cast<int>(LOCKEDTAN(it)));
 		_this.appendChild( element );
 	}
 
@@ -804,6 +872,11 @@ void AutomationClip::loadSettings( const QDomElement & _this )
 {
 	QMutexLocker m(&m_clipMutex);
 
+	// Legacy compatibility: Previously tangents were not stored in
+	// the project file. So if any node doesn't have tangent information
+	// we will generate the tangents
+	bool shouldGenerateTangents = false;
+
 	clear();
 
 	movePosition( _this.attribute( "pos" ).toInt() );
@@ -828,6 +901,22 @@ void AutomationClip::loadSettings( const QDomElement & _this )
 			float timeMapOutValue = LocaleHelper::toFloat(element.attribute("outValue"));
 
 			m_timeMap[timeMapPos] = AutomationNode(this, timeMapInValue, timeMapOutValue, timeMapPos);
+
+			// Load tangents if there is information about it (it's enough to check for either inTan or outTan)
+			if (element.hasAttribute("inTan"))
+			{
+				float inTan = LocaleHelper::toFloat(element.attribute("inTan"));
+				float outTan = LocaleHelper::toFloat(element.attribute("outTan"));
+				bool lockedTan = static_cast<bool>(element.attribute("lockedTan", "0").toInt());
+
+				m_timeMap[timeMapPos].setInTangent(inTan);
+				m_timeMap[timeMapPos].setOutTangent(outTan);
+				m_timeMap[timeMapPos].setLockedTangents(lockedTan);
+			}
+			else
+			{
+				shouldGenerateTangents = true;
+			}
 		}
 		else if( element.tagName() == "object" )
 		{
@@ -851,7 +940,8 @@ void AutomationClip::loadSettings( const QDomElement & _this )
 	{
 		changeLength( len );
 	}
-	generateTangents();
+
+	if (shouldGenerateTangents) { generateTangents(); }
 }
 
 
@@ -1108,6 +1198,12 @@ void AutomationClip::generateTangents(timeMap::iterator it, int numToGenerate)
 
 	for (int i = 0; i < numToGenerate && it != m_timeMap.end(); ++i, ++it)
 	{
+		// Skip the node if it has locked tangents (were manually edited)
+		if (LOCKEDTAN(it))
+		{
+			continue;
+		}
+
 		if (it + 1 == m_timeMap.end())
 		{
 			// Previously, the last value's tangent was always set to 0. That logic was kept for both tangents