internal static void Open(int current, BGCurve curve, Action <BGCurvePointComponent> action)
        {
            BGCurveChosePointWindow.action  = action;
            BGCurveChosePointWindow.current = current;
            BGCurveChosePointWindow.curve   = curve;

            instance = BGEditorUtility.ShowPopupWindow <BGCurveChosePointWindow>(WindowSize);
        }
        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            // idea.. partially copy/pasted from BGCcChoseDrawer
            // this is a required startup call
            SetUp(position, property, label, () =>
            {
                if (!(property.objectReferenceValue != null))
                {
                    DrawProperty(property);
                }
                else
                {
                    var point = (BGCurvePointComponent)property.objectReferenceValue;

                    var pointCount = point.Curve.PointsCount;

                    if (pointCount < 2)
                    {
                        DrawProperty(property);
                    }
                    else
                    {
                        var pointIndex    = point.Curve.IndexOf(point);
                        var buttonContent = new GUIContent("" + pointIndex, "Object has multiple components attached. Click to chose.");

                        var buttonWidth = GUI.skin.button.CalcSize(buttonContent).x;

                        Rect.width -= buttonWidth;
                        EditorGUI.PropertyField(Rect, property);


                        if (GUI.Button(new Rect(Rect)
                        {
                            width = buttonWidth, x = Rect.xMax
                        }, buttonContent))
                        {
                            BGCurveChosePointWindow.Open(pointIndex, point.Curve, newPoint =>
                            {
                                property.objectReferenceValue = newPoint;
                                property.serializedObject.ApplyModifiedProperties();
                                EditorUtility.SetDirty(property.serializedObject.targetObject);
                            });
                        }
                    }
                }
            });
        }
        public static void ShowField(BGCurvePointI point, BGCurvePointField field, Action <string, AnimationCurve> animationCurveCallback = null)
        {
            var name = point.Curve.IndexOf(field) + ") " + field.FieldName;

            switch (field.Type)
            {
            case BGCurvePointField.TypeEnum.Bool:
                BGEditorUtility.BoolField(name, point.GetField <bool>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Int:
                BGEditorUtility.IntField(name, point.GetField <int>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Float:
                BGEditorUtility.FloatField(name, point.GetField <float>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Vector3:
                BGEditorUtility.Vector3Field(name, null, point.GetField <Vector3>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Bounds:
                BGEditorUtility.BoundsField(name, point.GetField <Bounds>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Color:
                BGEditorUtility.ColorField(name, point.GetField <Color>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.String:
                BGEditorUtility.TextField(name, point.GetField <string>(field.FieldName), v => point.SetField(field.FieldName, v), false);
                break;

            case BGCurvePointField.TypeEnum.AnimationCurve:
                BGEditorUtility.Horizontal(() =>
                {
                    BGEditorUtility.AnimationCurveField(name, point.GetField <AnimationCurve>(field.FieldName), v => point.SetField(field.FieldName, v));

                    if (animationCurveCallback != null && GUILayout.Button("Set", GUILayout.Width(40)))
                    {
                        animationCurveCallback(field.FieldName, point.GetField <AnimationCurve>(field.FieldName));
                    }
                });

                break;

            case BGCurvePointField.TypeEnum.Quaternion:
                BGEditorUtility.QuaternionField(name, point.GetField <Quaternion>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.GameObject:
                BGEditorUtility.GameObjectField(name, point.GetField <GameObject>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Component:
                BGEditorUtility.ComponentChoosableField(name, point.GetField <Component>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.BGCurve:
                BGEditorUtility.BGCurveField(name, point.GetField <BGCurve>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.BGCurvePointComponent:
                BGEditorUtility.Horizontal(() =>
                {
                    BGEditorUtility.BGCurvePointComponentField(name, point.GetField <BGCurvePointComponent>(field.FieldName), v => point.SetField(field.FieldName, v));
                    var currentPoint = point.GetField <BGCurvePointComponent>(field.FieldName);

                    if (currentPoint == null || currentPoint.Curve.PointsCount < 2)
                    {
                        return;
                    }

                    var indexOfField = currentPoint.Curve.IndexOf(currentPoint);

                    if (GUILayout.Button("" + indexOfField, GUILayout.Width(40)))
                    {
                        BGCurveChosePointWindow.Open(indexOfField, currentPoint.Curve, c => point.SetField(field.FieldName, c));
                    }
                });
                break;

            case BGCurvePointField.TypeEnum.BGCurvePointGO:
                BGEditorUtility.BGCurvePointGOField(name, point.GetField <BGCurvePointGO>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;
            }
        }