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 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 DrawBoundsEdge(Rect bounds, Color color, TrimEdge edge, float width = 4.0f)
{
var r = bounds;
r.yMin += 2.0f;
r.yMax -= 2.0f;
r.width = width;
r.x = edge == TrimEdge.End ? bounds.xMax : bounds.xMin - width;
EditorGUI.DrawRect(r, color);
}
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 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 TrimClipWithEditMode(TimelineClip clip, TrimEdge edge, double time)
{
var clipItem = ItemsUtils.ToItem(clip);
EditMode.BeginTrim(clipItem, edge);
if (edge == TrimEdge.Start)
{
EditMode.TrimStart(clipItem, time);
}
else
{
EditMode.TrimEnd(clipItem, time, false);
}
EditMode.FinishTrim();
}
public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge)
{
if (EditModeUtils.HasBlends(m_Item, edge))
{
EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge);
var cursorType = (edge == TrimEdge.End)
? TimelineCursors.CursorType.MixRight
: TimelineCursors.CursorType.MixLeft;
TimelineCursors.SetCursor(cursorType);
}
else
{
TimelineCursors.ClearCursor();
}
}
public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection)
{
m_OriginalClipStart = item.start;
m_OriginalClipEnd = item.end;
m_TrimStartShift = 0.0;
var sortedClips = ItemsUtils.GetItemsExcept(item.parentTrack, new[] { item })
.OfType <ITrimmable>()
.OrderBy(c => c.start);
var clipStart = (DiscreteTime)item.start;
var clipEnd = (DiscreteTime)item.end;
m_NextItems = sortedClips.Where(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd).ToArray();
var overlapped = sortedClips.LastOrDefault(c => (DiscreteTime)c.start == clipStart && (DiscreteTime)c.end == clipEnd);
if (overlapped != null)
{
m_BlendDuration = overlapped.end - overlapped.start;
}
else
{
m_BlendDuration = 0.0;
var prevClip = sortedClips.LastOrDefault(c => (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end <= clipEnd);
if (prevClip != null)
{
m_BlendDuration += Math.Max(prevClip.end - item.start, 0.0);
}
var nextClip = sortedClips.FirstOrDefault(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd);
if (nextClip != null)
{
m_BlendDuration += Math.Max(item.end - nextClip.start, 0.0);
}
}
}
public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge)
{
bool shouldDraw = m_ItemToBeReplaced != null && (edge == TrimEdge.End && m_Item.end > m_ClipOriginalEdgeValue) ||
(edge == TrimEdge.Start && m_Item.start < m_ClipOriginalEdgeValue);
if (shouldDraw)
{
var cursorType = TimelineCursors.CursorType.Replace;
if (EditModeUtils.HasBlends(m_Item, edge))
{
color = DirectorStyles.kMixToolColor;
cursorType = (edge == TrimEdge.End)
? TimelineCursors.CursorType.MixRight
: TimelineCursors.CursorType.MixLeft;
}
EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge);
TimelineCursors.SetCursor(cursorType);
}
else
{
TimelineCursors.ClearCursor();
}
}
public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection)
{
m_Item = item;
var sortedItems = ItemsUtils.GetItemsExcept(item.parentTrack, new[] { item })
.OfType <ITrimmable>()
.OrderBy(c => c.start);
var itemStart = (DiscreteTime)item.start;
var itemEnd = (DiscreteTime)item.end;
var overlapped = sortedItems.LastOrDefault(c => (DiscreteTime)c.start == itemStart && (DiscreteTime)c.end == itemEnd);
ITrimmable nextItem;
ITrimmable prevItem;
m_Min = 0.0;
m_Max = double.PositiveInfinity;
var blendableItem = item as IBlendable;
if (blendableItem != null && blendableItem.supportsBlending)
{
if (trimDirection == TrimEdge.Start)
{
nextItem = sortedItems.FirstOrDefault(c => (DiscreteTime)c.start >= itemStart && (DiscreteTime)c.end > itemEnd);
prevItem = sortedItems.LastOrDefault(c => (DiscreteTime)c.start <= itemStart && (DiscreteTime)c.end < itemEnd);
if (prevItem != null)
{
m_Min = prevItem.start + EditModeUtils.BlendDuration(prevItem, TrimEdge.Start);
}
if (nextItem != null)
{
m_Max = nextItem.start;
}
}
else
{
nextItem = sortedItems.FirstOrDefault(c => c != overlapped && (DiscreteTime)c.start >= itemStart && (DiscreteTime)c.end >= itemEnd);
prevItem = sortedItems.LastOrDefault(c => c != overlapped && (DiscreteTime)c.start <= itemStart && (DiscreteTime)c.end <= itemEnd);
if (prevItem != null)
{
m_Min = prevItem.end;
}
if (nextItem != null)
{
m_Max = nextItem.end - EditModeUtils.BlendDuration(nextItem, TrimEdge.End);
}
}
}
else
{
nextItem = sortedItems.FirstOrDefault(c => (DiscreteTime)c.start > itemStart);
prevItem = sortedItems.LastOrDefault(c => (DiscreteTime)c.start < itemStart);
if (prevItem != null)
{
m_Min = prevItem.end;
}
if (nextItem != null)
{
m_Max = nextItem.start;
}
}
}
public static void DrawTrimGUI(WindowState state, TimelineItemGUI item, TrimEdge edge)
{
trimDrawer.DrawGUI(state, item.rect, modeColor, edge);
}
public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection)
{
m_Item = item;
var sortedClips = ItemsUtils.GetItemsExcept(item.parentTrack, new[] { item })
.OfType <ITrimmable>()
.OrderBy(c => c.start);
var clipStart = (DiscreteTime)item.start;
var clipEnd = (DiscreteTime)item.end;
var overlapped = sortedClips.LastOrDefault(c => (DiscreteTime)c.start == clipStart && (DiscreteTime)c.end == clipEnd);
ITrimmable nextItem;
ITrimmable prevItem;
m_Min = 0.0;
m_Max = double.PositiveInfinity;
if (trimDirection == TrimEdge.Start)
{
nextItem = sortedClips.FirstOrDefault(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end > clipEnd);
prevItem = sortedClips.LastOrDefault(c => (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end < clipEnd);
if (prevItem != null)
{
m_Min = prevItem.start + EditModeUtils.BlendDuration(prevItem, TrimEdge.Start) + TimelineClip.kMinDuration;
}
if (nextItem != null)
{
m_Max = nextItem.start;
}
m_ItemToBeReplaced = prevItem;
if (m_ItemToBeReplaced != null)
{
m_ClipOriginalEdgeValue = m_ItemToBeReplaced.end;
}
}
else
{
nextItem = sortedClips.FirstOrDefault(c => c != overlapped && (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd);
prevItem = sortedClips.LastOrDefault(c => c != overlapped && (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end <= clipEnd);
if (prevItem != null)
{
m_Min = prevItem.end;
}
if (nextItem != null)
{
m_Max = nextItem.end - EditModeUtils.BlendDuration(nextItem, TrimEdge.End) - TimelineClip.kMinDuration;
}
m_ItemToBeReplaced = nextItem;
if (m_ItemToBeReplaced != null)
{
m_ClipOriginalEdgeValue = m_ItemToBeReplaced.start;
}
}
m_TrimReplace = false;
}
public TimelineClipHandle(TimelineClipGUI theClipGUI, TrimEdge trimDirection)
{
m_TrimDirection = trimDirection;
m_ClipGUI = theClipGUI;
}
public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge)
{
EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge);
TimelineCursors.SetCursor(TimelineCursors.CursorType.Ripple);
}
public TimelineClipHandle(TimelineClipGUI theClipGUI, TrimEdge trimDirection)
{
m_TrimDirection = trimDirection;
m_ClipGUI = theClipGUI;
m_ZOrder = theClipGUI.zOrder.ChangeLayer(Layer.ClipHandles);
}
