public static void AddMenuItems(GenericMenu menu, GroupTrack track)
{
TimelineWindow.TimelineState state = TimelineWindow.instance.state;
TrackType[] array = TimelineHelpers.GetMixableTypes();
array = (from x in array
orderby(!x.trackType.Assembly.FullName.Contains("UnityEngine.Sequence")) ? 1 : 0
select x).ToArray <TrackType>();
TrackType[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
TrackType trackType = array2[i];
if (trackType.trackType != typeof(GroupTrack))
{
GenericMenu.MenuFunction2 menuFunction = delegate(object e)
{
track.SetCollapsed(false);
state.GetWindow().AddTrack((e as TrackType).trackType, track, null);
TimelineTrackBaseGUI timelineTrackBaseGUI = TimelineTrackBaseGUI.FindGUITrack(track);
if (timelineTrackBaseGUI != null)
{
TimelineWindow.instance.treeView.data.SetExpanded(timelineTrackBaseGUI, true);
}
};
object obj = trackType;
string text = TimelineHelpers.GetTrackCategoryName(trackType);
if (!string.IsNullOrEmpty(text))
{
text += "/";
}
menu.AddItem(new GUIContent("Add " + text + TimelineHelpers.GetTrackMenuName(trackType)), false, menuFunction, obj);
}
}
}
private float DrawRecordButton(Rect rect, TimelineWindow.TimelineState state)
{
float result;
if (this.trackAllowsRecording)
{
TrackAsset track = (!base.IsSubTrack()) ? base.track : base.ParentTrack();
using (new EditorGUI.DisabledScope(base.track.locked || !state.ValidateBindingForTrack(track).IsValid()))
{
if (this.IsRecording(state))
{
state.editorWindow.Repaint();
float num = Time.get_realtimeSinceStartup() % 1f;
GUIContent none = TimelineTrackGUI.s_ArmForRecordContentOn;
if (num < 0.22f)
{
none = GUIContent.none;
}
if (GUI.Button(rect, none, GUIStyle.get_none()))
{
state.UnarmForRecord(base.track);
}
}
else if (GUI.Button(rect, TimelineTrackGUI.s_ArmForRecordContentOff, GUIStyle.get_none()))
{
state.ArmForRecord(base.track);
}
result = 16f;
return(result);
}
}
result = 0f;
return(result);
}
private static void FrameClips(TimelineWindow.TimelineState state)
{
int num = 0;
float num2 = 3.40282347E+38f;
float num3 = -3.40282347E+38f;
foreach (TrackAsset current in state.timeline.tracks)
{
num += current.clips.Length;
if (num > 1)
{
return;
}
TimelineClip[] clips = current.clips;
for (int i = 0; i < clips.Length; i++)
{
TimelineClip timelineClip = clips[i];
num2 = Mathf.Min(num2, (float)timelineClip.start);
num3 = Mathf.Max(num3, (float)timelineClip.start + (float)timelineClip.duration);
}
}
if (num == 1)
{
float num4 = num3 - num2;
if (num4 > 0f)
{
state.SetTimeAreaShownRange(Mathf.Max(0f, num2 - num4), num3 + num4);
}
else
{
state.SetTimeAreaShownRange(0f, 100f);
}
}
}
private void UpdateCurveEditorIfNeeded(TimelineWindow.TimelineState state)
{
if (Event.get_current().get_type() == 8 && this.m_DataSource != null && this.m_BindingHierarchy != null && !(this.m_DataSource.animationClip == null))
{
AnimationClipCurveInfo curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(this.m_DataSource.animationClip);
int version = curveInfo.version;
if (version != this.m_LastClipVersion)
{
if (this.m_LastCurveCount != curveInfo.curves.Length)
{
this.m_BindingHierarchy.RefreshTree();
this.m_LastCurveCount = curveInfo.curves.Length;
}
else
{
this.m_BindingHierarchy.RefreshCurves();
}
if (this.m_LastClipVersion == -1)
{
this.FrameClip();
}
this.m_LastClipVersion = version;
}
if (state.timeInFrames)
{
this.m_CurveEditor.state = new ClipCurveEditor.FrameFormatCurveEditorState();
}
else
{
this.m_CurveEditor.state = new ClipCurveEditor.UnformattedCurveEditorState();
}
this.m_CurveEditor.invSnap = state.frameRate;
}
}
private void DrawTrackHeader(Rect headerRect, TimelineWindow.TimelineState state, float indentWidth, float inlineCurveHeight)
{
using (new GUIViewportScope(headerRect))
{
headerRect.set_x(headerRect.get_x() + indentWidth);
headerRect.set_width(headerRect.get_width() - indentWidth);
if (Event.get_current().get_type() == 7)
{
bool hasProblems = this.DetectProblems(state);
this.RefreshStateIfBindingProblemIsFound(state, hasProblems);
this.UpdateBindingProblemValues(hasProblems);
}
Rect rect = headerRect;
rect.set_height(rect.get_height() - inlineCurveHeight);
this.DrawHeaderBackground(headerRect);
rect.set_x(rect.get_x() + this.m_Styles.trackSwatchStyle.get_fixedWidth());
Rect rect2 = new Rect(headerRect.get_xMax() - 16f - 3f, rect.get_y() + (rect.get_height() - 16f) / 2f, 16f, 16f);
rect.set_x(rect.get_x() + this.DrawTrackIconKind(rect, state));
this.DrawTrackBinding(rect, headerRect, state);
if (base.track.mediaType == TimelineAsset.MediaType.Group)
{
return;
}
rect2.set_x(rect2.get_x() - this.DrawTrackDropDownMenu(rect2, state));
rect2.set_x(rect2.get_x() - this.DrawInlineCurveButton(rect2, state));
rect2.set_x(rect2.get_x() - this.DrawMuteButton(rect2, state));
rect2.set_x(rect2.get_x() - this.DrawLockButton(rect2));
rect2.set_x(rect2.get_x() - this.DrawRecordButton(rect2, state));
rect2.set_x(rect2.get_x() - this.DrawCustomTrackButton(rect2, state));
}
this.DrawTrackColorKind(headerRect, state);
}
public bool CanDraw(TrackAsset track, TimelineWindow.TimelineState state)
{
float[] keys = this.m_DataSource.GetKeys();
bool flag = track.clips.Length == 0;
return(keys != null || (state.IsArmedForRecord(track) && flag));
}
private void UpdateDragTarget(TimelineClipGUI uiClip, Vector2 point, TimelineWindow.TimelineState state)
{
List <IBounds> elementsAtPosition = Manipulator.GetElementsAtPosition(state.quadTree, point);
TimelineTrackGUI timelineTrackGUI = elementsAtPosition.OfType <TimelineTrackGUI>().FirstOrDefault((TimelineTrackGUI t) => MoveClip.ValidateClipDrag(t.track, uiClip.clip));
this.m_HasValidDropTarget = (timelineTrackGUI != null && timelineTrackGUI.track.IsCompatibleWithItem(uiClip.clip));
if (this.m_HasValidDropTarget)
{
AnimationTrack animationTrack = timelineTrackGUI.track as AnimationTrack;
float start = state.PixelToTime(this.m_PreviewRect.get_x());
float end = state.PixelToTime(this.m_PreviewRect.get_xMax());
bool hasValidDropTarget;
if (animationTrack != null && animationTrack.CanConvertToClipMode())
{
hasValidDropTarget = ((animationTrack.animClip.get_startTime() < start || animationTrack.animClip.get_stopTime() > end) && (start <animationTrack.animClip.get_startTime() || end> animationTrack.animClip.get_stopTime()));
}
else
{
float num = end - start;
start = Math.Max(start, 0f);
end = start + num;
hasValidDropTarget = (!timelineTrackGUI.track.clips.Any((TimelineClip x) => x.start >= (double)start && x.end <= (double)end) && !timelineTrackGUI.track.clips.Any((TimelineClip x) => (double)start >= x.start && (double)end <= x.end));
}
this.m_HasValidDropTarget = hasValidDropTarget;
}
this.m_DropTarget = ((!this.m_HasValidDropTarget) ? null : timelineTrackGUI);
}
private void DrawCurveEditorForInfiniteClip(Rect headerRect, Rect trackRect, TimelineWindow.TimelineState state)
{
if (this.m_TrackGUI.clipCurveEditor != null)
{
InlineCurveEditor.DrawCurveEditor(this.m_TrackGUI, state, headerRect, trackRect, Vector2.get_zero(), this.m_TrackGUI.locked);
}
}
public static bool HandleShortcut(TimelineWindow.TimelineState state, Event evt, T item)
{
T[] items = new T[]
{
item
};
bool result;
foreach (ItemAction <T> current in ItemAction <T> .actions)
{
object[] customAttributes = current.GetType().GetCustomAttributes(typeof(ShortcutAttribute), true);
object[] array = customAttributes;
for (int i = 0; i < array.Length; i++)
{
ShortcutAttribute shortcutAttribute = (ShortcutAttribute)array[i];
if (shortcutAttribute.IsRecognized(evt))
{
if (MenuItemActionBase.s_ShowActionTriggeredByShortcut)
{
Debug.Log(current.GetType().Name);
}
bool flag = current.Execute(state, items);
state.Refresh();
state.Evaluate();
result = flag;
return(result);
}
}
}
result = false;
return(result);
}
public void PrepareForRecord(TimelineWindow.TimelineState state)
{
this.m_ProcessedClips.Clear();
this.m_RebindList.Clear();
this.m_RefreshState = false;
this.m_TracksToProcess.Clear();
}
private static void Frame(TimelineWindow.TimelineState state, float start, float duration, float marginFactor)
{
float num = duration * marginFactor;
state.SetTimeAreaShownRange(Mathf.Max(start - num, -10f), start + duration + num);
state.Evaluate();
}
public void FinializeTrack(TrackAsset track, TimelineWindow.TimelineState state)
{
AnimationTrack animationTrack = track as AnimationTrack;
if (!animationTrack.inClipMode)
{
EditorUtility.SetDirty(animationTrack.GetOrCreateClip());
}
if (this.recordClip != null)
{
if (!this.m_ProcessedClips.Contains(this.recordClip.animationClip))
{
this.m_ProcessedClips.Add(this.recordClip.animationClip);
}
if (this.m_ClipTime > this.recordClip.duration)
{
TimelineUndo.PushUndo(track, "Add Key");
this.recordClip.duration = this.m_ClipTime;
this.m_RefreshState = true;
}
track.CalculateExtrapolationTimes();
}
this.recordClip = null;
this.m_ClipTime = 0.0;
if (this.m_needRebuildRects)
{
state.CalculateRowRects();
this.m_needRebuildRects = false;
}
}
public void Init(TimelineClipGUI gui, TimelineWindow.TimelineState state)
{
TrackAsset track = gui.parentTrackGUI.track;
var source = SelectionManager.SelectedClipGUI().GroupBy((TimelineClipGUI p) => p.parentTrackGUI, (TimelineClipGUI p) => p.clip, (TimelineTrackGUI key, IEnumerable <TimelineClip> g) => new
{
track = key,
clips = g.ToList <TimelineClip>()
});
if (!source.Any(r => r.track.track == track && r.clips[0] != gui.clip))
{
this.m_RippleTotal = 0f;
List <TimelineClip> exclude = SelectionManager.SelectedItems <TimelineClip>().ToList <TimelineClip>();
exclude.Add(gui.clip);
if ((this.m_Direction & Ripple.RippleDirection.After) == Ripple.RippleDirection.After)
{
this.m_RippleAfter = (from c in track.clips
where !exclude.Contains(c) && c.start >= gui.clip.start
select c).ToList <TimelineClip>();
}
if ((this.m_Direction & Ripple.RippleDirection.Before) == Ripple.RippleDirection.Before)
{
this.m_RippleBefore = (from c in track.clips
where !exclude.Contains(c) && c.start < gui.clip.start
select c).ToList <TimelineClip>();
}
}
}
public static bool HandleShortcut(TimelineWindow.TimelineState state, Event evt)
{
bool result;
if (EditorGUI.IsEditingTextField())
{
result = false;
}
else
{
foreach (TimelineAction current in TimelineAction.actions)
{
object[] customAttributes = current.GetType().GetCustomAttributes(typeof(ShortcutAttribute), true);
object[] array = customAttributes;
for (int i = 0; i < array.Length; i++)
{
ShortcutAttribute shortcutAttribute = (ShortcutAttribute)array[i];
if (shortcutAttribute.IsRecognized(evt))
{
if (MenuItemActionBase.s_ShowActionTriggeredByShortcut)
{
Debug.Log(current.GetType().Name);
}
result = current.Execute(state);
return(result);
}
}
}
result = false;
}
return(result);
}
private void CreateInlineCurveEditor(TimelineWindow.TimelineState state)
{
if (Event.get_current().get_type() == 8)
{
if (this.clipCurveEditor == null)
{
AnimationClip animationClip = this.clip.animationClip;
if (animationClip != null && animationClip.get_empty())
{
animationClip = null;
}
if (animationClip != null && !this.clip.recordable)
{
animationClip = null;
}
if (this.clip.curves != null || animationClip != null)
{
state.AddEndFrameDelegate(delegate(ITimelineState istate, Event currentEvent)
{
this.clipCurveEditor = new ClipCurveEditor(new TimelineClipCurveDataSource(this), this.m_ParentTrack.TimelineWindow);
return(true);
});
}
}
}
}
public static bool HandleShortcut(TimelineWindow.TimelineState state, Event evt, TrackAsset track)
{
List <TrackAsset> list = SelectionManager.SelectedTracks().ToList <TrackAsset>();
if (list.All((TrackAsset x) => x != track))
{
list.Add(track);
}
bool result;
foreach (TrackAction current in TrackAction.actions)
{
object[] customAttributes = current.GetType().GetCustomAttributes(typeof(ShortcutAttribute), true);
object[] array = customAttributes;
for (int i = 0; i < array.Length; i++)
{
ShortcutAttribute shortcutAttribute = (ShortcutAttribute)array[i];
if (shortcutAttribute.IsRecognized(evt))
{
if (MenuItemActionBase.s_ShowActionTriggeredByShortcut)
{
Debug.Log(current.GetType().Name);
}
result = current.Execute(state, list.ToArray());
return(result);
}
}
}
result = false;
return(result);
}
public void DrawBlendingCurves(TimelineWindow.TimelineState state)
{
if (Event.get_current().get_type() == 7)
{
Color color = (!SelectionManager.Contains(this.clip)) ? Color.get_white() : TrackDrawer.GetHighlightColor(Color.get_white());
Color colorTrackBackground = DirectorStyles.Instance.customSkin.colorTrackBackground;
Color color2 = (!SelectionManager.Contains(this.clip)) ? DirectorStyles.Instance.customSkin.colorTrackBackground : Color.get_white();
if (this.blendInKind == TimelineClipGUI.BlendKind.Ease)
{
ClipRenderer.RenderTexture(this.mixInRect, DirectorStyles.Instance.timelineClip.get_normal().get_background(), DirectorStyles.Instance.blendingIn.get_normal().get_background(), color, false);
EditorGUI.DrawRect(new Rect(this.mixInRect.get_xMax() - 2f, this.mixInRect.get_yMin(), 2f, this.mixInRect.get_height()), colorTrackBackground);
Graphics.DrawAAPolyLine(4f, new Vector3[]
{
new Vector3(this.mixInRect.get_xMin() + 1f, this.mixInRect.get_yMax() - 1f, 0f),
new Vector3(this.mixInRect.get_xMax(), this.mixInRect.get_yMin() - 1.5f, 0f)
}, color2);
}
if (this.blendOutKind == TimelineClipGUI.BlendKind.Ease || this.blendOutKind == TimelineClipGUI.BlendKind.Mix)
{
ClipRenderer.RenderTexture(this.mixOutRect, DirectorStyles.Instance.timelineClip.get_normal().get_background(), DirectorStyles.Instance.blendingOut.get_normal().get_background(), color, false);
EditorGUI.DrawRect(new Rect(this.mixOutRect.get_xMin(), this.mixOutRect.get_yMin(), 2f, this.mixOutRect.get_height()), colorTrackBackground);
Graphics.DrawLineAA(4f, new Vector3(this.mixOutRect.get_xMin() + 1.5f, this.mixOutRect.get_yMin() + 1.5f, 0f), new Vector3(this.mixOutRect.get_xMax(), this.mixOutRect.get_yMax() - 1f, 0f), color2);
}
if (this.blendInKind == TimelineClipGUI.BlendKind.Mix)
{
ClipRenderer.RenderTexture(this.mixInRect, DirectorStyles.Instance.timelineClip.get_normal().get_background(), DirectorStyles.Instance.blendingOut.get_normal().get_background(), color, false);
EditorGUI.DrawRect(new Rect(this.mixInRect.get_xMax(), this.mixInRect.get_yMin(), 2f, this.mixOutRect.get_height()), colorTrackBackground);
Graphics.DrawAAPolyLine(4f, new Vector3[]
{
new Vector3(this.mixInRect.get_xMin(), this.mixInRect.get_yMin(), 0f),
new Vector3(this.mixInRect.get_xMax(), this.mixInRect.get_yMax() - 1f, 0f)
}, color2);
}
}
}
public void Draw(Rect parentRect, TimelineWindow.TimelineState state)
{
if (this.m_InitUnionRect)
{
this.m_Start = (from c in this.m_Members
orderby c.clip.start
select c).First <TimelineClipGUI>().clip.start;
this.m_Duration = this.m_Members.Sum((TimelineClipGUI c) => c.clip.duration);
this.m_InitUnionRect = false;
}
this.m_Union = new Rect((float)this.m_Start * state.timeAreaScale.x, 0f, (float)this.m_Duration * state.timeAreaScale.x, 0f);
this.m_Union.set_xMin(this.m_Union.get_xMin() + (state.timeAreaTranslation.x + parentRect.get_x()));
this.m_Union.set_xMax(this.m_Union.get_xMax() + (state.timeAreaTranslation.x + parentRect.get_x()));
this.m_Union.set_y(parentRect.get_y() + 4f);
this.m_Union.set_height(parentRect.get_height() - 8f);
if (this.m_Union.get_x() < parentRect.get_xMin())
{
float num = parentRect.get_xMin() - this.m_Union.get_x();
this.m_Union.set_x(parentRect.get_xMin());
this.m_Union.set_width(this.m_Union.get_width() - num);
}
if (this.m_Union.get_xMax() >= parentRect.get_xMin())
{
if (this.m_Union.get_xMin() <= parentRect.get_xMax())
{
EditorGUI.DrawRect(this.m_Union, DirectorStyles.Instance.customSkin.colorClipUnion);
}
}
}
public override bool DrawTrack(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, ITimelineState state)
{
this.m_TrackRect = trackRect;
TimelineWindow.TimelineState timelineState = (TimelineWindow.TimelineState)state;
bool result;
if (!this.CanDraw(trackAsset, timelineState))
{
result = true;
}
else
{
if (timelineState.recording && timelineState.IsArmedForRecord(trackAsset))
{
InfiniteTrackDrawer.DrawRecordBackground(trackRect);
}
GUI.Box(trackRect, GUIContent.none, DirectorStyles.Instance.infiniteTrack);
Rect rect = trackRect;
rect.set_yMin(rect.get_yMax());
rect.set_height(15f);
GUI.DrawTexture(rect, DirectorStyles.Instance.bottomShadow.get_normal().get_background(), 0);
float[] keys = this.m_DataSource.GetKeys();
if (keys != null && keys.Length > 0)
{
float[] array = keys;
for (int i = 0; i < array.Length; i++)
{
float key = array[i];
this.DrawKeyFrame(key, timelineState);
}
}
result = true;
}
return(result);
}
public static bool Do(TimelineWindow.TimelineState state, TrackAsset track)
{
PasteIntoAction.DoPasteClips(state, track);
PasteIntoAction.DoPasteMarkers(state, track);
state.Refresh();
return(true);
}
public virtual void DrawOverlays(Event evt, TimelineWindow.TimelineState state)
{
if (this.Overlay != null)
{
this.Overlay(this, evt, state);
}
}
private static void DoPasteMarkers(TimelineWindow.TimelineState state, TrackAsset track)
{
if (track is ITimelineMarkerContainer)
{
List <TimelineMarker> list = (from x in Clipboard.GetData <EditorMarker>()
select x.theMarker into x
orderby x.time
select x).ToList <TimelineMarker>();
double num = 0.0;
if (list.Count <TimelineMarker>() == 0)
{
num = 0.0;
}
else
{
num = list.Last <TimelineMarker>().time + 0.5;
}
TimelineMarker timelineMarker = null;
foreach (TimelineMarker current in list)
{
if (current != null)
{
if (timelineMarker != null)
{
num += current.time - timelineMarker.time;
}
MarkerModifiers.DuplicateAtTime(current, track, state.currentDirector, num);
timelineMarker = current;
}
}
}
}
private static string GetTrackDisplayName(TrackAsset track, TimelineWindow.TimelineState state)
{
string result;
if (track == null)
{
result = "";
}
else
{
string name = track.get_name();
if (track.get_name().StartsWith(track.GetType().Name))
{
if (state.currentDirector != null)
{
GameObject sceneGameObject = TimelineUtility.GetSceneGameObject(state.currentDirector, track);
if (sceneGameObject != null)
{
name = sceneGameObject.get_name();
}
}
}
result = name;
}
return(result);
}
public override bool Execute(TimelineWindow.TimelineState state)
{
bool result;
if (state.IsEditingASubItem())
{
result = false;
}
else if (SelectionManager.Count() == 0)
{
result = false;
}
else
{
bool flag = false;
foreach (TimelineClip current in SelectionManager.SelectedItems <TimelineClip>())
{
flag |= TimelineHelpers.NudgeClip(current, state, 1.0);
}
if (flag)
{
state.Evaluate();
}
result = true;
}
return(result);
}
private float DrawTrackIconKind(Rect rect, TimelineWindow.TimelineState state)
{
float result;
if (base.track != null && base.track.isSubTrack)
{
result = 0f;
}
else
{
rect.set_yMin(rect.get_yMin() + (rect.get_height() - 16f) / 2f);
rect.set_width(16f);
rect.set_height(16f);
if (this.m_HadProblems)
{
this.GenerateIconForBindingValidationResult(this.m_Styles, this.GetTrackBindingValidationResult(state));
if (TimelineTrackGUI.CanDrawIcon(this.m_ProblemIcon))
{
this.DrawErrorIcon(rect, state);
}
}
else if (TimelineTrackGUI.CanDrawIcon(this.headerIcon))
{
GUI.Box(rect, this.headerIcon, GUIStyle.get_none());
}
result = rect.get_width();
}
return(result);
}
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(TimelineWindow.TimelineState state)
{
IEnumerable <EditorClip> data = Clipboard.GetData <EditorClip>();
foreach (EditorClip current in data)
{
double end = current.clip.parentTrack.clips.Last <TimelineClip>().end;
current.clip.DuplicateAtTime(current.clip.parentTrack, end, state.currentDirector);
}
IEnumerable <EditorMarker> data2 = Clipboard.GetData <EditorMarker>();
foreach (EditorMarker current2 in data2)
{
double newTime = current2.theMarker.parentTrack.end + 0.5;
MarkerModifiers.DuplicateAtTime(current2.theMarker, state.currentDirector, newTime);
}
IEnumerable <TrackAsset> data3 = Clipboard.GetData <TrackAsset>();
foreach (TrackAsset current3 in data3)
{
current3.Duplicate(state.currentDirector, state.timeline);
}
state.Refresh();
return(true);
}
protected override void OnMouseDrag(Event evt, TimelineWindow.TimelineState state, TimelineClipHandle handle)
{
ManipulateEdges edges = ManipulateEdges.Both;
float delta = evt.get_delta().x / state.timeAreaScale.x;
TimelineUndo.PushUndo(handle.clip.clip.parentTrack, "Trim Clip");
TimelineClipHandle.DragDirection direction = handle.direction;
if (direction != TimelineClipHandle.DragDirection.Right)
{
if (direction == TimelineClipHandle.DragDirection.Left)
{
double num = this.m_FrameSnap.ApplyOffset(handle.clip.clip.start, delta, state);
if (num > 0.0)
{
double num2 = num - handle.clip.clip.start;
handle.clip.clip.start = num;
if (handle.clip.clip.duration - num2 > TimelineClip.kMinDuration)
{
handle.clip.clip.duration -= num2;
}
}
edges = ManipulateEdges.Left;
}
}
else
{
double val = this.m_FrameSnap.ApplyOffset(handle.clip.clip.duration, delta, state);
handle.clip.clip.duration = Math.Max(val, TimelineClip.kMinDuration);
edges = ManipulateEdges.Right;
}
if (this.m_MagnetEngine != null && evt.get_modifiers() != 1)
{
this.m_MagnetEngine.Snap(evt.get_delta().x, edges);
}
}
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 override bool Execute(TimelineWindow.TimelineState state, TrackAsset[] tracks)
{
HashSet <TrackAsset> hashSet = new HashSet <TrackAsset>();
for (int i = 0; i < tracks.Length; i++)
{
TrackAsset trackAsset = tracks[i];
TrackAsset trackAsset2 = trackAsset.parent as TrackAsset;
bool flag = false;
while (trackAsset2 != null && !flag)
{
if (hashSet.Contains(trackAsset2))
{
flag = true;
}
trackAsset2 = (trackAsset2.parent as TrackAsset);
}
if (!flag)
{
hashSet.Add(trackAsset);
}
}
foreach (TrackAsset current in hashSet)
{
current.Duplicate(state.currentDirector, null);
}
state.Refresh();
return(true);
}
