public static TimelineClip CreateClipOnTrack(Object asset, TrackAsset parentTrack, ITimelineState state, Vector2 mousePosition)
{
double end = parentTrack.end;
TimelineClip timelineClip = parentTrack.CreateClipFromAsset(asset);
if (timelineClip != null)
{
SelectionManager.Clear();
timelineClip.timeScale = 1.0;
if (!float.IsPositiveInfinity(mousePosition.x) && !float.IsPositiveInfinity(mousePosition.y))
{
timelineClip.start = (double)state.ScreenSpacePixelToTimeAreaTime(mousePosition.x);
}
else
{
timelineClip.start = state.SnapToFrameIfRequired(end);
}
timelineClip.start = Math.Max(0.0, timelineClip.start);
timelineClip.mixInCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
timelineClip.mixOutCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
SelectionManager.Add(timelineClip);
parentTrack.CalculateExtrapolationTimes();
state.Refresh();
}
return(timelineClip);
}
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);
}
}
void DrawTrackButtons(Rect headerRect, WindowState state)
{
const float buttonSize = WindowConstants.trackHeaderButtonSize;
const float padding = WindowConstants.trackHeaderButtonPadding;
var buttonRect = new Rect(headerRect.xMax - buttonSize - padding, headerRect.y + ((headerRect.height - buttonSize) / 2f), buttonSize, buttonSize);
if (GUI.Button(buttonRect, EditorGUIUtility.IconContent("CreateAddNew"), m_Styles.trackGroupAddButton))
{
// the drop down will apply to all selected tracks
if (!SelectionManager.Contains(track))
{
SelectionManager.Clear();
SelectionManager.Add(track);
}
SequencerContextMenu.ShowNewTracksContextMenu(SelectionManager.SelectedTracks().ToArray(), TimelineWindow.state, buttonRect);
}
buttonRect.x -= buttonSize;
var suitePadding = DrawButtonSuite(2, ref buttonRect);
DrawMuteButton(buttonRect, state);
buttonRect.x -= buttonSize + padding;
DrawLockButton(buttonRect, state);
buttonRect.x -= suitePadding;
}
void SelectionChangedCallback(int[] ids)
{
if (Event.current.button == 1)
{
var selectableItem = PickerUtils.PickedSelectable();
if (selectableItem != null)
{
return;
}
}
if (Event.current.command || Event.current.control || Event.current.shift)
{
SelectionManager.UnSelectTracks();
}
else
{
SelectionManager.Clear();
}
foreach (var id in ids)
{
var trackGUI = (TimelineTrackBaseGUI)m_TreeView.FindItem(id);
SelectionManager.Add(trackGUI.track);
}
m_State.GetWindow().Repaint();
}
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(ActionContext actionContext)
{
// otherwise select all tracks.
SelectionManager.Clear();
TimelineWindow.instance.allTracks.ForEach(x => SelectionManager.Add(x.track));
return(true);
}
static void FinalizeInsertItemsUsingCurrentEditMode(WindowState state, IList <ItemsPerTrack> itemsGroups, double candidateTime)
{
EditMode.FinalizeInsertItemsAtTime(itemsGroups, candidateTime);
SelectionManager.Clear();
foreach (var itemsGroup in itemsGroups)
{
var track = itemsGroup.targetTrack;
var items = itemsGroup.items;
EditModeUtils.SetParentTrack(items, track);
track.SortClips();
TrackExtensions.ComputeBlendsFromOverlaps(track.clips);
track.CalculateExtrapolationTimes();
foreach (var item in items)
{
if (item.gui != null)
{
item.gui.Select();
}
}
}
var allItems = itemsGroups.SelectMany(x => x.items).ToList();
foreach (var item in allItems)
{
SelectionManager.Add(item);
}
FrameItems(state, allItems);
}
static void AddNewTrackMenuCommand(GenericMenu menu, TrackAsset parentTrack, TimelineGroupGUI parentGroup, Type type, WindowState state)
{
GenericMenu.MenuFunction2 lastMethod = trackType =>
{
SelectionManager.Clear();
TimelineHelpers.CreateTrack((Type)trackType, parentTrack);
};
var category = TimelineHelpers.GetTrackCategoryName(type);
if (!string.IsNullOrEmpty(category))
{
category += "/";
}
var name = category + TimelineHelpers.GetTrackMenuName(type);
var disabled = (parentTrack != null && parentTrack.lockedInHierarchy) || state.editSequence.isReadOnly;
bool addenu = true;
var attr = Attribute.GetCustomAttribute(type, typeof(TrackAttribute)) as TrackAttribute;
if (attr != null)
{
addenu = !attr.onlyInSub;
}
if (addenu)
{
AddCommandToMenu(menu, name, lastMethod, type, !disabled);
}
}
public static ISelectable HandleSingleSelection(Event evt)
{
var item = PickerUtils.TopmostPickedItemOfType <ISelectable>(i => i.CanSelect(evt));
if (item != null)
{
var selected = item.IsSelected();
if (!selected && CanClearSelection(evt))
{
SelectionManager.Clear();
}
if (evt.modifiers == EventModifiers.Shift)
{
if (!selected)
{
RangeSelectItems((item as TimelineItemGUI)?.item);
}
}
else
{
HandleItemSelection(evt, item);
}
}
return(item);
}
static void AddTrackMenuCommands(GenericMenu newTrackMenu, TrackAsset parentTrack, TimelineGroupGUI parentGroup, WindowState state)
{
// Add Group or SubGroup
var title = parentTrack == null?L10n.Tr("Track Group") : L10n.Tr("Track Sub-Group");
var disabled = (parentTrack != null && parentTrack.lockedInHierarchy) || state.editSequence.isReadOnly;
GenericMenu.MenuFunction command = () =>
{
SelectionManager.Clear();
TimelineHelpers.CreateTrack <GroupTrack>(parentTrack, title);
};
AddCommandToMenu(newTrackMenu, title, command, !disabled);
newTrackMenu.AddSeparator("");
var allTypes = TypeUtility.AllTrackTypes().Where(x => x != typeof(GroupTrack) && !TypeUtility.IsHiddenInMenu(x)).ToList();
var builtIn = allTypes.Where(x => x.Assembly.Equals(typeof(TimelineAsset).Assembly)).OrderBy(i => i.FullName).ToList();
var customTypes = allTypes.Except(builtIn).ToList();
foreach (var t in builtIn)
{
AddNewTrackMenuCommand(newTrackMenu, parentTrack, parentGroup, t, state);
}
if (builtIn.Any() && customTypes.Any())
{
newTrackMenu.AddSeparator("");
}
foreach (var t in customTypes)
{
AddNewTrackMenuCommand(newTrackMenu, parentTrack, parentGroup, t, state);
}
}
public override bool Execute(WindowState state)
{
// otherwise select all tracks.
SelectionManager.Clear();
state.GetWindow().allTracks.ForEach(x => SelectionManager.Add(x.track));
return(true);
}
public static IMarker AddMarkerCommand(TrackAsset target, Type markerType, double time)
{
SelectionManager.Clear();
var marker = MarkerModifier.CreateMarkerAtTime(target, markerType, time);
TimelineWindow.instance.state.Refresh();
return(marker);
}
public override bool Execute(TimelineWindow.TimelineState state, TimelineClip[] clips)
{
state.Stop();
ClipModifier.Delete(state.timeline, clips);
SelectionManager.Clear();
state.Refresh(true);
return(true);
}
static void AddMarkersCallback(ICollection <TrackAsset> targets, Type markerType, double time, Object obj)
{
SelectionManager.Clear();
foreach (var target in targets)
{
var marker = TimelineHelpers.CreateMarkerOnTrack(markerType, obj, target, time);
SelectionManager.Add(marker);
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
}
protected override bool MouseDown(Event evt, WindowState state)
{
var handle = PickerUtils.PickedLayerableOfType <TimelineClipHandle>();
if (handle == null)
{
return(false);
}
if (handle.clipGUI.clip.parentTrack != null && handle.clipGUI.clip.parentTrack.lockedInHierarchy)
{
return(false);
}
if (ItemSelection.CanClearSelection(evt))
{
SelectionManager.Clear();
}
if (!SelectionManager.Contains(handle.clipGUI.clip))
{
SelectionManager.Add(handle.clipGUI.clip);
}
m_TrimClipHandler = handle;
m_IsCaptured = true;
state.AddCaptured(this);
m_UndoSaved = false;
var clip = m_TrimClipHandler.clipGUI.clip;
m_OriginalDuration = clip.duration;
m_OriginalTimeScale = clip.timeScale;
m_OriginalEaseInDuration = clip.easeInDuration;
m_OriginalEaseOutDuration = clip.easeOutDuration;
RefreshOverlayStrings(m_TrimClipHandler, state);
// in ripple trim, the right edge moves and needs to snap
var edges = ManipulateEdges.Right;
if (EditMode.editType != EditMode.EditType.Ripple && m_TrimClipHandler.trimDirection == TrimEdge.Start)
{
edges = ManipulateEdges.Left;
}
m_SnapEngine = new SnapEngine(m_TrimClipHandler.clipGUI, new TrimClipAttractionHandler(), edges, state,
evt.mousePosition);
EditMode.BeginTrim(ItemsUtils.ToItem(clip), m_TrimClipHandler.trimDirection);
return(true);
}
protected float DrawTrackDropDownMenu(Rect rect, TimelineWindow.TimelineState state)
{
rect.set_y(rect.get_y() + 2f);
if (GUI.Button(rect, GUIContent.none, this.m_Styles.trackOptions))
{
SelectionManager.Clear();
SelectionManager.Add(base.track);
base.DisplayTrackMenu(state);
}
return(16f);
}
private static void SelectMarkerInInspector(ITimelineState state, TimelineMarker newEvent)
{
EditorWindow.FocusWindowIfItsOpen <InspectorWindow>();
SelectionManager.Clear();
newEvent.selected = true;
Object[] objects = new Object[]
{
EditorItemFactory.GetEditorMarker(newEvent)
};
Selection.set_objects(objects);
}
float DrawTrackDropDownMenu(Rect rect)
{
rect.y += WindowConstants.trackOptionButtonVerticalPadding;
if (GUI.Button(rect, GUIContent.none, m_Styles.trackOptions))
{
SelectionManager.Clear();
SelectionManager.Add(track);
DisplayTrackMenu();
}
return(WindowConstants.trackHeaderButtonSize);
}
public static void RangeSelect <T>(IList <T> totalCollection, IList <T> currentSelection, T clickedItem, Action <T> selector, Action <T> remover) where T : class
{
var firstSelect = currentSelection.FirstOrDefault();
if (firstSelect == null)
{
selector(clickedItem);
return;
}
var idxFirstSelect = totalCollection.IndexOf(firstSelect);
var idxLastSelect = totalCollection.IndexOf(currentSelection.Last());
var idxClicked = totalCollection.IndexOf(clickedItem);
//case 927807: selection is invalid
if (idxFirstSelect < 0)
{
SelectionManager.Clear();
selector(clickedItem);
return;
}
// Expand the selection between the first selected clip and clicked clip (insertion order is important)
if (idxFirstSelect < idxClicked)
{
for (var i = idxFirstSelect; i <= idxClicked; ++i)
{
selector(totalCollection[i]);
}
}
else
{
for (var i = idxFirstSelect; i >= idxClicked; --i)
{
selector(totalCollection[i]);
}
}
// If clicked inside the selected range, shrink the selection between the the click and last selected clip
if (Math.Min(idxFirstSelect, idxLastSelect) < idxClicked && idxClicked < Math.Max(idxFirstSelect, idxLastSelect))
{
for (var i = Math.Min(idxLastSelect, idxClicked); i <= Math.Max(idxLastSelect, idxClicked); ++i)
{
remover(totalCollection[i]);
}
}
// Ensure clicked clip is selected
selector(clickedItem);
}
protected override bool MouseUp(Event evt, WindowState state)
{
if (!m_Dragged)
{
var item = PickerUtils.TopmostPickedItem() as ISelectable;
if (item == null)
{
return(false);
}
if (!item.IsSelected())
{
return(false);
}
// Re-selecting an item part of a multi-selection should only keep this item selected.
if (SelectionManager.Count() > 1 && ItemSelection.CanClearSelection(evt))
{
SelectionManager.Clear();
item.Select();
return(true);
}
if (m_CycleMarkersPending)
{
m_CycleMarkersPending = false;
TimelineMarkerClusterGUI.CycleMarkers();
return(true);
}
return(false);
}
m_TimeAreaAutoPanner = null;
DropItems();
m_SnapEngine = null;
m_MoveItemHandler = null;
state.Evaluate();
state.RemoveCaptured(this);
m_Dragged = false;
TimelineCursors.ClearCursor();
return(true);
}
public override bool Execute(TimelineWindow.TimelineState state, TimelineMarker[] markers)
{
state.Stop();
for (int i = 0; i < markers.Length; i++)
{
TimelineMarker timelineMarker = markers[i];
ITimelineMarkerContainer timelineMarkerContainer = timelineMarker.parentTrack as ITimelineMarkerContainer;
if (timelineMarkerContainer != null)
{
timelineMarkerContainer.RemoveMarker(timelineMarker);
}
}
SelectionManager.Clear();
state.Refresh(true);
return(true);
}
private static void SelectMenuCallback(Func <TimelineClip, bool> selector, TimelineWindow.TimelineState state)
{
List <TimelineClipGUI> allClipGuis = state.GetWindow().treeView.allClipGuis;
if (allClipGuis != null)
{
SelectionManager.Clear();
for (int num = 0; num != allClipGuis.Count; num++)
{
TimelineClipGUI timelineClipGUI = allClipGuis[num];
if (timelineClipGUI != null && timelineClipGUI.clip != null && selector(timelineClipGUI.clip))
{
SelectionManager.Add(timelineClipGUI.clip);
}
}
}
}
float DrawTrackDropDownMenu(Rect rect)
{
rect.y += WindowConstants.trackOptionButtonVerticalPadding;
if (GUI.Button(rect, GUIContent.none, m_Styles.trackOptions))
{
// the drop down will apply to all selected tracks
if (!SelectionManager.Contains(track))
{
SelectionManager.Clear();
SelectionManager.Add(track);
}
SequencerContextMenu.ShowTrackContextMenu(SelectionManager.SelectedTracks().ToArray(), null);
}
return(WindowConstants.trackHeaderButtonSize);
}
public override bool Execute(TimelineWindow.TimelineState state, TimelineClip[] clips)
{
PlayableDirector director = (state == null) ? null : state.currentDirector;
for (int i = 0; i < clips.Length; i++)
{
TimelineClip clip = clips[i];
TimelineClip timelineClip = clip.Duplicate(director);
if (timelineClip != null && state != null)
{
SelectionManager.Clear();
SelectionManager.Add(timelineClip);
}
}
if (state != null)
{
state.Refresh();
}
return(true);
}
static void AddSingleMarkerCallback(Type markerType, double time, TimelineAsset timeline, PlayableDirector director, Object assignableObject)
{
timeline.CreateMarkerTrack();
var markerTrack = timeline.markerTrack;
SelectionManager.Clear();
var marker = TimelineHelpers.CreateMarkerOnTrack(markerType, assignableObject, markerTrack, time);
SelectionManager.Add(marker);
if (typeof(INotification).IsAssignableFrom(markerType) && director != null)
{
if (director != null && director.GetGenericBinding(markerTrack) == null)
{
director.SetGenericBinding(markerTrack, director.gameObject);
}
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
}
static void OnMouseClick(IClipCurveEditorOwner clipCurveEditorOwner, Event currentEvent)
{
if (currentEvent.modifiers == ManipulatorsUtils.actionModifier)
{
if (clipCurveEditorOwner.inlineCurvesSelected)
{
SelectionManager.Clear();
}
else
{
clipCurveEditorOwner.SelectCurves();
}
}
else
{
clipCurveEditorOwner.SelectCurves();
}
HandleCurrentEvent();
}
static void SelectMenuCallback(Func <TimelineClip, bool> selector, WindowState state)
{
var allClips = state.GetWindow().treeView.allClipGuis;
if (allClips == null)
{
return;
}
SelectionManager.Clear();
for (var i = 0; i != allClips.Count; ++i)
{
var c = allClips[i];
if (c != null && c.clip != null && selector(c.clip))
{
SelectionManager.Add(c.clip);
}
}
}
public override bool Execute(TimelineWindow.TimelineState state)
{
IClipCurveEditorOwner currentInlineEditorCurve = SelectionManager.GetCurrentInlineEditorCurve();
bool result;
if (currentInlineEditorCurve != null && currentInlineEditorCurve.clipCurveEditor != null)
{
currentInlineEditorCurve.clipCurveEditor.SelectAllKeys();
result = true;
}
else
{
SelectionManager.Clear();
state.GetWindow().allTracks.ForEach(delegate(TimelineTrackBaseGUI x)
{
SelectionManager.Add(x.track);
});
result = true;
}
return(result);
}
protected override bool OnFinish(Event evt, WindowState state, Rect rect)
{
var selectables = state.spacePartitioner.GetItemsInArea <ISelectable>(rect).ToList();
if (!selectables.Any())
{
return(false);
}
if (ItemSelection.CanClearSelection(evt))
{
SelectionManager.Clear();
}
foreach (var selectable in selectables)
{
ItemSelection.HandleItemSelection(evt, selectable);
}
return(true);
}
public override void Init(IControl parent)
{
parent.KeyDown += delegate(object target, Event evt, TimelineWindow.TimelineState state)
{
bool result;
if (EditorGUI.get_actionKey() && evt.get_keyCode() == 97)
{
SelectionManager.Clear();
foreach (TimelineTrackBaseGUI current in TimelineWindow.instance.allTracks)
{
SelectionManager.Add(current.track);
}
result = base.ConsumeEvent();
}
else
{
result = base.IgnoreEvent();
}
return(result);
};
}
