Mindgames/Library/PackageCache/com.unity.visualeffectgraph@6.9.0-preview/Editor/Controls/VFXLabeledField.cs

   1 using UnityEngine;
   2 using UnityEngine.UIElements;
   3 using UnityEditor.UIElements;
   4 using System;
   5
   6 namespace UnityEditor.VFX.UIElements
   7 {
   8     //Copied from mousefield dragger but add notifications needed for delayed fields
   9     public class VFXFieldMouseDragger<T>
  10     {
  11         Action m_OnDragFinished;
  12         public VFXFieldMouseDragger(IValueField<T> drivenField, Action onDragFinished = null)
  13         {
  14             m_DrivenField = drivenField;
  15             m_DragElement = null;
  16             m_DragHotZone = new Rect(0, 0, -1, -1);
  17             m_OnDragFinished = onDragFinished;
  18             dragging = false;
  19         }
  20
  21         IValueField<T> m_DrivenField;
  22         VisualElement m_DragElement;
  23         Rect m_DragHotZone;
  24
  25         public bool dragging;
  26         public T startValue;
  27
  28         public void SetDragZone(VisualElement dragElement)
  29         {
  30             SetDragZone(dragElement, new Rect(0, 0, -1, -1));
  31         }
  32
  33         public void SetDragZone(VisualElement dragElement, Rect hotZone)
  34         {
  35             if (m_DragElement != null)
  36             {
  37                 m_DragElement.UnregisterCallback<MouseDownEvent>(UpdateValueOnMouseDown);
  38                 m_DragElement.UnregisterCallback<MouseMoveEvent>(UpdateValueOnMouseMove);
  39                 m_DragElement.UnregisterCallback<MouseUpEvent>(UpdateValueOnMouseUp);
  40                 m_DragElement.UnregisterCallback<KeyDownEvent>(UpdateValueOnKeyDown);
  41             }
  42
  43             m_DragElement = dragElement;
  44             m_DragHotZone = hotZone;
  45
  46             if (m_DragElement != null)
  47             {
  48                 dragging = false;
  49                 m_DragElement.RegisterCallback<MouseDownEvent>(UpdateValueOnMouseDown);
  50                 m_DragElement.RegisterCallback<MouseMoveEvent>(UpdateValueOnMouseMove);
  51                 m_DragElement.RegisterCallback<MouseUpEvent>(UpdateValueOnMouseUp);
  52                 m_DragElement.RegisterCallback<KeyDownEvent>(UpdateValueOnKeyDown);
  53             }
  54         }
  55
  56         void UpdateValueOnMouseDown(MouseDownEvent evt)
  57         {
  58             if (evt.button == 0 && (m_DragHotZone.width < 0 || m_DragHotZone.height < 0 || m_DragHotZone.Contains(m_DragElement.WorldToLocal(evt.mousePosition))))
  59             {
  60                 m_DragElement.CaptureMouse();
  61
  62                 // Make sure no other elements can capture the mouse!
  63                 evt.StopPropagation();
  64
  65                 dragging = true;
  66                 startValue = m_DrivenField.value;
  67
  68                 EditorGUIUtility.SetWantsMouseJumping(1);
  69             }
  70         }
  71
  72         void UpdateValueOnMouseMove(MouseMoveEvent evt)
  73         {
  74             if (dragging)
  75             {
  76                 DeltaSpeed s = evt.shiftKey ? DeltaSpeed.Fast : (evt.altKey ? DeltaSpeed.Slow : DeltaSpeed.Normal);
  77                 m_DrivenField.ApplyInputDeviceDelta(evt.mouseDelta, s, startValue);
  78             }
  79         }
  80
  81         void UpdateValueOnMouseUp(MouseUpEvent evt)
  82         {
  83             if (dragging)
  84             {
  85                 dragging = false;
  86                 MouseCaptureController.ReleaseMouse();
  87                 EditorGUIUtility.SetWantsMouseJumping(0);
  88                 if (m_OnDragFinished != null)
  89                     m_OnDragFinished();
  90             }
  91         }
  92
  93         void UpdateValueOnKeyDown(KeyDownEvent evt)
  94         {
  95             if (dragging && evt.keyCode == KeyCode.Escape)
  96             {
  97                 dragging = false;
  98                 m_DrivenField.value = startValue;
  99                 MouseCaptureController.ReleaseMouse();
 100                 EditorGUIUtility.SetWantsMouseJumping(0);
 101             }
 102         }
 103     }
 104     class VFXLabeledField<T, U> : VisualElement, INotifyValueChanged<U> where T : VisualElement, INotifyValueChanged<U>, new()
 105     {
 106         protected Label m_Label;
 107         protected T m_Control;
 108
 109         public VisualElement m_IndeterminateLabel;
 110
 111         public VFXLabeledField(Label existingLabel)
 112         {
 113             m_Label = existingLabel;
 114
 115             CreateControl();
 116             SetupLabel();
 117         }
 118
 119         bool m_Indeterminate;
 120
 121         public bool indeterminate
 122         {
 123             get {return m_Control.parent == null; }
 124
 125             set
 126             {
 127                 if (m_Indeterminate != value)
 128                 {
 129                     m_Indeterminate = value;
 130                     if (value)
 131                     {
 132                         m_Control.RemoveFromHierarchy();
 133                         Add(m_IndeterminateLabel);
 134                     }
 135                     else
 136                     {
 137                         m_IndeterminateLabel.RemoveFromHierarchy();
 138                         Add(m_Control);
 139                     }
 140                 }
 141             }
 142         }
 143
 144         public VFXLabeledField(string label)
 145         {
 146             if (!string.IsNullOrEmpty(label))
 147             {
 148                 m_Label = new Label() { text = label };
 149                 m_Label.AddToClassList("label");
 150
 151                 Add(m_Label);
 152             }
 153             style.flexDirection = FlexDirection.Row;
 154
 155             CreateControl();
 156             SetupLabel();
 157         }
 158
 159         void SetupLabel()
 160         {
 161             if (typeof(IValueField<U>).IsAssignableFrom(typeof(T)))
 162             {
 163                 m_Label.styleSheets.Add(Resources.Load<StyleSheet>("VFXLabeledField"));
 164                 if (typeof(U) == typeof(float))
 165                 {
 166                     var dragger = new VFXFieldMouseDragger<float>((IValueField<float>)m_Control, DragValueFinished);
 167                     dragger.SetDragZone(m_Label);
 168                     m_Label.AddToClassList("cursor-slide-arrow");
 169                 }
 170                 else if (typeof(U) == typeof(double))
 171                 {
 172                     var dragger = new VFXFieldMouseDragger<double>((IValueField<double>)m_Control, DragValueFinished);
 173                     dragger.SetDragZone(m_Label);
 174                     m_Label.AddToClassList("cursor-slide-arrow");
 175                 }
 176                 else if (typeof(U) == typeof(long))
 177                 {
 178                     var dragger = new VFXFieldMouseDragger<long>((IValueField<long>)m_Control, DragValueFinished);
 179                     dragger.SetDragZone(m_Label);
 180                     m_Label.AddToClassList("cursor-slide-arrow");
 181                 }
 182                 else if (typeof(U) == typeof(int))
 183                 {
 184                     var dragger = new VFXFieldMouseDragger<int>((IValueField<int>)m_Control, DragValueFinished);
 185                     dragger.SetDragZone(m_Label);
 186                     m_Label.AddToClassList("cursor-slide-arrow");
 187                 }
 188             }
 189
 190             m_IndeterminateLabel = new Label()
 191             {
 192                 name = "indeterminate",
 193                 text = VFXControlConstants.indeterminateText
 194             };
 195             m_IndeterminateLabel.SetEnabled(false);
 196         }
 197
 198         void DragValueFinished()
 199         {
 200             if (onValueDragFinished != null)
 201                 onValueDragFinished(this);
 202         }
 203
 204         public Action<VFXLabeledField<T, U>> onValueDragFinished;
 205
 206         void CreateControl()
 207         {
 208             m_Control = new T();
 209             Add(m_Control);
 210
 211             m_Control.RegisterValueChangedCallback(OnControlChange);
 212         }
 213
 214         void OnControlChange(ChangeEvent<U> e)
 215         {
 216             e.StopPropagation();
 217             using (ChangeEvent<U> evt = ChangeEvent<U>.GetPooled(e.previousValue, e.newValue))
 218             {
 219                 evt.target = this;
 220                 SendEvent(evt);
 221             }
 222         }
 223
 224         public T control
 225         {
 226             get { return m_Control; }
 227         }
 228
 229         public Label label
 230         {
 231             get { return m_Label; }
 232         }
 233
 234         public void SetValueAndNotify(U newValue)
 235         {
 236             (m_Control as INotifyValueChanged<U>).value = newValue;
 237         }
 238
 239         public void SetValueWithoutNotify(U newValue)
 240         {
 241             (m_Control as INotifyValueChanged<U>).SetValueWithoutNotify(newValue);
 242         }
 243
 244         public U value
 245         {
 246             get { return m_Control.value; }
 247             set { m_Control.value = value; }
 248         }
 249     }
 250
 251     abstract class ValueControl<T> : VisualElement
 252     {
 253         protected Label m_Label;
 254
 255         protected ValueControl(Label existingLabel)
 256         {
 257             m_Label = existingLabel;
 258         }
 259
 260         protected ValueControl(string label)
 261         {
 262             if (!string.IsNullOrEmpty(label))
 263             {
 264                 m_Label = new Label() { text = label };
 265                 m_Label.AddToClassList("label");
 266
 267                 Add(m_Label);
 268             }
 269             style.flexDirection = FlexDirection.Row;
 270         }
 271
 272         public T GetValue()
 273         {
 274             return m_Value;
 275         }
 276
 277         public void SetValue(T value)
 278         {
 279             m_Value = value;
 280             ValueToGUI(false);
 281         }
 282
 283         public T value
 284         {
 285             get { return GetValue(); }
 286             set { SetValue(value); }
 287         }
 288
 289         public void SetMultiplier(T multiplier)
 290         {
 291             m_Multiplier = multiplier;
 292         }
 293
 294         protected T m_Value;
 295         protected T m_Multiplier;
 296
 297         public System.Action OnValueChanged;
 298
 299         protected abstract void ValueToGUI(bool force);
 300     }
 301 }