From 999c10e4b32fe1f8c4692cfd6187d74504d4861e Mon Sep 17 00:00:00 2001
From: IanCaio <iancaio_dev@hotmail.com>
Date: Fri, 6 Oct 2023 19:37:46 -0300
Subject: [PATCH] Adds feature to edit tangents of Cubic Hermite progressions
 (#5924)

Enables the editing of a node's tangents of Cubic Hermite progressions.

* First commit

	This commit introduces the use of AutomationNodes instead of just floats for keeping the automation values. The AutomationNodes will give more flexibility when it comes to storing extra information about the values (and make it possible to have multiple progression types in the future). Now the tangents are stored on the node, requiring one less timeMap on the automation pattern. Some methods had to be changed for that, since before they used const_iterator, which wouldn't allow us to change the tangent values.

TODO:
	- Check TODO comments that were added in places of the code I had some doubts about.
	- Maybe change the timeMap to hold pointers to AutomationNodes and not actual instances.
	- In some pieces of the code, I check if the AutomationNode already exists before setting its value or creating another node. I think that's unnecessary since if I create another node and assign it to the current existing one it could just clone its value. (That would not be valid for pointers to AutomationNodes, so that's something to consider when deciding between the two).
	- I still didn't find a good solution for renaming QMap::iterator method from "value()" to something else, so now we have lines that look a bit odd like "it.value().getValue()", because value() is actually returning the node, and getValue() is getting the node's automation value.

* Implements inValue/outValue on Automation Nodes

	This commit is a big change in comparison to the previous one. Automation nodes now have a inValue and outValue instead of a single value. The inValue represents the core value of the node, which is used for incoming progressions. The outValue represents the value of the node for progressions starting from that node on. In practice, the true value of the node is the inValue and outValue represents a way of creating discrete jumps in a node's position.
	By default inValue and outValue are the same. The user will then be allowed to change the outValue to create those discrete jumps. Because their values might be different, we now need two tangents for a single node: One for the curve coming before the node and one for the curve coming after the node. So instead of a single tangent variable, we now have inTangent and outTangent. If inValue and outValue are the same, so are inTangent and outTangent, but if they are different both are calculated according to the curve before and after the node.
	On the Automation Editor, the inValue of the node is represented by our default blue circle, while the outValue is represented by a red circle with 80% alpha (we should add a variable to the Automation Editor class to hold the color of this second circle in the future).
	Lots of comments were added on the modified files to explain the existing methods where changes were required (not only explaining the logic of the methods but the reason behind using inValue or outValue on them). Lots of TODO comments were also added as placeholders for changes that could or should be done before the finishing of this PR (or after it).
	For now only the logic for the nodes was added, but there's still no way for the user to change outValues (on the next commit a small placeholder shortcut will be added to do that for testing purposes).
	The drawing of the notes detuning on the piano roll was updated to account for the discrete jumps.
	The drawing of the pattern TCO was updated to account for the discrete jumps.
	The drawing of the pattern on the AutomationEditor was updated to account for the discrete jumps.

	IMPORTANT:
		- There were changes to the loadSettings and saveSettings of AutomationPatterns, to account for inValues and outValues, but I didn't create an upgrade routine yet.

	Some behavior that is important to mention:
		- Most operations on nodes (drawing, moving, X/Y flipping, and even selection copy/paste, apparently not fully finished) ignore the outValue, basically reseting it to the inValue. So when an user moves a node with a discrete jump, for example, that discrete jump will be lost and the user will need to set it again. Obviously in the future we might want to keep that information, but that isn't a critical issue, just a behavior that can be improved later by upgrading the code.
		- Later on we might want to connect a signal to the AutomationNode class, so it calls generateTangents when node data is changed.
		- When an object is disconnected from an automation pattern and it has to rescale the values so they fit the new range of values (max and min) the outValue is reset, meaning all discrete jumps are lost. This behavior will be changed in the future.

	Things that I think are also important noting:
		- Mainly in the src/gui/editor/AutomationEditor.cpp file there were lots of codes that apparently are related to a feature that is not yet finished (moving/cutting/copying/pasting selections of automation values). This doesn't sound good unless it's currently being worked on. I tried my best to update the current code to comply to the use of AutomationNodes so their developing can be picked up from a unbroken state. As with other operations involving AutomationNodes, they only account for the inValue discarding any discrete jumps that were present.
		- I added comments on some logic that seemed flawed in the src/gui/editor/AutomationEditor.cpp file so it can be reviewed. It's beyond the scope of this PR, but since I had to read and change a lot on that file I thought it was pertinent to at least comment those observations.

