public void TrimStart(ITrimmable item, double time, bool affectTimeScale)
{
var prevEnd = item.end;
// HACK If time is negative, make sure we shift the SetStart operation to a positive space.
if (time < 0.0)
{
m_TrimStartShift = Math.Max(-time, m_TrimStartShift);
}
item.start = m_OriginalClipEnd - item.duration + m_TrimStartShift;
time += m_TrimStartShift;
if (m_BlendDuration > 0.0)
{
time = Math.Min(time, item.end - m_BlendDuration);
}
item.SetStart(time, affectTimeScale);
item.start = m_OriginalClipStart;
var offset = item.end - prevEnd;
foreach (var timelineClip in m_NextItems)
{
timelineClip.start += offset;
}
}
public static void FinishTrim()
{
s_CurrentTrimItem = null;
TimelineCursors.ClearCursor();
ClearEditMode();
}
public static void FinishTrim()
{
s_CurrentTrimItem = null;
TimelineCursors.ClearCursor();
ClearEditMode();
TimelineEditor.Refresh(RefreshReason.ContentsModified);
}
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 void TrimEnd(ITrimmable item, double time, bool affectTimeScale)
{
var prevEnd = item.end;
if (m_BlendDuration > 0.0)
{
time = Math.Max(time, item.start + m_BlendDuration);
}
item.SetEnd(time, affectTimeScale);
var offset = item.end - prevEnd;
foreach (var timelineClip in m_NextItems)
{
timelineClip.start += offset;
}
}
public void TrimEnd(ITrimmable item, double time, bool affectTimeScale)
{
time = Math.Min(Math.Max(time, m_Min), m_Max);
if (m_ItemToBeReplaced != null)
{
if (!m_TrimReplace)
{
m_TrimReplace = item.end <= m_ItemToBeReplaced.start;
}
}
item.SetEnd(time, affectTimeScale);
if (m_ItemToBeReplaced != null && m_TrimReplace)
{
var nextStart = Math.Max(item.end, m_ClipOriginalEdgeValue);
m_ItemToBeReplaced.SetStart(nextStart);
}
}
private void Cleanup()
{
WeakReference reference;
int count = this.registeredObjects.Count;
while ((count > 0) && this.registeredObjects.TryDequeue(out reference))
{
count--;
ITrimmable target = reference.Target as ITrimmable;
if ((target != null) && reference.IsAlive)
{
IIsDisposed disposed = target as IIsDisposed;
if ((disposed == null) || !disposed.IsDisposed)
{
target.Trim();
this.registeredObjects.Enqueue(reference);
}
}
}
}
public void TrimStart(ITrimmable item, double time)
{
time = Math.Min(Math.Max(time, m_Min), m_Max);
if (m_ItemToBeReplaced != null)
{
if (!m_TrimReplace)
{
m_TrimReplace = item.start >= m_ItemToBeReplaced.end;
}
}
time = Math.Max(time, 0.0);
item.SetStart(time);
if (m_ItemToBeReplaced != null && m_TrimReplace)
{
var prevEnd = Math.Min(item.start, m_ClipOriginalEdgeValue);
m_ItemToBeReplaced.SetEnd(prevEnd, false);
}
}
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 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 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 void RegisterTrimmableObject(ITrimmable trimmableObject)
{
CleanupManager.RegisterTrimmableObject(trimmableObject);
}
internal static void RegisterTrimmableObject(ITrimmable trimmableObject)
{
trimmableCleanupSource.RegisterTrimmableObject(trimmableObject);
}
public void RegisterTrimmableObject(ITrimmable trimmable)
{
Validate.IsNotNull <ITrimmable>(trimmable, "trimmable");
this.registeredObjects.Enqueue(new WeakReference(trimmable));
}
public void TrimStart(ITrimmable item, double time)
{
time = Math.Min(Math.Max(time, m_Min), m_Max);
item.SetStart(time);
}
public void TrimEnd(ITrimmable item, double time, bool affectTimeScale)
{
time = Math.Min(Math.Max(time, m_Min), m_Max);
item.SetEnd(time, affectTimeScale);
}
public static void RegisterTrimmableObject(ITrimmable trimmable)
{
controller.RegisterTrimmableObject(trimmable);
}
