diff --git a/src/timeline2/model/timelinemodel.hpp b/src/timeline2/model/timelinemodel.hpp
index 8eea22365..010df549b 100644
--- a/src/timeline2/model/timelinemodel.hpp
+++ b/src/timeline2/model/timelinemodel.hpp
@@ -1,791 +1,793 @@
/***************************************************************************
* Copyright (C) 2017 by Nicolas Carion *
* 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 . *
***************************************************************************/
#ifndef TIMELINEMODEL_H
#define TIMELINEMODEL_H
#include "definitions.h"
#include "undohelper.hpp"
#include
#include
#include
#include
#include
#include
#include
#include
class AssetParameterModel;
class EffectStackModel;
class ClipModel;
class CompositionModel;
class DocUndoStack;
class GroupsModel;
class SnapModel;
class TimelineItemModel;
class TrackModel;
/* @brief This class represents a Timeline object, as viewed by the backend.
In general, the Gui associated with it will send modification queries (such as resize or move), and this class authorize them or not depending on the
validity of the modifications.
This class also serves to keep track of all objects. It holds pointers to all tracks and clips, and gives them unique IDs on creation. These Ids are used in
any interactions with the objects and have nothing to do with Melt IDs.
This is the entry point for any modifications that has to be made on an element. The dataflow beyond this entry point may vary, for example when the user
request a clip resize, the call is deferred to the clip itself, that check if there is enough data to extend by the requested amount, compute the new in and
out, and then asks the track if there is enough room for extension. To avoid any confusion on which function to call first, rembember to always call the
version in timeline. This is also required to generate the Undo/Redo operators
The undo/redo system is designed around lambda functions. Each time a function executes an elementary change to the model, it writes the corresponding
operation and its reverse, respectively in the redo and the undo lambdas. This way, if an operation fails for some reason, we can easily cancel the steps
that have been done so far without corrupting anything. The other advantage is that operations are easy to compose, and you get a undo/redo pair for free no
matter in which way you combine them.
Most of the modification functions are named requestObjectAction. Eg, if the object is a clip and we want to move it, we call requestClipMove. These
functions always return a bool indicating success, and when they return false they should guarantee than nothing has been modified. Most of the time, these
functions come in two versions: the first one is the entry point if you want to perform only the action (and not compose it with other actions). This version
will generally automatically push and Undo object on the Application stack, in case the user later wants to cancel the operation. It also generally goes the
extra mile to ensure the operation is done in a way that match the user's expectation: for example requestClipMove checks whether the clip belongs to a group
and in that case actually mouves the full group. The other version of the function, if it exists, is intended for composition (using the action as part of a
complex operation). It takes as input the undo/redo lambda corresponding to the action that is being performed and accumulates on them. Note that this
version does the minimal job: in the example of the requestClipMove, it will not move the full group if the clip is in a group.
Generally speaking, we don't check ahead of time if an action is going to succeed or not before applying it.
We just apply it naively, and if it fails at some point, we use the undo operator that we are constructing on the fly to revert what we have done so far.
For example, when we move a group of clips, we apply the move operation to all the clips inside this group (in the right order). If none fails, we are good,
otherwise we revert what we've already done.
This kind of behaviour frees us from the burden of simulating the actions before actually applying theme. This is a good thing because this simulation step
would be very sensitive to corruptions and small discrepancies, which we try to avoid at all cost.
It derives from AbstractItemModel (indirectly through TimelineItemModel) to provide the model to the QML interface. An itemModel is organized with row and
columns that contain the data. It can be hierarchical, meaning that a given index (row,column) can contain another level of rows and column.
Our organization is as follows: at the top level, each row contains a track. These rows are in the same order as in the actual timeline.
Then each of this row contains itself sub-rows that correspond to the clips.
Here the order of these sub-rows is unrelated to the chronological order of the clips,
but correspond to their Id order. For example, if you have three clips, with ids 12, 45 and 150, they will receive row index 0,1 and 2.
This is because the order actually doesn't matter since the clips are rendered based on their positions rather than their row order.
The id order has been chosen because it is consistent with a valid ordering of the clips.
The columns are never used, so the data is always in column 0
An ModelIndex in the ItemModel consists of a row number, a column number, and a parent index. In our case, tracks have always an empty parent, and the clip
have a track index as parent.
A ModelIndex can also store one additional integer, and we exploit this feature to store the unique ID of the object it corresponds to.
*/
class TimelineModel : public QAbstractItemModel_shared_from_this
{
Q_OBJECT
protected:
/* @brief this constructor should not be called. Call the static construct instead
*/
TimelineModel(Mlt::Profile *profile, std::weak_ptr undo_stack);
public:
friend class TrackModel;
template friend class MoveableItem;
friend class ClipModel;
friend class CompositionModel;
friend class GroupsModel;
friend class TimelineController;
friend struct TimelineFunctions;
/// Two level model: tracks and clips on track
enum {
NameRole = Qt::UserRole + 1,
ResourceRole, /// clip only
ServiceRole, /// clip only
StartRole, /// clip only
BinIdRole, /// clip only
TrackIdRole,
FakeTrackIdRole,
FakePositionRole,
MarkersRole, /// clip only
StatusRole, /// clip only
TypeRole, /// clip only
KeyframesRole,
DurationRole,
InPointRole, /// clip only
OutPointRole, /// clip only
FramerateRole, /// clip only
GroupedRole, /// clip only
HasAudio, /// clip only
CanBeAudioRole, /// clip only
CanBeVideoRole, /// clip only
IsDisabledRole, /// track only
IsAudioRole,
SortRole,
ShowKeyframesRole,
- AudioLevelsRole, /// clip only
- AudioChannelsRole, /// clip only
- IsCompositeRole, /// track only
- IsLockedRole, /// track only
- HeightRole, /// track only
- TrackTagRole, /// track only
- FadeInRole, /// clip only
- FadeOutRole, /// clip only
- FileHashRole, /// clip only
- SpeedRole, /// clip only
- ReloadThumbRole, /// clip only
- PositionOffsetRole,/// clip only
- ItemATrack, /// composition only
+ AudioLevelsRole, /// clip only
+ AudioChannelsRole, /// clip only
+ IsCompositeRole, /// track only
+ IsLockedRole, /// track only
+ HeightRole, /// track only
+ TrackTagRole, /// track only
+ FadeInRole, /// clip only
+ FadeOutRole, /// clip only
+ FileHashRole, /// clip only
+ SpeedRole, /// clip only
+ ReloadThumbRole, /// clip only
+ PositionOffsetRole, /// clip only
+ ItemATrack, /// composition only
ItemIdRole,
ThumbsFormatRole, /// track only
EffectNamesRole, // track and clip only
EffectsEnabledRole, // track and clip only
GrabbedRole, /// clip+composition only
TrackActiveRole, /// track only
AudioRecordRole /// track only
};
~TimelineModel() override;
Mlt::Tractor *tractor() const { return m_tractor.get(); }
/* @brief Load tracks from the current tractor, used on project opening
*/
void loadTractor();
/* @brief Returns the current tractor's producer, useful fo control seeking, playing, etc
*/
std::shared_ptr producer();
Mlt::Profile *getProfile();
/* @brief returns the number of tracks */
int getTracksCount() const;
/* @brief returns the track index (id) from its position */
int getTrackIndexFromPosition(int pos) const;
/* @brief returns the track index (id) from its position */
Q_INVOKABLE bool isAudioTrack(int trackId) const;
/* @brief returns the number of clips */
int getClipsCount() const;
/* @brief returns the number of compositions */
int getCompositionsCount() const;
/* @brief Returns the id of the track containing clip (-1 if it is not inserted)
@param clipId Id of the clip to test */
Q_INVOKABLE int getClipTrackId(int clipId) const;
/* @brief Returns the id of the track containing composition (-1 if it is not inserted)
@param clipId Id of the composition to test */
Q_INVOKABLE int getCompositionTrackId(int compoId) const;
/* @brief Convenience function that calls either of the previous ones based on item type*/
Q_INVOKABLE int getItemTrackId(int itemId) const;
Q_INVOKABLE int getCompositionPosition(int compoId) const;
int getCompositionPlaytime(int compoId) const;
/* Returns an item position, item can be clip or composition */
Q_INVOKABLE int getItemPosition(int itemId) const;
/* Returns an item duration, item can be clip or composition */
int getItemPlaytime(int itemId) const;
/* Returns the current speed of a clip */
double getClipSpeed(int clipId) const;
/* @brief Helper function to query the amount of free space around a clip
* @param clipId: the queried clip. If it is not inserted on a track, this functions returns 0
* @param after: if true, we return the blank after the clip, otherwise, before.
*/
int getBlankSizeNearClip(int clipId, bool after) const;
/* @brief if the clip belongs to a AVSplit group, then return the id of the other corresponding clip. Otherwise, returns -1 */
int getClipSplitPartner(int clipId) const;
/* @brief Helper function that returns true if the given ID corresponds to a clip */
Q_INVOKABLE bool isClip(int id) const;
/* @brief Helper function that returns true if the given ID corresponds to a composition */
Q_INVOKABLE bool isComposition(int id) const;
/* @brief Helper function that returns true if the given ID corresponds to a timeline item (composition or clip) */
Q_INVOKABLE bool isItem(int id) const;
/* @brief Helper function that returns true if the given ID corresponds to a track */
Q_INVOKABLE bool isTrack(int id) const;
/* @brief Helper function that returns true if the given ID corresponds to a group */
Q_INVOKABLE bool isGroup(int id) const;
/* @brief Given a composition Id, returns its underlying parameter model */
std::shared_ptr getCompositionParameterModel(int compoId) const;
/* @brief Given a clip Id, returns its underlying effect stack model */
std::shared_ptr getClipEffectStackModel(int clipId) const;
/* @brief Returns the position of clip (-1 if it is not inserted)
@param clipId Id of the clip to test
*/
Q_INVOKABLE int getClipPosition(int clipId) const;
Q_INVOKABLE bool addClipEffect(int clipId, const QString &effectId, bool notify = true);
Q_INVOKABLE bool addTrackEffect(int trackId, const QString &effectId);
bool removeFade(int clipId, bool fromStart);
Q_INVOKABLE bool copyClipEffect(int clipId, const QString &sourceId);
Q_INVOKABLE bool copyTrackEffect(int trackId, const QString &sourceId);
bool adjustEffectLength(int clipId, const QString &effectId, int duration, int initialDuration);
/* @brief Returns the closest snap point within snapDistance
*/
Q_INVOKABLE int suggestSnapPoint(int pos, int snapDistance);
/** @brief Return the previous track of same type as source trackId, or trackId if no track found */
Q_INVOKABLE int getPreviousTrackId(int trackId);
/** @brief Return the next track of same type as source trackId, or trackId if no track found */
Q_INVOKABLE int getNextTrackId(int trackId);
/* @brief Returns the in cut position of a clip
@param clipId Id of the clip to test
*/
int getClipIn(int clipId) const;
/* @brief Returns the clip state (audio/video only)
*/
PlaylistState::ClipState getClipState(int clipId) const;
/* @brief Returns the bin id of the clip master
@param clipId Id of the clip to test
*/
const QString getClipBinId(int clipId) const;
/* @brief Returns the duration of a clip
@param clipId Id of the clip to test
*/
int getClipPlaytime(int clipId) const;
/* @brief Returns the size of the clip's frame (widthxheight)
@param clipId Id of the clip to test
*/
QSize getClipFrameSize(int clipId) const;
/* @brief Returns the number of clips in a given track
@param trackId Id of the track to test
*/
int getTrackClipsCount(int trackId) const;
/* @brief Returns the number of compositions in a given track
@param trackId Id of the track to test
*/
int getTrackCompositionsCount(int trackId) const;
/* @brief Returns the position of the track in the order of the tracks
@param trackId Id of the track to test
*/
int getTrackPosition(int trackId) const;
/* @brief Returns the track's index in terms of mlt's internal representation
*/
int getTrackMltIndex(int trackId) const;
/* @brief Returns a sort position for tracks.
* @param separated: if true, the tracks will be sorted like: V2,V1,A1,A2
* Otherwise, the tracks will be sorted like V2,A2,V1,A1
*/
int getTrackSortValue(int trackId, bool separated) const;
/* @brief Returns the ids of the tracks below the given track in the order of the tracks
Returns an empty list if no track available
@param trackId Id of the track to test
*/
QList getLowerTracksId(int trackId, TrackType type = TrackType::AnyTrack) const;
/* @brief Returns the MLT track index of the video track just below the given track
@param trackId Id of the track to test
*/
int getPreviousVideoTrackPos(int trackId) const;
/* @brief Returns the Track id of the video track just below the given track
@param trackId Id of the track to test
*/
int getPreviousVideoTrackIndex(int trackId) const;
/* @brief Returns the Id of the corresponding audio track. If trackId corresponds to video1, this will return audio 1 and so on */
int getMirrorAudioTrackId(int trackId) const;
int getMirrorVideoTrackId(int trackId) const;
int getMirrorTrackId(int trackId) const;
/* @brief Move a clip to a specific position
This action is undoable
Returns true on success. If it fails, nothing is modified.
If the clip is not in inserted in a track yet, it gets inserted for the first time.
If the clip is in a group, the call is deferred to requestGroupMove
@param clipId is the ID of the clip
@param trackId is the ID of the target track
@param position is the position where we want to move
@param updateView if set to false, no signal is sent to qml
@param logUndo if set to false, no undo object is stored
*/
Q_INVOKABLE bool requestClipMove(int clipId, int trackId, int position, bool updateView = true, bool logUndo = true, bool invalidateTimeline = false);
/* @brief Move a composition to a specific position This action is undoable
Returns true on success. If it fails, nothing is modified. If the clip is
not in inserted in a track yet, it gets inserted for the first time. If
the clip is in a group, the call is deferred to requestGroupMove @param
transid is the ID of the composition @param trackId is the ID of the
track */
Q_INVOKABLE bool requestCompositionMove(int compoId, int trackId, int position, bool updateView = true, bool logUndo = true);
/* Same function, but accumulates undo and redo, and doesn't check
for group*/
bool requestClipMove(int clipId, int trackId, int position, bool updateView, bool invalidateTimeline, Fun &undo, Fun &redo);
bool requestCompositionMove(int transid, int trackId, int compositionTrack, int position, bool updateView, bool finalMove, Fun &undo, Fun &redo);
/* When timeline edit mode is insert or overwrite, we fake the move (as it will overlap existing clips, and only process the real move on drop */
bool requestFakeClipMove(int clipId, int trackId, int position, bool updateView, bool invalidateTimeline, Fun &undo, Fun &redo);
bool requestFakeClipMove(int clipId, int trackId, int position, bool updateView, bool logUndo, bool invalidateTimeline);
bool requestFakeGroupMove(int clipId, int groupId, int delta_track, int delta_pos, bool updateView = true, bool logUndo = true);
bool requestFakeGroupMove(int clipId, int groupId, int delta_track, int delta_pos, bool updateView, bool finalMove, Fun &undo, Fun &redo,
bool allowViewRefresh = true);
/* @brief Given an intended move, try to suggest a more valid one
(accounting for snaps and missing UI calls)
@param clipId id of the clip to
move
@param trackId id of the target track
@param position target position
@param snapDistance the maximum distance for a snap result, -1 for no snapping
of the clip
@param dontRefreshMasterClip when false, no view refresh is attempted
*/
Q_INVOKABLE int suggestItemMove(int itemId, int trackId, int position, int cursorPosition, int snapDistance = -1);
Q_INVOKABLE int suggestClipMove(int clipId, int trackId, int position, int cursorPosition, int snapDistance = -1);
Q_INVOKABLE int suggestCompositionMove(int compoId, int trackId, int position, int cursorPosition, int snapDistance = -1);
/* @brief Request clip insertion at given position. This action is undoable
Returns true on success. If it fails, nothing is modified.
@param binClipId id of the clip in the bin
@param track Id of the track where to insert
@param position Requested position
@param ID return parameter of the id of the inserted clip
@param logUndo if set to false, no undo object is stored
@param refreshView whether the view should be refreshed
@param useTargets: if true, the Audio/video split will occur on the set targets. Otherwise, they will be computed as an offset from the middle line
*/
bool requestClipInsertion(const QString &binClipId, int trackId, int position, int &id, bool logUndo = true, bool refreshView = false,
bool useTargets = true);
/* Same function, but accumulates undo and redo*/
bool requestClipInsertion(const QString &binClipId, int trackId, int position, int &id, bool logUndo, bool refreshView, bool useTargets, Fun &undo,
Fun &redo);
protected:
/* @brief Creates a new clip instance without inserting it.
This action is undoable, returns true on success
@param binClipId: Bin id of the clip to insert
@param id: return parameter for the id of the newly created clip.
@param state: The desired clip state (original, audio/video only).
*/
bool requestClipCreation(const QString &binClipId, int &id, PlaylistState::ClipState state, double speed, Fun &undo, Fun &redo);
public:
/* @brief Deletes the given clip or composition from the timeline.
This action is undoable.
Returns true on success. If it fails, nothing is modified.
If the clip/composition is in a group, the call is deferred to requestGroupDeletion
@param clipId is the ID of the clip/composition
@param logUndo if set to false, no undo object is stored */
Q_INVOKABLE bool requestItemDeletion(int itemId, bool logUndo = true);
/* Same function, but accumulates undo and redo*/
bool requestItemDeletion(int itemId, Fun &undo, Fun &redo);
/* @brief Move a group to a specific position
This action is undoable
Returns true on success. If it fails, nothing is modified.
If the clips in the group are not in inserted in a track yet, they get inserted for the first time.
@param clipId is the id of the clip that triggers the group move
@param groupId is the id of the group
@param delta_track is the delta applied to the track index
@param delta_pos is the requested position change
@param updateView if set to false, no signal is sent to qml for the clip clipId
@param logUndo if set to true, an undo object is created
@param allowViewRefresh if false, the view will never get updated (useful for suggestMove)
*/
bool requestGroupMove(int itemId, int groupId, int delta_track, int delta_pos, bool updateView = true, bool logUndo = true);
bool requestGroupMove(int itemId, int groupId, int delta_track, int delta_pos, bool updateView, bool finalMove, Fun &undo, Fun &redo,
bool allowViewRefresh = true);
/* @brief Deletes all clips inside the group that contains the given clip.
This action is undoable
Note that if their is a hierarchy of groups, all of them will be deleted.
Returns true on success. If it fails, nothing is modified.
@param clipId is the id of the clip that triggers the group deletion
*/
Q_INVOKABLE bool requestGroupDeletion(int clipId, bool logUndo = true);
bool requestGroupDeletion(int clipId, Fun &undo, Fun &redo);
/* @brief Change the duration of an item (clip or composition)
This action is undoable
Returns the real size reached (can be different, if snapping occurs).
If it fails, nothing is modified, and -1 is returned
@param itemId is the ID of the item
@param size is the new size of the item
@param right is true if we change the right side of the item, false otherwise
@param logUndo if set to true, an undo object is created
@param snap if set to true, the resize order will be coerced to use the snapping grid
+ if @param allowSingleResize is false, then the resize will also be applied to any clip in the same AV group (allow resizing audio and video at the same
+ time)
*/
Q_INVOKABLE int requestItemResize(int itemId, int size, bool right, bool logUndo = true, int snapDistance = -1, bool allowSingleResize = false);
/* Same function, but accumulates undo and redo and doesn't deal with snapping*/
bool requestItemResize(int itemId, int size, bool right, bool logUndo, Fun &undo, Fun &redo, bool blockUndo = false);
/* @brief Group together a set of ids
The ids are either a group ids or clip ids. The involved clip must already be inserted in a track
This action is undoable
Returns the group id on success, -1 if it fails and nothing is modified.
Typically, ids would be ids of clips, but for convenience, some of them can be ids of groups as well.
@param ids Set of ids to group
*/
int requestClipsGroup(const std::unordered_set &ids, bool logUndo = true, GroupType type = GroupType::Normal);
int requestClipsGroup(const std::unordered_set &ids, Fun &undo, Fun &redo, GroupType type = GroupType::Normal);
/* @brief Destruct the topmost group containing clip
This action is undoable
Returns true on success. If it fails, nothing is modified.
@param id of the clip to degroup (all clips belonging to the same group will be ungrouped as well)
*/
bool requestClipUngroup(int itemId, bool logUndo = true);
/* Same function, but accumulates undo and redo*/
bool requestClipUngroup(int itemId, Fun &undo, Fun &redo);
// convenience functions for several ids at the same time
bool requestClipsUngroup(const std::unordered_set &itemIds, bool logUndo = true);
/* @brief Create a track at given position
This action is undoable
Returns true on success. If it fails, nothing is modified.
@param Requested position (order). If set to -1, the track is inserted last.
@param id is a return parameter that holds the id of the resulting track (-1 on failure)
*/
bool requestTrackInsertion(int pos, int &id, const QString &trackName = QString(), bool audioTrack = false);
/* Same function, but accumulates undo and redo*/
bool requestTrackInsertion(int pos, int &id, const QString &trackName, bool audioTrack, Fun &undo, Fun &redo, bool updateView = true);
/* @brief Delete track with given id
This also deletes all the clips contained in the track.
This action is undoable
Returns true on success. If it fails, nothing is modified.
@param trackId id of the track to delete
*/
bool requestTrackDeletion(int trackId);
/* Same function, but accumulates undo and redo*/
bool requestTrackDeletion(int trackId, Fun &undo, Fun &redo);
/* @brief Get project duration
Returns the duration in frames
*/
int duration() const;
static int seekDuration; // Duration after project end where seeking is allowed
/* @brief Get all the elements of the same group as the given clip.
If there is a group hierarchy, only the topmost group is considered.
@param clipId id of the clip to test
*/
std::unordered_set getGroupElements(int clipId);
/* @brief Removes all the elements on the timeline (tracks and clips)
*/
bool requestReset(Fun &undo, Fun &redo);
/* @brief Updates the current the pointer to the current undo_stack
Must be called for example when the doc change
*/
void setUndoStack(std::weak_ptr undo_stack);
protected:
/* @brief Requests the best snapped position for a clip
@param pos is the clip's requested position
@param length is the clip's duration
@param pts snap points to ignore (for example currently moved clip)
@param snapDistance the maximum distance for a snap result, -1 for no snapping
@returns best snap position or -1 if no snap point is near
*/
int getBestSnapPos(int pos, int length, const std::vector &pts = std::vector(), int cursorPosition = 0, int snapDistance = -1);
public:
/* @brief Requests the next snapped point
@param pos is the current position
*/
int getNextSnapPos(int pos);
/* @brief Requests the previous snapped point
@param pos is the current position
*/
int getPreviousSnapPos(int pos);
/* @brief Add a new snap point
@param pos is the current position
*/
void addSnap(int pos);
/* @brief Remove snap point
@param pos is the current position
*/
void removeSnap(int pos);
/* @brief Request composition insertion at given position.
This action is undoable
Returns true on success. If it fails, nothing is modified.
@param transitionId Identifier of the Mlt transition to insert (as given by repository)
@param track Id of the track where to insert
@param position Requested position
@param length Requested initial length.
@param id return parameter of the id of the inserted composition
@param logUndo if set to false, no undo object is stored
*/
bool requestCompositionInsertion(const QString &transitionId, int trackId, int position, int length, std::unique_ptr transProps, int &id,
bool logUndo = true);
/* Same function, but accumulates undo and redo*/
bool requestCompositionInsertion(const QString &transitionId, int trackId, int compositionTrack, int position, int length,
std::unique_ptr transProps, int &id, Fun &undo, Fun &redo, bool finalMove = false);
/* @brief This function change the global (timeline-wise) enabled state of the effects
It disables/enables track and clip effects (recursively)
*/
void setTimelineEffectsEnabled(bool enabled);
/* @brief Get a timeline clip id by its position or -1 if not found
*/
int getClipByPosition(int trackId, int position) const;
/* @brief Get a timeline composition id by its starting position or -1 if not found
*/
int getCompositionByPosition(int trackId, int position) const;
/* @brief Returns a list of all items that are intersect with a given range.
* @param trackId is the id of the track for concerned items. Setting trackId to -1 returns items on all tracks
* @param start is the position where we the items should start
* @param end is the position after which items will not be selected, set to -1 to get all clips on track
* @param listCompositions if enabled, the list will also contains composition ids
*/
std::unordered_set getItemsInRange(int trackId, int start, int end = -1, bool listCompositions = true);
/* @brief Returns a list of all luma files used in the project
*/
QStringList extractCompositionLumas() const;
/* @brief Inform asset view of duration change
*/
virtual void adjustAssetRange(int clipId, int in, int out);
void requestClipReload(int clipId);
void requestClipUpdate(int clipId, const QVector &roles);
/** @brief define current edit mode (normal, insert, overwrite */
void setEditMode(TimelineMode::EditMode mode);
Q_INVOKABLE bool normalEdit() const;
/** @brief Returns the effectstack of a given clip. */
std::shared_ptr getClipEffectStack(int itemId);
std::shared_ptr getTrackEffectStackModel(int trackId);
/** @brief Add slowmotion effect to clip in timeline.
@param clipId id of the target clip
@param speed: speed in percentage. 100 corresponds to original speed, 50 to half the speed
This functions create an undo object and also apply the effect to the corresponding audio if there is any.
Returns true on success, false otherwise (and nothing is modified)
*/
bool requestClipTimeWarp(int clipId, double speed);
/* @brief Same function as above, but doesn't check for paired audio and accumulate undo/redo
*/
bool requestClipTimeWarp(int clipId, double speed, Fun &undo, Fun &redo);
void replugClip(int clipId);
/** @brief Refresh the tractor profile in case a change was requested. */
void updateProfile(Mlt::Profile *profile);
/** @brief Clear the current selection
@param onDeletion is true when the selection is cleared as a result of a deletion
*/
Q_INVOKABLE bool requestClearSelection(bool onDeletion = false);
// same function with undo/redo accumulation
void requestClearSelection(bool onDeletion, Fun &undo, Fun &redo);
/** @brief Add the given item to the selection
If @param clear is true, the selection is first cleared
*/
Q_INVOKABLE void requestAddToSelection(int itemId, bool clear = false);
/** @brief Remove the given item from the selection */
Q_INVOKABLE void requestRemoveFromSelection(int itemId);
/** @brief Set the selection to the set of given ids */
bool requestSetSelection(const std::unordered_set &ids);
// same function with undo/redo
bool requestSetSelection(const std::unordered_set &ids, Fun &undo, Fun &redo);
/** @brief Returns a set containing all the items in the selection */
std::unordered_set getCurrentSelection() const;
protected:
/* @brief Register a new track. This is a call-back meant to be called from TrackModel
@param pos indicates the number of the track we are adding. If this is -1, then we add at the end.
*/
void registerTrack(std::shared_ptr track, int pos = -1, bool doInsert = true, bool reloadView = true);
/* @brief Register a new clip. This is a call-back meant to be called from ClipModel
*/
void registerClip(const std::shared_ptr &clip, bool registerProducer = false);
/* @brief Register a new composition. This is a call-back meant to be called from CompositionModel
*/
void registerComposition(const std::shared_ptr &composition);
/* @brief Register a new group. This is a call-back meant to be called from GroupsModel
*/
void registerGroup(int groupId);
/* @brief Deregister and destruct the track with given id.
@parame updateView Whether to send updates to the model. Must be false when called from a constructor/destructor
*/
Fun deregisterTrack_lambda(int id, bool updateView = false);
/* @brief Return a lambda that deregisters and destructs the clip with given id.
Note that the clip must already be deleted from its track and groups.
*/
Fun deregisterClip_lambda(int id);
/* @brief Return a lambda that deregisters and destructs the composition with given id.
*/
Fun deregisterComposition_lambda(int compoId);
/* @brief Deregister a group with given id
*/
void deregisterGroup(int id);
/* @brief Helper function to get a pointer to the track, given its id
*/
std::shared_ptr getTrackById(int trackId);
const std::shared_ptr getTrackById_const(int trackId) const;
/*@brief Helper function to get a pointer to a clip, given its id*/
std::shared_ptr getClipPtr(int clipId) const;
/*@brief Helper function to get a pointer to a composition, given its id*/
std::shared_ptr getCompositionPtr(int compoId) const;
/* @brief Returns next valid unique id to create an object
*/
static int getNextId();
/* @brief unplant and the replant all the compositions in the correct order
@param currentCompo is the id of a compo that have not yet been planted, if any. Otherwise send -1
*/
bool replantCompositions(int currentCompo, bool updateView);
/* @brief Unplant the composition with given Id */
bool unplantComposition(int compoId);
/* Internal functions to delete a clip or a composition. In general, you should call requestItemDeletion */
bool requestClipDeletion(int clipId, Fun &undo, Fun &redo);
bool requestCompositionDeletion(int compositionId, Fun &undo, Fun &redo);
/** @brief Check tracks duration and update black track accordingly */
void updateDuration();
/** @brief Get a track tag (A1, V1, V2,...) through its id */
const QString getTrackTagById(int trackId) const;
/** @brief Attempt to make a clip move without ever updating the view */
bool requestClipMoveAttempt(int clipId, int trackId, int position);
public:
/* @brief Debugging function that checks consistency with Mlt objects */
bool checkConsistency();
protected:
/* @brief Refresh project monitor if cursor was inside range */
void checkRefresh(int start, int end);
/* @brief Send signal to require clearing effet/composition view */
void clearAssetView(int itemId);
bool m_blockRefresh;
signals:
/* @brief signal triggered by clearAssetView */
void requestClearAssetView(int);
void requestMonitorRefresh();
/* @brief signal triggered by track operations */
void invalidateZone(int in, int out);
/* @brief signal triggered when a track duration changed (insertion/deletion) */
void durationUpdated();
/* @brief Signal sent whenever the selection changes */
void selectionChanged();
protected:
std::unique_ptr m_tractor;
std::list> m_allTracks;
std::unordered_map>::iterator>
m_iteratorTable; // this logs the iterator associated which each track id. This allows easy access of a track based on its id.
std::unordered_map> m_allClips; // the keys are the clip id, and the values are the corresponding pointers
std::unordered_map>
m_allCompositions; // the keys are the composition id, and the values are the corresponding pointers
static int next_id; // next valid id to assign
std::unique_ptr m_groups;
std::shared_ptr m_snaps;
std::unordered_set m_allGroups; // ids of all the groups
std::weak_ptr m_undoStack;
Mlt::Profile *m_profile;
// The black track producer. Its length / out should always be adjusted to the projects's length
std::unique_ptr m_blackClip;
mutable QReadWriteLock m_lock; // This is a lock that ensures safety in case of concurrent access
bool m_timelineEffectsEnabled;
bool m_id; // id of the timeline itself
// id of the selection. If -1, there is no selection, if positive, then it might either be the id of the selection group, or the id of an individual
// item, or, finally, the id of a group which is not of type selection. The last case happens when the selection exactly matches an existing group
// (in that case we cannot further group it because the selection would have only one child, which is prohibited by design)
int m_currentSelection = -1;
// The index of the temporary overlay track in tractor, or -1 if not connected
int m_overlayTrackCount;
// The preferred audio target for clip insertion or -1 if not defined
int m_audioTarget;
// The preferred video target for clip insertion or -1 if not defined
int m_videoTarget;
// Timeline editing mode
TimelineMode::EditMode m_editMode;
// what follows are some virtual function that corresponds to the QML. They are implemented in TimelineItemModel
protected:
virtual void _beginRemoveRows(const QModelIndex &, int, int) = 0;
virtual void _beginInsertRows(const QModelIndex &, int, int) = 0;
virtual void _endRemoveRows() = 0;
virtual void _endInsertRows() = 0;
virtual void notifyChange(const QModelIndex &topleft, const QModelIndex &bottomright, bool start, bool duration, bool updateThumb) = 0;
virtual void notifyChange(const QModelIndex &topleft, const QModelIndex &bottomright, const QVector &roles) = 0;
virtual void notifyChange(const QModelIndex &topleft, const QModelIndex &bottomright, int role) = 0;
virtual QModelIndex makeClipIndexFromID(int) const = 0;
virtual QModelIndex makeCompositionIndexFromID(int) const = 0;
virtual QModelIndex makeTrackIndexFromID(int) const = 0;
virtual void _resetView() = 0;
};
#endif
diff --git a/tests/modeltest.cpp b/tests/modeltest.cpp
index 069264af3..27b152343 100644
--- a/tests/modeltest.cpp
+++ b/tests/modeltest.cpp
@@ -1,1790 +1,1854 @@
#include "test_utils.hpp"
using namespace fakeit;
std::default_random_engine g(42);
Mlt::Profile profile_model;
TEST_CASE("Basic creation/deletion of a track", "[TrackModel]")
{
Logger::clear();
auto binModel = pCore->projectItemModel();
std::shared_ptr undoStack = std::make_shared(nullptr);
std::shared_ptr guideModel = std::make_shared(undoStack);
// Here we do some trickery to enable testing.
// We mock the project class so that the undoStack function returns our undoStack
Mock pmMock;
When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
ProjectManager &mocked = pmMock.get();
pCore->m_projectManager = &mocked;
// We also mock timeline object to spy few functions and mock others
TimelineItemModel tim(&profile_model, undoStack);
Mock timMock(tim);
auto timeline = std::shared_ptr(&timMock.get(), [](...) {});
TimelineItemModel::finishConstruct(timeline, guideModel);
Fake(Method(timMock, adjustAssetRange));
// This is faked to allow to count calls
Fake(Method(timMock, _resetView));
int id1 = TrackModel::construct(timeline);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 1);
REQUIRE(timeline->getTrackPosition(id1) == 0);
// In the current implementation, when a track is added/removed, the model is notified with _resetView
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
int id2 = TrackModel::construct(timeline);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 2);
REQUIRE(timeline->getTrackPosition(id2) == 1);
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
int id3 = TrackModel::construct(timeline);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 3);
REQUIRE(timeline->getTrackPosition(id3) == 2);
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
int id4;
REQUIRE(timeline->requestTrackInsertion(1, id4));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 4);
REQUIRE(timeline->getTrackPosition(id1) == 0);
REQUIRE(timeline->getTrackPosition(id4) == 1);
REQUIRE(timeline->getTrackPosition(id2) == 2);
REQUIRE(timeline->getTrackPosition(id3) == 3);
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
// Test deletion
REQUIRE(timeline->requestTrackDeletion(id3));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 3);
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
REQUIRE(timeline->requestTrackDeletion(id1));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 2);
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
REQUIRE(timeline->requestTrackDeletion(id4));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 1);
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
REQUIRE(timeline->requestTrackDeletion(id2));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTracksCount() == 0);
Verify(Method(timMock, _resetView)).Exactly(Once);
RESET(timMock);
SECTION("Delete a track with groups")
{
int tid1, tid2;
REQUIRE(timeline->requestTrackInsertion(-1, tid1));
REQUIRE(timeline->requestTrackInsertion(-1, tid2));
REQUIRE(timeline->checkConsistency());
QString binId = createProducer(profile_model, "red", binModel);
int length = 20;
int cid1, cid2, cid3, cid4;
REQUIRE(timeline->requestClipInsertion(binId, tid1, 2, cid1));
REQUIRE(timeline->requestClipInsertion(binId, tid2, 0, cid2));
REQUIRE(timeline->requestClipInsertion(binId, tid2, length, cid3));
REQUIRE(timeline->requestClipInsertion(binId, tid2, 2 * length, cid4));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipsCount() == 4);
REQUIRE(timeline->getTracksCount() == 2);
auto g1 = std::unordered_set({cid1, cid3});
auto g2 = std::unordered_set({cid2, cid4});
auto g3 = std::unordered_set({cid1, cid4});
REQUIRE(timeline->requestClipsGroup(g1));
REQUIRE(timeline->requestClipsGroup(g2));
REQUIRE(timeline->requestClipsGroup(g3));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->requestTrackDeletion(tid1));
REQUIRE(timeline->getClipsCount() == 3);
REQUIRE(timeline->getTracksCount() == 1);
REQUIRE(timeline->checkConsistency());
}
binModel->clean();
pCore->m_projectManager = nullptr;
Logger::print_trace();
}
TEST_CASE("Basic creation/deletion of a clip", "[ClipModel]")
{
Logger::clear();
auto binModel = pCore->projectItemModel();
std::shared_ptr undoStack = std::make_shared(nullptr);
std::shared_ptr guideModel = std::make_shared(undoStack);
std::shared_ptr timeline = TimelineItemModel::construct(&profile_model, guideModel, undoStack);
// Here we do some trickery to enable testing.
// We mock the project class so that the undoStack function returns our undoStack
Mock pmMock;
When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
ProjectManager &mocked = pmMock.get();
pCore->m_projectManager = &mocked;
QString binId = createProducer(profile_model, "red", binModel);
QString binId2 = createProducer(profile_model, "green", binModel);
REQUIRE(timeline->getClipsCount() == 0);
int id1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
REQUIRE(timeline->getClipsCount() == 1);
REQUIRE(timeline->checkConsistency());
int id2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
REQUIRE(timeline->getClipsCount() == 2);
REQUIRE(timeline->checkConsistency());
int id3 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
REQUIRE(timeline->getClipsCount() == 3);
REQUIRE(timeline->checkConsistency());
// Test deletion
REQUIRE(timeline->requestItemDeletion(id2));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipsCount() == 2);
REQUIRE(timeline->requestItemDeletion(id3));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipsCount() == 1);
REQUIRE(timeline->requestItemDeletion(id1));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipsCount() == 0);
binModel->clean();
pCore->m_projectManager = nullptr;
Logger::print_trace();
}
TEST_CASE("Clip manipulation", "[ClipModel]")
{
Logger::clear();
auto binModel = pCore->projectItemModel();
binModel->clean();
std::shared_ptr undoStack = std::make_shared(nullptr);
std::shared_ptr guideModel = std::make_shared(undoStack);
// Here we do some trickery to enable testing.
// We mock the project class so that the undoStack function returns our undoStack
Mock pmMock;
When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
ProjectManager &mocked = pmMock.get();
pCore->m_projectManager = &mocked;
// We also mock timeline object to spy few functions and mock others
TimelineItemModel tim(&profile_model, undoStack);
Mock timMock(tim);
auto timeline = std::shared_ptr(&timMock.get(), [](...) {});
TimelineItemModel::finishConstruct(timeline, guideModel);
Fake(Method(timMock, adjustAssetRange));
// This is faked to allow to count calls
Fake(Method(timMock, _resetView));
Fake(Method(timMock, _beginInsertRows));
Fake(Method(timMock, _beginRemoveRows));
Fake(Method(timMock, _endInsertRows));
Fake(Method(timMock, _endRemoveRows));
QString binId = createProducer(profile_model, "red", binModel);
QString binId2 = createProducer(profile_model, "blue", binModel);
QString binId3 = createProducer(profile_model, "green", binModel);
int cid1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
int tid1 = TrackModel::construct(timeline);
int tid2 = TrackModel::construct(timeline);
int tid3 = TrackModel::construct(timeline);
int cid2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
int cid3 = ClipModel::construct(timeline, binId3, -1, PlaylistState::VideoOnly);
int cid4 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
Verify(Method(timMock, _resetView)).Exactly(3_Times);
RESET(timMock);
// for testing purposes, we make sure the clip will behave as regular clips
// (ie their size is fixed, we cannot resize them past their original size)
timeline->m_allClips[cid1]->m_endlessResize = false;
timeline->m_allClips[cid2]->m_endlessResize = false;
timeline->m_allClips[cid3]->m_endlessResize = false;
timeline->m_allClips[cid4]->m_endlessResize = false;
+ SECTION("Endless clips can be resized both sides")
+ {
+ timeline->m_allClips[cid1]->m_endlessResize = true;
+
+ REQUIRE(timeline->checkConsistency());
+ REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
+ REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
+ int l = timeline->getClipPlaytime(cid1);
+
+ // try resizing uninserted clip
+ REQUIRE(timeline->requestItemResize(cid1, l + 2, false) == l + 2);
+ REQUIRE(timeline->getClipPlaytime(cid1) == l + 2);
+ undoStack->undo();
+ REQUIRE(timeline->getClipPlaytime(cid1) == l);
+ undoStack->redo();
+ REQUIRE(timeline->getClipPlaytime(cid1) == l + 2);
+ undoStack->undo();
+ REQUIRE(timeline->getClipPlaytime(cid1) == l);
+
+ REQUIRE(timeline->requestItemResize(cid1, 3 * l, true) == 3 * l);
+ REQUIRE(timeline->getClipPlaytime(cid1) == 3 * l);
+ undoStack->undo();
+ REQUIRE(timeline->getClipPlaytime(cid1) == l);
+ undoStack->redo();
+ REQUIRE(timeline->getClipPlaytime(cid1) == 3 * l);
+ undoStack->undo();
+ REQUIRE(timeline->getClipPlaytime(cid1) == l);
+
+ // try resizing inserted clip
+ int pos = 10;
+ REQUIRE(timeline->requestClipMove(cid1, tid1, pos));
+
+ auto state = [&](int s, int p) {
+ REQUIRE(timeline->checkConsistency());
+ REQUIRE(timeline->getClipTrackId(cid1) == tid1);
+ REQUIRE(timeline->getClipPosition(cid1) == p);
+ REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
+ REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
+ REQUIRE(timeline->getClipPlaytime(cid1) == s);
+ };
+ state(l, pos);
+
+ // too big
+ REQUIRE(timeline->requestItemResize(cid1, l + pos + 2, false) == -1);
+
+ REQUIRE(timeline->requestItemResize(cid1, l + 2, false) == l + 2);
+ state(l + 2, pos - 2);
+ undoStack->undo();
+ state(l, pos);
+ undoStack->redo();
+ state(l + 2, pos - 2);
+ undoStack->undo();
+ state(l, pos);
+
+ REQUIRE(timeline->requestItemResize(cid1, 3 * l, true) == 3 * l);
+ state(3 * l, pos);
+ undoStack->undo();
+ state(l, pos);
+ undoStack->redo();
+ state(3 * l, pos);
+ undoStack->undo();
+ state(l, pos);
+ }
+
SECTION("Insert a clip in a track and change track")
{
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
REQUIRE(timeline->getClipTrackId(cid1) == -1);
REQUIRE(timeline->getClipPosition(cid1) == -1);
int pos = 10;
REQUIRE(timeline->requestClipMove(cid1, tid1, pos));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == pos);
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
// Check that the model was correctly notified
CHECK_INSERT(Once);
pos = 1;
REQUIRE(timeline->requestClipMove(cid1, tid2, pos));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid2);
REQUIRE(timeline->getClipPosition(cid1) == pos);
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
CHECK_MOVE(Once);
// Check conflicts
int pos2 = binModel->getClipByBinID(binId)->frameDuration();
REQUIRE(timeline->requestClipMove(cid2, tid1, pos2));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid2) == pos2);
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
CHECK_INSERT(Once);
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, pos2 + 2));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid2);
REQUIRE(timeline->getClipPosition(cid1) == pos);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid2) == pos2);
CHECK_MOVE(Once);
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, pos2 - 2));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid2);
REQUIRE(timeline->getClipPosition(cid1) == pos);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid2) == pos2);
CHECK_MOVE(Once);
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid2) == pos2);
CHECK_MOVE(Once);
}
int length = binModel->getClipByBinID(binId)->frameDuration();
SECTION("Insert consecutive clips")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
CHECK_INSERT(Once);
REQUIRE(timeline->requestClipMove(cid2, tid1, length));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid2) == length);
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
CHECK_INSERT(Once);
}
SECTION("Resize orphan clip")
{
REQUIRE(timeline->getClipPlaytime(cid2) == length);
REQUIRE(timeline->requestItemResize(cid2, 5, true) == 5);
REQUIRE(timeline->checkConsistency());
REQUIRE(binModel->getClipByBinID(binId)->frameDuration() == length);
auto inOut = std::pair{0, 4};
REQUIRE(timeline->m_allClips[cid2]->getInOut() == inOut);
REQUIRE(timeline->getClipPlaytime(cid2) == 5);
REQUIRE(timeline->requestItemResize(cid2, 10, false) == -1);
REQUIRE(timeline->requestItemResize(cid2, length + 1, true) == -1);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipPlaytime(cid2) == 5);
REQUIRE(timeline->getClipPlaytime(cid2) == 5);
REQUIRE(timeline->requestItemResize(cid2, 2, false) == 2);
REQUIRE(timeline->checkConsistency());
inOut = std::pair{3, 4};
REQUIRE(timeline->m_allClips[cid2]->getInOut() == inOut);
REQUIRE(timeline->getClipPlaytime(cid2) == 2);
REQUIRE(timeline->requestItemResize(cid2, length, true) == -1);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipPlaytime(cid2) == 2);
CAPTURE(timeline->m_allClips[cid2]->m_producer->get_in());
REQUIRE(timeline->requestItemResize(cid2, length - 2, true) == -1);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->requestItemResize(cid2, length - 3, true) == length - 3);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipPlaytime(cid2) == length - 3);
}
SECTION("Resize inserted clips")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->checkConsistency());
CHECK_INSERT(Once);
REQUIRE(timeline->requestItemResize(cid1, 5, true) == 5);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipPlaytime(cid1) == 5);
REQUIRE(timeline->getClipPosition(cid1) == 0);
CHECK_RESIZE(Once);
REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
REQUIRE(timeline->checkConsistency());
REQUIRE(binModel->getClipByBinID(binId)->frameDuration() == length);
CHECK_INSERT(Once);
REQUIRE(timeline->requestItemResize(cid1, 6, true) == -1);
REQUIRE(timeline->requestItemResize(cid1, 6, false) == -1);
REQUIRE(timeline->checkConsistency());
NO_OTHERS();
REQUIRE(timeline->requestItemResize(cid2, length - 5, false) == length - 5);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipPosition(cid2) == 10);
CHECK_RESIZE(Once);
REQUIRE(timeline->requestItemResize(cid1, 10, true) == 10);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
CHECK_RESIZE(Once);
}
SECTION("Change track of resized clips")
{
// // REQUIRE(timeline->allowClipMove(cid2, tid1, 5));
REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
// // REQUIRE(timeline->allowClipMove(cid1, tid2, 10));
REQUIRE(timeline->requestClipMove(cid1, tid2, 10));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->requestItemResize(cid1, 5, false) == 5);
REQUIRE(timeline->checkConsistency());
// // REQUIRE(timeline->allowClipMove(cid1, tid1, 0));
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
}
SECTION("Clip Move")
{
REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid2) == 5);
REQUIRE(timeline->requestClipMove(cid1, tid1, 5 + length));
auto state = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5 + length);
REQUIRE(timeline->getClipPosition(cid2) == 5);
};
state();
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 3 + length));
state();
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 0));
state();
REQUIRE(timeline->requestClipMove(cid2, tid1, 0));
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5 + length);
REQUIRE(timeline->getClipPosition(cid2) == 0);
};
state2();
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 0));
state2();
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, length - 5));
state2();
REQUIRE(timeline->requestClipMove(cid1, tid1, length));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == length);
REQUIRE(timeline->getClipPosition(cid2) == 0);
REQUIRE(timeline->requestItemResize(cid2, length - 5, true) == length - 5);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == length);
REQUIRE(timeline->getClipPosition(cid2) == 0);
REQUIRE(timeline->requestClipMove(cid1, tid1, length - 5));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == length - 5);
REQUIRE(timeline->getClipPosition(cid2) == 0);
REQUIRE(timeline->requestItemResize(cid2, length - 10, false) == length - 10);
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == length - 5);
REQUIRE(timeline->getClipPosition(cid2) == 5);
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == length - 5);
REQUIRE(timeline->getClipPosition(cid2) == 5);
REQUIRE(timeline->requestClipMove(cid2, tid1, 0));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == length - 5);
REQUIRE(timeline->getClipPosition(cid2) == 0);
}
SECTION("Move and resize")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->requestItemResize(cid1, length - 2, false) == length - 2);
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
auto state = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getClipPlaytime(cid1) == length - 2);
};
state();
// try to resize past the left end
REQUIRE(timeline->requestItemResize(cid1, length, false) == -1);
state();
REQUIRE(timeline->requestItemResize(cid1, length - 4, true) == length - 4);
REQUIRE(timeline->requestClipMove(cid2, tid1, length - 4 + 1));
REQUIRE(timeline->requestItemResize(cid2, length - 2, false) == length - 2);
REQUIRE(timeline->requestClipMove(cid2, tid1, length - 4 + 1));
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getClipPlaytime(cid1) == length - 4);
REQUIRE(timeline->getClipPosition(cid2) == length - 4 + 1);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 2);
};
state2();
// the gap between the two clips is 1 frame, we try to resize them by 2 frames
REQUIRE(timeline->requestItemResize(cid1, length - 2, true) == -1);
state2();
REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
state2();
REQUIRE(timeline->requestClipMove(cid2, tid1, length - 4));
auto state3 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getClipPlaytime(cid1) == length - 4);
REQUIRE(timeline->getClipPosition(cid2) == length - 4);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 2);
};
state3();
// Now the gap is 0 frames, the resize should still fail
REQUIRE(timeline->requestItemResize(cid1, length - 2, true) == -1);
state3();
REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
state3();
// We move cid1 out of the way
REQUIRE(timeline->requestClipMove(cid1, tid2, 0));
// now resize should work
REQUIRE(timeline->requestItemResize(cid1, length - 2, true) == length - 2);
REQUIRE(timeline->requestItemResize(cid2, length, false) == length);
REQUIRE(timeline->checkConsistency());
}
SECTION("Group and selection")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->requestClipMove(cid2, tid1, length + 3));
REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * length + 5));
auto pos_state = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getClipPosition(cid2) == length + 3);
REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 5);
};
auto state0 = [&]() {
pos_state();
REQUIRE_FALSE(timeline->m_groups->isInGroup(cid1));
REQUIRE_FALSE(timeline->m_groups->isInGroup(cid2));
REQUIRE_FALSE(timeline->m_groups->isInGroup(cid3));
};
state0();
REQUIRE(timeline->requestClipsGroup({cid1, cid2}));
auto state = [&]() {
pos_state();
REQUIRE_FALSE(timeline->m_groups->isInGroup(cid3));
REQUIRE(timeline->m_groups->isInGroup(cid1));
int gid = timeline->m_groups->getRootId(cid1);
REQUIRE(timeline->m_groups->getLeaves(gid) == std::unordered_set{cid1, cid2});
};
state();
// undo/redo should work fine
undoStack->undo();
state0();
undoStack->redo();
state();
// Tricky case, we do a non-trivial selection before undoing
REQUIRE(timeline->requestSetSelection({cid1, cid3}));
REQUIRE(timeline->getCurrentSelection() == std::unordered_set{cid1, cid2, cid3});
undoStack->undo();
state0();
REQUIRE(timeline->requestSetSelection({cid1, cid3}));
REQUIRE(timeline->getCurrentSelection() == std::unordered_set{cid1, cid3});
undoStack->redo();
state();
// same thing, but when ungrouping manually
REQUIRE(timeline->requestSetSelection({cid1, cid3}));
REQUIRE(timeline->getCurrentSelection() == std::unordered_set{cid1, cid2, cid3});
REQUIRE(timeline->requestClipUngroup(cid1));
state0();
// normal undo/redo
undoStack->undo();
state();
undoStack->redo();
state0();
// undo/redo mixed with selections
REQUIRE(timeline->requestSetSelection({cid1, cid3}));
REQUIRE(timeline->getCurrentSelection() == std::unordered_set{cid1, cid3});
undoStack->undo();
state();
REQUIRE(timeline->requestSetSelection({cid1, cid3}));
REQUIRE(timeline->getCurrentSelection() == std::unordered_set{cid1, cid2, cid3});
undoStack->redo();
state0();
}
SECTION("Group move")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->requestClipMove(cid2, tid1, length + 3));
REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * length + 5));
REQUIRE(timeline->requestClipMove(cid4, tid2, 4));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipTrackId(cid4) == tid2);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getClipPosition(cid2) == length + 3);
REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 5);
REQUIRE(timeline->getClipPosition(cid4) == 4);
// check that move is possible without groups
REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * length + 3));
REQUIRE(timeline->checkConsistency());
undoStack->undo();
REQUIRE(timeline->checkConsistency());
// check that move is possible without groups
REQUIRE(timeline->requestClipMove(cid4, tid2, 9));
REQUIRE(timeline->checkConsistency());
undoStack->undo();
REQUIRE(timeline->checkConsistency());
auto state = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipTrackId(cid4) == tid2);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(timeline->getClipPosition(cid2) == length + 3);
REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 5);
REQUIRE(timeline->getClipPosition(cid4) == 4);
};
state();
// grouping
REQUIRE(timeline->requestClipsGroup({cid1, cid3}));
REQUIRE(timeline->requestClipsGroup({cid1, cid4}));
// move left is now forbidden, because clip1 is at position 0
REQUIRE_FALSE(timeline->requestClipMove(cid3, tid1, 2 * length + 3));
state();
// this move is impossible, because clip1 runs into clip2
REQUIRE_FALSE(timeline->requestClipMove(cid4, tid2, 9));
state();
// this move is possible
REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * length + 8));
auto state1 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->getTrackClipsCount(tid3) == 0);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipTrackId(cid4) == tid2);
REQUIRE(timeline->getClipPosition(cid1) == 3);
REQUIRE(timeline->getClipPosition(cid2) == length + 3);
REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 8);
REQUIRE(timeline->getClipPosition(cid4) == 7);
};
state1();
// this move is possible
REQUIRE(timeline->requestClipMove(cid1, tid2, 8));
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getTrackClipsCount(tid2) == 2);
REQUIRE(timeline->getTrackClipsCount(tid3) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid2);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid2);
REQUIRE(timeline->getClipTrackId(cid4) == tid3);
REQUIRE(timeline->getClipPosition(cid1) == 8);
REQUIRE(timeline->getClipPosition(cid2) == length + 3);
REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 5 + 8);
REQUIRE(timeline->getClipPosition(cid4) == 4 + 8);
};
state2();
undoStack->undo();
state1();
undoStack->redo();
state2();
REQUIRE(timeline->requestClipMove(cid1, tid1, 3));
state1();
}
SECTION("Group move consecutive clips")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 7));
REQUIRE(timeline->requestClipMove(cid2, tid1, 7 + length));
REQUIRE(timeline->requestClipMove(cid3, tid1, 7 + 2 * length));
REQUIRE(timeline->requestClipMove(cid4, tid1, 7 + 3 * length));
REQUIRE(timeline->requestClipsGroup({cid1, cid2, cid3, cid4}));
auto state = [&](int tid, int start) {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid) == 4);
int i = 0;
for (int cid : std::vector({cid1, cid2, cid3, cid4})) {
REQUIRE(timeline->getClipTrackId(cid) == tid);
REQUIRE(timeline->getClipPosition(cid) == start + i * length);
REQUIRE(timeline->getClipPlaytime(cid) == length);
i++;
}
};
state(tid1, 7);
auto check_undo = [&](int target, int tid, int oldTid) {
state(tid, target);
undoStack->undo();
state(oldTid, 7);
undoStack->redo();
state(tid, target);
undoStack->undo();
state(oldTid, 7);
};
REQUIRE(timeline->requestClipMove(cid1, tid1, 6));
qDebug() << "state1";
state(tid1, 6);
undoStack->undo();
state(tid1, 7);
undoStack->redo();
state(tid1, 6);
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
qDebug() << "state2";
state(tid1, 0);
undoStack->undo();
state(tid1, 6);
undoStack->redo();
state(tid1, 0);
undoStack->undo();
state(tid1, 6);
undoStack->undo();
state(tid1, 7);
REQUIRE(timeline->requestClipMove(cid3, tid1, 1 + 2 * length));
qDebug() << "state3";
check_undo(1, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid4, tid1, 4 + 3 * length));
qDebug() << "state4";
check_undo(4, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid4, tid1, 11 + 3 * length));
qDebug() << "state5";
check_undo(11, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid2, tid1, 13 + length));
qDebug() << "state6";
check_undo(13, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid1, tid1, 20));
qDebug() << "state7";
check_undo(20, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid4, tid1, 7 + 4 * length));
qDebug() << "state8";
check_undo(length + 7, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid2, tid1, 7 + 2 * length));
qDebug() << "state9";
check_undo(length + 7, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid1, tid1, 7 + length));
qDebug() << "state10";
check_undo(length + 7, tid1, tid1);
REQUIRE(timeline->requestClipMove(cid2, tid2, 8 + length));
qDebug() << "state11";
check_undo(8, tid2, tid1);
}
SECTION("Group move to unavailable track")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 10));
REQUIRE(timeline->requestClipMove(cid2, tid2, 12));
REQUIRE(timeline->requestClipsGroup({cid1, cid2}));
auto state = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid2) == tid2);
REQUIRE(timeline->getClipPosition(cid1) == 10);
REQUIRE(timeline->getClipPosition(cid2) == 12);
};
state();
REQUIRE_FALSE(timeline->requestClipMove(cid2, tid1, 10));
state();
REQUIRE_FALSE(timeline->requestClipMove(cid2, tid1, 100));
state();
REQUIRE_FALSE(timeline->requestClipMove(cid1, tid3, 100));
state();
}
SECTION("Group move with non-consecutive track ids")
{
int tid5 = TrackModel::construct(timeline);
int cid6 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
Q_UNUSED(cid6);
int tid6 = TrackModel::construct(timeline);
REQUIRE(tid5 + 1 != tid6);
REQUIRE(timeline->requestClipMove(cid1, tid5, 10));
REQUIRE(timeline->requestClipMove(cid2, tid5, length + 10));
REQUIRE(timeline->requestClipsGroup({cid1, cid2}));
auto state = [&](int t) {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(t) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == t);
REQUIRE(timeline->getClipTrackId(cid2) == t);
REQUIRE(timeline->getClipPosition(cid1) == 10);
REQUIRE(timeline->getClipPosition(cid2) == 10 + length);
};
state(tid5);
REQUIRE(timeline->requestClipMove(cid1, tid6, 10));
state(tid6);
}
SECTION("Creation and movement of AV groups")
{
int tid6b = TrackModel::construct(timeline, -1, -1, QString(), true);
int tid6 = TrackModel::construct(timeline, -1, -1, QString(), true);
int tid5 = TrackModel::construct(timeline);
int tid5b = TrackModel::construct(timeline);
auto state0 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid5) == 0);
REQUIRE(timeline->getTrackClipsCount(tid6) == 0);
};
state0();
QString binId3 = createProducerWithSound(profile_model, binModel);
int cid6 = -1;
REQUIRE(timeline->requestClipInsertion(binId3, tid5, 3, cid6, true, true, false));
int cid7 = timeline->m_groups->getSplitPartner(cid6);
auto check_group = [&]() {
// we check that the av group was correctly created
REQUIRE(timeline->getGroupElements(cid6) == std::unordered_set({cid6, cid7}));
int g1 = timeline->m_groups->getDirectAncestor(cid6);
REQUIRE(timeline->m_groups->getDirectChildren(g1) == std::unordered_set({cid6, cid7}));
REQUIRE(timeline->m_groups->getType(g1) == GroupType::AVSplit);
};
auto state = [&](int pos) {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid5) == 1);
REQUIRE(timeline->getTrackClipsCount(tid6) == 1);
REQUIRE(timeline->getClipTrackId(cid6) == tid5);
REQUIRE(timeline->getClipTrackId(cid7) == tid6);
REQUIRE(timeline->getClipPosition(cid6) == pos);
REQUIRE(timeline->getClipPosition(cid7) == pos);
REQUIRE(timeline->getClipPtr(cid6)->clipState() == PlaylistState::VideoOnly);
REQUIRE(timeline->getClipPtr(cid7)->clipState() == PlaylistState::AudioOnly);
check_group();
};
state(3);
undoStack->undo();
state0();
undoStack->redo();
state(3);
// test deletion + undo after selection
REQUIRE(timeline->requestSetSelection({cid6}));
REQUIRE(timeline->getCurrentSelection() == std::unordered_set{cid6, cid7});
REQUIRE(timeline->requestItemDeletion(cid6, true));
state0();
undoStack->undo();
state(3);
undoStack->redo();
state0();
undoStack->undo();
state(3);
// simple translation on the right
REQUIRE(timeline->requestClipMove(cid6, tid5, 10, true, true, true));
state(10);
undoStack->undo();
state(3);
undoStack->redo();
state(10);
// simple translation on the left, moving the audio clip this time
REQUIRE(timeline->requestClipMove(cid7, tid6, 1, true, true, true));
state(1);
undoStack->undo();
state(10);
undoStack->redo();
state(1);
// change track, moving video
REQUIRE(timeline->requestClipMove(cid6, tid5b, 7, true, true, true));
auto state2 = [&](int pos) {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid5b) == 1);
REQUIRE(timeline->getTrackClipsCount(tid6b) == 1);
REQUIRE(timeline->getClipTrackId(cid6) == tid5b);
REQUIRE(timeline->getClipTrackId(cid7) == tid6b);
REQUIRE(timeline->getClipPosition(cid6) == pos);
REQUIRE(timeline->getClipPosition(cid7) == pos);
REQUIRE(timeline->getClipPtr(cid6)->clipState() == PlaylistState::VideoOnly);
REQUIRE(timeline->getClipPtr(cid7)->clipState() == PlaylistState::AudioOnly);
check_group();
};
state2(7);
undoStack->undo();
state(1);
undoStack->redo();
state2(7);
// change track, moving audio
REQUIRE(timeline->requestClipMove(cid7, tid6b, 2, true, true, true));
state2(2);
undoStack->undo();
state2(7);
undoStack->redo();
state2(2);
undoStack->undo();
undoStack->undo();
state(1);
}
SECTION("Clip clone")
{
int cid6 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
int l = timeline->getClipPlaytime(cid6);
REQUIRE(timeline->requestItemResize(cid6, l - 3, true, true, -1) == l - 3);
REQUIRE(timeline->requestItemResize(cid6, l - 7, false, true, -1) == l - 7);
int newId;
std::function undo = []() { return true; };
std::function redo = []() { return true; };
REQUIRE(TimelineFunctions::cloneClip(timeline, cid6, newId, PlaylistState::VideoOnly, undo, redo));
REQUIRE(timeline->m_allClips[cid6]->binId() == timeline->m_allClips[newId]->binId());
// TODO check effects
}
binModel->clean();
pCore->m_projectManager = nullptr;
Logger::print_trace();
}
TEST_CASE("Check id unicity", "[ClipModel]")
{
Logger::clear();
auto binModel = pCore->projectItemModel();
binModel->clean();
std::shared_ptr undoStack = std::make_shared(nullptr);
std::shared_ptr guideModel = std::make_shared(undoStack);
// Here we do some trickery to enable testing.
// We mock the project class so that the undoStack function returns our undoStack
Mock pmMock;
When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
ProjectManager &mocked = pmMock.get();
pCore->m_projectManager = &mocked;
// We also mock timeline object to spy few functions and mock others
TimelineItemModel tim(&profile_model, undoStack);
Mock timMock(tim);
auto timeline = std::shared_ptr(&timMock.get(), [](...) {});
TimelineItemModel::finishConstruct(timeline, guideModel);
RESET(timMock);
QString binId = createProducer(profile_model, "red", binModel);
std::vector track_ids;
std::unordered_set all_ids;
std::bernoulli_distribution coin(0.5);
const int nbr = 20;
for (int i = 0; i < nbr; i++) {
if (coin(g)) {
int tid = TrackModel::construct(timeline);
REQUIRE(all_ids.count(tid) == 0);
all_ids.insert(tid);
track_ids.push_back(tid);
REQUIRE(timeline->getTracksCount() == track_ids.size());
} else {
int cid = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
REQUIRE(all_ids.count(cid) == 0);
all_ids.insert(cid);
REQUIRE(timeline->getClipsCount() == all_ids.size() - track_ids.size());
}
}
REQUIRE(timeline->checkConsistency());
REQUIRE(all_ids.size() == nbr);
REQUIRE(all_ids.size() != track_ids.size());
binModel->clean();
pCore->m_projectManager = nullptr;
Logger::print_trace();
}
TEST_CASE("Undo and Redo", "[ClipModel]")
{
Logger::clear();
auto binModel = pCore->projectItemModel();
binModel->clean();
std::shared_ptr undoStack = std::make_shared(nullptr);
std::shared_ptr guideModel = std::make_shared(undoStack);
// Here we do some trickery to enable testing.
// We mock the project class so that the undoStack function returns our undoStack
Mock pmMock;
When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
ProjectManager &mocked = pmMock.get();
pCore->m_projectManager = &mocked;
// We also mock timeline object to spy few functions and mock others
TimelineItemModel tim(&profile_model, undoStack);
Mock timMock(tim);
auto timeline = std::shared_ptr(&timMock.get(), [](...) {});
TimelineItemModel::finishConstruct(timeline, guideModel);
RESET(timMock);
QString binId = createProducer(profile_model, "red", binModel);
QString binId2 = createProducer(profile_model, "blue", binModel);
int cid1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
int tid1 = TrackModel::construct(timeline);
int tid2 = TrackModel::construct(timeline);
int cid2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
timeline->m_allClips[cid1]->m_endlessResize = false;
timeline->m_allClips[cid2]->m_endlessResize = false;
int length = 20;
int nclips = timeline->m_allClips.size();
SECTION("requestCreateClip")
{
// an invalid clip id shouldn't get created
{
int temp;
Fun undo = []() { return true; };
Fun redo = []() { return true; };
REQUIRE_FALSE(timeline->requestClipCreation("impossible bin id", temp, PlaylistState::VideoOnly, 1., undo, redo));
}
auto state0 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->m_allClips.size() == nclips);
};
state0();
QString binId3 = createProducer(profile_model, "green", binModel);
int cid3;
{
Fun undo = []() { return true; };
Fun redo = []() { return true; };
REQUIRE(timeline->requestClipCreation(binId3, cid3, PlaylistState::VideoOnly, 1., undo, redo));
pCore->pushUndo(undo, redo, QString());
}
auto state1 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->m_allClips.size() == nclips + 1);
REQUIRE(timeline->getClipPlaytime(cid3) == length);
REQUIRE(timeline->getClipTrackId(cid3) == -1);
};
state1();
QString binId4 = binId3 + "/1/10";
int cid4;
{
Fun undo = []() { return true; };
Fun redo = []() { return true; };
REQUIRE(timeline->requestClipCreation(binId4, cid4, PlaylistState::VideoOnly, 1., undo, redo));
pCore->pushUndo(undo, redo, QString());
}
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->m_allClips.size() == nclips + 2);
REQUIRE(timeline->getClipPlaytime(cid4) == 10);
REQUIRE(timeline->getClipTrackId(cid4) == -1);
auto inOut = std::pair({1, 10});
REQUIRE(timeline->m_allClips.at(cid4)->getInOut() == inOut);
REQUIRE(timeline->getClipPlaytime(cid3) == length);
REQUIRE(timeline->getClipTrackId(cid3) == -1);
};
state2();
undoStack->undo();
state1();
undoStack->undo();
state0();
undoStack->redo();
state1();
undoStack->redo();
state2();
}
SECTION("requestInsertClip")
{
auto state0 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->m_allClips.size() == nclips);
};
state0();
QString binId3 = createProducer(profile_model, "green", binModel);
int cid3;
REQUIRE(timeline->requestClipInsertion(binId3, tid1, 12, cid3, true));
auto state1 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->m_allClips.size() == nclips + 1);
REQUIRE(timeline->getClipPlaytime(cid3) == length);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipPosition(cid3) == 12);
};
state1();
QString binId4 = binId3 + "/1/10";
int cid4;
REQUIRE(timeline->requestClipInsertion(binId4, tid2, 17, cid4, true));
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->m_allClips.size() == nclips + 2);
REQUIRE(timeline->getClipPlaytime(cid4) == 10);
REQUIRE(timeline->getClipTrackId(cid4) == tid2);
REQUIRE(timeline->getClipPosition(cid4) == 17);
auto inOut = std::pair({1, 10});
REQUIRE(timeline->m_allClips.at(cid4)->getInOut() == inOut);
REQUIRE(timeline->getClipPlaytime(cid3) == length);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipPosition(cid3) == 12);
};
state2();
undoStack->undo();
state1();
undoStack->undo();
state0();
undoStack->redo();
state1();
undoStack->redo();
state2();
}
int init_index = undoStack->index();
SECTION("Basic move undo")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(undoStack->index() == init_index + 1);
CHECK_INSERT(Once);
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(undoStack->index() == init_index + 2);
// Move on same track does not trigger insert/remove row
CHECK_MOVE(0);
undoStack->undo();
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(undoStack->index() == init_index + 1);
CHECK_MOVE(0);
undoStack->redo();
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 0);
REQUIRE(undoStack->index() == init_index + 2);
CHECK_MOVE(0);
undoStack->undo();
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(undoStack->index() == init_index + 1);
CHECK_MOVE(0);
REQUIRE(timeline->requestClipMove(cid1, tid1, 2 * length));
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 2 * length);
REQUIRE(undoStack->index() == init_index + 2);
CHECK_MOVE(0);
undoStack->undo();
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(undoStack->index() == init_index + 1);
CHECK_MOVE(0);
undoStack->redo();
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 2 * length);
REQUIRE(undoStack->index() == init_index + 2);
CHECK_MOVE(0);
undoStack->undo();
CHECK_MOVE(0);
undoStack->undo();
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
REQUIRE(timeline->getClipTrackId(cid1) == -1);
REQUIRE(undoStack->index() == init_index);
CHECK_REMOVE(Once);
}
SECTION("Basic resize orphan clip undo")
{
REQUIRE(timeline->getClipPlaytime(cid2) == length);
REQUIRE(timeline->requestItemResize(cid2, length - 5, true) == length - 5);
REQUIRE(undoStack->index() == init_index + 1);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 5);
REQUIRE(timeline->requestItemResize(cid2, length - 10, false) == length - 10);
REQUIRE(undoStack->index() == init_index + 2);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 10);
REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
REQUIRE(undoStack->index() == init_index + 2);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 10);
undoStack->undo();
REQUIRE(undoStack->index() == init_index + 1);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 5);
undoStack->redo();
REQUIRE(undoStack->index() == init_index + 2);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 10);
undoStack->undo();
REQUIRE(undoStack->index() == init_index + 1);
REQUIRE(timeline->getClipPlaytime(cid2) == length - 5);
undoStack->undo();
REQUIRE(undoStack->index() == init_index);
REQUIRE(timeline->getClipPlaytime(cid2) == length);
}
SECTION("Basic resize inserted clip undo")
{
REQUIRE(timeline->getClipPlaytime(cid2) == length);
auto check = [&](int pos, int l) {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid2) == tid1);
REQUIRE(timeline->getClipPlaytime(cid2) == l);
REQUIRE(timeline->getClipPosition(cid2) == pos);
};
REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
INFO("Test 1");
check(5, length);
REQUIRE(undoStack->index() == init_index + 1);
REQUIRE(timeline->requestItemResize(cid2, length - 5, true) == length - 5);
INFO("Test 2");
check(5, length - 5);
REQUIRE(undoStack->index() == init_index + 2);
REQUIRE(timeline->requestItemResize(cid2, length - 10, false) == length - 10);
INFO("Test 3");
check(10, length - 10);
REQUIRE(undoStack->index() == init_index + 3);
REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
INFO("Test 4");
check(10, length - 10);
REQUIRE(undoStack->index() == init_index + 3);
undoStack->undo();
INFO("Test 5");
check(5, length - 5);
REQUIRE(undoStack->index() == init_index + 2);
undoStack->redo();
INFO("Test 6");
check(10, length - 10);
REQUIRE(undoStack->index() == init_index + 3);
undoStack->undo();
INFO("Test 7");
check(5, length - 5);
REQUIRE(undoStack->index() == init_index + 2);
undoStack->undo();
INFO("Test 8");
check(5, length);
REQUIRE(undoStack->index() == init_index + 1);
}
SECTION("Clip Insertion Undo")
{
QString binId3 = createProducer(profile_model, "red", binModel);
REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
auto state1 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(undoStack->index() == init_index + 1);
};
state1();
int cid3;
REQUIRE_FALSE(timeline->requestClipInsertion(binId3, tid1, 5, cid3));
state1();
REQUIRE_FALSE(timeline->requestClipInsertion(binId3, tid1, 6, cid3));
state1();
REQUIRE(timeline->requestClipInsertion(binId3, tid1, 5 + length, cid3));
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(timeline->getClipPosition(cid3) == 5 + length);
REQUIRE(timeline->m_allClips[cid3]->isValid());
REQUIRE(undoStack->index() == init_index + 2);
};
state2();
REQUIRE(timeline->requestClipMove(cid3, tid1, 10 + length));
auto state3 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(timeline->getClipPosition(cid3) == 10 + length);
REQUIRE(undoStack->index() == init_index + 3);
};
state3();
REQUIRE(timeline->requestItemResize(cid3, 1, true) == 1);
auto state4 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipTrackId(cid3) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(timeline->getClipPlaytime(cid3) == 1);
REQUIRE(timeline->getClipPosition(cid3) == 10 + length);
REQUIRE(undoStack->index() == init_index + 4);
};
state4();
undoStack->undo();
state3();
undoStack->undo();
state2();
undoStack->undo();
state1();
undoStack->redo();
state2();
undoStack->redo();
state3();
undoStack->redo();
state4();
undoStack->undo();
state3();
undoStack->undo();
state2();
undoStack->undo();
state1();
}
SECTION("Clip Deletion undo")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
auto state1 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(undoStack->index() == init_index + 1);
};
state1();
int nbClips = timeline->getClipsCount();
REQUIRE(timeline->requestItemDeletion(cid1));
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
REQUIRE(timeline->getClipsCount() == nbClips - 1);
REQUIRE(undoStack->index() == init_index + 2);
};
state2();
undoStack->undo();
state1();
undoStack->redo();
state2();
undoStack->undo();
state1();
}
SECTION("Select then delete")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
REQUIRE(timeline->requestClipMove(cid2, tid2, 1));
auto state1 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
REQUIRE(timeline->getClipTrackId(cid2) == tid2);
REQUIRE(timeline->getClipPosition(cid2) == 1);
};
state1();
REQUIRE(timeline->requestSetSelection({cid1, cid2}));
int nbClips = timeline->getClipsCount();
REQUIRE(timeline->requestItemDeletion(cid1));
auto state2 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
REQUIRE(timeline->getClipsCount() == nbClips - 2);
};
state2();
undoStack->undo();
state1();
undoStack->redo();
state2();
undoStack->undo();
state1();
}
SECTION("Track insertion undo")
{
std::map orig_trackPositions, final_trackPositions;
for (const auto &it : timeline->m_iteratorTable) {
int track = it.first;
int pos = timeline->getTrackPosition(track);
orig_trackPositions[track] = pos;
if (pos >= 1) pos++;
final_trackPositions[track] = pos;
}
auto checkPositions = [&](const std::map &pos) {
for (const auto &p : pos) {
REQUIRE(timeline->getTrackPosition(p.first) == p.second);
}
};
checkPositions(orig_trackPositions);
int new_tid;
REQUIRE(timeline->requestTrackInsertion(1, new_tid));
checkPositions(final_trackPositions);
undoStack->undo();
checkPositions(orig_trackPositions);
undoStack->redo();
checkPositions(final_trackPositions);
undoStack->undo();
checkPositions(orig_trackPositions);
}
SECTION("Track deletion undo")
{
int nb_clips = timeline->getClipsCount();
int nb_tracks = timeline->getTracksCount();
REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
auto state1 = [&]() {
REQUIRE(timeline->checkConsistency());
REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
REQUIRE(timeline->getClipTrackId(cid1) == tid1);
REQUIRE(timeline->getClipPosition(cid1) == 5);
REQUIRE(undoStack->index() == init_index + 1);
REQUIRE(timeline->getClipsCount() == nb_clips);
REQUIRE(timeline->getTracksCount() == nb_tracks);
};
state1();
REQUIRE(timeline->requestTrackDeletion(tid1));
REQUIRE(timeline->getClipsCount() == nb_clips - 1);
REQUIRE(timeline->getTracksCount() == nb_tracks - 1);
undoStack->undo();
state1();
undoStack->redo();
REQUIRE(timeline->getClipsCount() == nb_clips - 1);
REQUIRE(timeline->getTracksCount() == nb_tracks - 1);
undoStack->undo();
state1();
}
int clipCount = timeline->m_allClips.size();
SECTION("Clip creation and resize")
{
int cid6;
auto state0 = [&]() {
REQUIRE(timeline->m_allClips.size() == clipCount);
REQUIRE(timeline->checkConsistency());
};
state0();
{
std::function undo = []() { return true; };
std::function redo = []() { return true; };
REQUIRE(timeline->requestClipCreation(binId, cid6, PlaylistState::VideoOnly, 1., undo, redo));
pCore->pushUndo(undo, redo, QString());
}
int l = timeline->getClipPlaytime(cid6);
auto state1 = [&]() {
REQUIRE(timeline->m_allClips.size() == clipCount + 1);
REQUIRE(timeline->isClip(cid6));
REQUIRE(timeline->getClipTrackId(cid6) == -1);
REQUIRE(timeline->getClipPlaytime(cid6) == l);
};
state1();
{
std::function undo = []() { return true; };
std::function redo = []() { return true; };
REQUIRE(timeline->requestItemResize(cid6, l - 5, true, true, undo, redo, false));
pCore->pushUndo(undo, redo, QString());
}
auto state2 = [&]() {
REQUIRE(timeline->m_allClips.size() == clipCount + 1);
REQUIRE(timeline->isClip(cid6));
REQUIRE(timeline->getClipTrackId(cid6) == -1);
REQUIRE(timeline->getClipPlaytime(cid6) == l - 5);
};
state2();
{
std::function undo = []() { return true; };
std::function redo = []() { return true; };
REQUIRE(timeline->requestClipMove(cid6, tid1, 7, true, true, undo, redo));
pCore->pushUndo(undo, redo, QString());
}
auto state3 = [&]() {
REQUIRE(timeline->m_allClips.size() == clipCount + 1);
REQUIRE(timeline->isClip(cid6));
REQUIRE(timeline->getClipTrackId(cid6) == tid1);
REQUIRE(timeline->getClipPosition(cid6) == 7);
REQUIRE(timeline->getClipPlaytime(cid6) == l - 5);
};
state3();
{
std::function undo = []() { return true; };
std::function redo = []() { return true; };
REQUIRE(timeline->requestItemResize(cid6, l - 6, false, true, undo, redo, false));
pCore->pushUndo(undo, redo, QString());
}
auto state4 = [&]() {
REQUIRE(timeline->m_allClips.size() == clipCount + 1);
REQUIRE(timeline->isClip(cid6));
REQUIRE(timeline->getClipTrackId(cid6) == tid1);
REQUIRE(timeline->getClipPosition(cid6) == 8);
REQUIRE(timeline->getClipPlaytime(cid6) == l - 6);
};
state4();
undoStack->undo();
state3();
undoStack->undo();
state2();
undoStack->undo();
state1();
undoStack->undo();
state0();
undoStack->redo();
state1();
undoStack->redo();
state2();
undoStack->redo();
state3();
undoStack->redo();
state4();
}
binModel->clean();
pCore->m_projectManager = nullptr;
Logger::print_trace();
}
TEST_CASE("Snapping", "[Snapping]")
{
Logger::clear();
auto binModel = pCore->projectItemModel();
binModel->clean();
std::shared_ptr undoStack = std::make_shared(nullptr);
std::shared_ptr guideModel = std::make_shared(undoStack);
// Here we do some trickery to enable testing.
// We mock the project class so that the undoStack function returns our undoStack
Mock pmMock;
When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
ProjectManager &mocked = pmMock.get();
pCore->m_projectManager = &mocked;
// We also mock timeline object to spy few functions and mock others
TimelineItemModel tim(&profile_model, undoStack);
Mock timMock(tim);
auto timeline = std::shared_ptr(&timMock.get(), [](...) {});
TimelineItemModel::finishConstruct(timeline, guideModel);
RESET(timMock);
QString binId = createProducer(profile_model, "red", binModel, 50);
QString binId2 = createProducer(profile_model, "blue", binModel);
int tid1 = TrackModel::construct(timeline);
int cid1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
int tid2 = TrackModel::construct(timeline);
int cid2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
int cid3 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
timeline->m_allClips[cid1]->m_endlessResize = false;
timeline->m_allClips[cid2]->m_endlessResize = false;
timeline->m_allClips[cid3]->m_endlessResize = false;
int length = timeline->getClipPlaytime(cid1);
int length2 = timeline->getClipPlaytime(cid2);
SECTION("getBlankSizeNearClip")
{
REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
// before
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 0);
// after
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == INT_MAX);
REQUIRE(timeline->requestClipMove(cid1, tid1, 10));
// before
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 10);
// after
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == INT_MAX);
REQUIRE(timeline->requestClipMove(cid2, tid1, 25 + length));
// before
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 10);
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, false) == 15);
// after
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == 15);
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, true) == INT_MAX);
REQUIRE(timeline->requestClipMove(cid2, tid1, 10 + length));
// before
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 10);
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, false) == 0);
// after
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == 0);
REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, true) == INT_MAX);
}
SECTION("Snap move to a single clip")
{
int beg = 30;
// in the absence of other clips, a valid move shouldn't be modified
for (int snap = -1; snap <= 5; ++snap) {
REQUIRE(timeline->suggestClipMove(cid2, tid2, beg, -1, snap) == beg);
REQUIRE(timeline->suggestClipMove(cid2, tid2, beg + length, -1, snap) == beg + length);
REQUIRE(timeline->checkConsistency());
}
// We add a clip in first track to create snap points
REQUIRE(timeline->requestClipMove(cid1, tid1, beg));
// Now a clip in second track should snap to beginning
auto check_snap = [&](int pos, int perturb, int snap) {
if (snap >= perturb) {
REQUIRE(timeline->suggestClipMove(cid2, tid2, pos + perturb, -1, snap) == pos);
REQUIRE(timeline->suggestClipMove(cid2, tid2, pos - perturb, -1, snap) == pos);
} else {
REQUIRE(timeline->suggestClipMove(cid2, tid2, pos + perturb, -1, snap) == pos + perturb);
REQUIRE(timeline->suggestClipMove(cid2, tid2, pos - perturb, -1, snap) == pos - perturb);
}
};
for (int snap = -1; snap <= 5; ++snap) {
for (int perturb = 0; perturb <= 6; ++perturb) {
// snap to beginning
check_snap(beg, perturb, snap);
check_snap(beg + length, perturb, snap);
// snap to end
check_snap(beg - length2, perturb, snap);
check_snap(beg + length - length2, perturb, snap);
REQUIRE(timeline->checkConsistency());
}
}
// Same test, but now clip is moved in position 0 first
REQUIRE(timeline->requestClipMove(cid2, tid2, 0));
for (int snap = -1; snap <= 5; ++snap) {
for (int perturb = 0; perturb <= 6; ++perturb) {
// snap to beginning
check_snap(beg, perturb, snap);
check_snap(beg + length, perturb, snap);
// snap to end
check_snap(beg - length2, perturb, snap);
check_snap(beg + length - length2, perturb, snap);
REQUIRE(timeline->checkConsistency());
}
}
}
binModel->clean();
pCore->m_projectManager = nullptr;
Logger::print_trace();
}