static bool InternalExecute(Event evt, WindowState state)
{
if (state.IsCurrentEditingASequencerTextField())
{
return(false);
}
var tracks = SelectionManager.SelectedTracks().ToList();
var items = SelectionManager.SelectedClipGUI();
foreach (var item in items)
{
var trackGUI = item.parent as TimelineTrackBaseGUI;
if (trackGUI == null)
{
continue;
}
if (!tracks.Contains(trackGUI.track))
{
tracks.Add(trackGUI.track);
}
}
return(ActionManager.HandleShortcut(evt,
ActionManager.TrackActions,
x => ActionManager.ExecuteTrackAction(x, tracks)));
}
protected override bool ExecuteCommand(Event evt, WindowState state)
{
if (state.IsCurrentEditingASequencerTextField())
{
return(false);
}
var tracks = SelectionManager.SelectedTracks().ToList();
var itemGUIs = SelectionManager.SelectedClipGUI();
foreach (var itemGUI in itemGUIs)
{
var trackGUI = itemGUI.parent == null ? null : itemGUI.parent as TimelineTrackBaseGUI;
if (trackGUI == null)
{
continue;
}
if (!tracks.Contains(trackGUI.track))
{
tracks.Add(trackGUI.track);
}
}
return(TrackAction.HandleShortcut(state, evt, tracks.ToArray()));
}
public static IEnumerable <TimelineItemGUI> SelectedItemGUI()
{
IEnumerable <TimelineItemGUI> first = SelectionManager.SelectedClipGUI().Cast <TimelineItemGUI>();
IEnumerable <TimelineItemGUI> second = SelectionManager.SelectedMarkerGUI().Cast <TimelineItemGUI>();
return(first.Union(second));
}
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>();
}
}
}
bool ShouldShowClipCurves(WindowState state)
{
if (m_TrackGUI.clips.Count == 0)
{
return(false);
}
// Is a clip selected or being recorded to?
return(SelectionManager.SelectedClipGUI().FirstOrDefault(x => x.parent == m_TrackGUI) != null ||
state.recording && state.IsArmedForRecord(m_TrackGUI.track) && m_TrackGUI.clips.FirstOrDefault(x => m_TrackGUI.track.IsRecordingToClip(x.clip)) != null);
}
public override bool Execute(WindowState state)
{
var inlineCurveEditor = SelectionManager.GetCurrentInlineEditorCurve();
if (ShouldHandleInlineCurve(inlineCurveEditor))
{
FrameInlineCurves(inlineCurveEditor, state, true);
return(true);
}
if (state.IsCurrentEditingASequencerTextField())
{
return(false);
}
if (SelectionManager.Count() == 0)
{
Invoke <FrameAllAction>(state);
return(true);
}
var startTime = float.MaxValue;
var endTime = float.MinValue;
var clips = SelectionManager.SelectedClipGUI();
var markers = SelectionManager.SelectedMarkers();
if (!clips.Any() && !markers.Any())
{
return(false);
}
foreach (var c in clips)
{
startTime = Mathf.Min(startTime, (float)c.clip.start);
endTime = Mathf.Max(endTime, (float)c.clip.end);
if (c.clipCurveEditor != null)
{
c.clipCurveEditor.FrameClip();
}
}
foreach (var marker in markers)
{
startTime = Mathf.Min(startTime, (float)marker.time);
endTime = Mathf.Max(endTime, (float)marker.time);
}
FrameRange(startTime, endTime, state);
return(true);
}
public override bool Execute(TimelineWindow.TimelineState state)
{
bool result;
if (state.IsEditingASubItem())
{
result = false;
}
else if (SelectionManager.Count() == 0)
{
result = false;
}
else
{
float num = 3.40282347E+38f;
float num2 = -3.40282347E+38f;
IEnumerable <TimelineClipGUI> enumerable = SelectionManager.SelectedClipGUI();
if (!enumerable.Any <TimelineClipGUI>())
{
result = false;
}
else
{
foreach (TimelineClipGUI current in enumerable)
{
num = Mathf.Min(num, (float)current.clip.start);
num2 = Mathf.Max(num2, (float)current.clip.start + (float)current.clip.duration);
if (current.clipCurveEditor != null)
{
current.clipCurveEditor.FrameClip();
}
}
float num3 = num2 - num;
if (Mathf.Abs(num3) < 1.401298E-45f)
{
num3 = 1f;
}
state.SetTimeAreaShownRange(Mathf.Max(num - num3 * 0.2f, -10f), num2 + num3 * 0.2f);
state.Evaluate();
result = true;
}
}
return(result);
}
void DrawCurveEditorsForClipsOnTrack(Rect headerRect, Rect trackRect, WindowState state)
{
if (m_TrackGUI.clips.Count == 0)
{
return;
}
if (Event.current.type == EventType.Layout)
{
var selectedClip = SelectionManager.SelectedClipGUI().FirstOrDefault(x => x.parent == m_TrackGUI);
if (selectedClip != null)
{
m_LastSelectedClipGUI = selectedClip;
SelectFromCurveOwner(m_LastSelectedClipGUI);
}
else if (state.recording && state.IsArmedForRecord(m_TrackGUI.track))
{
if (m_LastSelectedClipGUI == null || !m_TrackGUI.track.IsRecordingToClip(m_LastSelectedClipGUI.clip))
{
var clip = m_TrackGUI.clips.FirstOrDefault(x => m_TrackGUI.track.IsRecordingToClip(x.clip));
if (clip != null)
{
m_LastSelectedClipGUI = clip;
}
}
}
if (m_LastSelectedClipGUI == null)
{
m_LastSelectedClipGUI = m_TrackGUI.clips[0];
}
}
if (m_LastSelectedClipGUI == null || m_LastSelectedClipGUI.clipCurveEditor == null || m_LastSelectedClipGUI.isInvalid)
{
return;
}
var activeRange = new Vector2(state.TimeToPixel(m_LastSelectedClipGUI.clip.start), state.TimeToPixel(m_LastSelectedClipGUI.clip.end));
DrawCurveEditor(m_LastSelectedClipGUI, state, headerRect, trackRect, activeRange, m_TrackGUI.locked);
m_LastSelectionWasClip = true;
}
public override bool Execute(WindowState state)
{
if (state.IsEditingASubItem())
{
return(false);
}
if (SelectionManager.Count() == 0)
{
return(false);
}
var startTime = float.MaxValue;
var endTime = float.MinValue;
var clips = SelectionManager.SelectedClipGUI();
var markers = SelectionManager.SelectedMarkers();
if (!clips.Any() && !markers.Any())
{
return(false);
}
foreach (var c in clips)
{
startTime = Mathf.Min(startTime, (float)c.clip.start);
endTime = Mathf.Max(endTime, (float)c.clip.end);
if (c.clipCurveEditor != null)
{
c.clipCurveEditor.FrameClip();
}
}
foreach (var marker in markers)
{
startTime = Mathf.Min(startTime, (float)marker.time);
endTime = Mathf.Max(endTime, (float)marker.time);
}
FrameRange(startTime, endTime, state);
return(true);
}
public override void Init(IControl parent)
{
parent.ContextClick += delegate(object target, Event evt, TimelineWindow.TimelineState state)
{
IEnumerable <TimelineClipGUI> source = SelectionManager.SelectedClipGUI();
bool result;
if (!source.Any <TimelineClipGUI>())
{
result = base.IgnoreEvent();
}
else if (!source.Any((TimelineClipGUI c) => c.bounds.Contains(evt.get_mousePosition())))
{
result = base.IgnoreEvent();
}
else
{
TimelineClipGUI timelineClipGUI = target as TimelineClipGUI;
SequencerContextMenu.Show(timelineClipGUI.parentTrackGUI.drawer, evt.get_mousePosition());
result = base.ConsumeEvent();
}
return(result);
};
}
public override void Draw(Rect headerRect, Rect trackRect, TimelineWindow.TimelineState state, float identWidth)
{
if (base.track.GetShowInlineCurves() && this.inlineCurveEditor == null)
{
this.inlineCurveEditor = new InlineCurveEditor(this);
}
this.UpdateInfiniteClipEditor(base.track as AnimationTrack, state.GetWindow());
Rect trackRect2 = trackRect;
float num = this.InlineAnimationCurveHeight();
trackRect.set_height(trackRect.get_height() - num);
if (Event.get_current().get_type() == 7)
{
this.m_TrackRect = trackRect;
state.quadTree.Insert(this);
int num2 = this.BlendHash();
if (this.m_BlendHash != num2)
{
this.UpdateClipOverlaps();
this.m_BlendHash = num2;
}
base.isDropTarget = false;
}
if (TimelineTrackGUI.s_ArmForRecordContentOn == null)
{
TimelineTrackGUI.s_ArmForRecordContentOn = new GUIContent(TimelineWindow.styles.autoKey.get_active().get_background());
}
if (TimelineTrackGUI.s_ArmForRecordContentOff == null)
{
TimelineTrackGUI.s_ArmForRecordContentOff = new GUIContent(TimelineWindow.styles.autoKey.get_normal().get_background());
}
base.track.SetCollapsed(!base.isExpanded);
headerRect.set_width(headerRect.get_width() - 2f);
if (this.m_TrackHash != base.track.Hash())
{
this.RebuildGUICache(state);
}
bool flag = false;
Vector2 timeAreaShownRange = state.timeAreaShownRange;
if (base.drawer != null)
{
flag = base.drawer.DrawTrack(trackRect, base.track, timeAreaShownRange, state);
}
if (!flag)
{
using (new GUIViewportScope(trackRect))
{
this.DrawBackground(trackRect, state);
if (this.resortClips)
{
int num3 = 0;
this.SortClipsByStartTime();
this.ResetClipParityID();
foreach (TimelineClipGUI current in this.m_ClipGUICache)
{
current.parityID = this.GetNextClipParityID();
current.zOrder = num3++;
if (SelectionManager.Contains(current.clip))
{
current.zOrder += 1000;
}
}
IEnumerable <TimelineClipGUI> selectedClips = SelectionManager.SelectedClipGUI();
this.m_ClipGUICache = (from x in this.m_ClipGUICache
orderby selectedClips.Contains(x), x.clip.start
select x).ToList <TimelineClipGUI>();
this.resortClips = false;
}
if (this.resortEvents)
{
int num4 = 0;
this.SortEventsByStartTime();
foreach (TimelineMarkerGUI current2 in this.m_MarkerGuiCache)
{
current2.zOrder = num4++;
if (SelectionManager.Contains(current2.timelineMarker))
{
current2.zOrder += 1000;
}
}
IEnumerable <TimelineMarkerGUI> selectedMarkers = SelectionManager.SelectedMarkerGUI();
this.m_MarkerGuiCache = (from x in this.m_MarkerGuiCache
orderby selectedMarkers.Contains(x), x.timelineMarker.time
select x).ToList <TimelineMarkerGUI>();
this.resortEvents = false;
}
this.DrawClips(trackRect, state);
this.DrawEvents(trackRect, state);
this.DrawClipConnectors();
}
if (this.m_InfiniteTrackDrawer != null)
{
this.m_InfiniteTrackDrawer.DrawTrack(trackRect, base.track, timeAreaShownRange, state);
}
}
this.DrawTrackHeader(headerRect, state, identWidth, num);
this.DrawInlineCurves(headerRect, trackRect2, state, identWidth, num);
this.DrawMuteState(trackRect, state);
this.DrawLockState(trackRect, state);
}
public override void Init(IControl parent)
{
parent.MouseDown += delegate(object target, Event evt, TimelineWindow.TimelineState state)
{
this.m_UndoSet = false;
this.m_IsCaptured = (this.m_CaptureOnNextMouseDrag = false);
bool result;
if (evt.get_modifiers() == 4 || evt.get_button() == 2 || evt.get_button() == 1)
{
result = base.IgnoreEvent();
}
else if (!SelectionManager.IsMouseHoveringOnItem())
{
result = base.IgnoreEvent();
}
else
{
TimelineClipGUI timelineClipGUI = (TimelineClipGUI)target;
if (!SelectionManager.Contains(timelineClipGUI.clip))
{
result = base.IgnoreEvent();
}
else
{
this.m_FrameSnap.Reset();
this.m_CaptureOnNextMouseDrag = true;
this.m_MouseDownPosition = evt.get_mousePosition();
this.m_HasValidDropTarget = false;
result = base.ConsumeEvent();
}
}
return(result);
};
parent.MouseUp += delegate(object target, Event evt, TimelineWindow.TimelineState state)
{
bool result;
if (!this.m_IsCaptured)
{
result = base.IgnoreEvent();
}
else
{
this.m_MagnetEngine = null;
if (this.m_IsVerticalDrag)
{
state.captured.Clear();
this.m_IsVerticalDrag = false;
state.isDragging = false;
if (this.m_HasValidDropTarget && this.m_DropTarget != null)
{
TimelineClipGUI timelineClipGUI = (TimelineClipGUI)target;
if (TrackExtensions.MoveClipToTrack(timelineClipGUI.clip, this.m_DropTarget.track))
{
timelineClipGUI.clip.start = (double)state.PixelToTime(this.m_PreviewRect.get_x());
timelineClipGUI.parentTrackGUI.SortClipsByStartTime();
this.m_DropTarget.SortClipsByStartTime();
state.Refresh();
}
}
}
state.Evaluate();
state.captured.Remove(target as IControl);
this.m_IsCaptured = false;
this.m_IsDragDriver = false;
result = base.ConsumeEvent();
}
return(result);
};
parent.DragExited += delegate(object target, Event evt, TimelineWindow.TimelineState state)
{
this.m_IsVerticalDrag = false;
return(base.IgnoreEvent());
};
parent.MouseDrag += delegate(object target, Event evt, TimelineWindow.TimelineState state)
{
if (!this.m_IsCaptured && this.m_CaptureOnNextMouseDrag)
{
state.captured.Add(target as IControl);
this.m_IsCaptured = true;
this.m_CaptureOnNextMouseDrag = false;
TimelineClipGUI timelineClipGUI = (TimelineClipGUI)target;
this.m_IsDragDriver = MoveItemUtilities.IsDriver(timelineClipGUI, evt, state);
if (this.m_IsDragDriver)
{
this.m_DragPixelOffset = Vector2.get_zero();
this.m_IsDragDriverActive = false;
if (!SelectionManager.IsMultiSelect() && state.edgeSnaps)
{
this.m_MagnetEngine = new MagnetEngine(timelineClipGUI, new MoveClipAttractionHandler(), state);
}
}
}
bool result;
if (!this.m_IsCaptured)
{
result = base.IgnoreEvent();
}
else
{
TimelineClipGUI timelineClipGUI2 = (TimelineClipGUI)target;
if (SelectionManager.Count() == 1)
{
TimelineClipGUI timelineClipGUI3 = SelectionManager.SelectedClipGUI().FirstOrDefault <TimelineClipGUI>();
if (timelineClipGUI3 != null)
{
TimelineTrackGUI dropTargetAt = MoveClip.GetDropTargetAt(state, evt.get_mousePosition());
if (dropTargetAt != null)
{
bool flag = dropTargetAt != timelineClipGUI3.parentTrackGUI;
if (flag && !this.m_IsVerticalDrag)
{
state.isDragging = true;
this.m_HasValidDropTarget = false;
this.m_DropTarget = null;
this.m_MouseDownPosition.x = evt.get_mousePosition().x;
this.m_PreviewOffset = this.m_MouseDownPosition - timelineClipGUI2.bounds.get_position();
}
else if (this.m_IsVerticalDrag && !flag)
{
state.isDragging = false;
this.m_HasValidDropTarget = false;
this.m_DropTarget = null;
this.m_DragPixelOffset = evt.get_mousePosition() - this.m_MouseDownPosition - evt.get_delta();
}
this.m_IsVerticalDrag = flag;
}
}
}
if (this.m_IsVerticalDrag)
{
this.m_PreviewRect = new Rect(evt.get_mousePosition().x, evt.get_mousePosition().y, timelineClipGUI2.bounds.get_width(), timelineClipGUI2.bounds.get_height());
this.m_PreviewRect.set_position(this.m_PreviewRect.get_position() - this.m_PreviewOffset);
this.UpdateDragTarget(timelineClipGUI2, evt.get_mousePosition(), state);
result = base.ConsumeEvent();
}
else
{
if (this.m_IsDragDriver)
{
this.m_DragPixelOffset += evt.get_delta();
this.m_IsDragDriverActive |= (Math.Abs(this.m_DragPixelOffset.x) > MoveClip.kDragBufferInPixels);
if (this.m_IsDragDriverActive)
{
float delta = this.m_DragPixelOffset.x / state.timeAreaScale.x;
this.m_DragPixelOffset = Vector3.get_zero();
this.SetUndo();
if (SelectionManager.IsMultiSelect())
{
double currentValue = (from x in SelectionManager.SelectedItems <TimelineClip>()
select x.start).DefaultIfEmpty(timelineClipGUI2.clip.start).Min();
this.m_FrameSnap.ApplyOffset(currentValue, delta, state);
foreach (TimelineClip current in from x in SelectionManager.SelectedItems <TimelineClip>()
orderby x.start
select x)
{
if (current.start + this.m_FrameSnap.lastOffsetApplied < 0.0)
{
break;
}
current.start += this.m_FrameSnap.lastOffsetApplied;
}
}
else
{
timelineClipGUI2.clip.start = this.m_FrameSnap.ApplyOffset(timelineClipGUI2.clip.start, delta, state);
}
if (this.m_MagnetEngine != null)
{
this.m_MagnetEngine.Snap(evt.get_delta().x);
}
timelineClipGUI2.InvalidateEditor();
timelineClipGUI2.parentTrackGUI.SortClipsByStartTime();
state.Evaluate();
}
}
result = base.ConsumeEvent();
}
}
return(result);
};
parent.Overlay += delegate(object target, Event evt, TimelineWindow.TimelineState state)
{
if (this.m_MagnetEngine != null)
{
this.m_MagnetEngine.OnGUI();
}
bool result;
if (this.m_IsVerticalDrag)
{
TimelineClipGUI timelineClipGUI = (TimelineClipGUI)target;
Color color = (!this.m_HasValidDropTarget) ? DirectorStyles.Instance.customSkin.colorInvalidDropTarget : DirectorStyles.Instance.customSkin.colorValidDropTarget;
timelineClipGUI.DrawDragPreview(this.m_PreviewRect, color);
result = base.ConsumeEvent();
}
else if (this.m_IsDragDriver)
{
IEnumerable <TimelineClip> enumerable = SelectionManager.SelectedItems <TimelineClip>();
double num = 1.7976931348623157E+308;
double num2 = -1.7976931348623157E+308;
foreach (TimelineClip current in enumerable)
{
if (current.start < num)
{
num = current.start;
}
if (current.end > num2)
{
num2 = current.end;
}
}
this.m_SelectionIndicator.Draw(num, num2, this.m_MagnetEngine);
result = base.ConsumeEvent();
}
else
{
result = base.IgnoreEvent();
}
return(result);
};
}