* Fixes and refactor code on AutomationEditor.cpp

	While implementing the automation nodes, I noticed AutomatinEditor.cpp had some issues regarding flawed logic, code style convention, code that could comply to DRY paradigm, conditions that resulted in Undefined Behavior and unused legacy code. That's probably due to how old some changes are, they probably reflect a much different state of LMMS's code base. To make the transition to automation nodes a better one and avoid having to rework everything later I'm using the fact I have to get in touch with most of this code to try to fix some things.

	This commit starts refactoring AutomationEditor::mousePressEvent and AutomationEditor::mouseMoveEvent. There are still things to be improved on both but I'll slowly commit them so I can have better versioning control of the PR.

	Some changes worth noting:
		- A new action was created in the AutomationEditor class for drawing lines, since its logic was too mixed up with the logic of drawing and dragging a single node.
		- Changed most variable names to fit the current code style (just very few left to change).
		- Improved comments explaining the code.
		- Created a separate method for checking if the mouse position is sitting over an existing node (previously this code was repeated inside the event method and it had flaws on its logic, most of the times returning that the user didn't click a node even when he/she clicked one). Method is called getNodeAt(x,y,r), r being the "radius" to be considered (not actually a radius, the area is actually a square).

	Some changes that are still planned:
		- Removing legacy code for features that weren't finished (select and move selection) if it's agreed.
		- Adding some logic to the DRAW_LINE action so it can be even improved.
		- Not forgetting the main focus of the PR, adding a way for the user to edit the outValue of nodes.

* Avoids unnecessary check in putValue

	When adding a value to a particular time, instead of checking if there's a node there already and manually setting its value, we just assign it with a new AutomationNode. QMap silently removes the existing node and adds the new one.

* Adds upgrade routine for the automation nodes

	Adds an upgrade method for the change in the automation nodes settings. The "value" attribute of the <time> element is deleted and assigned to the "inValue" and "outValue" attributes.

	Now older project files can be loaded properly.

* Allows dragging outValues on the Automation Editor

	This commit introduces a way for the user to drag outValues on the Automation Editor, by Alt+clicking the outValue red node and dragging up and down.

	A new action was added for that purpose, called MOVE_OUTVALUE. When the user clicks a outValue sphere with the Alt modifier, m_action is set to MOVE_OUTVALUE, and the time position of the node being affected is stored on m_draggedOutValueKey. That is later used on the mouseMoveEvent to update the outValue of the node.

	Removed repeated code on the mouseReleaseEvent and removed excessive blank lines after a method.

	Things to keep in mind when testing through this commit's build:
		- Creating/Moving an automation node resets the outValue
		- When the outValue is changed, generateTangents isn't called automatically. So you'll notice that after adding another automation node the curves change (that's because after the new node being added the tangents are then recalculated).

	Still lots of work ahead!

* Small fix inside AutomationPattern.cpp

	Unnecessary loop was removed with call to appropriate method.

* Creates separate files for AutomationNode

	Creates a separate header and source file for the AutomationNode class.

* Adds more members to AutomationNode

	Adds 2 new members to the AutomationNode class:
		m_pattern - A pointer to the pattern this node belongs to
		m_key - The time position (timeMap key) of this node

	The constructors (and places they were used) were updated accordingly. AutomationNode was also made a friend class of AutomationPattern so it can access private/protected methods from its pointer. This will be later used to allow AutomationNode's to call generateTangents once their values are updated.

	Small fix on a code block related to moving selections inside the mouseMoveEvent from AutomationEditor.

* Removes unused code from AutomationEditor

	This commit removes code that was not currently used in the AutomationEditor. Most of it was related to a feature I believe was once functional but broke along the way, but the code was not cleaned up in an effort to fix it later. The feature allowed selecting and moving/cutting/copying/pasting/removing values from the automation pattern. It added up to lots of lines of code, which so far I was keeping up to date to the changes. However, I believe (and others devs agree) that rewritting this code later might be a better approach than trying to fix what we currently have, so I'm removing the obsolete code. The git history will allow us to reference back to it when implementing the feature again and this will make it harder for this PR to introduce bugs because a certain affected feature couldn't be tested.

	It also makes reviewing easier, for there are less affected code to cover.

For reviewing purposes:
	I used a single commit for removing the mentioned code, so its diff in relation to the previous commit should give a good idea of everything that was removed.

* Changes to the outValues now update the tangents

	The methods that change the inValue and outValue of nodes now also generate new tangents for the previous, current and next nodes (the ones affected), so now when the user drags the node outValue the curve is updated accordingly.

* Keeps discrete jumps when flipping patterns

	Adds a method to the automation node that returns the valueOffset between inValue and outValue. AutomationPattern::putValue now has an extra parameter called outValueOffset (defaults to 0), so when it adds a node to the timeMap the outValue is set according to this offset. flipY() will calculate the offset and invert it, so the discrete jumps are kept but flipped vertically as well. flipX() doesn't need to calculate this offset because it uses the outValue itself.

Obs:
	I believe cleanObjects() was meant to be called everytime AutomationPattern::flipX() is called, but it was inside a conditional that would only call it on some situations. I moved it outside of the conditional.

* Allows reseting outValues on the AutomationEditor

	User can now reset the outValue of nodes on a very analogous way to removing nodes but with the Alt key pressed. Alt + right clicking over the node (or dragging over an area), or Alt + clicking on it on Erase mode (or dragging over an area) will reset the outValues of the nodes.
	To do that, two new actions were created: ERASE_VALUES (for the regular node removing) and RESET_OUTVALUES (for the outValues reseting). Those are checked for in the moveMouseEvent, which acts accordingly. The removePoints() method was removed and two new methods were added instead: removeNodes() and resetNodes(), which will remove nodes on a tick range or reset them respectivately.

	The AutomationNode.h and AutomationNode.cpp files were fixed to fit the current code style conventions. The other files were kept as is, so they can be changed all at once at the end of the PR.

	Change requests made by Veratil were done.

* Makes so dragging nodes keep the outValue

	This commit makes a small change to setDragValue. When starting the drag (m_dragging == false), it checks if the time position being dragged already has a node. If it does, then the offset between inValue and offValue is stored on m_dragOutValueOffset so it can be used on the putValue calls, keeping the offset. If there isn't a node in the time position, m_dragOutValueOffset is set to 0.

* Fixes code style on modified code

	Fixes the modified code to comply to current code style convention.

	I tried to keep the changes exclusive to the lines modified by this PR (to keep the diff cleaner), but I might have fixed a couple of other because either they were hard to differentiate on the current diff or because they were too close in context. But still, tried to keep changes mostly to the lines actually changed by the PR.

* Adds a QProperty for the node outValue color

	Adds a CSS property for the outValue color and renames the one used for the inValue color so they are consistent.

	Colors were added to classic and default themes. The original inValue colors were kept, but to fit with the outValue node they had a little bit of transparency added.

* Adds doxygen comments on methods

	Adds doxygen comments explaining methods that were either introduced by this PR or which had parameters modified by this PR.

	Changes valueAt(timeMap::iterator, int offset) method, so it can handle offsets equal to 0 properly. This method is currently never used with an offset of 0 (because this case scenario is handled before this method is called), but it was a simply modification so I just added the conditional to make it possible to use an offset of 0.

* Refactor flipX and flipY methods

	AutomationPattern::flipX and AutomationPattern::flipY had some issues to the logic that caused UBs (from accessing an iterator past QMap::end()) and possibly misbehaviors when flipping an empty pattern.
	Both were refactored to fix those noted issues.

* Add a new edit mode to Automation Editor

	Adds another editing mode to Automation Editor (DRAW_OUTVALUES), specific to deal with node outValues. The Pixmap being used is the same as the DRAW edit mode for now.

	The way it works now:

DRAW Mode (Shortcut SHIFT+D)
	Shift + Left click = Draws lines of nodes
	Left click = Draws/Drag node
	Right click = Remove nodes

ERASE Mode (Shortcut SHIFT+E)
	Left click = Remove nodes
	Right click = Reset outValues

DRAW_OUTVALUES Mode (Shortcut SHIFT+C)
	Left click = Drags outValue
	Right click = Reset outValues

	Now using a switch statement on the events to make things more organized.

* Improves the Draw OutValue edit mode

	Now, instead of only being able to change an outValue by clicking over the sphere representing it, the user can also click on any time on the pattern: If the quantized time of the place he clicked has a node, the outValue of its node will be set to the value where the mouse click happened and the outValue will start being dragged. Very similar to the way it works for the node itself on the draw mode.

* Adds mutex to AutomationPattern

	Adds a recursive mutex to the AutomationPattern class and locks it on every method that access the member variables. Also rename the mutex from the AutomationEditor class and add locks to some methods that didn't have it before (except on methods that don't access member variables).

* Veratil's review changes

	Applies changes requested by Veratil:
		- Replaces NULL with nullptr where necessary on AutomationEditor.cpp
		- Fixes spacing on the mutex commit (plus some other places)
		- Changes some if blocks to one liners
		- Replace while with do-while on some places, since the condition was already checked for earlier on the method.
		- Moves getNodeAt call a level up on the block, since it's called on both conditionals below.
		- Fixes identation on some code inside AutomationEditor::mousePressEvent.
		- Adds explicits blocks on a switch statement. Even though this was not necessary for that particular one (because there was no variable declaration inside it) it helps keeping it consistent with another switch statement that happened earlier.

I also added a break statement to the last case of a switch (even though it was not needed, it's safer to avoid mistakes in the future with new cases being added).

* Changes the inValue sphere to be draw first

	The red sphere representing the outValue was drawed after the blue sphere representing the inValue. Because of that, if they had the same value the red sphere would be on top. For the user, it makes more sense to be able to see the blue sphere representing the input value on top instead. This commit changes the order of the drawing.

* Changes comments and variables names

	Fixes some comments pointed out on Spekular's review. Changes the AutomationNode's variable m_key to m_pos (leaving a comment on the header reminding that it matches the timeMap key). Removes comments related to removed code. Fixes code style on a pointer declaration.

* Changes QProperty variables to use MEMBER

	Instead of creating a getter and setter for each QProperty, we use MEMBER instead and access those variables directly.

* Overloads some AutomationNode's operators

	Overloads compound assignment operators +=, -=, *= and /= for AutomationNodes, making it so they affect the inValue and outValue of the node being assigned. Changes AutomationPattern::flipY() so it uses the new operators.

* Improves getNodeAt method

	Makes the AutomationEditor::getNodeAt method more efficient, by exiting if the node we are checking is already past the position we given (since the nodes are ordered in the timeMap, all subsequent nodes will also be past the position). Now instead of returning the last node that is inside the coordinates, it returns the first.
	Also improves AutomationEditor::mousePressEvent to avoid getNodeAt being called twice unnecessarily.

* Changes behavior of setDragValue

	Now, instead of keeping the offset between the inValue and outValue while dragging a node, setDragValue will either keep the current outValue intact, or move it together with the inValue if they are the same.
	The putValue method now doesn't have an offset parameter. If we want to put a node with an outValue different from the inValue we use putValues instead.

* Moves getNodeAt to an upper level, reducing lines

	Creates a boolean before the m_editMode switch, that will be true if the action being processed affects outValues and false if it affects inValues. That way we can move the statement clickedNode=getNodeAt() before the switch-case, reducing repeated lines.

* Changes icon of Draw OutValue edit mode

	Changes the icon for the Draw OutValue tool and toolbar action, so it's different from the Draw mode. Just a placeholder until a visual artist come up with something better or we change the controls.

* Removes unnecessary non-const methods

	Some getter methods had declarations for both const and
non-const object types, when just the const one were needed (no changes
to the object are made). The unnecessary ones were removed.
	Also fixes formatting on operator /= method.

* Fixes formatting and doxygen comments

	Fixes doxygen comments on AutomationPattern.cpp and
AutomationEditor.cpp (also changes one so it uses the same format as the
rest of the file).
	Fixes some formatting issues (removal of excessive tabs,
changing some statements to be one line instead of multiple lines,
fixing of spacing, use of one line ifs, removal of unnecessary else on a
method, use of ternary expressions, etc).

* Adds helper macros for AutomationNodes

	Adds 3 macros to the AutomationNode header file: INVAL, OUTVAL
and POS, which return the InValue, OutValue and Key of a node
respectively. This improved redability and made statements shorter on
the AutomationPattern.cpp code.
	Macros weren't added for InTangent and OutTangent, since those
are only used once in the code (and INTAN/OUTTAN might not have their
meaning as obvious as INVAL/OUTVAL).

* Removes tabs from ternary operator

	Removed tabs to improve formatting on a ternary operator
as requested and also removed a comment that doesn't seem necessary.

* Update files to use AutomationNode macros

	Other files besides "AutomationPattern.cpp" also included the
AutomationNode.h header and handled automation nodes, but they weren't
using the macros. Those were updated to use INVAL, OUTVAL and POS
macros.
	Two conditionals were changed to one liners for consistency.

* Addresses my own code review

	This commit addresses some fixes from a review I made from the
code on Github and also one requested change from Veratil.

	Changes:
	- Fixes code style issues.
	- Adds a helper MACRO to return the offset between the inValue
and outValue of a node and use it where getValueOffset was called.
	- Removes conditional that was not needed inside
AutomationPattern::valueAt.
	- Updates InlineAutomation.h to use the helper MACROs and
account for the outValue when deciding whether to save or discard an
inline automation.
	- Adds TODO comments on two loops present on
src/code/AutomationPattern.cpp that could be optimized.
	- Fixes some comments.
	- Uses INVAL(it) instead of valueAt(POS(it)) on the flip methods
when possible.
	- Adds a resetOutValue() method to AutomationNode and use it
where convenient.
	- Fixes a small "bug" where flipping a pattern from the TCO
context menu, when the pattern is smaller than the TCO, would use the
inValue of the last node for the node created at the end of the TCO
instead of the outValue (which is the value that the position would have
if the pattern continued).

* Addresses Veratil's review

	- Fixes some code style issues
	- Changes to improve readability at some snippets
	- Uses if one-liners when convenient
	- On a polynomial expression inside AutomationPattern::valueAt,
uses some variables to improve readability (those will be optimized out
by the compiler)
	- Removes unnecessary casting on alignedX variable inside
AutomationEditor::mousePressEvent (it was also using C-style casting
instead of static_cast)

* Adds helper MACROs for node tangents

	Adds INTAN and OUTTAN macros to retrieve a node's InTangent and
OutTangent respectively, and replace calls to getInTangent/getOutTangent
with those macros.

* Fixes header inclusion order

* Removes mutex from AutomationEditor

	Now that there's a mutex protecting the AutomationPattern on its
own methods, there's no need to have a mutex on the AutomationEditor
class. The editor's member variables don't need to be protected because
LMMS's UI runs from a single thread.
	This commit removes the m_patternEditorMutex.

* Locks mutex on AutomationPattern copy assignment

	On the copy assignment constructor of AutomationPattern, the
values were being copied from the other pattern without locking its
mutex, which could result in race conditions. Now the constructor locks
the other pattern's mutex.

	Other small changes:
	- Removes unnecessary comments and fix others.
	- Uses the OFFSET macro on the generateTangents method.
	- Uses the resetOutValue() method on
AutomationEditor::mousePressEvent, in a place where I forgot to change
it.

* Changes resetOutValue() so it generates tangents

	Changes the AutomationNode::resetOutValue() method so it calls
setOutValue() instead of directly setting the m_outValue, since the
latter will also take care of generating tangents.
	Fixes small bug where reseting outValues would not recalculate
the tangents.

* Changes some methods to use for loops

	AutomationEditor::removeNodes and AutomationEditor::resetNodes
were previously using while loops where for loops are much more well
suited. Both methods were changed to use those instead.

* Move removeNodes/resetNodes to AutomationPattern

	- Renames AutomationPattern::removeValue to
AutomationPattern::removeNode.
	- Moves AutomationEditor::removeNodes and
AutomationEditor::resetNodes to AutomationPattern, since they are more
suited there and could be reused in other areas of code that need to
remove a range of nodes.

* Optimizes loop inside putValue/putValues

	There was a TODO comment about a loop that could be optimized
inside putValue/putValues. It went through all the ticks in the
surrounding values instead of just going through the nodes that were in
that range. Now that the removeNodes/resetNodes methods are part of the
AutomationPattern we can use them to optimize the loop.

	Changes:
	- removeNodes/resetNodes will remove or reset a node if a range
with start == end is given (before it would return).
	- The loop was replaced with a call to removeNodes from
newTime + 1 to newTime + quantization() - 1 (which will cover the nodes
that are between the quantization limits). We add a conditional that
quantization() is greater than 1 to avoid a bug where the added node is
removed by that call because we get a range from [newTime + 1, newTime].

* Adds comment to mysterious calculation

	There was a calculation on the drawAutomationPoint method that
wasn't really obvious at first glance. Thanks to @PhysSong, a comment
was added explaining the reasoning behind the calculation.

* Reduces indentation on getNodeAt

	Reduces one indentation level on AutomationEditor::getNodeAt()
by reversing the conditional.
	Fixes style on switch statements.

* Applies Veratil suggestions

	Condense two code blocks in a single one by using a ternary
operator on the only variable that changed between them.

	Comment out a "else" block that currently doesn't have anything
(placeholder for future code).

	Format a for statement in multiple lines to improve readability.

* Updates comment from changed code

	Updates comment to better match the recently changed code.

* Uses lambda functions to extract code

	Uses two helper lambda functions inside
AutomationEditor::mousePressEvent to extract code and use fewer lines on
places where it's repeated.

* Fixes behavior of AutomationPattern::flipX

	To truly flip a pattern horizontally, we also needed to swap the
inValues and outValues of the nodes being flipped. This commit fixes
that behavior by including the swap when necessary.

	Also adds a TODO comment regarding the behavior of the
generateTangents method when the difference between inValue and outValue
is very small.

* Changes pattern XML for backwards compatibility

	Changes the inValue attribute name on the XML from "inValue" to
"value" to make projects created with the new automation pattern
partially backwards compatible (outValues will still not be loaded
obviously, but the inValues will be loaded as the regular pattern values
we had before).

* Fixes bug on AutomationPattern::resetNodes

	Fixes bug on AutomationPattern::resetNodes: If it was called
with tick0 == tick1, m_timeMap.find() return value was being used to
call resetOutValue. When QMap::find() doesn't find a value it returns
QMap::end() though, resulting in a SegFault.
	Fixed by checking if the return value is QMap::end() first.

* Adds drawing of automation node tangents

	This introduces a method on the AutomationEditor that draws a
line and an ellipse representing the inTangent and outTangent of
Automation Nodes, so they can be visualized on the Cubic Hermite
progression.
	The tangents are not yet editable.

* Adds mode to edit tangents

	Adds the edit mode that will be used to edit tangents. For now
there's no functionality, only the GUI elements were added.

* Adds comment about copy-assignment

	Adds a note about the default copy-assignment from
AutomationNode being used on the AutomationPattern constructor. If any
dynamic allocated resources are added to the class, an user-defined
copy-assignment constructor should be used instead.

	Also changes the position of an arithmetics operator on a
multiline statement for readability.

* Changes flipY logic and address PhysSong review

	This commit addresses PhysSong review:
	- An if-statement was replaced with a ternary operator on
AutomationEditor::paintEvent().
	- One comment was improved on PianoRow::drawDetuningInfo() to
make it clearer that drawing cubic hermit curves as straight lines is
just a temporary thing.
	- While applying the requested changes on the
AutomationPattern::flipY() method, I noticed that even though it
accepted any integer values as min and max, the current logic (both on
master and on the previous commit from this PR) would only work if the
range was [-max,+max] or [0,+max]. If min was -5 and max 10 for example,
the flipping could return us a pattern with values out of range. This
commit replaces the logic with an improved one that now relies on the
distance between the node and the edges of the range instead, thus
working for any range instead of those two mentioned earlier. The new
logic also attend to the request of using a for-loop and also using
in-place operations.

* Implements the dragging of node tangents

	Implements the action of dragging node tangents. A method called
getClosestNode returns the node that is closest to the mouse X position.
Then the action begins, with the tick of the node having its tangent
dragged stored in a local variable. It's also calculated whether we are
dragging the inTangent or outTangent.
	The new tangent is calculated as the tangent between the current
mouse position and the automation node.

* Saves tangent information from automation patterns

	Now saves the tangent values of automation pattern nodes. While
loading, for backwards compatibility, if any node doesn't have tangent
information the tangents are generated. Else, they are loaded from the
project file and kept.

	Dragging a node still resets all tangents. Moving an outValue
resets the tangents from the surrounding nodes.

* Implements the locking of tangents

	Now when the used manually edits a node's tangent, the node
locks both its tangents so they aren't recalculated by
AutomationPattern::generateTangents().
	When the used resets the tangents of a node (by right clicking
close to it on the edit tangents mode) they are unlocked again, and are
allowed to be recalculated.
	This information is saved on the project file as well.
	A macro was added to quickly return whether a node's tangents
are locked.
	AutomationEditor was made a friend class of AutomationPattern to
enable it to call generateTangents when a node's tangent is reset.

* Checks only for inTan on the LoadSettings

	When loading an automation node, when checking if we have
tangent information we only have to check for either inTan or outTan,
because if we have one we will have the other.

* Adds a convenient way to reset multiple tangents

	Now right clicking and dragging on Edit Tangents mode will reset
multiple tangents (similar to how it works for the reseting and removal
of nodes).

* Fixes small bug on generateTangents

	AutomationPattern::generateTangents() expects that a valid node
is given. While generating the amount of tangents requested, it avoids
going out of bound by checking if the node after the one being iterated
is the end of the timeMap, then setting the tangents to 0 and returning.
That worked fine before, but now we skip nodes that have their tangents
locked, so it could happen that the last tangent was locked and skipped
and we end up iterating m_timeMap.end().
	This was causing a segmentation fault if we edited the tangents
of the last node and added a new node after it. To avoid that, a second
conditional was added to the for-loop to check if the current node is
the end of the timemap.

* Fixes bug with Edit Tangents shortcut

	Bug found by @superpaik. I was setting the Edit Tangents
shortcut to the Draw OutValues mode, overriding its correct shortcut and
leaving Edit Tangents with none.

* Disables Edit Tan mode on other progressions

	The Edit tangents mode is now disabled when the user switches to
a different progression mode and reenabled when it changes back to Cubic
Hermite mode.

* Keep tangents when dragging nodes

	As requested by @superpaik after testing, logic was added to the
AutomationPattern::setDragValue method to keep a node's tangents if they
were locked.
	First, the method checks if the tangents were locked in the
first drag iteration and store its values if they were.
	Then, everytime the dragging routine puts a new value in the
timemap, it will set its tangents and lock them if needed.

* Changes tangent calculation behavior

	Changes the behavior of the tangent calculation for the Edit
Tangent mode. The new behavior will be submitted for testing to see if
it's considered better than the previous one, and reverted if it isn't.
	Also fixes a possible division by 0 bug.

* Fixes undo/redo with tangents editing

	The tangents editing logic was missing adding a journalling
checkpoint, hence the undo/redo wasn't working properly.
	This commit fixes it.

* Uses function to check if tangents can be edited

As per requested by PR review, instead of checking if the automation
clip uses Cubic Hermite progression to allow changing tangents, we now
instead use a method that will return true if the current progression
type allows tangent editing. That way it's easier to allow tangent
editing for new progression types that might be added in the future.

* Fixes bug reported by zonkmachine

	- The Edit Tangents button was not updating correctly when
the clip was changed inside the automation editor. This was fixed by
making the update routine a separate method and calling it on the places
necessary (when changing progression modes and when changing clips).
	- Some suggestions from messmerd PR review were also included.

* A couple review requests forgotten

	- Just adds 2 more review requested changes that were forgotten
in the previous commit.

* Address Sakertooth's review

* Adresses Sakertooth's review

* Address Sakertooth's review

	- Simplifies method that updates the edit tangent button on the
automation editor

---------

Co-authored-by: Hyunjin Song <tteu.ingog@gmail.com>
---
 data/themes/classic/edit_tangent.png | Bin 0 -> 4141 bytes
 data/themes/classic/style.css        |   1 +
 data/themes/default/edit_tangent.png | Bin 0 -> 467 bytes
 data/themes/default/style.css        |   1 +
 include/AutomationClip.h             |  28 ++++
 include/AutomationEditor.h           |  42 ++++-
 include/AutomationNode.h             |  21 +++
 src/core/AutomationClip.cpp          |  97 ++++++++++-
 src/core/AutomationNode.cpp          |   9 +-
 src/gui/editors/AutomationEditor.cpp | 238 +++++++++++++++++++++++++--
 10 files changed, 418 insertions(+), 19 deletions(-)
 create mode 100644 data/themes/classic/edit_tangent.png
 create mode 100644 data/themes/default/edit_tangent.png

diff --git a/data/themes/classic/edit_tangent.png b/data/themes/classic/edit_tangent.png
new file mode 100644
index 0000000000000000000000000000000000000000..438673b33a9df5bd8911668d9901c7bf4cda0249
GIT binary patch
literal 4141
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

literal 0
HcmV?d00001

diff --git a/data/themes/classic/style.css b/data/themes/classic/style.css
index c73da5a2b..522d694ff 100644
--- a/data/themes/classic/style.css
+++ b/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);
diff --git a/data/themes/default/edit_tangent.png b/data/themes/default/edit_tangent.png
new file mode 100644
index 0000000000000000000000000000000000000000..7bc4000947d592734ba6abcafa68f4f03829baa6
GIT binary patch
literal 467
zcmV;^0WAKBP)<h;3K|Lk000e1NJLTq000yK000yS1^@s6jfou%00004b3#c}2nYxW
zd<bNS00009a7bBm0001Q0001Q0r8^TLjV8(8FWQhbW?9;ba!ELWdL_~cP?peYja~^
zaAhuUa%Y?FJQ@H10Z>UqK~y-6t<$k;ltC25@pJEf1`Ba5QV1zhM4upqAQpm^*xT9&
zCQV8!3rq6=K8!&G#m+(t8%>oE6j_KSB(R&EIe(iJqMz=E%q?fm{O&N^iBigGt@X_I
zaYXC^pGzqpYOQnqSvek$uS<Fw5yw6I67UFk0z5CJyaVR8zXOkfQBVFZ5WU!68eBbZ
zaANx{aB1-21@M~fPo<QXeK-AIbk+6*c-RCyM>lPM0hU^U9WVjz49VxBKtvSVJGSpN
z0VOFjUjysSKuP<VxzZ9mh=`RT13eV{Ch4N2%dNmeNi#{SO~8n#z(+|pnt+l7yr{L_
zADSNmt^sr4b~Cirx^4R_u<$Jh70}s!W&03#(D%RpIak0fN$(@#^p~{@wx4C@7VtyT
zn~2zzbR=oI2;7)Xr^~b1Z1VeF*L7Di^JZpV1C}$h8;wRwKLPr&;lM+*=bZom002ov
JPDHLkV1l+Tz#;$u

