UnityCsReference/Editor/Mono/GUI/GradientField.cs at master · LifeOrGame/UnityCsReference · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License

using UnityEngine;
using UnityEditorInternal;

namespace UnityEditor
{
    public sealed partial class EditorGUILayout
    {
        // Gradient versions
        internal static Gradient GradientField(Gradient value, params GUILayoutOption[] options)
        {
            Rect r = s_LastRect = GUILayoutUtility.GetRect(EditorGUIUtility.fieldWidth, kLabelFloatMaxW, EditorGUI.kSingleLineHeight, EditorGUI.kSingleLineHeight, EditorStyles.colorField, options);
            return EditorGUI.GradientField(r, value);
        }

        internal static Gradient GradientField(string label, Gradient value, params GUILayoutOption[] options)
        {
            Rect r = s_LastRect = GUILayoutUtility.GetRect(kLabelFloatMinW, kLabelFloatMaxW, EditorGUI.kSingleLineHeight, EditorGUI.kSingleLineHeight, EditorStyles.colorField, options);
            return EditorGUI.GradientField(label, r, value);
        }

        internal static Gradient GradientField(GUIContent label, Gradient value, params GUILayoutOption[] options)
        {
            Rect r = s_LastRect = GUILayoutUtility.GetRect(kLabelFloatMinW, kLabelFloatMaxW, EditorGUI.kSingleLineHeight, EditorGUI.kSingleLineHeight, EditorStyles.colorField, options);
            return EditorGUI.GradientField(label, r, value);
        }

        // SerializedProperty versions
        internal static Gradient GradientField(SerializedProperty value, params GUILayoutOption[] options)
        {
            Rect r = s_LastRect = GUILayoutUtility.GetRect(kLabelFloatMinW, kLabelFloatMaxW, EditorGUI.kSingleLineHeight, EditorGUI.kSingleLineHeight, EditorStyles.colorField, options);
            return EditorGUI.GradientField(r, value);
        }

        internal static Gradient GradientField(string label, SerializedProperty value, params GUILayoutOption[] options)
        {
            Rect r = s_LastRect = GUILayoutUtility.GetRect(kLabelFloatMinW, kLabelFloatMaxW, EditorGUI.kSingleLineHeight, EditorGUI.kSingleLineHeight, EditorStyles.colorField, options);
            return EditorGUI.GradientField(label, r, value);
        }

        internal static Gradient GradientField(GUIContent label, SerializedProperty value, params GUILayoutOption[] options)
        {
            Rect r = s_LastRect = GUILayoutUtility.GetRect(kLabelFloatMinW, kLabelFloatMaxW, EditorGUI.kSingleLineHeight, EditorGUI.kSingleLineHeight, EditorStyles.colorField, options);
            return EditorGUI.GradientField(label, r, value);
        }
    }


    public sealed partial class EditorGUI
    {
        static readonly int s_GradientHash = "s_GradientHash".GetHashCode();
        static int s_GradientID;

        // Gradient versions
        internal static Gradient GradientField(Rect position, Gradient gradient)
        {
            return GradientField(position, gradient, false);
        }

        internal static Gradient GradientField(Rect position, Gradient gradient, bool hdr)
        {
            int id = EditorGUIUtility.GetControlID(s_GradientHash, FocusType.Keyboard, position);
            return DoGradientField(position, id, gradient, null, hdr);
        }

        internal static Gradient GradientField(string label, Rect position, Gradient gradient)
        {
            return GradientField(EditorGUIUtility.TempContent(label), position, gradient);
        }

        internal static Gradient GradientField(GUIContent label, Rect position, Gradient gradient)
        {
            int id = EditorGUIUtility.GetControlID(s_GradientHash, FocusType.Keyboard, position);
            return DoGradientField(PrefixLabel(position, id, label), id, gradient, null, false);
        }

        // SerializedProperty versions
        internal static Gradient GradientField(Rect position, SerializedProperty gradient)
        {
            return GradientField(position, gradient, false);
        }

        internal static Gradient GradientField(Rect position, SerializedProperty gradient, bool hdr)
        {
            int id = EditorGUIUtility.GetControlID(s_GradientHash, FocusType.Keyboard, position);
            return DoGradientField(position, id, null, gradient, hdr);
        }

        internal static Gradient GradientField(string label, Rect position, SerializedProperty property)
        {
            return GradientField(EditorGUIUtility.TempContent(label), position, property);
        }

        internal static Gradient GradientField(GUIContent label, Rect position, SerializedProperty property)
        {
            int id = EditorGUIUtility.GetControlID(s_GradientHash, FocusType.Keyboard, position);
            return DoGradientField(PrefixLabel(position, id, label), id, null, property, false);
        }

        internal static Gradient DoGradientField(Rect position, int id, Gradient value, SerializedProperty property, bool hdr)
        {
            Event evt = Event.current;

            switch (evt.GetTypeForControl(id))
            {
                case EventType.MouseDown:
                    if (position.Contains(evt.mousePosition))
                    {
                        if (evt.button == 0)
                        {
                            s_GradientID = id;
                            GUIUtility.keyboardControl = id;
                            Gradient gradient = property != null ? property.gradientValue : value;
                            GradientPicker.Show(gradient, hdr);
                            GUIUtility.ExitGUI();
                        }
                        else if (evt.button == 1)
                        {
                            if (property != null)
                                GradientContextMenu.Show(property.Copy());
                            // TODO: make work for Gradient value
                        }
                    }
                    break;
                case EventType.Repaint:
                {
                    Rect r2 = new Rect(position.x + 1, position.y + 1, position.width - 2, position.height - 2);    // Adjust for box drawn on top
                    if (property != null)
                        GradientEditor.DrawGradientSwatch(r2, property, Color.white);
                    else
                        GradientEditor.DrawGradientSwatch(r2, value, Color.white);
                    EditorStyles.colorPickerBox.Draw(position, GUIContent.none, id);
                    break;
                }
                case EventType.ExecuteCommand:
                    if (s_GradientID == id && evt.commandName == GradientPicker.GradientPickerChangedCommand)
                    {
                        GUI.changed = true;
                        GradientPreviewCache.ClearCache();
                        HandleUtility.Repaint();
                        if (property != null)
                            property.gradientValue = GradientPicker.gradient;

                        return GradientPicker.gradient;
                    }
                    break;
                case EventType.ValidateCommand:
                    if (s_GradientID == id && evt.commandName == EventCommandNames.UndoRedoPerformed)
                    {
                        if (property != null)
                            GradientPicker.SetCurrentGradient(property.gradientValue);
                        GradientPreviewCache.ClearCache();
                        return value;
                    }
                    break;
                case EventType.KeyDown:
                    if (GUIUtility.keyboardControl == id && (evt.keyCode == KeyCode.Space || evt.keyCode == KeyCode.Return || evt.keyCode == KeyCode.KeypadEnter))
                    {
                        Event.current.Use();
                        Gradient gradient = property != null ? property.gradientValue : value;
                        GradientPicker.Show(gradient, hdr);
                        GUIUtility.ExitGUI();
                    }
                    break;
            }
            return value;
        }
    }
}