public override bool Execute(IEnumerable <TrackAsset> tracks)
{
tracks = tracks.RemoveTimelineMarkerTrackFromList(TimelineEditor.inspectedAsset);
if (tracks.Any())
{
SelectionManager.RemoveTimelineSelection();
}
foreach (var track in TrackExtensions.FilterTracks(tracks))
{
var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector);
SelectionManager.Add(newTrack);
foreach (var childTrack in newTrack.GetFlattenedChildTracks())
{
SelectionManager.Add(childTrack);
}
if (TimelineEditor.inspectedDirector != null)
{
var binding = TimelineEditor.inspectedDirector.GetGenericBinding(track);
if (binding != null)
{
TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, L10n.Tr("Duplicate"));
TimelineEditor.inspectedDirector.SetGenericBinding(newTrack, binding);
}
}
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
return(true);
}
void DrawTrackButtons(Rect headerRect, WindowState state)
{
const float buttonSize = WindowConstants.trackHeaderButtonSize;
const float padding = WindowConstants.trackHeaderButtonPadding;
var buttonRect = new Rect(headerRect.xMax - buttonSize - padding, headerRect.y + ((headerRect.height - buttonSize) / 2f), buttonSize, buttonSize);
if (GUI.Button(buttonRect, EditorGUIUtility.IconContent("CreateAddNew"), m_Styles.trackGroupAddButton))
{
// the drop down will apply to all selected tracks
if (!SelectionManager.Contains(track))
{
SelectionManager.Clear();
SelectionManager.Add(track);
}
SequencerContextMenu.ShowNewTracksContextMenu(SelectionManager.SelectedTracks().ToArray(), TimelineWindow.state, buttonRect);
}
buttonRect.x -= buttonSize;
var suitePadding = DrawButtonSuite(2, ref buttonRect);
DrawMuteButton(buttonRect, state);
buttonRect.x -= buttonSize + padding;
DrawLockButton(buttonRect, state);
buttonRect.x -= suitePadding;
}
public static bool SelectDownTrack(bool shift = false)
{
if (TrackHeadActive())
{
var nextTrack = SelectionManager.SelectedTracks().Last().NextTrack();
if (nextTrack != null)
{
if (shift)
{
if (SelectionManager.Contains(nextTrack))
{
SelectionManager.Remove(SelectionManager.SelectedTracks().Last());
}
SelectionManager.Add(nextTrack);
}
else
{
SelectionManager.SelectOnly(nextTrack);
}
FrameTrackHeader(GetVisibleTracks().First(x => x.track == nextTrack));
}
return(true);
}
return(false);
}
public override bool Execute(WindowState state, TrackAsset[] tracks)
{
if (tracks.Any())
{
SelectionManager.RemoveTimelineSelection();
}
foreach (var track in TrackExtensions.FilterTracks(tracks))
{
var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector);
SelectionManager.Add(newTrack);
foreach (var childTrack in newTrack.GetFlattenedChildTracks())
{
SelectionManager.Add(childTrack);
}
if (TimelineEditor.inspectedDirector != null)
{
var binding = TimelineEditor.inspectedDirector.GetGenericBinding(track);
if (binding != null)
{
TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, "Duplicate");
TimelineEditor.inspectedDirector.SetGenericBinding(newTrack, binding);
}
}
}
state.Refresh();
return(true);
}
public override bool Execute(IEnumerable <TrackAsset> tracks)
{
tracks = tracks.RemoveTimelineMarkerTrackFromList(TimelineEditor.inspectedAsset);
if (tracks.Any())
{
SelectionManager.RemoveTimelineSelection();
}
foreach (var track in TrackExtensions.FilterTracks(tracks))
{
var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector);
//Add all duplicated tracks to selection
SelectionManager.Add(newTrack);
foreach (var childTrack in newTrack.GetFlattenedChildTracks())
{
SelectionManager.Add(childTrack);
}
//Duplicate bindings for tracks and subtracks
if (TimelineEditor.inspectedDirector != null)
{
DuplicateBindings(track, newTrack, TimelineEditor.inspectedDirector);
}
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
return(true);
}
public static bool SelectLeftItem(bool shift = false)
{
if (ClipAreaActive())
{
var items = SelectionManager.SelectedItems().ToList();
var clipOnly = FilterItems(ref items);
var item = items.Last();
var prev = item.PreviousItem(clipOnly);
if (prev != null)
{
if (shift)
{
if (SelectionManager.Contains(prev))
{
SelectionManager.Remove(item);
}
SelectionManager.Add(prev);
}
else
{
SelectionManager.SelectOnly(prev);
}
TimelineHelpers.FrameItems(new[] { prev });
}
else if (item != null && !shift && item.parentTrack != TimelineEditor.inspectedAsset.markerTrack)
{
SelectionManager.SelectOnly(item.parentTrack);
}
return(true);
}
return(false);
}
public static bool SelectRightItem(bool shift = false)
{
if (ClipAreaActive())
{
var items = SelectionManager.SelectedItems().ToList();
var clipOnly = FilterItems(ref items);
var item = items.Last();
var next = item.NextItem(clipOnly);
if (next != null)
{
if (shift)
{
if (SelectionManager.Contains(next))
{
SelectionManager.Remove(item);
}
SelectionManager.Add(next);
}
else
{
SelectionManager.SelectOnly(next);
}
TimelineHelpers.FrameItems(new[] { next });
return(true);
}
}
return(false);
}
private static bool CanStartRectableSelect(Event evt, List <IBounds> elements, out bool hasOneSelected)
{
hasOneSelected = false;
bool result;
foreach (IBounds current in elements)
{
if (current != null)
{
if (current is InlineCurveEditor)
{
hasOneSelected = true;
result = false;
return(result);
}
if (current is TimelineItemGUI)
{
SelectionManager.Contains((current as TimelineItemGUI).item);
if (SelectionManager.Contains((current as TimelineItemGUI).item) && evt.get_modifiers() == null)
{
SelectionManager.Add((current as TimelineItemGUI).item);
hasOneSelected = true;
}
result = false;
return(result);
}
}
}
result = true;
return(result);
}
internal bool Execute(WindowState state, Func <ITimelineItem, ITimelineItem, double> gapBetweenItems)
{
var selectedItems = SelectionManager.SelectedItems().ToItemsPerTrack().ToList();
if (selectedItems.Any())
{
var requestedTime = CalculateDuplicateTime(selectedItems, gapBetweenItems);
var duplicatedItems = TimelineHelpers.DuplicateItemsUsingCurrentEditMode(state, TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector, selectedItems, requestedTime, "Duplicate Items");
TimelineHelpers.FrameItems(state, duplicatedItems);
SelectionManager.RemoveTimelineSelection();
foreach (var item in duplicatedItems)
{
SelectionManager.Add(item);
}
}
var tracks = SelectionManager.SelectedTracks().ToArray();
if (tracks.Length > 0)
{
TrackAction.Invoke <DuplicateTracks>(state, tracks);
}
state.Refresh();
return(true);
}
public override bool Execute(ActionContext actionContext)
{
// otherwise select all tracks.
SelectionManager.Clear();
TimelineWindow.instance.allTracks.ForEach(x => SelectionManager.Add(x.track));
return(true);
}
static void FinalizeInsertItemsUsingCurrentEditMode(WindowState state, IList <ItemsPerTrack> itemsGroups, double candidateTime)
{
EditMode.FinalizeInsertItemsAtTime(itemsGroups, candidateTime);
SelectionManager.Clear();
foreach (var itemsGroup in itemsGroups)
{
var track = itemsGroup.targetTrack;
var items = itemsGroup.items;
EditModeUtils.SetParentTrack(items, track);
track.SortClips();
TrackExtensions.ComputeBlendsFromOverlaps(track.clips);
track.CalculateExtrapolationTimes();
foreach (var item in items)
{
if (item.gui != null)
{
item.gui.Select();
}
}
}
var allItems = itemsGroups.SelectMany(x => x.items).ToList();
foreach (var item in allItems)
{
SelectionManager.Add(item);
}
FrameItems(state, allItems);
}
static void PasteTracks()
{
var trackData = TimelineEditor.clipboard.GetTracks().ToList();
if (trackData.Any())
{
SelectionManager.RemoveTimelineSelection();
}
foreach (var track in trackData)
{
var newTrack = track.item.Duplicate(TimelineEditor.clipboard.exposedPropertyTable, TimelineEditor.inspectedDirector, TimelineEditor.inspectedAsset);
if (track.binding != null)
{
TimelineHelpers.Bind(newTrack, track.binding, TimelineEditor.inspectedDirector);
}
SelectionManager.Add(newTrack);
foreach (var childTrack in newTrack.GetFlattenedChildTracks())
{
SelectionManager.Add(childTrack);
}
if (track.parent != null && track.parent.timelineAsset == TimelineEditor.inspectedAsset)
{
TrackExtensions.ReparentTracks(new List <TrackAsset> {
newTrack
}, track.parent, track.item);
}
}
}
internal bool Execute(ActionContext context, Func <ITimelineItem, ITimelineItem, double> gapBetweenItems)
{
List <ITimelineItem> items = new List <ITimelineItem>();
items.AddRange(context.clips.Select(p => p.ToItem()));
items.AddRange(context.markers.Select(p => p.ToItem()));
List <ItemsPerTrack> selectedItems = items.ToItemsPerTrack().ToList();
if (selectedItems.Any())
{
var requestedTime = CalculateDuplicateTime(selectedItems, gapBetweenItems);
var duplicatedItems = TimelineHelpers.DuplicateItemsUsingCurrentEditMode(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector, selectedItems, requestedTime, "Duplicate Items");
TimelineHelpers.FrameItems(duplicatedItems);
SelectionManager.RemoveTimelineSelection();
foreach (var item in duplicatedItems)
{
SelectionManager.Add(item);
}
}
var tracks = context.tracks.ToArray();
if (tracks.Length > 0)
{
tracks.Invoke <DuplicateTracks>();
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
return(true);
}
internal void ItemDoubleClickedCallback(int id)
{
var gui = m_TreeView.FindItem(id);
var trackGUI = gui as TimelineTrackGUI;
if (trackGUI != null)
{
if (trackGUI.track == null || trackGUI.track.lockedInHierarchy)
{
return;
}
var selection = SelectionManager.SelectedItems().ToList();
var items = ItemsUtils.GetItems(trackGUI.track).ToList();
var addToSelection = !selection.SequenceEqual(items);
foreach (var i in items)
{
if (addToSelection)
{
SelectionManager.Add(i);
}
else
{
SelectionManager.Remove(i);
}
}
return;
}
if (gui is TimelineGroupGUI groupGUI)
{
KeyboardNavigation.ToggleCollapseGroup(new[] { groupGUI.track });
}
}
private static void HandleSingleSelection(Event evt, TimelineWindow.TimelineState state, List <IBounds> elements)
{
if (RectangleSelect.CanClearSelection(evt))
{
SelectionManager.Clear();
}
TimelineItemGUI timelineItemGUI = RectangleSelect.PickItemGUI(elements);
if (evt.get_modifiers() == 1)
{
timelineItemGUI.parentTrackGUI.RangeSelectItems(timelineItemGUI, state);
}
else if (evt.get_modifiers() == 2 || evt.get_modifiers() == 8)
{
bool flag = SelectionManager.Contains(timelineItemGUI.item);
if (flag)
{
SelectionManager.Remove(timelineItemGUI.item);
}
else
{
SelectionManager.Add(timelineItemGUI.item);
}
}
else
{
SelectionManager.Add(timelineItemGUI.item);
}
}
public static bool SelectUpTrack(bool shift = false)
{
if (TrackHeadActive())
{
var prevTrack = PreviousTrack(SelectionManager.SelectedTracks().Last());
if (prevTrack != null)
{
if (shift)
{
if (SelectionManager.Contains(prevTrack))
{
SelectionManager.Remove(SelectionManager.SelectedTracks().Last());
}
SelectionManager.Add(prevTrack);
}
else
{
SelectionManager.SelectOnly(prevTrack);
}
FrameTrackHeader(GetVisibleTracks().First(x => x.track == prevTrack));
}
return(true);
}
return(false);
}
void ItemDoubleClickedCallback(int id)
{
var trackGUI = m_TreeView.FindItem(id) as TimelineTrackGUI;
if (trackGUI == null)
{
return;
}
if (trackGUI.track == null || trackGUI.track.lockedInHierarchy)
{
return;
}
var selection = SelectionManager.SelectedItems().ToList();
var items = ItemsUtils.GetItems(trackGUI.track).ToList();
var addToSelection = !selection.SequenceEqual(items);
foreach (var i in items)
{
if (addToSelection)
{
SelectionManager.Add(i);
}
else
{
SelectionManager.Remove(i);
}
}
}
void Cancel()
{
if (!m_Grabbing)
{
return;
}
// TODO fix undo reselection persistency
// identify the clips by their playable asset, since that reference will survive the undo
// This is a workaround, until a more persistent fix for selection of clips across Undo can be found
var assets = movingItems.SelectMany(x => x.clips).Select(x => x.asset);
Undo.RevertAllDownToGroup(m_GrabbedModalUndoGroup);
// reselect the clips from the original clip
var clipsToSelect = movingItems.Select(x => x.originalTrack).SelectMany(x => x.GetClips()).Where(x => assets.Contains(x.asset)).ToArray();
SelectionManager.RemoveTimelineSelection();
foreach (var c in clipsToSelect)
{
SelectionManager.Add(c);
}
Done();
}
static void PasteTracks(WindowState state)
{
var trackData = TimelineEditor.clipboard.GetTracks().ToList();
if (trackData.Any())
{
SelectionManager.RemoveTimelineSelection();
}
foreach (var track in trackData)
{
var newTrack = track.item.Duplicate(state.editSequence.director, state.editSequence.asset);
SelectionManager.Add(newTrack);
foreach (var childTrack in newTrack.GetFlattenedChildTracks())
{
SelectionManager.Add(childTrack);
}
if (track.parent != null && track.parent.timelineAsset == state.editSequence.asset)
{
TrackExtensions.ReparentTracks(new List <TrackAsset> {
newTrack
}, track.parent, track.item);
}
}
}
public static TimelineClip CreateClipOnTrack(Object asset, TrackAsset parentTrack, ITimelineState state, Vector2 mousePosition)
{
double end = parentTrack.end;
TimelineClip timelineClip = parentTrack.CreateClipFromAsset(asset);
if (timelineClip != null)
{
SelectionManager.Clear();
timelineClip.timeScale = 1.0;
if (!float.IsPositiveInfinity(mousePosition.x) && !float.IsPositiveInfinity(mousePosition.y))
{
timelineClip.start = (double)state.ScreenSpacePixelToTimeAreaTime(mousePosition.x);
}
else
{
timelineClip.start = state.SnapToFrameIfRequired(end);
}
timelineClip.start = Math.Max(0.0, timelineClip.start);
timelineClip.mixInCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
timelineClip.mixOutCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
SelectionManager.Add(timelineClip);
parentTrack.CalculateExtrapolationTimes();
state.Refresh();
}
return(timelineClip);
}
void SelectionChangedCallback(int[] ids)
{
if (Event.current.button == 1)
{
var selectableItem = PickerUtils.PickedSelectable();
if (selectableItem != null)
{
return;
}
}
if (Event.current.command || Event.current.control || Event.current.shift)
{
SelectionManager.UnSelectTracks();
}
else
{
SelectionManager.Clear();
}
foreach (var id in ids)
{
var trackGUI = (TimelineTrackBaseGUI)m_TreeView.FindItem(id);
SelectionManager.Add(trackGUI.track);
}
m_State.GetWindow().Repaint();
}
public override bool Execute(TimelineWindow.TimelineState state, TimelineMarker[] markers)
{
PlayableDirector directorComponent = (state == null) ? null : state.currentDirector;
bool result;
if (!markers.Any <TimelineMarker>())
{
result = false;
}
else
{
SelectionManager.Clear();
for (int i = 0; i < markers.Length; i++)
{
TimelineMarker theMarker = markers[i];
TimelineMarker timelineMarker = MarkerModifiers.Duplicate(theMarker, directorComponent);
if (timelineMarker != null && state != null)
{
SelectionManager.Add(timelineMarker);
}
}
if (state != null)
{
state.Refresh();
}
result = true;
}
return(result);
}
public override bool Execute(WindowState state)
{
// otherwise select all tracks.
SelectionManager.Clear();
state.GetWindow().allTracks.ForEach(x => SelectionManager.Add(x.track));
return(true);
}
public override void Select()
{
zOrder = zOrderProvider.Next();
SelectionManager.Add(clip);
if (clipCurveEditor != null && SelectionManager.Count() == 1)
{
SelectionManager.SelectInlineCurveEditor(this);
}
}
public override void Select()
{
MoveToTop();
SelectionManager.Add(clip);
if (clipCurveEditor != null && SelectionManager.Count() == 1)
{
SelectionManager.SelectInlineCurveEditor(this);
}
}
static void AddMarkersCallback(ICollection <TrackAsset> targets, Type markerType, double time, Object obj)
{
SelectionManager.Clear();
foreach (var target in targets)
{
var marker = TimelineHelpers.CreateMarkerOnTrack(markerType, obj, target, time);
SelectionManager.Add(marker);
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
}
protected float DrawTrackDropDownMenu(Rect rect, TimelineWindow.TimelineState state)
{
rect.set_y(rect.get_y() + 2f);
if (GUI.Button(rect, GUIContent.none, this.m_Styles.trackOptions))
{
SelectionManager.Clear();
SelectionManager.Add(base.track);
base.DisplayTrackMenu(state);
}
return(16f);
}
protected override bool MouseDown(Event evt, WindowState state)
{
var handle = PickerUtils.PickedLayerableOfType <TimelineClipHandle>();
if (handle == null)
{
return(false);
}
if (handle.clipGUI.clip.parentTrack != null && handle.clipGUI.clip.parentTrack.lockedInHierarchy)
{
return(false);
}
if (ItemSelection.CanClearSelection(evt))
{
SelectionManager.Clear();
}
if (!SelectionManager.Contains(handle.clipGUI.clip))
{
SelectionManager.Add(handle.clipGUI.clip);
}
m_TrimClipHandler = handle;
m_IsCaptured = true;
state.AddCaptured(this);
m_UndoSaved = false;
var clip = m_TrimClipHandler.clipGUI.clip;
m_OriginalDuration = clip.duration;
m_OriginalTimeScale = clip.timeScale;
m_OriginalEaseInDuration = clip.easeInDuration;
m_OriginalEaseOutDuration = clip.easeOutDuration;
RefreshOverlayStrings(m_TrimClipHandler, state);
// in ripple trim, the right edge moves and needs to snap
var edges = ManipulateEdges.Right;
if (EditMode.editType != EditMode.EditType.Ripple && m_TrimClipHandler.trimDirection == TrimEdge.Start)
{
edges = ManipulateEdges.Left;
}
m_SnapEngine = new SnapEngine(m_TrimClipHandler.clipGUI, new TrimClipAttractionHandler(), edges, state,
evt.mousePosition);
EditMode.BeginTrim(ItemsUtils.ToItem(clip), m_TrimClipHandler.trimDirection);
return(true);
}
private static void HandleReselection(List <IBounds> elements)
{
foreach (IBounds current in elements)
{
if (current is TimelineClipGUI)
{
TimelineClipGUI timelineClipGUI = current as TimelineClipGUI;
SelectionManager.Add(timelineClipGUI.item);
break;
}
}
}
float DrawTrackDropDownMenu(Rect rect)
{
rect.y += WindowConstants.trackOptionButtonVerticalPadding;
if (GUI.Button(rect, GUIContent.none, m_Styles.trackOptions))
{
SelectionManager.Clear();
SelectionManager.Add(track);
DisplayTrackMenu();
}
return(WindowConstants.trackHeaderButtonSize);
}