literal 0
HcmV?d00001

diff --git a/data/themes/default/style.css b/data/themes/default/style.css
index 344aa0519..26b2dd14b 100644
--- a/data/themes/default/style.css
+++ b/data/themes/default/style.css
@@ -56,6 +56,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;
diff --git a/include/AutomationClip.h b/include/AutomationClip.h
index ceb5611c9..0b49978c7 100644
--- a/include/AutomationClip.h
+++ b/include/AutomationClip.h
@@ -46,6 +46,7 @@ class TimePos;
 namespace gui
 {
 class AutomationClipView;
+class AutomationEditor;
 } // namespace gui
 
 
@@ -111,6 +112,13 @@ public:
 
 	void 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 resetTangents(const int tick0, const int tick1);
+
 	void recordValue(TimePos time, float value);
 
 	TimePos setDragValue( const TimePos & time,
@@ -151,6 +159,17 @@ public:
 		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 +238,9 @@ private:
 	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 +252,7 @@ private:
 
 	friend class gui::AutomationClipView;
 	friend class AutomationNode;
+	friend class gui::AutomationEditor;
 
 } ;
 
@@ -261,6 +284,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();
diff --git a/include/AutomationEditor.h b/include/AutomationEditor.h
index ecefa8b26..dad0e4916 100644
--- a/include/AutomationEditor.h
+++ b/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 @@ public:
 	{
 		Draw,
 		Erase,
-		DrawOutValues
+		DrawOutValues,
+		EditTangents
 	};
 
 public slots:
