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); }; }