public void OnAttractedEdge(IAttractable attractable, AttractedEdge edge, double time, double duration)
{
TimelineClipGUI timelineClipGUI = attractable as TimelineClipGUI;
if (timelineClipGUI != null)
{
TimelineClip clip = timelineClipGUI.clip;
if (edge == AttractedEdge.Right)
{
clip.duration = time - clip.start;
clip.duration = Math.Max(clip.duration, TimelineClip.kMinDuration);
}
else if (edge == AttractedEdge.Left)
{
double num = time - clip.start;
double newValue = clip.clipIn + num * clip.timeScale;
if (DragClipHandle.SetClipIn(clip, newValue, num))
{
this.m_FrameSnap.Reset();
}
}
else
{
clip.start = time;
clip.duration = duration;
}
}
}
public void OnAttractedEdge(IAttractable attractable, AttractedEdge edge, double time, double duration)
{
TimelineMarkerGUI timelineMarkerGUI = attractable as TimelineMarkerGUI;
if (timelineMarkerGUI != null)
{
timelineMarkerGUI.timelineMarker.time = time;
}
}
public SnapEngine(IAttractable attractable, IAttractionHandler attractionHandler, ManipulateEdges manipulateEdges, WindowState state,
Vector2 mousePosition, IEnumerable <ISnappable> snappables = null)
{
m_Attractable = attractable;
m_ManipulateEdges = manipulateEdges;
m_AttractionHandler = attractionHandler;
m_State = state;
m_CurrentTimes = m_GrabbedTimes = new TimeBoundaries(m_Attractable.start, m_Attractable.end);
m_GrabbedTime = m_State.PixelToTime(mousePosition.x);
// Add Time zero as Magnet
AddMagnet(0.0, true, state);
// Add current Time as Magnet
// case1157280 only add current time as magnet if visible
if (TimelineWindow.instance.currentMode.ShouldShowTimeCursor(m_State))
{
AddMagnet(state.editSequence.time, true, state);
}
if (state.IsEditingASubTimeline())
{
// Add start and end of evaluable range as Magnets
// This includes the case where the master timeline has a fixed length
var range = state.editSequence.GetEvaluableRange();
AddMagnet(range.start, true, state);
AddMagnet(range.end, true, state);
}
else if (state.masterSequence.asset.durationMode == TimelineAsset.DurationMode.FixedLength)
{
// Add end sequence Time as Magnet
AddMagnet(state.masterSequence.asset.duration, true, state);
}
if (snappables == null)
{
snappables = GetVisibleSnappables(m_State);
}
foreach (var snappable in snappables)
{
if (!attractable.ShouldSnapTo(snappable))
{
continue;
}
var edges = snappable.SnappableEdgesFor(attractable, manipulateEdges);
foreach (var edge in edges)
{
AddMagnet(edge.time, edge.showSnapHint, state);
}
}
}
public IEnumerable <Edge> SnappableEdgesFor(IAttractable attractable, ManipulateEdges manipulateEdges)
{
var edges = new List <Edge>();
var attractableGUI = attractable as TimelineMarkerGUI;
var canAddEdges = !(attractableGUI != null && attractableGUI.parent == parent);
if (canAddEdges)
{
edges.Add(new Edge(time));
}
return(edges);
}
public IEnumerable <Edge> SnappableEdgesFor(IAttractable attractable)
{
List <Edge> list = new List <Edge>();
if (attractable != this)
{
bool flag = !base.parentTrackGUI.get_hasChildren() || base.parentTrackGUI.isExpanded;
if (flag)
{
list.Add(new Edge(this.clip.start));
list.Add(new Edge(this.clip.end));
}
}
return(list);
}
public void OnAttractedEdge(IAttractable attractable, AttractedEdge edge, double time, double duration)
{
TimelineClipGUI timelineClipGUI = attractable as TimelineClipGUI;
if (timelineClipGUI != null)
{
TimelineClip clip = timelineClipGUI.clip;
if (edge == AttractedEdge.Left || edge == AttractedEdge.None)
{
clip.start = time;
}
else
{
clip.start = time - clip.duration;
}
}
}
public void OnAttractedEdge(IAttractable attractable, ManipulateEdges manipulateEdges, AttractedEdge edge, double time)
{
var clipGUI = attractable as TimelineClipGUI;
if (clipGUI == null)
{
return;
}
var clipItem = ItemsUtils.ToItem(clipGUI.clip);
if (manipulateEdges == ManipulateEdges.Right)
{
bool affectTimeScale = Event.current.modifiers == EventModifiers.Shift; // TODO Do not use Event.current from here.
EditMode.TrimEnd(clipItem, time, affectTimeScale);
}
else if (manipulateEdges == ManipulateEdges.Left)
{
EditMode.TrimStart(clipItem, time);
}
}
public IEnumerable <Edge> SnappableEdgesFor(IAttractable attractable)
{
List <Edge> list = new List <Edge>();
IEnumerable <Edge> result;
if (attractable == this)
{
result = list;
}
else
{
TimelineMarkerGUI timelineMarkerGUI = attractable as TimelineMarkerGUI;
bool flag = (timelineMarkerGUI == null || !(timelineMarkerGUI.parentTrackGUI.track == base.parentTrackGUI.track)) && (!base.parentTrackGUI.get_hasChildren() || base.parentTrackGUI.isExpanded);
if (flag)
{
list.Add(new Edge(this.timelineMarker.time));
}
result = list;
}
return(result);
}
public void OnAttractedEdge(IAttractable attractable, ManipulateEdges manipulateEdges, AttractedEdge edge, double time)
{
var clipGUI = attractable as TimelineClipGUI;
if (clipGUI == null)
{
return;
}
var clipItem = ItemsUtils.ToItem(clipGUI.clip);
if (manipulateEdges == ManipulateEdges.Right)
{
bool affectTimeScale = IsAffectingTimeScale(clipGUI.clip);
EditMode.TrimEnd(clipItem, time, affectTimeScale);
}
else if (manipulateEdges == ManipulateEdges.Left)
{
bool affectTimeScale = IsAffectingTimeScale(clipGUI.clip);
EditMode.TrimStart(clipItem, time, affectTimeScale);
}
}
public void OnAttractedEdge(IAttractable attractable, ManipulateEdges manipulateEdges, AttractedEdge edge, double time)
{
double offset;
if (edge == AttractedEdge.Right)
{
var duration = end - start;
var startTime = time - duration;
startTime = EditMode.AdjustStartTime(m_State, m_RightMostMovingItems, startTime);
offset = startTime + duration - end;
}
else
{
if (edge == AttractedEdge.Left)
{
time = EditMode.AdjustStartTime(m_State, m_LeftMostMovingItems, time);
}
offset = time - start;
}
if (start + offset < 0.0)
{
offset = -start;
}
if (!offset.Equals(0.0))
{
foreach (var grabbedClips in movingItems)
{
grabbedClips.start += offset;
}
EditMode.UpdateMove();
RefreshPreviewItems();
}
}
public MagnetEngine(IAttractable attractable, IAttractionHandler attractionHandler, TimelineWindow.TimelineState state)
{
this.m_Attractable = attractable;
this.m_AttractionHandler = attractionHandler;
this.m_State = state;
Rect timeAreaBounds = TimelineWindow.instance.timeAreaBounds;
timeAreaBounds.set_height(3.40282347E+38f);
List <IBounds> elementsInRectangle = Manipulator.GetElementsInRectangle(state.quadTree, timeAreaBounds);
IEnumerable <ISnappable> enumerable = elementsInRectangle.OfType <ISnappable>();
this.AddMagnet(0.0, timeAreaBounds, state);
this.AddMagnet(state.time, timeAreaBounds, state);
this.AddMagnet(state.timeline.get_duration(), timeAreaBounds, state);
foreach (ISnappable current in enumerable)
{
IEnumerable <Edge> enumerable2 = current.SnappableEdgesFor(attractable);
foreach (Edge current2 in enumerable2)
{
this.AddMagnet(current2.time, timeAreaBounds, state);
}
}
}
public IEnumerable <Edge> SnappableEdgesFor(IAttractable attractable, ManipulateEdges manipulateEdges)
{
var edges = new List <Edge>();
bool canAddEdges = !parent.muted;
if (canAddEdges)
{
// Hack: Trim Start in Ripple mode should not have any snap point added
if (EditMode.editType == EditMode.EditType.Ripple && manipulateEdges == ManipulateEdges.Left)
{
return(edges);
}
if (attractable != this)
{
if (EditMode.editType == EditMode.EditType.Ripple)
{
bool skip = false;
// Hack: Since Trim End and Move in Ripple mode causes other snap point to move on the same track (which is not supported), disable snapping for this special cases...
// TODO Find a proper way to have different snap edges for each edit mode.
if (manipulateEdges == ManipulateEdges.Right)
{
var otherClipGUI = attractable as TimelineClipGUI;
skip = otherClipGUI != null && otherClipGUI.parent == parent;
}
else if (manipulateEdges == ManipulateEdges.Both)
{
var moveHandler = attractable as MoveItemHandler;
skip = moveHandler != null && moveHandler.movingItems.Any(clips => clips.targetTrack == clip.parentTrack && clip.start >= clips.start);
}
if (skip)
{
return(edges);
}
}
AddEdge(edges, clip.start);
AddEdge(edges, clip.end);
}
else
{
if (manipulateEdges == ManipulateEdges.Right)
{
var d = TimelineHelpers.GetClipAssetEndTime(clip);
if (d < double.MaxValue)
{
if (clip.SupportsLooping())
{
var l = TimelineHelpers.GetLoopDuration(clip);
var shownTime = TimelineWindow.instance.state.timeAreaShownRange;
do
{
AddEdge(edges, d, false);
d += l;
}while (d < shownTime.y);
}
else
{
AddEdge(edges, d, false);
}
}
}
if (manipulateEdges == ManipulateEdges.Left)
{
var clipInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip.animationClip);
if (clipInfo != null && clipInfo.keyTimes.Any())
{
AddEdge(edges, clip.FromLocalTimeUnbound(clipInfo.keyTimes.Min()), false);
}
}
}
}
return(edges);
}
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
attractable = animator.GetComponent <IAttractable>();
base.OnStateEnter(animator, stateInfo, layerIndex);
}