@@ -118,6 +120,13 @@ protected:
 	inline void drawLevelTick(QPainter & p, int tick, float value);
 
 	timeMap::iterator getNodeAt(int x, int y, bool outValue = false, int r = 5);
+	/**
+	 * @brief Given a mouse X coordinate, returns a timeMap::iterator that points to
+	 *        the closest node.
+	 * @param Int X coordinate
+	 * @return timeMap::iterator with the closest node or timeMap.end() if there are no nodes.
+	 */
+	timeMap::iterator getClosestNode(int x);
 
 	void drawLine( int x0, float y0, int x1, float y1 );
 	bool fineTuneValue(timeMap::iterator node, bool editingOutValue);
@@ -133,6 +142,12 @@ protected slots:
 	void setEditMode(int mode);
 
 	void setProgressionType(AutomationClip::ProgressionType type);
+	/**
+	 * @brief This method handles the AutomationEditorWindow event of changing
+	 * progression types. After that, it calls updateEditTanButton so the edit
+	 * tangents button is updated accordingly
+	 * @param Int New progression type
+	 */
 	void setProgressionType(int type);
 	void setTension();
 
@@ -153,7 +168,9 @@ private:
 		EraseValues,
 		MoveOutValue,
 		ResetOutValues,
-		DrawLine
+		DrawLine,
+		MoveTangent,
+		ResetTangents
 	} ;
 
 	// some constants...
