Bug Can't create bindings for an enum - "not compatible"

Code (csharp):

1. public enum MyEnum
2. {
3.     A,
4.     B,
5.     C
6. }
7.  
8. public class Test : MonoBehaviour
9. {
10.     public MyEnum myEnum;
11. }
12.  
13. [CustomEditor(typeof(Test))]
14. public class TestEditor : Editor
15. {
16.     private VisualElement rootElement;
17.  
18.     private void OnEnable()
19.     {
20.         rootElement = new VisualElement();
21.     }
22.  
23.     public override VisualElement CreateInspectorGUI()
24.     {
25.         rootElement.Clear();
26.  
27.         var enumField = new EnumField("My Enum");
28.         enumField.bindingPath = "myEnum";
29.  
30.         rootElement.Add(enumField);
31.         rootElement.Bind(serializedObject);
32.  
33.         return rootElement;
34.     }
35. }

Gives:

Code (csharp):

1. Field type UnityEditor.UIElements.EnumField is not compatible with Enum property "myEnum"
2. UnityEditor.UIElements.BindingExtensions:Bind(VisualElement, SerializedObject)
3. TestEditor:CreateInspectorGUI() (at Assets/Editor/TestEditor.cs:23)
4. UnityEditor.InspectorWindow:RedrawFromNative()

I tried making a PopupField<MyEnum>, that gave the same result.

This should work, right?

 

2019.2.0f1

 

I worked around it by using a PropertyField for the property, but that runs into a different issue; I'm not able to get
RegisterCallback to do anything for a PropertyField that targets an enum:

Code (csharp):

1.  
2. using System;
3. using UnityEditor;
4. using UnityEditor.UIElements;
5. using UnityEngine;
6. using UnityEngine.UIElements;
7.  
8. [CustomEditor(typeof(Test))]
9. public class TestEditor : Editor
10. {
11.     private VisualElement rootElement;
12.  
13.     private void OnEnable()
14.     {
15.         rootElement = new VisualElement();
16.     }
17.  
18.     public override VisualElement CreateInspectorGUI()
19.     {
20.         rootElement.Clear();
21.  
22.         var enumProp = new PropertyField(serializedObject.FindProperty("myEnum"));
23.         var intProp  = new PropertyField(serializedObject.FindProperty("val"));
24.  
25.         // none of these gets called
26.         enumProp.RegisterCallback<ChangeEvent<MyEnum>>(Callback_MyEnum);
27.         enumProp.RegisterCallback<ChangeEvent<Enum  >>(Callback_Enum);
28.         enumProp.RegisterCallback<ChangeEvent<int   >>(Callback_Int);
29.         enumProp.RegisterCallback<ChangeEvent<object>>(Callback_Object);
30.  
31.         // this gets called
32.         intProp.RegisterCallback<ChangeEvent<int>>(Callback_Int);
33.  
34.         rootElement.Add(enumProp);
35.         rootElement.Add(intProp);
36.         rootElement.Bind(serializedObject);
37.         return rootElement;
38.     }
39.  
40.     private void Callback_MyEnum(ChangeEvent<MyEnum> evt) => Debug.Log("My enum");
41.     private void Callback_Int   (ChangeEvent<int>    evt) => Debug.Log("int");
42.     private void Callback_Enum  (ChangeEvent<Enum>   evt) => Debug.Log("enum");
43.     private void Callback_Object(ChangeEvent<object> evt) => Debug.Log("object");
44. }

 

Maybe, this could be helpful. But, I'm on 2019.3.0a12

Code (CSharp):

1.  
2. [CustomEditor(typeof(Test))]
3. public class TestEditor : Editor
4. {
5.   Test _boundData;
6.  
7.   public override VisualElement CreateInspectorGUI()
8.   {
9.     /*
10.     ...
11.     after setting up your inspector
12.     ...
13.      */
14.  
15.     // get object which is bound with this custom editor
16.     _boundData = (Test)target;
17.     // set visualelement reference which you want to send event to from your Test object.
18.     _boundData.event_send_target = yourVisualElement;
19.     // register event callback
20.     yourVisualElement.RegisterCallback<ChangeEvent<Test>>(your_callback_function);
21.  
22.   }
23. }
24.  
25. public class Test : MonoBehaviour
26. {
27.   public MyEnum myEnum;
28.   public VisualElement event_send_target;
29.  
30. #if UNITY_EDITOR
31.   // detect change and send event
32.   void OnValidate()
33.   {
34.     // send event
35.     if (event_send_target != null)
36.     {
37.       using (var changeEvent = ChangeEvent<Test>.GetPooled())
38.       {
39.         changeEvent.target = event_send_target;
40.         event_send_target.SendEvent(changeEvent);
41.       }
42.     }
43.   }
44. #endif
45. }
46.   public enum MyEnum
47.   {
48.     A,
49.     B,
50.     C
51.   }

 

This is related topic:
https://forum.unity.com/threads/serializedobject-changed-event.702296/#post-4740635

 

Thanks!

I'd really prefer not to leak details about the editor into the runtime code, but I can hide those details behind #if's, so I'll look into if it's viable..

 

Thanks!

Backports are not an issue, this project won't have any issues updating to a newer Unity version. You could consider adding a better error message to 2019.2 - "enum isn't supported yet" or something along those lines.

I think I called bind explicitly because that was done in some example? Not sure. If we don't need to do that - when does the binding happen? There's nothing in that code that relates the SerializedObject to the VisualElement tree.

 

It's probably my bad - I got it from the UI Elements Examples repo, and there the SerializedObjects are edited in an EditorWindow instead of an Editor in the Inspector Comparer Window.

It's not super-intuitive that the binding happens automatically, but I'm super in favour of it. I've pretty much always wondered why the hell the default IMGUI Editor didn't automatically do serializedObject.ApplyModifiedProperties at the end of OnInspectorGUI.

 

Glad I found this. Incredibly frustrating issue but at least there is a workaround.