public KeyIdentifier(CurveRenderer _renderer, int _curveId, int _keyIndex, EditorCurveBinding _binding)
 {
     this.renderer = _renderer;
     this.curveId = _curveId;
     this.key = _keyIndex;
     this.binding = _binding;
 }

 private static void PrepareHierarchy(EditorCurveBinding curveBinding)
 {
   GameObject orGetGameObject = CurveBindingUtility.CreateOrGetGameObject(curveBinding.path);
   if (!((UnityEngine.Object) orGetGameObject.GetComponent(curveBinding.type) == (UnityEngine.Object) null))
     return;
   orGetGameObject.AddComponent(curveBinding.type);
 }

 private TreeViewItem AddAnimatableObjectToHierarchy(GameObject root, EditorCurveBinding[] curveBindings, TreeViewItem parentNode, string path)
 {
     TreeViewItem item = new AddCurvesPopupObjectNode(parentNode, path, GetClassName(root, curveBindings[0])) {
         icon = AssetPreview.GetMiniThumbnail(AnimationUtility.GetAnimatedObject(root, curveBindings[0]))
     };
     List<TreeViewItem> visibleItems = new List<TreeViewItem>();
     List<EditorCurveBinding> list2 = new List<EditorCurveBinding>();
     for (int i = 0; i < curveBindings.Length; i++)
     {
         EditorCurveBinding binding = curveBindings[i];
         list2.Add(binding);
         if ((i == (curveBindings.Length - 1)) || (AnimationWindowUtility.GetPropertyGroupName(curveBindings[i + 1].propertyName) != AnimationWindowUtility.GetPropertyGroupName(binding.propertyName)))
         {
             TreeViewItem item2 = this.CreateNode(list2.ToArray(), item);
             if (item2 != null)
             {
                 visibleItems.Add(item2);
             }
             list2.Clear();
         }
     }
     visibleItems.Sort();
     TreeViewUtility.SetChildParentReferences(visibleItems, item);
     return item;
 }

 public KeyIdentifier(AnimationCurve _curve, int _curveId, int _keyIndex, EditorCurveBinding _binding)
 {
     this.curve = _curve;
     this.curveId = _curveId;
     this.key = _keyIndex;
     this.binding = _binding;
 }

		public static RotationCurveInterpolation.State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
		{
			RotationCurveInterpolation.State result;
			result.allAreNonBaked = true;
			result.allAreBaked = false;
			result.allAreRotations = false;
			for (int i = 0; i < selection.Length; i++)
			{
				EditorCurveBinding data = selection[i];
				RotationCurveInterpolation.Mode modeFromCurveData = RotationCurveInterpolation.GetModeFromCurveData(data);
				if (modeFromCurveData == RotationCurveInterpolation.Mode.NonBaked)
				{
					result.allAreNonBaked = false;
				}
				else
				{
					if (modeFromCurveData == RotationCurveInterpolation.Mode.Baked)
					{
						result.allAreBaked = false;
					}
					else
					{
						result.allAreRotations = false;
					}
				}
			}
			return result;
		}

        public static State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
        {
            State state;
            state.allAreNonBaked = true;
            state.allAreBaked = false;
            state.allAreRotations = false;
            foreach (EditorCurveBinding binding in selection)
            {
                switch (GetModeFromCurveData(binding))
                {
                    case Mode.NonBaked:
                        state.allAreNonBaked = false;
                        break;

                    case Mode.Baked:
                        state.allAreBaked = false;
                        break;

                    default:
                        state.allAreRotations = false;
                        break;
                }
            }
            return state;
        }

 public static System.Type GetEditorCurveValueType(GameObject rootGameObject, EditorCurveBinding curveBinding)
 {
     if (rootGameObject != null)
     {
         return AnimationUtility.GetEditorCurveValueType(rootGameObject, curveBinding);
     }
     return GetEditorCurveValueType(curveBinding);
 }

 public static object GetCurrentValue(GameObject rootGameObject, EditorCurveBinding curveBinding)
 {
     if (rootGameObject != null)
     {
         return AnimationWindowUtility.GetCurrentValue(rootGameObject, curveBinding);
     }
     return GetCurrentValue(curveBinding);
 }

 public static void CreateDefaultCurves(AnimationWindowState state, EditorCurveBinding[] properties)
 {
   AnimationClip activeAnimationClip = state.activeAnimationClip;
   GameObject activeRootGameObject = state.activeRootGameObject;
   properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(state.activeAnimationClip, properties);
   foreach (EditorCurveBinding property in properties)
     state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(activeAnimationClip, activeRootGameObject, property));
 }

		public static void SetEditorCurve(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve)
		{
			AnimationUtility.Internal_SetEditorCurve(clip, binding, curve);
			if (AnimationUtility.onCurveWasModified != null)
			{
				AnimationUtility.onCurveWasModified(clip, binding, (curve == null) ? AnimationUtility.CurveModifiedType.CurveDeleted : AnimationUtility.CurveModifiedType.CurveModified);
			}
		}

		public static void SetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
		{
			AnimationUtility.Internal_SetObjectReferenceCurve(clip, binding, keyframes);
			if (AnimationUtility.onCurveWasModified != null)
			{
				AnimationUtility.onCurveWasModified(clip, binding, (keyframes == null) ? AnimationUtility.CurveModifiedType.CurveDeleted : AnimationUtility.CurveModifiedType.CurveModified);
			}
		}

 public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
 {
   if (curveData.type != typeof (Transform))
     return -1;
   int num = !((UnityEngine.Object) clip == (UnityEngine.Object) null) ? clip.GetInstanceID() : 0;
   string str = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
   return num * 19603 ^ curveData.path.GetHashCode() * 729 ^ curveData.type.GetHashCode() * 27 ^ str.GetHashCode();
 }

 private static void AddRotationPropertyModification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification)
 {
     if (modification.previousValue != null)
     {
         EditorCurveBinding binding = baseBinding;
         binding.propertyName = modification.previousValue.propertyPath;
         AnimationMode.AddPropertyModification(binding, modification.previousValue, modification.keepPrefabOverride);
     }
 }

 private static EditorCurveBinding[] GenerateTransformCurveBindingArray(string path, string property, System.Type type, int count)
 {
     EditorCurveBinding[] bindingArray = new EditorCurveBinding[count];
     for (int i = 0; i < count; i++)
     {
         bindingArray[i] = EditorCurveBinding.FloatCurve(path, type, property + kPostFix[i]);
     }
     return bindingArray;
 }

 public AnimationClipCurveData(EditorCurveBinding binding)
 {
   this.path = binding.path;
   this.type = binding.type;
   this.propertyName = binding.propertyName;
   this.curve = (AnimationCurve) null;
   this.classID = binding.m_ClassID;
   this.scriptInstanceID = binding.m_ScriptInstanceID;
 }

 public static RotationCurveInterpolation.Mode GetModeFromCurveData(EditorCurveBinding data)
 {
   if (AnimationWindowUtility.IsTransformType(data.type) && data.propertyName.StartsWith("localEulerAngles"))
   {
     if (data.propertyName.StartsWith("localEulerAnglesBaked"))
       return RotationCurveInterpolation.Mode.Baked;
     return data.propertyName.StartsWith("localEulerAnglesRaw") ? RotationCurveInterpolation.Mode.RawEuler : RotationCurveInterpolation.Mode.NonBaked;
   }
   return AnimationWindowUtility.IsTransformType(data.type) && data.propertyName.StartsWith("m_LocalRotation") ? RotationCurveInterpolation.Mode.RawQuaternions : RotationCurveInterpolation.Mode.Undefined;
 }

		public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
		{
			if (curveData.type != typeof(Transform))
			{
				return -1;
			}
			int num = (!(clip == null)) ? clip.GetInstanceID() : 0;
			string text = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
			return num * 19603 ^ curveData.path.GetHashCode() * 729 ^ curveData.type.GetHashCode() * 27 ^ text.GetHashCode();
		}

 public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
 {
     if (curveData.type != typeof(Transform))
     {
         return -1;
     }
     int num = (clip != null) ? clip.GetInstanceID() : 0;
     string str = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
     return ((((num * 0x4c93) ^ (curveData.path.GetHashCode() * 0x2d9)) ^ (curveData.type.GetHashCode() * 0x1b)) ^ str.GetHashCode());
 }

		public static void CreateDefaultCurves(AnimationWindowState state, EditorCurveBinding[] properties)
		{
			AnimationClip activeAnimationClip = state.m_ActiveAnimationClip;
			GameObject rootGameObject = state.m_RootGameObject;
			properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(state.m_ActiveAnimationClip, properties);
			EditorCurveBinding[] array = properties;
			for (int i = 0; i < array.Length; i++)
			{
				EditorCurveBinding binding = array[i];
				state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(activeAnimationClip, rootGameObject, binding));
			}
		}

		private static PropertyModification FindPropertyModification(GameObject root, UndoPropertyModification[] modifications, EditorCurveBinding binding)
		{
			for (int i = 0; i < modifications.Length; i++)
			{
				EditorCurveBinding lhs;
				AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[i].propertyModification, root, out lhs);
				if (lhs == binding)
				{
					return modifications[i].propertyModification;
				}
			}
			return null;
		}