@@ -173,6 +190,7 @@ private:
 	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 +233,11 @@ private:
 	// 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 +248,7 @@ private:
 
 	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 +257,7 @@ private:
 	QBrush m_graphColor;
 	QColor m_nodeInValueColor;
 	QColor m_nodeOutValueColor;
+	QColor m_nodeTangentLineColor;
 	QBrush m_scaleColor;
 	QColor m_crossColor;
 	QColor m_backgroundShade;
@@ -285,8 +310,21 @@ protected slots:
 
 private slots:
 	void updateWindowTitle();
+	void setProgressionType(int progType);
+	/**
+	 * @brief The Edit Tangent edit mode should only be available for
+	 * Cubic Hermite progressions, so this method is responsable for disabling it
+	 * for other edit modes and reenabling it when it changes back to the Edit Tangent
+	 * mode.
+	 */
+	void updateEditTanButton();
 
 private:
+	QAction* m_drawAction;
+	QAction* m_eraseAction;
+	QAction* m_drawOutAction;
+	QAction* m_editTanAction;
+
 	QAction* m_discreteAction;
 	QAction* m_linearAction;
 	QAction* m_cubicHermiteAction;
diff --git a/include/AutomationNode.h b/include/AutomationNode.h
index a922109e6..60154332f 100644
--- a/include/AutomationNode.h
+++ b/include/AutomationNode.h
@@ -125,6 +125,22 @@ public:
 		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 @@ private:
 	// 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
