static bool SelectFirstClipStartingFrom(TrackAsset track)
{
List <TrackAsset> visibleTracks = GetVisibleTracks().Select(x => x.track).ToList();
int idx = visibleTracks.IndexOf(track);
ITimelineItem item = null;
for (int i = idx; i < visibleTracks.Count; ++i)
{
var items = visibleTracks[i].GetItems().OfType <ClipItem>();
if (!items.Any() || visibleTracks[i].lockedInHierarchy)
{
continue;
}
item = items.First();
break;
}
if (item != null)
{
SelectionManager.SelectOnly(item);
TimelineHelpers.FrameItems(new[] { item });
return(true);
}
return(false);
}
static PrevItemInfo CalculatePrevItemInfo(List <ITimelineItem> orderedSelection, List <ITimelineItem> orderedSiblings, IEnumerable <Type> itemTypes)
{
ITimelineItem previousItem = null;
ITimelineItem firstSelectedItem = null;
var gap = double.PositiveInfinity;
foreach (var type in itemTypes)
{
var firstSelectedItemOfType = orderedSelection.FirstOrDefault(i => i.GetType() == type);
if (firstSelectedItemOfType == null)
{
continue;
}
var previousItemOfType = orderedSiblings.LastOrDefault(i => i.GetType() == type && i.start < firstSelectedItemOfType.start);
if (previousItemOfType == null)
{
continue;
}
var currentGap = firstSelectedItemOfType.start - previousItemOfType.end;
if (currentGap < gap)
{
gap = currentGap;
firstSelectedItem = firstSelectedItemOfType;
previousItem = previousItemOfType;
}
}
return(new PrevItemInfo(previousItem, firstSelectedItem));
}
public static bool InvokeByName <T>(string actionName, TimelineWindow.TimelineState state, T item) where T : class, ITimelineItem
{
ITimelineItem[] items = new ITimelineItem[]
{
item
};
return(ItemActionInvoker.InvokeByName <T>(actionName, state, items));
}
public static double BlendDuration(ITimelineItem item, TrimEdge edge)
{
var blendable = item as IBlendable;
if (blendable == null)
{
return(0.0);
}
return(edge == TrimEdge.Start ? blendable.leftBlendDuration : blendable.rightBlendDuration);
}
public static void TrimEnd(ITimelineItem item, double time, bool affectTimeScale)
{
var itemToTrim = item as ITrimmable;
if (itemToTrim == null)
{
return;
}
trimMode.TrimEnd(itemToTrim, time, affectTimeScale);
}
public static void TrimStart(ITimelineItem item, double time)
{
var itemToTrim = item as ITrimmable;
if (itemToTrim == null)
{
return;
}
trimMode.TrimStart(itemToTrim, time);
}
public static double TimeGapBetweenItems(ITimelineItem leftItem, ITimelineItem rightItem)
{
if (leftItem is MarkerItem && rightItem is MarkerItem)
{
var markerType = ((MarkerItem)leftItem).marker.GetType();
var gap = TimeReferenceUtility.PixelToTime(StyleManager.UssStyleForType(markerType).fixedWidth) - TimeReferenceUtility.PixelToTime(0);
return(gap);
}
return(0.0);
}
public static double TimeGapBetweenItems(ITimelineItem leftItem, ITimelineItem rightItem, WindowState state)
{
if (leftItem is MarkerItem && rightItem is MarkerItem)
{
var markerType = ((MarkerItem)leftItem).marker.GetType();
var gap = state.PixelDeltaToDeltaTime(StyleManager.UssStyleForType(markerType).fixedWidth);
return(gap);
}
return(0.0);
}
public static bool HasBlends(ITimelineItem item, TrimEdge edge)
{
var blendable = item as IBlendable;
if (blendable == null)
{
return(false);
}
return(edge == TrimEdge.Start && blendable.hasLeftBlend || edge == TrimEdge.End && blendable.hasRightBlend);
}
public static bool Contains(ITimelineItem item)
{
var clipItem = item as ClipItem;
if (clipItem != null)
{
return(Contains(clipItem.clip));
}
var markerItem = item as MarkerItem;
return(markerItem != null && Contains(markerItem.marker));
}
public static void BeginTrim(ITimelineItem item, TrimEdge trimDirection)
{
var itemToTrim = item as ITrimmable;
if (itemToTrim == null)
{
return;
}
s_CurrentTrimItem = itemToTrim;
s_CurrentTrimDirection = trimDirection;
trimMode.OnBeforeTrim(itemToTrim, trimDirection);
TimelineUndo.PushUndo(itemToTrim.parentTrack, "Trim Clip");
}
public static void BeginTrim(ITimelineItem item, TrimEdge trimDirection)
{
var itemToTrim = item as ITrimmable;
if (itemToTrim == null)
{
return;
}
s_CurrentTrimItem = itemToTrim;
s_CurrentTrimDirection = trimDirection;
trimMode.OnBeforeTrim(itemToTrim, trimDirection);
UndoExtensions.RegisterTrack(itemToTrim.parentTrack, L10n.Tr("Trim Clip"));
}
public static bool UnCollapseGroup()
{
if (TrackHeadActive())
{
var quit = false;
foreach (var track in SelectionManager.SelectedTracks())
{
if (!track.GetChildTracks().Any())
{
continue;
}
if (!quit && track.GetCollapsed())
{
quit = true;
}
track.SetCollapsed(false);
}
if (quit)
{
TimelineEditor.Refresh(RefreshReason.ContentsModified);
return(true);
}
// Transition to Clip area
var visibleTracks = GetVisibleTracks().Select(x => x.track).ToList();
var idx = visibleTracks.IndexOf(SelectionManager.SelectedTracks().Last());
ITimelineItem item = null;
for (var i = idx; i < visibleTracks.Count; ++i)
{
var items = visibleTracks[i].GetItems().OfType <ClipItem>();
if (!items.Any())
{
continue;
}
item = items.First();
break;
}
if (item != null)
{
SelectionManager.SelectOnly(item);
TimelineHelpers.FrameItems(new[] { item });
return(true);
}
}
return(false);
}
public static void RangeSelectItems(ITimelineItem lastItemToSelect)
{
var selectSorted = SelectionManager.SelectedItems().ToList();
var firstSelect = selectSorted.FirstOrDefault();
if (firstSelect == null)
{
SelectionManager.Add(lastItemToSelect);
return;
}
var allItems = TimelineWindow.instance.allTracks.OfType <TimelineTrackGUI>().SelectMany(ttGui => ItemsUtils.GetItems(ttGui.track)).ToList();
TimelineHelpers.RangeSelect(allItems, selectSorted, lastItemToSelect, SelectionManager.Add, SelectionManager.Remove);
}
public static void RangeSelectItems(ITimelineItem lastItemToSelect)
{
var selectSorted = SelectionManager.SelectedItems().ToList();
var firstSelect = selectSorted.FirstOrDefault();
if (firstSelect == null)
{
SelectionManager.Add(lastItemToSelect);
return;
}
var allTracks = TimelineEditor.inspectedAsset.flattenedTracks;
var allItems = allTracks.SelectMany(ItemsUtils.GetItems).ToList();
TimelineHelpers.RangeSelect(allItems, selectSorted, lastItemToSelect, SelectionManager.Add, SelectionManager.Remove);
}
static void DrawItemInternal(ITimelineItem item, Rect rect, bool isValid)
{
var clipGUI = item.gui as TimelineClipGUI;
if (clipGUI != null)
{
if (isValid)
{
clipGUI.DrawGhostClip(rect);
}
else
{
clipGUI.DrawInvalidClip(rect);
}
}
}
public static bool Contains(ITimelineItem item)
{
TimelineClip timelineClip = item as TimelineClip;
bool result;
if (timelineClip != null)
{
result = SelectionManager.Contains(timelineClip);
}
else
{
TimelineMarker timelineMarker = item as TimelineMarker;
result = (timelineMarker != null && SelectionManager.Contains(timelineMarker));
}
return(result);
}
internal virtual bool IsCompatibleWithItem(ITimelineItem item)
{
TimelineClip timelineClip = item as TimelineClip;
bool result;
if (timelineClip != null)
{
result = this.ValidateClipType(timelineClip.asset.GetType());
}
else
{
TimelineMarker timelineMarker = item as TimelineMarker;
result = (timelineMarker != null && this is ITimelineMarkerContainer);
}
return(result);
}
public static void Add(ITimelineItem item)
{
TimelineClip timelineClip = item as TimelineClip;
if (timelineClip != null)
{
SelectionManager.Add(timelineClip);
}
else
{
TimelineMarker timelineMarker = item as TimelineMarker;
if (timelineMarker != null)
{
SelectionManager.Add(timelineMarker);
}
}
}
public static void Add(ITimelineItem item)
{
var clipItem = item as ClipItem;
if (clipItem != null)
{
Add(clipItem.clip);
}
else
{
var markerItem = item as MarkerItem;
if (markerItem != null)
{
Add(markerItem.marker);
}
}
}
public static void SelectOnly(ITimelineItem item)
{
var clipItem = item as ClipItem;
if (clipItem != null)
{
SelectOnly(clipItem.clip);
}
else
{
var markerItem = item as MarkerItem;
if (markerItem != null)
{
SelectOnly(markerItem.marker);
}
}
}
static ITimelineItem NextItem(this ITimelineItem item, bool clipOnly)
{
var items = item.parentTrack.GetItems().ToArray();
if (clipOnly)
{
items = items.Where(x => x is ClipItem).ToArray();
}
else
{
items = items.Where(x => x is MarkerItem).ToArray();
}
var idx = Array.IndexOf(items, item);
return(idx < items.Length - 1 ? items[idx + 1] : null);
}
public void AddAndIncrementSequence(ITimelineItem timelineItem)
{
Add(timelineItem);
switch (timelineItem)
{
case MediaFile _:
MediaSequence++;
break;
case Discontinuity _:
DiscontinuitySequence = DiscontinuitySequence + 1;
break;
default:
throw new ArgumentException($"Unsupported value: {timelineItem}");
}
}
public static bool Overlaps(ITimelineItem item, double from, double to)
{
var discreteFrom = (DiscreteTime)from;
var discreteTo = (DiscreteTime)to;
var discreteStart = (DiscreteTime)item.start;
if (discreteStart >= discreteFrom && discreteStart < discreteTo)
{
return(true);
}
var discreteEnd = (DiscreteTime)item.end;
if (discreteEnd > discreteFrom && discreteEnd <= discreteTo)
{
return(true);
}
return(false);
}
public ItemsGroup(IEnumerable <ITimelineItem> items)
{
Debug.Assert(items != null && items.Any());
m_Items = items.ToArray();
m_LeftMostItem = null;
m_RightMostItem = null;
foreach (var item in m_Items)
{
if (m_LeftMostItem == null || item.start < m_LeftMostItem.start)
{
m_LeftMostItem = item;
}
if (m_RightMostItem == null || item.end > m_RightMostItem.end)
{
m_RightMostItem = item;
}
}
}
static ITimelineItem GetClosestItem(TrackAsset track, ITimelineItem refItem)
{
var start = refItem.start;
var end = refItem.end;
var items = track.GetItems().ToList();
if (refItem is ClipItem)
{
items = items.Where(x => x is ClipItem).ToList();
}
else
{
items = items.Where(x => x is MarkerItem).ToList();
}
if (!items.Any())
{
return(null);
}
ITimelineItem ret = null;
var scoreToBeat = double.NegativeInfinity;
foreach (var item in items)
{
// test for overlap
var low = Math.Max(item.start, start);
var high = Math.Min(item.end, end);
if (low <= high)
{
var score = high - low;
if (score >= scoreToBeat)
{
scoreToBeat = score;
ret = item;
}
}
}
return(ret);
}
public TimelineItemViewModel(ITimelineItem model)
{
this.model = model;
}
public bool Equals(ITimelineItem other)
{
return(Equals((object)other));
}
public void AddItem(ITimelineItem[] items)
{
if (items == null || items.Length == 0)
{
return;
}
lock (_timelineItems)
{
foreach (ITimelineItem item in items)
{
if (_itemDateMax < item.ItemEndTime)
{
_itemDateMax = item.ItemEndTime;
}
_timelineItems.Add(item);
}
_timelineItems.AddRange(items);
// int width = (int)Math.Ceiling((_itemDateMax - _worldStartTime).TotalMinutes * _currentWidthPerMinutes);
// int height = (int)Math.Ceiling(_axes.Count * _axisHeight);
// SetAutoScrollMinSize(new Size(width, height));
}
}
public void AddItem(ITimelineItem item)
{
AddItem(new ITimelineItem[] { item });
}
public ReceivedTimelineEventArgs(ITimelineItem[] receivedItems)
{
this.ReceivedItems = receivedItems;
}
protected virtual void OnReceivedTimeline(ITimelineItem[] receivedItems)
{
if (this.ReceivedTimeline != null)
this.ReceivedTimeline(this, new ReceivedTimelineEventArgs(receivedItems));
}
public PrevItemInfo(ITimelineItem item, ITimelineItem firstSelectedItem)
{
this.item = item;
this.firstSelectedItem = firstSelectedItem;
blending = item != null && item.end > firstSelectedItem.start;
}
public static PlacementValidity GetPlacementValidity(ITimelineItem item, IEnumerable <ITimelineItem> otherItems)
{
if (item.duration <= 0.0)
{
return(PlacementValidity.Valid); //items without any duration can always be placed
}
var sortedItems = otherItems.Where(i => i.duration > 0.0).OrderBy(c => c.start);
var candidates = new List <ITimelineItem>();
foreach (var sortedItem in sortedItems)
{
if ((DiscreteTime)sortedItem.start >= (DiscreteTime)item.end)
{
// No need to process further
break;
}
if ((DiscreteTime)sortedItem.end <= (DiscreteTime)item.start)
{
// Skip
continue;
}
candidates.Add(sortedItem);
}
var discreteStart = (DiscreteTime)item.start;
var discreteEnd = (DiscreteTime)item.end;
// Note: Order of tests matters
for (int i = 0, n = candidates.Count; i < n; i++)
{
var candidate = candidates[i];
var blendItem = item as IBlendable;
if (blendItem != null && blendItem.supportsBlending)
{
if (EditModeUtils.Contains(candidate.start, candidate.end, item))
{
return(PlacementValidity.InvalidIsWithin);
}
if (i < n - 1)
{
var nextCandidate = candidates[i + 1];
var discreteNextCandidateStart = (DiscreteTime)nextCandidate.start;
var discreteCandidateEnd = (DiscreteTime)candidate.end;
if (discreteCandidateEnd > discreteNextCandidateStart)
{
if (discreteStart >= discreteNextCandidateStart)
{
// Note: In case the placement is fully within a blend,
// InvalidStartsInBlend MUST have priority
return(PlacementValidity.InvalidStartsInBlend);
}
if (discreteEnd > discreteNextCandidateStart && discreteEnd <= discreteCandidateEnd)
{
return(PlacementValidity.InvalidEndsInBlend);
}
if (discreteStart < discreteNextCandidateStart && discreteEnd > discreteCandidateEnd)
{
return(PlacementValidity.InvalidContainsBlend);
}
}
}
if (EditModeUtils.Contains(item.start, item.end, candidate))
{
return(PlacementValidity.InvalidContains);
}
}
else
{
if (EditModeUtils.Overlaps(item, candidate.start, candidate.end) ||
EditModeUtils.Overlaps(candidate, item.start, item.end))
{
return(PlacementValidity.InvalidOverlapWithNonBlendableClip);
}
}
}
return(PlacementValidity.Valid);
}
public ITimelineItem AddTimelineItem(ITimelineItem timelineItemToAdd, ITimelineItem previousTimelineItem)
{
throw new System.NotImplementedException();
}
