private void DoCurveColorIndicator(Rect rect, AnimationWindowHierarchyNode node)
{
if (Event.current.type != EventType.Repaint)
{
return;
}
Color color = GUI.color;
GUI.color = this.state.showCurveEditor ? (node.curves.Length != 1 || node.curves[0].isPPtrCurve ? AnimationWindowHierarchyGUI.k_KeyColorForNonCurves : CurveUtility.GetPropertyColor(node.curves[0].binding.propertyName)) : AnimationWindowHierarchyGUI.k_KeyColorInDopesheetMode;
bool flag = false;
if (AnimationMode.InAnimationMode())
{
foreach (AnimationWindowCurve curve in node.curves)
{
if (curve.m_Keyframes.Any <AnimationWindowKeyframe>((Func <AnimationWindowKeyframe, bool>)(key => this.state.time.ContainsTime(key.time))))
{
flag = true;
}
}
}
Texture image = !flag ? (Texture)CurveUtility.GetIconCurve() : (Texture)CurveUtility.GetIconKey();
rect = new Rect((float)((double)rect.xMax - 10.0 - (double)(image.width / 2) - 5.0), rect.yMin + 3f, (float)image.width, (float)image.height);
GUI.DrawTexture(rect, image, ScaleMode.ScaleToFit, true, 1f);
GUI.color = color;
}
public static bool IsNodeAmbiguous(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if (rootGameObject == null)
{
return false;
}
EditorCurveBinding? binding = node.binding;
if (binding.HasValue)
{
return AnimationUtility.AmbiguousBinding(node.binding.Value.path, node.binding.Value.m_ClassID, rootGameObject.transform);
}
if (node.hasChildren)
{
using (List<TreeViewItem>.Enumerator enumerator = node.children.GetEnumerator())
{
if (enumerator.MoveNext())
{
TreeViewItem current = enumerator.Current;
return AnimationWindowUtility.IsNodeAmbiguous(current as AnimationWindowHierarchyNode, rootGameObject);
}
}
return false;
}
return false;
}
private List <AnimationWindowCurve> GetCurvesAffectedByNodes(List <AnimationWindowHierarchyNode> nodes, bool includeLinkedCurves)
{
List <AnimationWindowCurve> source = new List <AnimationWindowCurve>();
using (List <AnimationWindowHierarchyNode> .Enumerator enumerator = nodes.GetEnumerator())
{
while (enumerator.MoveNext())
{
AnimationWindowHierarchyNode windowHierarchyNode = enumerator.Current;
if (windowHierarchyNode.parent is AnimationWindowHierarchyPropertyGroupNode && includeLinkedCurves)
{
windowHierarchyNode = (AnimationWindowHierarchyNode)windowHierarchyNode.parent;
}
if (windowHierarchyNode is AnimationWindowHierarchyPropertyGroupNode || windowHierarchyNode is AnimationWindowHierarchyPropertyNode)
{
source.AddRange((IEnumerable <AnimationWindowCurve>)AnimationWindowUtility.FilterCurves(this.state.allCurves.ToArray(), windowHierarchyNode.path, windowHierarchyNode.animatableObjectType, windowHierarchyNode.propertyName));
}
else
{
source.AddRange((IEnumerable <AnimationWindowCurve>)AnimationWindowUtility.FilterCurves(this.state.allCurves.ToArray(), windowHierarchyNode.path, windowHierarchyNode.animatableObjectType));
}
}
}
return(source.Distinct <AnimationWindowCurve>().ToList <AnimationWindowCurve>());
}
private List <AnimationWindowCurve> GetCurvesAffectedByNodes(List <AnimationWindowHierarchyNode> nodes, bool includeLinkedCurves)
{
List <AnimationWindowCurve> curves = new List <AnimationWindowCurve>();
foreach (var node in nodes)
{
AnimationWindowHierarchyNode hierarchyNode = node;
if (hierarchyNode.parent is AnimationWindowHierarchyPropertyGroupNode && includeLinkedCurves)
{
hierarchyNode = (AnimationWindowHierarchyNode)hierarchyNode.parent;
}
if (hierarchyNode.curves == null)
{
continue;
}
if (hierarchyNode.curves.Length > 0)
{
// Property or propertygroup
if (hierarchyNode is AnimationWindowHierarchyPropertyGroupNode || hierarchyNode is AnimationWindowHierarchyPropertyNode)
{
curves.AddRange(AnimationWindowUtility.FilterCurves(hierarchyNode.curves, hierarchyNode.path, hierarchyNode.animatableObjectType, hierarchyNode.propertyName));
}
else
{
curves.AddRange(AnimationWindowUtility.FilterCurves(hierarchyNode.curves, hierarchyNode.path, hierarchyNode.animatableObjectType));
}
}
}
return(curves.Distinct().ToList());
}
private void RemoveCurvesFromNodes(List <AnimationWindowHierarchyNode> nodes)
{
foreach (AnimationWindowHierarchyNode current in nodes)
{
AnimationWindowHierarchyNode animationWindowHierarchyNode = current;
if (animationWindowHierarchyNode.parent is AnimationWindowHierarchyPropertyGroupNode)
{
EditorCurveBinding?binding = animationWindowHierarchyNode.binding;
if (binding.HasValue)
{
EditorCurveBinding?binding2 = animationWindowHierarchyNode.binding;
if (AnimationWindowUtility.ForceGrouping(binding2.Value))
{
animationWindowHierarchyNode = (AnimationWindowHierarchyNode)animationWindowHierarchyNode.parent;
}
}
}
List <AnimationWindowCurve> list;
if (animationWindowHierarchyNode is AnimationWindowHierarchyPropertyGroupNode || animationWindowHierarchyNode is AnimationWindowHierarchyPropertyNode)
{
list = AnimationWindowUtility.FilterCurves(this.state.allCurves.ToArray(), animationWindowHierarchyNode.path, animationWindowHierarchyNode.animatableObjectType, animationWindowHierarchyNode.propertyName);
}
else
{
list = AnimationWindowUtility.FilterCurves(this.state.allCurves.ToArray(), animationWindowHierarchyNode.path, animationWindowHierarchyNode.animatableObjectType);
}
foreach (AnimationWindowCurve current2 in list)
{
this.state.RemoveCurve(current2);
}
}
this.m_TreeView.ReloadData();
}
override protected void RenameEnded()
{
string newName = GetRenameOverlay().name;
string oldName = GetRenameOverlay().originalName;
if (newName != oldName)
{
Undo.RecordObject(state.activeAnimationClip, "Rename Curve");
foreach (AnimationWindowCurve curve in m_RenamedNode.curves)
{
EditorCurveBinding newBinding = AnimationWindowUtility.GetRenamedBinding(curve.binding, newName);
if (AnimationWindowUtility.CurveExists(newBinding, state.allCurves.ToArray()))
{
Debug.LogWarning("Curve already exists, renaming cancelled.");
continue;
}
AnimationWindowUtility.RenameCurvePath(curve, newBinding, curve.clip);
}
}
m_RenamedNode = null;
}
public static bool IsNodeAmbiguous(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if (rootGameObject == null)
{
return(false);
}
EditorCurveBinding?binding = node.binding;
if (binding.HasValue)
{
return(AnimationUtility.AmbiguousBinding(node.binding.Value.path, node.binding.Value.m_ClassID, rootGameObject.transform));
}
if (node.hasChildren)
{
using (List <TreeViewItem> .Enumerator enumerator = node.children.GetEnumerator())
{
if (enumerator.MoveNext())
{
TreeViewItem current = enumerator.Current;
return(AnimationWindowUtility.IsNodeAmbiguous(current as AnimationWindowHierarchyNode, rootGameObject));
}
}
return(false);
}
return(false);
}
private void DoCurveColorIndicator(Rect rect, AnimationWindowHierarchyNode node)
{
if (Event.current.type == EventType.Repaint)
{
Color color = GUI.color;
if (!this.state.showCurveEditor)
{
GUI.color = k_KeyColorInDopesheetMode;
}
else if ((node.curves.Length == 1) && !node.curves[0].isPPtrCurve)
{
GUI.color = CurveUtility.GetPropertyColor(node.curves[0].binding.propertyName);
}
else
{
GUI.color = k_KeyColorForNonCurves;
}
bool flag = false;
if (AnimationMode.InAnimationMode())
{
foreach (AnimationWindowCurve curve in node.curves)
{
if (curve.m_Keyframes.Any <AnimationWindowKeyframe>(key => this.state.time.ContainsTime(key.time)))
{
flag = true;
}
}
}
Texture image = !flag?CurveUtility.GetIconCurve() : CurveUtility.GetIconKey();
rect = new Rect(((rect.xMax - 10f) - (image.width / 2)) - 5f, rect.yMin + 3f, (float)image.width, (float)image.height);
GUI.DrawTexture(rect, image, ScaleMode.ScaleToFit, true, 1f);
GUI.color = color;
}
}
public static bool IsNodeLeftOverCurve(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if (rootGameObject == null)
{
return(false);
}
EditorCurveBinding?binding = node.binding;
if (binding.HasValue)
{
EditorCurveBinding?binding2 = node.binding;
return(AnimationUtility.GetEditorCurveValueType(rootGameObject, binding2.Value) == null);
}
if (node.hasChildren)
{
using (List <TreeViewItem> .Enumerator enumerator = node.children.GetEnumerator())
{
if (enumerator.MoveNext())
{
TreeViewItem current = enumerator.Current;
return(AnimationWindowUtility.IsNodeLeftOverCurve(current as AnimationWindowHierarchyNode, rootGameObject));
}
}
return(false);
}
return(false);
}
private List <AnimationWindowCurve> GetCurvesAffectedByNodes(List <AnimationWindowHierarchyNode> nodes, bool includeLinkedCurves)
{
List <AnimationWindowCurve> list = new List <AnimationWindowCurve>();
foreach (AnimationWindowHierarchyNode current in nodes)
{
AnimationWindowHierarchyNode animationWindowHierarchyNode = current;
if (animationWindowHierarchyNode.parent is AnimationWindowHierarchyPropertyGroupNode && includeLinkedCurves)
{
animationWindowHierarchyNode = (AnimationWindowHierarchyNode)animationWindowHierarchyNode.parent;
}
if (animationWindowHierarchyNode.curves.Length > 0)
{
if (animationWindowHierarchyNode is AnimationWindowHierarchyPropertyGroupNode || animationWindowHierarchyNode is AnimationWindowHierarchyPropertyNode)
{
list.AddRange(AnimationWindowUtility.FilterCurves(animationWindowHierarchyNode.curves, animationWindowHierarchyNode.path, animationWindowHierarchyNode.animatableObjectType, animationWindowHierarchyNode.propertyName));
}
else
{
list.AddRange(AnimationWindowUtility.FilterCurves(animationWindowHierarchyNode.curves, animationWindowHierarchyNode.path, animationWindowHierarchyNode.animatableObjectType));
}
}
}
return(list.Distinct <AnimationWindowCurve>().ToList <AnimationWindowCurve>());
}
public void SetTallMode(AnimationWindowHierarchyNode node, bool tallMode)
{
if (tallMode)
this.m_TallInstanceIDs.Add(node.id);
else
this.m_TallInstanceIDs.Remove(node.id);
}
public List <AnimationWindowHierarchyNode> CreateTreeFromCurves()
{
List <AnimationWindowHierarchyNode> list = new List <AnimationWindowHierarchyNode>();
List <AnimationWindowCurve> list2 = new List <AnimationWindowCurve>();
AnimationWindowCurve[] array = this.state.allCurves.ToArray();
AnimationWindowHierarchyNode parentNode = (AnimationWindowHierarchyNode)this.m_RootItem;
for (int i = 0; i < array.Length; i++)
{
AnimationWindowCurve animationWindowCurve = array[i];
AnimationWindowCurve animationWindowCurve2 = (i >= array.Length - 1) ? null : array[i + 1];
list2.Add(animationWindowCurve);
bool flag = animationWindowCurve2 != null && AnimationWindowUtility.GetPropertyGroupName(animationWindowCurve2.propertyName) == AnimationWindowUtility.GetPropertyGroupName(animationWindowCurve.propertyName);
bool flag2 = animationWindowCurve2 != null && animationWindowCurve.path.Equals(animationWindowCurve2.path) && animationWindowCurve.type == animationWindowCurve2.type;
if (i == array.Length - 1 || !flag || !flag2)
{
if (list2.Count > 1)
{
list.Add(this.AddPropertyGroupToHierarchy(list2.ToArray(), parentNode));
}
else
{
list.Add(this.AddPropertyToHierarchy(list2[0], parentNode));
}
list2.Clear();
}
}
return(list);
}
protected void DoNodeGUI(Rect rect, AnimationWindowHierarchyNode node, bool selected, bool focused, int row)
{
this.InitStyles();
if (!(node is AnimationWindowHierarchyMasterNode))
{
float indent = base.k_BaseIndent + ((node.depth + node.indent) * base.k_IndentWidth);
if (node is AnimationWindowHierarchyAddButtonNode)
{
if ((Event.current.type == EventType.MouseMove) && (s_WasInsideValueRectFrame >= 0))
{
if (s_WasInsideValueRectFrame >= (Time.frameCount - 1))
{
Event.current.Use();
}
else
{
s_WasInsideValueRectFrame = -1;
}
}
using (new EditorGUI.DisabledScope(!this.state.selection.canAddCurves))
{
this.DoAddCurveButton(rect, node, row);
}
}
else
{
this.DoRowBackground(rect, row);
this.DoIconAndName(rect, node, selected, focused, indent);
this.DoFoldout(node, rect, indent, row);
bool enabled = false;
if (node.curves != null)
{
if (< > f__am$cache0 == null)
{
protected override void RenameEnded()
{
string name = base.GetRenameOverlay().name;
string originalName = base.GetRenameOverlay().originalName;
if (name != originalName)
{
Undo.RecordObject(this.state.activeAnimationClip, "Rename Curve");
AnimationWindowCurve[] curves = this.m_RenamedNode.curves;
for (int i = 0; i < curves.Length; i++)
{
AnimationWindowCurve animationWindowCurve = curves[i];
string newPath = this.RenamePath(animationWindowCurve.path, name);
EditorCurveBinding renamedBinding = AnimationWindowUtility.GetRenamedBinding(animationWindowCurve.binding, newPath);
if (AnimationWindowUtility.CurveExists(renamedBinding, this.state.allCurves.ToArray()))
{
Debug.LogWarning("Curve already exists, renaming cancelled.");
}
else
{
AnimationWindowUtility.RenameCurvePath(animationWindowCurve, renamedBinding, animationWindowCurve.clip);
}
}
}
this.m_RenamedNode = null;
}
protected void DoNodeGUI(Rect rect, AnimationWindowHierarchyNode node, bool selected, bool focused, int row)
{
this.InitStyles();
if (node is AnimationWindowHierarchyMasterNode)
return;
float indent = this.k_BaseIndent + (float) (node.depth + node.indent) * this.k_IndentWidth;
if (node is AnimationWindowHierarchyAddButtonNode)
{
if (Event.current.type == EventType.MouseMove && AnimationWindowHierarchyGUI.s_WasInsideValueRectFrame >= 0)
{
if (AnimationWindowHierarchyGUI.s_WasInsideValueRectFrame >= Time.frameCount - 1)
Event.current.Use();
else
AnimationWindowHierarchyGUI.s_WasInsideValueRectFrame = -1;
}
EditorGUI.BeginDisabledGroup(!(bool) ((UnityEngine.Object) this.state.activeGameObject) || !AnimationWindowUtility.GameObjectIsAnimatable(this.state.activeGameObject, this.state.activeAnimationClip));
this.DoAddCurveButton(rect);
EditorGUI.EndDisabledGroup();
}
else
{
this.DoRowBackground(rect, row);
this.DoIconAndName(rect, node, selected, focused, indent);
this.DoFoldout(node, rect, indent);
EditorGUI.BeginDisabledGroup(this.state.animationIsReadOnly);
this.DoValueField(rect, node, row);
this.HandleContextMenu(rect, node);
EditorGUI.EndDisabledGroup();
this.DoCurveDropdown(rect, node);
this.DoCurveColorIndicator(rect, node);
}
EditorGUIUtility.SetIconSize(Vector2.zero);
}
public static bool IsNodeLeftOverCurve(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if (rootGameObject == null)
{
return false;
}
EditorCurveBinding? binding = node.binding;
if (binding.HasValue)
{
EditorCurveBinding? binding2 = node.binding;
return AnimationUtility.GetEditorCurveValueType(rootGameObject, binding2.Value) == null;
}
if (node.hasChildren)
{
using (List<TreeViewItem>.Enumerator enumerator = node.children.GetEnumerator())
{
if (enumerator.MoveNext())
{
TreeViewItem current = enumerator.Current;
return AnimationWindowUtility.IsNodeLeftOverCurve(current as AnimationWindowHierarchyNode, rootGameObject);
}
}
return false;
}
return false;
}
public static bool IsNodeAmbiguous(AnimationWindowHierarchyNode node)
{
EditorCurveBinding?binding = node.binding;
bool result;
if (binding.HasValue)
{
if (node.curves.Length > 0)
{
AnimationWindowSelectionItem selectionBinding = node.curves[0].selectionBinding;
if (selectionBinding != null)
{
if (selectionBinding.rootGameObject != null)
{
result = AnimationUtility.AmbiguousBinding(node.binding.Value.path, node.binding.Value.m_ClassID, selectionBinding.rootGameObject.transform);
return(result);
}
}
}
}
if (node.hasChildren)
{
using (List <TreeViewItem> .Enumerator enumerator = node.children.GetEnumerator())
{
if (enumerator.MoveNext())
{
TreeViewItem current = enumerator.Current;
result = AnimationWindowUtility.IsNodeAmbiguous(current as AnimationWindowHierarchyNode);
return(result);
}
}
}
result = false;
return(result);
}
private void RemoveCurvesFromNodes(List <AnimationWindowHierarchyNode> nodes)
{
foreach (AnimationWindowHierarchyNode node in nodes)
{
AnimationWindowHierarchyNode parent = node;
if (((parent.parent is AnimationWindowHierarchyPropertyGroupNode) && parent.binding.HasValue) && AnimationWindowUtility.ForceGrouping(parent.binding.Value))
{
parent = (AnimationWindowHierarchyNode)parent.parent;
}
List <AnimationWindowCurve> list = null;
if ((parent is AnimationWindowHierarchyPropertyGroupNode) || (parent is AnimationWindowHierarchyPropertyNode))
{
list = AnimationWindowUtility.FilterCurves(this.state.allCurves.ToArray(), parent.path, parent.animatableObjectType, parent.propertyName);
}
else
{
list = AnimationWindowUtility.FilterCurves(this.state.allCurves.ToArray(), parent.path, parent.animatableObjectType);
}
foreach (AnimationWindowCurve curve in list)
{
this.state.RemoveCurve(curve);
}
}
base.m_TreeView.ReloadData();
}
private void DoIconAndName(Rect rect, AnimationWindowHierarchyNode node, bool selected, bool focused, float indent)
{
EditorGUIUtility.SetIconSize(new Vector2(13f, 13f));
if (Event.current.type == EventType.Repaint)
{
if (selected)
{
TreeViewGUI.s_Styles.selectionStyle.Draw(rect, false, false, true, focused);
}
if (AnimationMode.InAnimationMode())
{
rect.width -= 77f;
}
bool flag = AnimationWindowUtility.IsNodeLeftOverCurve(node, this.state.activeRootGameObject);
bool flag2 = AnimationWindowUtility.IsNodeAmbiguous(node, this.state.activeRootGameObject);
string str = string.Empty;
string tooltip = string.Empty;
if (flag)
{
str = " (Missing!)";
tooltip = "The GameObject or Component is missing (" + node.path + ")";
}
if (flag2)
{
str = " (Duplicate GameObject name!)";
tooltip = "Target for curve is ambiguous since there are multiple GameObjects with same name (" + node.path + ")";
}
if (node.depth == 0)
{
if ((this.state.activeRootGameObject != null) && (this.state.activeRootGameObject.transform.Find(node.path) == null))
{
flag = true;
}
TreeViewGUI.s_Styles.content = new GUIContent(this.GetGameObjectName(node.path) + " : " + node.displayName + str, this.GetIconForNode(node), tooltip);
Color textColor = this.m_AnimationLineStyle.normal.textColor;
Color color = !EditorGUIUtility.isProSkin ? Color.black : ((Color)(Color.gray * 1.35f));
color = (!flag && !flag2) ? color : k_LeftoverCurveColor;
this.SetStyleTextColor(this.m_AnimationLineStyle, color);
rect.xMin += (int)(indent + base.k_FoldoutWidth);
GUI.Label(rect, TreeViewGUI.s_Styles.content, this.m_AnimationLineStyle);
this.SetStyleTextColor(this.m_AnimationLineStyle, textColor);
}
else
{
TreeViewGUI.s_Styles.content = new GUIContent(node.displayName + str, this.GetIconForNode(node), tooltip);
Color color3 = this.m_AnimationLineStyle.normal.textColor;
Color color4 = !EditorGUIUtility.isProSkin ? this.m_LightSkinPropertyTextColor : Color.gray;
color4 = (!flag && !flag2) ? color4 : k_LeftoverCurveColor;
this.SetStyleTextColor(this.m_AnimationLineStyle, color4);
rect.xMin += (int)((indent + base.k_IndentWidth) + base.k_FoldoutWidth);
GUI.Label(rect, TreeViewGUI.s_Styles.content, this.m_AnimationLineStyle);
this.SetStyleTextColor(this.m_AnimationLineStyle, color3);
}
}
if (this.IsRenaming(node.id) && (Event.current.type != EventType.Layout))
{
base.GetRenameOverlay().editFieldRect = new Rect(rect.x + base.k_IndentWidth, rect.y, (rect.width - base.k_IndentWidth) - 1f, rect.height);
}
}
public float GetNodeHeight(AnimationWindowHierarchyNode node)
{
if (node is AnimationWindowHierarchyAddButtonNode)
{
return(40f);
}
return((this.m_TreeView.state as AnimationWindowHierarchyState).GetTallMode(node) ? 32f : 16f);
}
private void HandleContextMenu(Rect rect, AnimationWindowHierarchyNode node)
{
if ((Event.current.type == EventType.ContextClick) && rect.Contains(Event.current.mousePosition))
{
this.state.SelectHierarchyItem(node.id, false, true);
this.GenerateMenu(this.state.selectedHierarchyNodes).ShowAsContext();
Event.current.Use();
}
}
public float GetNodeHeight(AnimationWindowHierarchyNode node)
{
if (node is AnimationWindowHierarchyAddButtonNode)
{
return(40f);
}
AnimationWindowHierarchyState animationWindowHierarchyState = this.m_TreeView.state as AnimationWindowHierarchyState;
return((!animationWindowHierarchyState.GetTallMode(node)) ? 16f : 32f);
}
public List <AnimationWindowKeyframe> GetAggregateKeys(AnimationWindowHierarchyNode hierarchyNode)
{
DopeLine dopeLine = this.dopelines.FirstOrDefault((DopeLine e) => e.m_HierarchyNodeID == hierarchyNode.id);
if (dopeLine == null)
{
return(null);
}
return(dopeLine.keys);
}
private float GetTopPixelOfRow(int row, List <TreeViewItem> rows)
{
float num = 0.0f;
for (int index = 0; index < row && index < rows.Count; ++index)
{
AnimationWindowHierarchyNode row1 = rows[index] as AnimationWindowHierarchyNode;
num += this.GetNodeHeight(row1);
}
return(num);
}
private void DoCurveDropdown(Rect rect, AnimationWindowHierarchyNode node, int row, bool enabled)
{
rect = new Rect((rect.xMax - 10f) - 12f, rect.yMin + 2f, 22f, 12f);
if (this.DoTreeViewButton(this.m_HierarchyItemButtonControlIDs[row], rect, GUIContent.none, this.m_AnimationCurveDropdown))
{
this.state.SelectHierarchyItem(node.id, false, false);
AnimationWindowHierarchyNode[] source = new AnimationWindowHierarchyNode[] { node };
this.GenerateMenu(source.ToList <AnimationWindowHierarchyNode>(), enabled).DropDown(rect);
Event.current.Use();
}
}
private float GetTopPixelOfRow(int row, List <TreeViewItem> rows)
{
float num = 0f;
for (int i = 0; (i < row) && (i < rows.Count); i++)
{
AnimationWindowHierarchyNode node = rows[i] as AnimationWindowHierarchyNode;
num += this.GetNodeHeight(node);
}
return(num);
}
public float GetNodeHeight(AnimationWindowHierarchyNode node)
{
if (node is AnimationWindowHierarchyAddButtonNode)
{
return(k_AddCurveButtonNodeHeight);
}
AnimationWindowHierarchyState hierarchyState = m_TreeView.state as AnimationWindowHierarchyState;
return(hierarchyState.GetTallMode(node) ? k_DopeSheetRowHeightTall : k_DopeSheetRowHeight);
}
private void DoCurveDropdown(Rect rect, AnimationWindowHierarchyNode node)
{
rect = new Rect((rect.xMax - 10f) - 12f, rect.yMin + 2f, 22f, 12f);
if (GUI.Button(rect, GUIContent.none, this.m_AnimationCurveDropdown))
{
this.state.SelectHierarchyItem(node.id, false, false);
AnimationWindowHierarchyNode[] source = new AnimationWindowHierarchyNode[] { node };
this.GenerateMenu(source.ToList <AnimationWindowHierarchyNode>()).DropDown(rect);
Event.current.Use();
}
}
public override Rect GetRowRect(int row, float rowWidth)
{
List <TreeViewItem> rows = base.m_TreeView.data.GetRows();
AnimationWindowHierarchyNode node = rows[row] as AnimationWindowHierarchyNode;
if (!node.topPixel.HasValue)
{
node.topPixel = new float?(this.GetTopPixelOfRow(row, rows));
}
return(new Rect(0f, node.topPixel.Value, rowWidth, this.GetNodeHeight(node)));
}
public override Vector2 GetTotalSize(List <TreeViewItem> rows)
{
float num = 0f;
for (int i = 0; i < rows.Count; i++)
{
AnimationWindowHierarchyNode node = rows[i] as AnimationWindowHierarchyNode;
num += this.GetNodeHeight(node);
}
return(new Vector2(1f, num));
}
public void SetTallMode(AnimationWindowHierarchyNode node, bool tallMode)
{
if (tallMode)
{
m_TallInstanceIDs.Add(node.id);
}
else
{
m_TallInstanceIDs.Remove(node.id);
}
}
float GetTopPixelOfRow(int row, IList <TreeViewItem> rows)
{
float top = 0f;
for (int i = 0; i < row && i < rows.Count; i++)
{
AnimationWindowHierarchyNode node = rows[i] as AnimationWindowHierarchyNode;
top += GetNodeHeight(node);
}
return(top);
}
public override Vector2 GetTotalSize()
{
List <TreeViewItem> rows = base.m_TreeView.data.GetRows();
float y = 0f;
for (int i = 0; i < rows.Count; i++)
{
AnimationWindowHierarchyNode node = rows[i] as AnimationWindowHierarchyNode;
y += this.GetNodeHeight(node);
}
return(new Vector2(1f, y));
}
protected void DoNodeGUI(Rect rect, AnimationWindowHierarchyNode node, bool selected, bool focused, int row)
{
InitStyles();
if (node is AnimationWindowHierarchyMasterNode)
{
return;
}
float indent = k_BaseIndent + (node.depth + node.indent) * k_IndentWidth;
if (node is AnimationWindowHierarchyAddButtonNode)
{
if (Event.current.type == EventType.MouseMove && s_WasInsideValueRectFrame >= 0)
{
if (s_WasInsideValueRectFrame >= Time.frameCount - 1)
{
Event.current.Use();
}
else
{
s_WasInsideValueRectFrame = -1;
}
}
using (new EditorGUI.DisabledScope(!state.selection.canAddCurves))
{
DoAddCurveButton(rect, node, row);
}
}
else
{
DoRowBackground(rect, row);
DoIconAndName(rect, node, selected, focused, indent);
DoFoldout(node, rect, indent, row);
bool enabled = false;
if (node.curves != null)
{
enabled = !Array.Exists(node.curves, curve => curve.animationIsEditable == false);
}
using (new EditorGUI.DisabledScope(!enabled))
{
DoValueField(rect, node, row);
}
DoCurveDropdown(rect, node, row, enabled);
HandleContextMenu(rect, node, enabled);
DoCurveColorIndicator(rect, node);
}
EditorGUIUtility.SetIconSize(Vector2.zero);
}
public override bool BeginRename(TreeViewItem item, float delay)
{
this.m_RenamedNode = item as AnimationWindowHierarchyNode;
GameObject rootGameObject = null;
if (this.m_RenamedNode.curves.Length > 0)
{
AnimationWindowSelectionItem selectionBinding = this.m_RenamedNode.curves[0].selectionBinding;
if (selectionBinding != null)
{
rootGameObject = selectionBinding.rootGameObject;
}
}
return base.GetRenameOverlay().BeginRename(this.GetGameObjectName(rootGameObject, this.m_RenamedNode.path), item.id, delay);
}
private AnimationWindowHierarchyPropertyNode AddPropertyToHierarchy(AnimationWindowCurve curve, AnimationWindowHierarchyNode parentNode)
{
AnimationWindowHierarchyPropertyNode node = new AnimationWindowHierarchyPropertyNode(curve.type, curve.propertyName, curve.path, parentNode, curve.binding, curve.isPPtrCurve);
if (parentNode.icon != null)
{
node.icon = parentNode.icon;
}
else
{
node.icon = this.GetIcon(curve.binding);
}
node.indent = curve.depth;
node.curves = new AnimationWindowCurve[] { curve };
return node;
}
private AnimationWindowHierarchyPropertyGroupNode AddPropertyGroupToHierarchy(AnimationWindowCurve[] curves, AnimationWindowHierarchyNode parentNode)
{
List<AnimationWindowHierarchyNode> windowHierarchyNodeList = new List<AnimationWindowHierarchyNode>();
AnimationWindowHierarchyPropertyGroupNode propertyGroupNode = new AnimationWindowHierarchyPropertyGroupNode(curves[0].type, AnimationWindowUtility.GetPropertyGroupName(curves[0].propertyName), curves[0].path, (TreeViewItem) parentNode);
propertyGroupNode.icon = this.GetIcon(curves[0].binding);
propertyGroupNode.indent = curves[0].depth;
propertyGroupNode.curves = curves;
foreach (AnimationWindowCurve curve in curves)
{
AnimationWindowHierarchyPropertyNode hierarchy = this.AddPropertyToHierarchy(curve, (AnimationWindowHierarchyNode) propertyGroupNode);
hierarchy.displayName = AnimationWindowUtility.GetPropertyDisplayName(hierarchy.propertyName);
windowHierarchyNodeList.Add((AnimationWindowHierarchyNode) hierarchy);
}
TreeViewUtility.SetChildParentReferences(new List<TreeViewItem>((IEnumerable<TreeViewItem>) windowHierarchyNodeList.ToArray()), (TreeViewItem) propertyGroupNode);
return propertyGroupNode;
}
public static bool IsNodeLeftOverCurve(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if ((UnityEngine.Object) rootGameObject == (UnityEngine.Object) null)
return false;
if (node.binding.HasValue)
return AnimationUtility.GetEditorCurveValueType(rootGameObject, node.binding.Value) == null;
if (node.hasChildren)
{
using (List<TreeViewItem>.Enumerator enumerator = node.children.GetEnumerator())
{
if (enumerator.MoveNext())
return AnimationWindowUtility.IsNodeLeftOverCurve(enumerator.Current as AnimationWindowHierarchyNode, rootGameObject);
}
}
return false;
}
public static bool IsNodeAmbiguous(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if ((UnityEngine.Object) rootGameObject == (UnityEngine.Object) null)
return false;
if (node.binding.HasValue)
return AnimationUtility.AmbiguousBinding(node.binding.Value.path, node.binding.Value.m_ClassID, rootGameObject.transform);
if (node.hasChildren)
{
using (List<TreeViewItem>.Enumerator enumerator = node.children.GetEnumerator())
{
if (enumerator.MoveNext())
return AnimationWindowUtility.IsNodeAmbiguous(enumerator.Current as AnimationWindowHierarchyNode, rootGameObject);
}
}
return false;
}
private AnimationWindowHierarchyPropertyGroupNode AddPropertyGroupToHierarchy(AnimationWindowCurve[] curves, AnimationWindowHierarchyNode parentNode)
{
List<AnimationWindowHierarchyNode> list = new List<AnimationWindowHierarchyNode>();
AnimationWindowHierarchyPropertyGroupNode node = new AnimationWindowHierarchyPropertyGroupNode(curves[0].type, AnimationWindowUtility.GetPropertyGroupName(curves[0].propertyName), curves[0].path, parentNode) {
icon = this.GetIcon(curves[0].binding),
indent = curves[0].depth,
curves = curves
};
foreach (AnimationWindowCurve curve in curves)
{
AnimationWindowHierarchyPropertyNode item = this.AddPropertyToHierarchy(curve, node);
item.displayName = AnimationWindowUtility.GetPropertyDisplayName(item.propertyName);
list.Add(item);
}
TreeViewUtility.SetChildParentReferences(new List<TreeViewItem>(list.ToArray()), node);
return node;
}
private AnimationWindowHierarchyPropertyGroupNode AddPropertyGroupToHierarchy(AnimationWindowCurve[] curves, AnimationWindowHierarchyNode parentNode)
{
List<AnimationWindowHierarchyNode> list = new List<AnimationWindowHierarchyNode>();
Type type = curves[0].type;
AnimationWindowHierarchyPropertyGroupNode animationWindowHierarchyPropertyGroupNode = new AnimationWindowHierarchyPropertyGroupNode(type, AnimationWindowUtility.GetPropertyGroupName(curves[0].propertyName), curves[0].path, parentNode);
animationWindowHierarchyPropertyGroupNode.icon = this.GetIcon(curves[0].binding);
animationWindowHierarchyPropertyGroupNode.indent = curves[0].depth;
animationWindowHierarchyPropertyGroupNode.curves = curves;
for (int i = 0; i < curves.Length; i++)
{
AnimationWindowCurve curve = curves[i];
AnimationWindowHierarchyPropertyNode animationWindowHierarchyPropertyNode = this.AddPropertyToHierarchy(curve, animationWindowHierarchyPropertyGroupNode);
animationWindowHierarchyPropertyNode.displayName = AnimationWindowUtility.GetPropertyDisplayName(animationWindowHierarchyPropertyNode.propertyName);
list.Add(animationWindowHierarchyPropertyNode);
}
TreeViewUtility.SetChildParentReferences(new List<TreeViewItem>(list.ToArray()), animationWindowHierarchyPropertyGroupNode);
return animationWindowHierarchyPropertyGroupNode;
}
private void DoCurveDropdown(Rect rect, AnimationWindowHierarchyNode node)
{
rect = new Rect((rect.xMax - 10f) - 12f, rect.yMin + 2f, 22f, 12f);
if (GUI.Button(rect, GUIContent.none, this.m_AnimationCurveDropdown))
{
this.state.SelectHierarchyItem(node.id, false, false);
AnimationWindowHierarchyNode[] source = new AnimationWindowHierarchyNode[] { node };
this.GenerateMenu(source.ToList<AnimationWindowHierarchyNode>()).DropDown(rect);
Event.current.Use();
}
}
private void DoIconAndName(Rect rect, AnimationWindowHierarchyNode node, bool selected, bool focused, float indent)
{
EditorGUIUtility.SetIconSize(new Vector2(13f, 13f));
int itemControlID = TreeView.GetItemControlID(node);
if (Event.current.type == EventType.Repaint)
{
bool isHover = (base.m_TreeView.dragging.GetDropTargetControlID() == itemControlID) && base.m_TreeView.data.CanBeParent(node);
this.m_AnimationLineStyle.Draw(rect, GUIContent.none, isHover, isHover, selected, selected);
if (AnimationMode.InAnimationMode())
{
rect.width -= 77f;
}
bool flag2 = AnimationWindowUtility.IsNodeLeftOverCurve(node, this.state.activeRootGameObject);
bool flag3 = AnimationWindowUtility.IsNodeAmbiguous(node, this.state.activeRootGameObject);
string str = string.Empty;
string tooltip = string.Empty;
if (flag2)
{
str = " (Missing!)";
tooltip = "The GameObject or Component is missing (" + node.path + ")";
}
if (flag3)
{
str = " (Duplicate GameObject name!)";
tooltip = "Target for curve is ambiguous since there are multiple GameObjects with same name (" + node.path + ")";
}
if (node.depth == 0)
{
if ((this.state.activeRootGameObject != null) && (this.state.activeRootGameObject.transform.Find(node.path) == null))
{
flag2 = true;
}
TreeViewGUI.s_Styles.content = new GUIContent(this.GetGameObjectName(node.path) + " : " + node.displayName + str, this.GetIconForNode(node), tooltip);
Color textColor = this.m_AnimationLineStyle.normal.textColor;
Color color = !EditorGUIUtility.isProSkin ? Color.black : ((Color) (Color.gray * 1.35f));
color = (!flag2 && !flag3) ? color : k_LeftoverCurveColor;
this.SetStyleTextColor(this.m_AnimationLineStyle, color);
rect.xMin += (int) (indent + base.k_FoldoutWidth);
GUI.Label(rect, TreeViewGUI.s_Styles.content, this.m_AnimationLineStyle);
this.SetStyleTextColor(this.m_AnimationLineStyle, textColor);
}
else
{
TreeViewGUI.s_Styles.content = new GUIContent(node.displayName + str, this.GetIconForNode(node), tooltip);
Color color3 = this.m_AnimationLineStyle.normal.textColor;
Color color4 = !EditorGUIUtility.isProSkin ? this.m_LightSkinPropertyTextColor : Color.gray;
color4 = (!flag2 && !flag3) ? color4 : k_LeftoverCurveColor;
this.SetStyleTextColor(this.m_AnimationLineStyle, color4);
rect.xMin += (int) ((indent + base.k_IndentWidth) + base.k_FoldoutWidth);
GUI.Label(rect, TreeViewGUI.s_Styles.content, this.m_AnimationLineStyle);
this.SetStyleTextColor(this.m_AnimationLineStyle, color3);
if (base.m_TreeView.dragging.GetRowMarkerControlID() == itemControlID)
{
base.m_DraggingInsertionMarkerRect = new Rect((rect.x + indent) + base.k_FoldoutWidth, rect.y, rect.width - indent, rect.height);
}
}
}
if (this.IsRenaming(node.id) && (Event.current.type != EventType.Layout))
{
base.GetRenameOverlay().editFieldRect = new Rect(rect.x + base.k_IndentWidth, rect.y, (rect.width - base.k_IndentWidth) - 1f, rect.height);
}
}
private void DoIconAndName(Rect rect, AnimationWindowHierarchyNode node, bool selected, bool focused, float indent)
{
EditorGUIUtility.SetIconSize(new Vector2(13f, 13f));
if (Event.current.type == EventType.Repaint)
{
if (selected)
{
TreeViewGUI.s_Styles.selectionStyle.Draw(rect, false, false, true, focused);
}
if (AnimationMode.InAnimationMode())
{
rect.width -= 77f;
}
bool flag = AnimationWindowUtility.IsNodeLeftOverCurve(node);
bool flag2 = AnimationWindowUtility.IsNodeAmbiguous(node);
bool flag3 = AnimationWindowUtility.IsNodePhantom(node);
string str = "";
string tooltip = "";
if (flag3)
{
str = " (Default Value)";
tooltip = "Transform position, rotation and scale can't be partially animated. This value will be animated to the default value";
}
if (flag)
{
str = " (Missing!)";
tooltip = "The GameObject or Component is missing (" + node.path + ")";
}
if (flag2)
{
str = " (Duplicate GameObject name!)";
tooltip = "Target for curve is ambiguous since there are multiple GameObjects with same name (" + node.path + ")";
}
Color textColor = this.m_AnimationLineStyle.normal.textColor;
Color color = textColor;
if (node.depth == 0)
{
string str3 = "";
if (node.curves.Length > 0)
{
AnimationWindowSelectionItem selectionBinding = node.curves[0].selectionBinding;
if (((selectionBinding != null) && (selectionBinding.rootGameObject != null)) && (selectionBinding.rootGameObject.transform.Find(node.path) == null))
{
flag = true;
}
string gameObjectName = this.GetGameObjectName((selectionBinding == null) ? null : selectionBinding.rootGameObject, node.path);
str3 = !string.IsNullOrEmpty(gameObjectName) ? (gameObjectName + " : ") : "";
}
TreeViewGUI.s_Styles.content = new GUIContent(str3 + node.displayName + str, this.GetIconForItem(node), tooltip);
color = !EditorGUIUtility.isProSkin ? Color.black : ((Color) (Color.gray * 1.35f));
}
else
{
TreeViewGUI.s_Styles.content = new GUIContent(node.displayName + str, this.GetIconForItem(node), tooltip);
color = !EditorGUIUtility.isProSkin ? this.m_LightSkinPropertyTextColor : Color.gray;
Color color3 = !selected ? this.m_PhantomCurveColor : ((Color) (this.m_PhantomCurveColor * 1.4f));
color = !flag3 ? color : color3;
}
color = (!flag && !flag2) ? color : k_LeftoverCurveColor;
this.SetStyleTextColor(this.m_AnimationLineStyle, color);
rect.xMin += ((int) (indent + TreeViewGUI.s_Styles.foldoutWidth)) + this.m_AnimationLineStyle.margin.left;
GUI.Label(rect, TreeViewGUI.s_Styles.content, this.m_AnimationLineStyle);
this.SetStyleTextColor(this.m_AnimationLineStyle, textColor);
}
if (this.IsRenaming(node.id) && (Event.current.type != EventType.Layout))
{
base.GetRenameOverlay().editFieldRect = new Rect(rect.x + base.k_IndentWidth, rect.y, (rect.width - base.k_IndentWidth) - 1f, rect.height);
}
}
private void DoValueField(Rect rect, AnimationWindowHierarchyNode node, int row)
{
bool flag = false;
if (AnimationMode.InAnimationMode())
{
EditorGUI.BeginDisabledGroup(this.state.animationIsReadOnly);
if (node is AnimationWindowHierarchyPropertyNode)
{
List<AnimationWindowCurve> curves = this.state.GetCurves(node, false);
if ((curves == null) || (curves.Count == 0))
{
return;
}
AnimationWindowCurve curve = curves[0];
object currentValue = CurveBindingUtility.GetCurrentValue(this.state.activeRootGameObject, curve.binding);
System.Type editorCurveValueType = CurveBindingUtility.GetEditorCurveValueType(this.state.activeRootGameObject, curve.binding);
if (currentValue is float)
{
float num = (float) currentValue;
Rect position = new Rect(rect.xMax - 75f, rect.y, 50f, rect.height);
if ((Event.current.type == EventType.MouseMove) && position.Contains(Event.current.mousePosition))
{
s_WasInsideValueRectFrame = Time.frameCount;
}
EditorGUI.BeginChangeCheck();
if (editorCurveValueType == typeof(bool))
{
num = !EditorGUI.Toggle(position, num != 0f) ? ((float) 0) : ((float) 1);
}
else
{
int id = GUIUtility.GetControlID(0x75bcc20, FocusType.Keyboard, position);
bool flag2 = (((GUIUtility.keyboardControl == id) && EditorGUIUtility.editingTextField) && (Event.current.type == EventType.KeyDown)) && ((Event.current.character == '\n') || (Event.current.character == '\x0003'));
num = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, position, new Rect(0f, 0f, 0f, 0f), id, num, EditorGUI.kFloatFieldFormatString, this.m_AnimationSelectionTextField, false);
if (flag2)
{
GUI.changed = true;
Event.current.Use();
}
}
if (float.IsInfinity(num) || float.IsNaN(num))
{
num = 0f;
}
if (EditorGUI.EndChangeCheck())
{
AnimationWindowKeyframe keyframe = null;
foreach (AnimationWindowKeyframe keyframe2 in curve.m_Keyframes)
{
if (Mathf.Approximately(keyframe2.time, this.state.time.time))
{
keyframe = keyframe2;
}
}
if (keyframe == null)
{
AnimationWindowUtility.AddKeyframeToCurve(curve, num, editorCurveValueType, this.state.time);
}
else
{
keyframe.value = num;
}
this.state.SaveCurve(curve);
flag = true;
}
}
}
EditorGUI.EndDisabledGroup();
if (flag)
{
this.state.ResampleAnimation();
}
}
}
public bool GetTallMode(AnimationWindowHierarchyNode node)
{
return this.m_TallInstanceIDs.Contains(node.id);
}
public static bool IsNodeLeftOverCurve(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if (rootGameObject != null)
{
if (node.binding.HasValue)
{
return (AnimationUtility.GetEditorCurveValueType(rootGameObject, node.binding.Value) == null);
}
if (node.hasChildren)
{
foreach (TreeViewItem item in node.children)
{
return IsNodeLeftOverCurve(item as AnimationWindowHierarchyNode, rootGameObject);
}
}
}
return false;
}
public List<AnimationWindowCurve> GetCurves(AnimationWindowHierarchyNode hierarchyNode, bool entireHierarchy)
{
return AnimationWindowUtility.FilterCurves(this.allCurves.ToArray(), hierarchyNode.path, hierarchyNode.animatableObjectType, hierarchyNode.propertyName);
}
private void DoFoldout(AnimationWindowHierarchyNode node, Rect rect, float indent, int row)
{
if (base.m_TreeView.data.IsExpandable(node))
{
Rect position = rect;
position.x = indent;
position.width = TreeViewGUI.s_Styles.foldoutWidth;
EditorGUI.BeginChangeCheck();
bool expand = GUI.Toggle(position, this.m_HierarchyItemFoldControlIDs[row], base.m_TreeView.data.IsExpanded(node), GUIContent.none, TreeViewGUI.s_Styles.foldout);
if (EditorGUI.EndChangeCheck())
{
if (Event.current.alt)
{
base.m_TreeView.data.SetExpandedWithChildren(node, expand);
}
else
{
base.m_TreeView.data.SetExpanded(node, expand);
}
}
}
else
{
AnimationWindowHierarchyPropertyNode node2 = node as AnimationWindowHierarchyPropertyNode;
AnimationWindowHierarchyState state = base.m_TreeView.state as AnimationWindowHierarchyState;
if ((node2 != null) && node2.isPptrNode)
{
Rect rect3 = rect;
rect3.x = indent;
rect3.width = TreeViewGUI.s_Styles.foldoutWidth;
EditorGUI.BeginChangeCheck();
bool tallMode = state.GetTallMode(node2);
tallMode = GUI.Toggle(rect3, this.m_HierarchyItemFoldControlIDs[row], tallMode, GUIContent.none, TreeViewGUI.s_Styles.foldout);
if (EditorGUI.EndChangeCheck())
{
state.SetTallMode(node2, tallMode);
}
}
}
}
private void HandleContextMenu(Rect rect, AnimationWindowHierarchyNode node)
{
if ((Event.current.type == EventType.ContextClick) && rect.Contains(Event.current.mousePosition))
{
this.state.SelectHierarchyItem(node.id, false, true);
this.GenerateMenu(this.state.selectedHierarchyNodes).ShowAsContext();
Event.current.Use();
}
}
public List<AnimationWindowKeyframe> GetAggregateKeys(AnimationWindowHierarchyNode hierarchyNode)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: reference to a compiler-generated method
DopeLine dopeLine = this.dopelines.FirstOrDefault<DopeLine>(new Func<DopeLine, bool>(new AnimationWindowState.\u003CGetAggregateKeys\u003Ec__AnonStorey43() { hierarchyNode = hierarchyNode }.\u003C\u003Em__71));
if (dopeLine == null)
return (List<AnimationWindowKeyframe>) null;
return dopeLine.keys;
}
public static bool IsNodeAmbiguous(AnimationWindowHierarchyNode node, GameObject rootGameObject)
{
if (rootGameObject != null)
{
if (node.binding.HasValue)
{
return AnimationUtility.AmbiguousBinding(node.binding.Value.path, node.binding.Value.m_ClassID, rootGameObject.transform);
}
if (node.hasChildren)
{
foreach (TreeViewItem item in node.children)
{
return IsNodeAmbiguous(item as AnimationWindowHierarchyNode, rootGameObject);
}
}
}
return false;
}
public override bool BeginRename(TreeViewItem item, float delay)
{
this.m_RenamedNode = item as AnimationWindowHierarchyNode;
return base.GetRenameOverlay().BeginRename(this.GetGameObjectName(this.m_RenamedNode.path), item.id, delay);
}
protected override void RenameEnded()
{
string name = base.GetRenameOverlay().name;
string originalName = base.GetRenameOverlay().originalName;
if (name != originalName)
{
foreach (AnimationWindowCurve curve in this.m_RenamedNode.curves)
{
string newPath = this.RenamePath(curve.path, name);
EditorCurveBinding renamedBinding = AnimationWindowUtility.GetRenamedBinding(curve.binding, newPath);
if (AnimationWindowUtility.CurveExists(renamedBinding, this.state.allCurves.ToArray()))
{
Debug.LogWarning("Curve already exists, renaming cancelled.");
}
else
{
AnimationWindowUtility.RenameCurvePath(curve, renamedBinding, this.state.activeAnimationClip);
}
}
}
this.m_RenamedNode = null;
}
public float GetNodeHeight(AnimationWindowHierarchyNode node)
{
if (node is AnimationWindowHierarchyAddButtonNode)
{
return 40f;
}
AnimationWindowHierarchyState state = base.m_TreeView.state as AnimationWindowHierarchyState;
return (!state.GetTallMode(node) ? 16f : 32f);
}
public List<AnimationWindowKeyframe> GetAggregateKeys(AnimationWindowHierarchyNode hierarchyNode)
{
DopeLine dopeLine = this.dopelines.FirstOrDefault((DopeLine e) => e.m_HierarchyNodeID == hierarchyNode.id);
if (dopeLine == null)
{
return null;
}
return dopeLine.keys;
}
private void DoCurveColorIndicator(Rect rect, AnimationWindowHierarchyNode node)
{
if (Event.current.type == EventType.Repaint)
{
Color color = GUI.color;
if (!this.state.showCurveEditor)
{
GUI.color = k_KeyColorInDopesheetMode;
}
else if ((node.curves.Length == 1) && !node.curves[0].isPPtrCurve)
{
GUI.color = CurveUtility.GetPropertyColor(node.curves[0].binding.propertyName);
}
else
{
GUI.color = k_KeyColorForNonCurves;
}
bool flag = false;
if (AnimationMode.InAnimationMode())
{
foreach (AnimationWindowCurve curve in node.curves)
{
if (Enumerable.Any<AnimationWindowKeyframe>(curve.m_Keyframes, new Func<AnimationWindowKeyframe, bool>(this, (IntPtr) this.<DoCurveColorIndicator>m__1)))
{
flag = true;
}
}
}
Texture image = !flag ? CurveUtility.GetIconCurve() : CurveUtility.GetIconKey();
rect = new Rect(((rect.xMax - 10f) - (image.width / 2)) - 5f, rect.yMin + 3f, (float) image.width, (float) image.height);
GUI.DrawTexture(rect, image, ScaleMode.ScaleToFit, true, 1f);
GUI.color = color;
}
}
private void DoCurveDropdown(Rect rect, AnimationWindowHierarchyNode node, int row, bool enabled)
{
rect = new Rect((rect.xMax - 10f) - 12f, rect.yMin + 2f, 22f, 12f);
if (this.DoTreeViewButton(this.m_HierarchyItemButtonControlIDs[row], rect, GUIContent.none, this.m_AnimationCurveDropdown))
{
this.state.SelectHierarchyItem(node.id, false, false);
AnimationWindowHierarchyNode[] source = new AnimationWindowHierarchyNode[] { node };
this.GenerateMenu(Enumerable.ToList<AnimationWindowHierarchyNode>(source), enabled).DropDown(rect);
Event.current.Use();
}
}
protected void DoNodeGUI(Rect rect, AnimationWindowHierarchyNode node, bool selected, bool focused, int row)
{
this.InitStyles();
if (!(node is AnimationWindowHierarchyMasterNode))
{
float indent = base.k_BaseIndent + ((node.depth + node.indent) * base.k_IndentWidth);
if (node is AnimationWindowHierarchyAddButtonNode)
{
if ((Event.current.type == EventType.MouseMove) && (s_WasInsideValueRectFrame >= 0))
{
if (s_WasInsideValueRectFrame >= (Time.frameCount - 1))
{
Event.current.Use();
}
else
{
s_WasInsideValueRectFrame = -1;
}
}
using (new EditorGUI.DisabledScope(!this.state.selection.canAddCurves))
{
this.DoAddCurveButton(rect, node, row);
}
}
else
{
this.DoRowBackground(rect, row);
this.DoIconAndName(rect, node, selected, focused, indent);
this.DoFoldout(node, rect, indent, row);
bool enabled = false;
if (node.curves != null)
{
if (<>f__am$cache0 == null)
{
private void DoAddCurveButton(Rect rect, AnimationWindowHierarchyNode node, int row)
{
float num = (rect.width - 230f) / 2f;
float num2 = 10f;
Rect position = new Rect(rect.xMin + num, rect.yMin + num2, rect.width - (num * 2f), rect.height - (num2 * 2f));
if (this.DoTreeViewButton(this.m_HierarchyItemButtonControlIDs[row], position, this.k_AnimatePropertyLabel, GUI.skin.button))
{
AddCurvesPopup.selection = this.state.selection;
AddCurvesPopupHierarchyDataSource.showEntireHierarchy = true;
if (AddCurvesPopup.ShowAtPosition(position, this.state, new UnityEditorInternal.AddCurvesPopup.OnNewCurveAdded(this.OnNewCurveAdded)))
{
GUIUtility.ExitGUI();
}
}
}