diff --git a/src/core/AutomationClip.cpp b/src/core/AutomationClip.cpp
index 3b36f6b49..3bfc5cf8e 100644
--- a/src/core/AutomationClip.cpp
+++ b/src/core/AutomationClip.cpp
@@ -422,6 +422,32 @@ void AutomationClip::resetNodes(const int tick0, const int tick1)
 
 
 
+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(std::min(tick0, tick1));
+	TimePos end = TimePos(std::max(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 +493,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 +530,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 +843,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 +867,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 +896,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 +935,8 @@ void AutomationClip::loadSettings( const QDomElement & _this )
 	{
 		changeLength( len );
 	}
-	generateTangents();
+
+	if (shouldGenerateTangents) { generateTangents(); }
 }
 
 
@@ -1108,6 +1193,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
diff --git a/src/core/AutomationNode.cpp b/src/core/AutomationNode.cpp
index eee4df8d2..f15c28f80 100644
--- a/src/core/AutomationNode.cpp
+++ b/src/core/AutomationNode.cpp
@@ -37,7 +37,8 @@ AutomationNode::AutomationNode() :
 	m_inValue(0),
 	m_outValue(0),
 	m_inTangent(0),
-	m_outTangent(0)
+	m_outTangent(0),
+	m_lockedTangents(false)
 {
 }
 
@@ -47,7 +48,8 @@ AutomationNode::AutomationNode(AutomationClip* clip, float value, int pos) :
 	m_inValue(value),
 	m_outValue(value),
 	m_inTangent(0),
-	m_outTangent(0)
+	m_outTangent(0),
+	m_lockedTangents(false)
 {
 }
 
@@ -57,7 +59,8 @@ AutomationNode::AutomationNode(AutomationClip* clip, float inValue, float outVal
 	m_inValue(inValue),
 	m_outValue(outValue),
 	m_inTangent(0),
-	m_outTangent(0)
+	m_outTangent(0),
+	m_lockedTangents(false)
 {
 }
 
diff --git a/src/gui/editors/AutomationEditor.cpp b/src/gui/editors/AutomationEditor.cpp
index f98066bba..282c335df 100644
--- a/src/gui/editors/AutomationEditor.cpp
+++ b/src/gui/editors/AutomationEditor.cpp
@@ -68,6 +68,7 @@ namespace lmms::gui
 QPixmap * AutomationEditor::s_toolDraw = nullptr;
 QPixmap * AutomationEditor::s_toolErase = nullptr;
 QPixmap * AutomationEditor::s_toolDrawOut = nullptr;
+QPixmap * AutomationEditor::s_toolEditTangents = nullptr;
 QPixmap * AutomationEditor::s_toolMove = nullptr;
 QPixmap * AutomationEditor::s_toolYFlip = nullptr;
 QPixmap * AutomationEditor::s_toolXFlip = nullptr;
@@ -106,6 +107,7 @@ AutomationEditor::AutomationEditor() :
 	m_graphColor(Qt::SolidPattern),
 	m_nodeInValueColor(0, 0, 0),
 	m_nodeOutValueColor(0, 0, 0),
+	m_nodeTangentLineColor(0, 0, 0),
 	m_scaleColor(Qt::SolidPattern),
 	m_crossColor(0, 0, 0),
 	m_backgroundShade(0, 0, 0)
@@ -180,6 +182,10 @@ AutomationEditor::AutomationEditor() :
 	{
 		s_toolDrawOut = new QPixmap(embed::getIconPixmap("edit_draw_outvalue"));
 	}
+	if (s_toolEditTangents == nullptr)
+	{
+		s_toolEditTangents = new QPixmap(embed::getIconPixmap("edit_tangent"));
+	}
 	if (s_toolMove == nullptr)
 	{
 		s_toolMove = new QPixmap(embed::getIconPixmap("edit_move"));
@@ -470,6 +476,17 @@ void AutomationEditor::mousePressEvent( QMouseEvent* mouseEvent )
 			Engine::getSong()->setModified();
 		}
 	};
+	auto resetTangent = [this](timeMap::iterator node)
+	{
+		if (node != m_clip->getTimeMap().end())
+		{
+			// Unlock the tangents from that node
+			node.value().setLockedTangents(false);
+			// Recalculate the tangents
+			m_clip->generateTangents(node, 1);
+			Engine::getSong()->setModified();
+		}
+	};
 
 	// If we clicked inside the AutomationEditor viewport (where the nodes are represented)
 	if (mouseEvent->y() > TOP_MARGIN && mouseEvent->x() >= VALUES_WIDTH)
@@ -654,6 +671,47 @@ void AutomationEditor::mousePressEvent( QMouseEvent* mouseEvent )
 				}
 			break;
 			}
