public void ProcessDelete(IUSHierarchyItem item)
{
var timelineContainerItem = item as USTimelineContainerHierarchyItem;
var timelineHierarchyItem = item as IUSTimelineHierarchyItem;
if (timelineContainerItem)
{
foreach (var child in timelineContainerItem.Children.ToList())
{
ProcessDelete(child);
}
USUndoManager.RegisterCompleteObjectUndo(this, "Remove Timeline Container");
USUndoManager.RegisterCompleteObjectUndo(USHierarchy, "Remove Timeline Container");
USHierarchy.RootItems.Remove(timelineContainerItem);
var gameObjectToDestroy = timelineContainerItem.TimelineContainer.gameObject;
USUndoManager.DestroyImmediate(timelineContainerItem);
USUndoManager.DestroyImmediate(gameObjectToDestroy);
}
else if (timelineHierarchyItem)
{
var parent = USHierarchy.GetParentOf(timelineHierarchyItem);
timelineHierarchyItem.RestoreBaseState();
USUndoManager.RegisterCompleteObjectUndo(parent, "Remove Timeline");
parent.RemoveChild(timelineHierarchyItem);
var gameObjectToDestroy = timelineHierarchyItem.TimelineToDestroy().gameObject;
USUndoManager.DestroyImmediate(timelineHierarchyItem);
USUndoManager.DestroyImmediate(gameObjectToDestroy);
}
}
private void ProcessDuplicate(IUSHierarchyItem item)
{
var timelineContainer = item as USTimelineContainerHierarchyItem;
if (timelineContainer != null)
{
var newTimelineContainer = USEditor.DuplicateTimelineContainer(timelineContainer.TimelineContainer, CurrentSequence);
USUndoManager.RegisterCreatedObjectUndo(newTimelineContainer.gameObject, "Duplicate Timeline");
AddNewTimelineContainer(newTimelineContainer);
}
var timeline = item as IUSTimelineHierarchyItem;
if (timeline != null)
{
USUndoManager.RegisterCompleteObjectUndo(this, "Duplicate Timeline");
USUndoManager.RegisterCompleteObjectUndo(USHierarchy, "Duplicate Timeline");
var newTimeline = USEditor.DuplicateTimeline(timeline.BaseTimeline, timeline.BaseTimeline.TimelineContainer);
USUndoManager.RegisterCreatedObjectUndo(newTimeline.gameObject, "Duplicate Timeline");
var parent = USHierarchy.GetParentOf(item) as USTimelineContainerHierarchyItem;
USUndoManager.RegisterCompleteObjectUndo(parent, "Duplicate Timeline");
parent.AddTimeline(newTimeline);
}
}
public static int Sorter(IUSHierarchyItem x, IUSHierarchyItem y)
{
var result = x.SortOrder.CompareTo(y.SortOrder);
if (result == 0 && x.SortName != null && y.SortName != null)
{
result = x.SortName.CompareTo(y.SortName);
}
return(result);
}
private void DrawHierarchyItem(IUSHierarchyItem item, int level)
{
using (new Shared.GUIBeginVertical())
{
item.FloatingWidth = FloatingWidth;
item.DoGUI(level);
if (item.IsExpanded)
{
// Draw all the children of the item
for (var i = 0; i < item.Children.Count; i++)
{
DrawHierarchyItem(item.Children[i], level + 1);
}
}
}
if (Event.current.type == EventType.Repaint)
{
item.LastRect = GUILayoutUtility.GetLastRect();
}
var clickableRect = item.LastRect;
clickableRect.width = FloatingWidth;
if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && clickableRect.Contains(Event.current.mousePosition))
{
OnItemClicked(item);
Event.current.Use();
}
if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && Event.current.clickCount == 2 && clickableRect.Contains(Event.current.mousePosition))
{
OnItemDoubleClicked(item);
Event.current.Use();
}
if (Event.current.type == EventType.MouseDown && Event.current.button == 1 && clickableRect.Contains(Event.current.mousePosition))
{
OnItemContextClicked(item);
Event.current.Use();
}
if (item.ForceContextClick)
{
OnItemContextClicked(item);
item.ForceContextClick = false;
}
}
private void OnItemClicked(IUSHierarchyItem item)
{
var timelineContainerItem = item as USTimelineContainerHierarchyItem;
if (timelineContainerItem != null && !USRuntimeUtility.HasObserverTimeline(timelineContainerItem.TimelineContainer.transform))
{
EditorGUIUtility.PingObject(timelineContainerItem.TimelineContainer.AffectedObject);
Selection.activeGameObject = timelineContainerItem.TimelineContainer.AffectedObject.gameObject;
Selection.activeTransform = timelineContainerItem.TimelineContainer.AffectedObject;
}
var timelineHierarchyItem = item as IUSTimelineHierarchyItem;
if (timelineHierarchyItem)
{
EditorGUIUtility.PingObject(timelineHierarchyItem.PingableObject);
Selection.activeTransform = timelineHierarchyItem.PingableObject;
}
}
private void GetISelectableContainers(IUSHierarchyItem item, ref List <ISelectableContainer> iSelectableContainers)
{
if (!item.IsISelectable())
{
return;
}
var containers = item.GetISelectableContainers();
if (containers != null && containers.Count > 0)
{
iSelectableContainers.AddRange(containers);
}
for (var i = 0; i < item.Children.Count; i++)
{
GetISelectableContainers(item.Children[i], ref iSelectableContainers);
}
}
public IUSHierarchyItem GetParentOfChild(IUSHierarchyItem parent, IUSHierarchyItem item)
{
if (parent.Children.Contains(item))
{
return(parent);
}
IUSHierarchyItem itemsParent = null;
for (var i = 0; i < parent.Children.Count; i++)
{
itemsParent = GetParentOfChild(parent.Children[i], item);
if (itemsParent != null)
{
break;
}
}
return(null);
}
public IUSHierarchyItem GetParentOf(IUSHierarchyItem item)
{
if (RootItems.Contains(item))
{
return(null);
}
IUSHierarchyItem itemsParent = null;
for (var i = 0; i < RootItems.Count; i++)
{
itemsParent = GetParentOfChild(RootItems[i], item);
if (itemsParent != null)
{
break;
}
}
return(itemsParent);
}
private void ProcessDuplicateToSequence(IUSHierarchyItem item, USSequencer sequence)
{
var affectedObject = default(Transform);
var timelineContainer = item as USTimelineContainerHierarchyItem;
var timeline = item as IUSTimelineHierarchyItem;
if (timelineContainer != null)
{
affectedObject = timelineContainer.TimelineContainer.AffectedObject;
}
if (timeline != null)
{
affectedObject = timeline.BaseTimeline.AffectedObject;
}
if (timelineContainer && USRuntimeUtility.HasTimelineContainerWithAffectedObject(sequence, affectedObject))
{
EditorUtility.DisplayDialog("Cannot continue", string.Format("The sequence {0} already has timelines for the object {1}", sequence.name, affectedObject.name), "Ok");
return;
}
if (timelineContainer)
{
var newTimelineContainer = USEditor.DuplicateTimelineContainer(timelineContainer.TimelineContainer, sequence);
USUndoManager.RegisterCreatedObjectUndo(newTimelineContainer.gameObject, "Duplicate Timeline");
}
if (timeline)
{
var newTimelineContainer = sequence.GetTimelineContainerFor(timeline.BaseTimeline.AffectedObject);
if (newTimelineContainer == null)
{
newTimelineContainer = sequence.CreateNewTimelineContainer(timeline.BaseTimeline.AffectedObject);
USUndoManager.RegisterCreatedObjectUndo(newTimelineContainer.gameObject, "Duplicate Timeline");
}
var newTimeline = USEditor.DuplicateTimeline(timeline.BaseTimeline, newTimelineContainer);
USUndoManager.RegisterCreatedObjectUndo(newTimeline.gameObject, "Duplicate Timeline");
}
}
public void SetupWithTimelineContainer(USTimelineContainer timelineContainer)
{
TimelineContainer = timelineContainer;
var timelines = TimelineContainer.Timelines;
if (TimelineContainer.Timelines.Count() > Children.Count)
{
var notInBoth = timelines.Where(
(timeline) => !Children.Any(
(item) =>
((item is IUSTimelineHierarchyItem) && (item as IUSTimelineHierarchyItem).IsForThisTimeline(timeline))
)
);
foreach (var extraTimeline in notInBoth)
{
IUSHierarchyItem hierarchyItem = null;
var customKeyValuePairs = USEditorUtility.CustomTimelineAttributes;
foreach (var customKeyValuePair in customKeyValuePairs)
{
if (extraTimeline.GetType() == customKeyValuePair.Key.InspectedType)
{
hierarchyItem = CreateInstance(customKeyValuePair.Value) as IUSHierarchyItem;
// This is here to capture the change in USTimelineBase BaseTimeline on the IUSTimelineHierarchyItem that occurse during initialize
USUndoManager.RegisterCompleteObjectUndo(hierarchyItem, "Add New Timeline");
hierarchyItem.Initialize(extraTimeline);
}
}
AddChild(hierarchyItem);
}
}
}
private void OnItemContextClicked(IUSHierarchyItem item)
{
var timelineContainerItem = item as USTimelineContainerHierarchyItem;
var timelineHierarchyItem = item as IUSTimelineHierarchyItem;
var contextMenu = new GenericMenu();
var canContextClickTimelineContainer = !timelineContainerItem || USEditorUtility.CanContextClickTimelineContainer(timelineContainerItem.TimelineContainer);
if (!canContextClickTimelineContainer)
{
return;
}
var canContextClickTimeline = !timelineHierarchyItem || USEditorUtility.CanContextClickTimeline(timelineHierarchyItem.BaseTimeline);
if (!canContextClickTimeline)
{
return;
}
if (timelineHierarchyItem || timelineContainerItem)
{
contextMenu.AddItem(new GUIContent("Remove"), false, () => ProcessDelete(item));
}
// if we context click on a hierarchy container, always allow the duplication
var isDuplicateEnabled = timelineContainerItem != null ? true :false;
// If we context click on a hierarchy item, we need to make sure we can duplicate that item.
if (timelineHierarchyItem)
{
var customAttribute = timelineHierarchyItem.GetType().GetCustomAttributes(typeof(USCustomTimelineHierarchyItem), true).FirstOrDefault() as USCustomTimelineHierarchyItem;
if (customAttribute != default(USCustomTimelineHierarchyItem))
{
if (customAttribute.CanBeManuallyAddToSequence && customAttribute.MaxNumberPerSequence > 1)
{
isDuplicateEnabled = true;
}
}
else
{
isDuplicateEnabled = true;
}
}
if (isDuplicateEnabled)
{
contextMenu.AddSeparator("Copy To/This Sequence");
contextMenu.AddItem(new GUIContent("Copy To/Duplicate"), false, () => ProcessDuplicate(item));
contextMenu.AddSeparator("Copy To/Other Sequences");
}
else
{
contextMenu.AddDisabledItem(new GUIContent("Copy To/This Sequence"));
}
var sequences = FindObjectsOfType(typeof(USSequencer)) as USSequencer[];
var orderedSequences = sequences.OrderBy(sequence => sequence.name).Where(sequence => sequence != CurrentSequence);
foreach (var sequence in orderedSequences)
{
contextMenu.AddItem(new GUIContent(string.Format("{0}/{1}", "Copy To", sequence.name)),
false,
(obj) => ProcessDuplicateToSequence(item, (USSequencer)obj),
sequence);
}
if (timelineContainerItem)
{
var customKeyValuePairs = USEditorUtility.CustomTimelineAttributes;
foreach (var customKeyValuePair in customKeyValuePairs)
{
var customTimelineDescription = customKeyValuePair.Key;
if (!customTimelineDescription.CanBeManuallyAddToSequence)
{
continue;
}
if (USRuntimeUtility.GetNumberOfTimelinesOfType(customTimelineDescription.InspectedType, timelineContainerItem.TimelineContainer) >= customTimelineDescription.MaxNumberPerSequence)
{
continue;
}
contextMenu.AddItem(
new GUIContent(string.Format("Add Timeline/{0}", customTimelineDescription.FriendlyName)),
false,
(obj) => { AddNewTimeline((obj as object[])[0] as USTimelineContainerHierarchyItem, (obj as object[])[1] as USCustomTimelineHierarchyItem); },
new object[] { timelineContainerItem, customTimelineDescription }
);
}
}
item.AddContextItems(contextMenu);
if (timelineContainerItem != null &&
(timelineContainerItem.TimelineContainer.AffectedObject == null ||
(Selection.activeGameObject != null &&
Selection.activeObject != timelineContainerItem.TimelineContainer.AffectedObject.gameObject)))
{
if (Selection.activeGameObject != null)
{
contextMenu.AddItem(
new GUIContent(string.Format("Update Affected Object : {0}", Selection.activeGameObject.name)),
false,
() => UpdateAffectedObject(timelineContainerItem, Selection.activeGameObject));
}
}
contextMenu.ShowAsContext();
}
/// <summary>
/// Removes a child and DOES NOT sort the hierarchy.
/// </summary>
/// <param name="child">Child.</param>
public void RemoveChild(IUSHierarchyItem child)
{
Children.Remove(child);
}
/// <summary>
/// Adds a child item and sorts the hierarchy
/// </summary>
/// <param name="child">Child.</param>
public void AddChild(IUSHierarchyItem child)
{
Children.Add(child);
Children.Sort(Sorter);
}
public void RemoveHierarchyItemFromRoot(IUSHierarchyItem hierarchyItem)
{
RootItems.Remove(hierarchyItem);
}
public void AddHierarchyItemToRoot(IUSHierarchyItem hierarchyItem)
{
RootItems.Add(hierarchyItem);
RootItems.Sort(IUSHierarchyItem.Sorter);
}