+			case EditMode::EditTangents:
+			{
+				if (!m_clip->canEditTangents())
+				{
+					update();
+					return;
+				}
+
+				m_clip->addJournalCheckPoint();
+
+				// Gets the closest node to the mouse click
+				timeMap::iterator node = getClosestNode(mouseEvent->x());
+
+				// Starts dragging a tangent
+				if (m_mouseDownLeft && node != tm.end())
+				{
+					// Lock the tangents from that node, so it can only be
+					// manually edited
+					node.value().setLockedTangents(true);
+
+					m_draggedTangentTick = POS(node);
+
+					// Are we dragging the out or in tangent?
+					m_draggedOutTangent = posTicks >= m_draggedTangentTick;
+
+					m_action = Action::MoveTangent;
+				}
+				// Resets node's tangent
+				else if (m_mouseDownRight)
+				{
+					// Resets tangent from node
+					resetTangent(node);
+
+					// Update the last clicked position so we reset all tangents from
+					// that point up to the point we release the mouse button
+					m_drawLastTick = posTicks;
+
+					m_action = Action::ResetTangents;
+				}
+			break;
+			}
 		}
 
 		update();
@@ -862,6 +920,51 @@ void AutomationEditor::mouseMoveEvent(QMouseEvent * mouseEvent )
 				}
 			break;
 			}
+			case EditMode::EditTangents:
+			{
+				// If we moved the mouse past the beginning correct the position in ticks
+				posTicks = std::max(posTicks, 0);
+
+				if (m_mouseDownLeft && m_action == Action::MoveTangent)
+				{
+					timeMap& tm = m_clip->getTimeMap();
+					auto it = tm.find(m_draggedTangentTick);
+
+					// Safety check
+					if (it == tm.end())
+					{
+						update();
+						return;
+					}
+
+					// Calculate new tangent
+					float y = m_draggedOutTangent
+						? yCoordOfLevel(OUTVAL(it))
+						: yCoordOfLevel(INVAL(it));
+					float dy = m_draggedOutTangent
+						? y - mouseEvent->y()
+						: mouseEvent->y() - y;
+					float dx = std::abs(posTicks - POS(it));
+					float newTangent = dy / std::max(dx, 1.0f);
+
+					if (m_draggedOutTangent)
+					{
+						it.value().setOutTangent(newTangent);
+					}
+					else
+					{
+						it.value().setInTangent(newTangent);
+					}
+				}
+				else if (m_mouseDownRight && m_action == Action::ResetTangents)
+				{
+					// Resets all tangents from the last clicked tick up to the current position tick
+					m_clip->resetTangents(m_drawLastTick, posTicks);
+
+					Engine::getSong()->setModified();
+				}
+			break;
+			}
 		}
 	}
 	else // If the mouse Y position is above the AutomationEditor viewport
@@ -937,6 +1040,43 @@ inline void AutomationEditor::drawAutomationPoint(QPainter & p, timeMap::iterato
 
 
 
+inline void AutomationEditor::drawAutomationTangents(QPainter& p, timeMap::iterator it)
+{
+	int x = xCoordOfTick(POS(it));
+	int y, tx, ty;
+
+	// The tangent value correlates the variation in the node value related to the increase
+	// in ticks. So to have a proportionate drawing of the tangent line, we need to find the
+	// relation between the number of pixels per tick and the number of pixels per value level.
+	float viewportHeight = (height() - SCROLLBAR_SIZE - 1) - TOP_MARGIN;
+	float pixelsPerTick = m_ppb / TimePos::ticksPerBar();
+	// std::abs just in case the topLevel is smaller than the bottomLevel for some reason
+	float pixelsPerLevel = std::abs(viewportHeight / (m_topLevel - m_bottomLevel));
+	float proportion = pixelsPerLevel / pixelsPerTick;
+
+	p.setPen(QPen(m_nodeTangentLineColor));
+	p.setBrush(QBrush(m_nodeTangentLineColor));
+
+	y = yCoordOfLevel(INVAL(it));
+	tx = x - 20;
+	ty = y + 20 * INTAN(it) * proportion;
+	p.drawLine(x, y, tx, ty);
+	p.setBrush(QBrush(m_nodeTangentLineColor.darker(200)));
+	p.drawEllipse(tx - 3, ty - 3, 6, 6);
+
+	p.setBrush(QBrush(m_nodeTangentLineColor));
+
+	y = yCoordOfLevel(OUTVAL(it));
+	tx = x + 20;
+	ty = y - 20 * OUTTAN(it) * proportion;
+	p.drawLine(x, y, tx, ty);
+	p.setBrush(QBrush(m_nodeTangentLineColor.darker(200)));
+	p.drawEllipse(tx - 3, ty - 3, 6, 6);
+}
+
+
+
+
 void AutomationEditor::paintEvent(QPaintEvent * pe )
 {
 	QStyleOption opt;
@@ -1197,6 +1337,11 @@ void AutomationEditor::paintEvent(QPaintEvent * pe )
 
 				// Draw circle
 				drawAutomationPoint(p, it);
+				// Draw tangents if necessary (only for manually edited tangents)
+				if (m_clip->canEditTangents() && LOCKEDTAN(it))
+				{
+					drawAutomationTangents(p, it);
+				}
 
 				++it;
 			}
@@ -1213,6 +1358,11 @@ void AutomationEditor::paintEvent(QPaintEvent * pe )
 			}
 			// Draw circle(the last one)
 			drawAutomationPoint(p, it);
+			// Draw tangents if necessary (only for manually edited tangents)
+			if (m_clip->canEditTangents() && LOCKEDTAN(it))
+			{
+				drawAutomationTangents(p, it);
+			}
 		}
 	}
 	else
@@ -1267,6 +1417,11 @@ void AutomationEditor::paintEvent(QPaintEvent * pe )
 			else { cursor = s_toolDrawOut; }
 			break;
 		}
+		case EditMode::EditTangents:
+		{
+			cursor = m_action == Action::MoveTangent ? s_toolMove : s_toolEditTangents;
+			break;
+		}
 	}
 	QPoint mousePosition = mapFromGlobal( QCursor::pos() );
 	if (cursor != nullptr && mousePosition.y() > TOP_MARGIN + SCROLLBAR_SIZE)
@@ -1819,6 +1974,49 @@ AutomationEditor::timeMap::iterator AutomationEditor::getNodeAt(int x, int y, bo
 	return tm.end();
 }
 
+AutomationEditor::timeMap::iterator AutomationEditor::getClosestNode(int x)
+{
+	// Remove the VALUES_WIDTH from the x position, so we have the actual viewport x
+	x -= VALUES_WIDTH;
+	// Convert the x position to the position in ticks
+	int posTicks = (x * TimePos::ticksPerBar() / m_ppb) + m_currentPosition;
+
+	// Get our pattern timeMap and create a iterator so we can check the nodes
+	timeMap& tm = m_clip->getTimeMap();
+
+	if (tm.isEmpty()) { return tm.end(); }
+
+	// Get the node with an equal or higher position
+	auto it = tm.lowerBound(posTicks);
+
+	// If there are no nodes equal or higher than the position return
+	// the one before it
+	if (it == tm.end())
+	{
+		--it;
+		return it;
+	}
+	// If the node returned is the first, return it
+	else if (it == tm.begin())
+	{
+		return it;
+	}
+	// Else return the closest node
+	else
+	{
+		// Distance from node to the right
+		int distanceRight = std::abs(POS(it) - posTicks);
+		// Distance from node to the left
+		int distanceLeft = std::abs(POS(--it) - posTicks);
+
+		if (distanceLeft >= distanceRight)
+		{
+			++it;
+		}
+		return it;
+	}
+}
+
 
 
 
@@ -1839,24 +2037,29 @@ AutomationEditorWindow::AutomationEditorWindow() :
 	DropToolBar *editActionsToolBar = addDropToolBarToTop(tr("Edit actions"));
 
 	auto editModeGroup = new ActionGroup(this);
-	QAction* drawAction = editModeGroup->addAction(embed::getIconPixmap("edit_draw"), tr("Draw mode (Shift+D)"));
-	drawAction->setShortcut(Qt::SHIFT | Qt::Key_D);
-	drawAction->setChecked(true);
+	m_drawAction = editModeGroup->addAction(embed::getIconPixmap("edit_draw"), tr("Draw mode (Shift+D)"));
+	m_drawAction->setShortcut(Qt::SHIFT | Qt::Key_D);
+	m_drawAction->setChecked(true);
 
-	QAction* eraseAction = editModeGroup->addAction(embed::getIconPixmap("edit_erase"), tr("Erase mode (Shift+E)"));
-	eraseAction->setShortcut(Qt::SHIFT | Qt::Key_E);
+	m_eraseAction = editModeGroup->addAction(embed::getIconPixmap("edit_erase"), tr("Erase mode (Shift+E)"));
+	m_eraseAction->setShortcut(Qt::SHIFT | Qt::Key_E);
 
-	QAction* drawOutAction = editModeGroup->addAction(embed::getIconPixmap("edit_draw_outvalue"), tr("Draw outValues mode (Shift+C)"));
-	drawOutAction->setShortcut(Qt::SHIFT | Qt::Key_C);
+	m_drawOutAction = editModeGroup->addAction(embed::getIconPixmap("edit_draw_outvalue"), tr("Draw outValues mode (Shift+C)"));
+	m_drawOutAction->setShortcut(Qt::SHIFT | Qt::Key_C);
+
+	m_editTanAction = editModeGroup->addAction(embed::getIconPixmap("edit_tangent"), tr("Edit tangents mode (Shift+T)"));
+	m_editTanAction->setShortcut(Qt::SHIFT | Qt::Key_T);
+	m_editTanAction->setEnabled(false);
 
 	m_flipYAction = new QAction(embed::getIconPixmap("flip_y"), tr("Flip vertically"), this);
 	m_flipXAction = new QAction(embed::getIconPixmap("flip_x"), tr("Flip horizontally"), this);
 
 	connect(editModeGroup, SIGNAL(triggered(int)), m_editor, SLOT(setEditMode(int)));
 
-	editActionsToolBar->addAction(drawAction);
-	editActionsToolBar->addAction(eraseAction);
-	editActionsToolBar->addAction(drawOutAction);
+	editActionsToolBar->addAction(m_drawAction);
+	editActionsToolBar->addAction(m_eraseAction);
+	editActionsToolBar->addAction(m_drawOutAction);
+	editActionsToolBar->addAction(m_editTanAction);
 	editActionsToolBar->addAction(m_flipXAction);
 	editActionsToolBar->addAction(m_flipYAction);
 
@@ -1874,7 +2077,7 @@ AutomationEditorWindow::AutomationEditorWindow() :
 	m_cubicHermiteAction = progression_type_group->addAction(
 				embed::getIconPixmap("progression_cubic_hermite"), tr( "Cubic Hermite progression"));
 
-	connect(progression_type_group, SIGNAL(triggered(int)), m_editor, SLOT(setProgressionType(int)));
+	connect(progression_type_group, SIGNAL(triggered(int)), this, SLOT(setProgressionType(int)));
 
 	// setup tension-stuff
 	m_tensionKnob = new Knob( KnobType::Small17, this, "Tension" );
@@ -2014,6 +2217,7 @@ void AutomationEditorWindow::setCurrentClip(AutomationClip* clip)
 		connect(m_flipYAction, SIGNAL(triggered()), clip, SLOT(flipY()));
 	}
 
+	updateEditTanButton();
 	emit currentClipChanged();
 }
 
@@ -2102,5 +2306,17 @@ void AutomationEditorWindow::updateWindowTitle()
 	setWindowTitle( tr( "Automation Editor - %1" ).arg( m_editor->m_clip->name() ) );
 }
 
+void AutomationEditorWindow::setProgressionType(int progType)
+{
+	m_editor->setProgressionType(progType);
+	updateEditTanButton();
+}
+
+void AutomationEditorWindow::updateEditTanButton()
+{
+	auto progType = currentClip()->progressionType();
+	m_editTanAction->setEnabled(AutomationClip::supportsTangentEditing(progType));
+	if (!m_editTanAction->isEnabled() && m_editTanAction->isChecked()) { m_drawAction->trigger(); }
+}
 
 } // namespace lmms::gui