2091 lines
80 KiB
C#
2091 lines
80 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections;
|
|
using System.Linq;
|
|
using Rive;
|
|
using Rive.Components;
|
|
using UnityEditor;
|
|
using UnityEditor.UIElements;
|
|
using UnityEngine;
|
|
using UnityEngine.UIElements;
|
|
|
|
namespace Rive.EditorTools
|
|
{
|
|
internal class DataBindingPlaygroundWindow : EditorWindow
|
|
{
|
|
private RiveWidget m_widget;
|
|
private ObjectField m_widgetField;
|
|
private HelpBox m_playModeHelpBox;
|
|
private VisualElement m_interactiveContainer;
|
|
private ScrollView m_propertiesScroll;
|
|
|
|
private readonly List<PropertyBinding> m_propertyBindings = new List<PropertyBinding>();
|
|
private readonly List<ListPropertyBinding> m_listBindings = new List<ListPropertyBinding>();
|
|
private readonly List<Action> m_triggerBindingDisposers = new List<Action>();
|
|
private bool m_isRefreshing;
|
|
private const double TriggerFiredHighlightSeconds = 0.75d;
|
|
private enum PlaygroundState
|
|
{
|
|
NotPlaying,
|
|
NoWidget,
|
|
NoFileMetadata,
|
|
NoViewModels,
|
|
NoArtboardMetadata,
|
|
NoDefaultViewModel,
|
|
WidgetNotLoaded,
|
|
NoViewModelInstance,
|
|
Ready
|
|
}
|
|
|
|
private FileMetadata m_fileMetadata;
|
|
private FileMetadata.ArtboardMetadata m_artboardMetadata;
|
|
private double m_nextRefreshTime;
|
|
private readonly Dictionary<string, ImageOutOfBandAsset> m_imageSelectionCache = new Dictionary<string, ImageOutOfBandAsset>();
|
|
private readonly Dictionary<string, ArtboardSelection> m_artboardSelectionCache = new Dictionary<string, ArtboardSelection>();
|
|
private readonly Dictionary<string, bool> m_viewModelExpansion = new Dictionary<string, bool>();
|
|
|
|
// Used for the artboard databinding dropdowns
|
|
private enum ArtboardViewModelBindingMode
|
|
{
|
|
ExistingInstance,
|
|
CreateNewInstance
|
|
}
|
|
|
|
private class ArtboardSelection
|
|
{
|
|
public Asset Asset;
|
|
public File File;
|
|
public string ArtboardName;
|
|
public ArtboardViewModelBindingMode ViewModelBindingMode = ArtboardViewModelBindingMode.ExistingInstance;
|
|
public string ExistingViewModelInstanceName;
|
|
public ViewModelInstance CustomViewModelInstance;
|
|
public readonly List<PropertyBinding> CustomBindings = new List<PropertyBinding>();
|
|
public readonly List<ListPropertyBinding> CustomListBindings = new List<ListPropertyBinding>();
|
|
|
|
public void DisposeCustomViewModelInstance()
|
|
{
|
|
CustomViewModelInstance?.Dispose();
|
|
CustomViewModelInstance = null;
|
|
CustomBindings.Clear();
|
|
CustomListBindings.Clear();
|
|
}
|
|
|
|
public void DisposeAll()
|
|
{
|
|
DisposeCustomViewModelInstance();
|
|
File = null;
|
|
}
|
|
}
|
|
|
|
private const string DocsBaseUrl = InspectorDocLinks.UnityDataBinding;
|
|
|
|
private class PropertyBinding
|
|
{
|
|
public string Path;
|
|
public VisualElement Control;
|
|
public Action<ViewModelInstance> Sync;
|
|
}
|
|
|
|
private class ListPropertyBinding
|
|
{
|
|
public string Path;
|
|
public VisualElement Control;
|
|
public Action<ViewModelInstance> Sync;
|
|
public List<ViewModelInstance> LastItems = new List<ViewModelInstance>();
|
|
public bool InitializedTypeSelection;
|
|
}
|
|
|
|
// Adapter that proxies a list property directly into a ListView without keeping a stale mirror.
|
|
private class ListPropertyAdapter : IList<ViewModelInstance>, IList
|
|
{
|
|
private readonly Func<ViewModelInstanceListProperty> m_propertyGetter;
|
|
private readonly Func<ViewModelInstance> m_factory;
|
|
|
|
public ListPropertyAdapter(Func<ViewModelInstanceListProperty> propertyGetter, Func<ViewModelInstance> factory)
|
|
{
|
|
m_propertyGetter = propertyGetter;
|
|
m_factory = factory;
|
|
}
|
|
|
|
private ViewModelInstanceListProperty Prop => m_propertyGetter?.Invoke();
|
|
|
|
public int Count => Prop?.Count ?? 0;
|
|
|
|
public bool IsReadOnly => false;
|
|
bool IList.IsFixedSize => false;
|
|
|
|
public ViewModelInstance this[int index]
|
|
{
|
|
get => Prop?.GetInstanceAt(index);
|
|
set => MoveOrReplace(index, value);
|
|
}
|
|
|
|
object IList.this[int index]
|
|
{
|
|
get => this[index];
|
|
set
|
|
{
|
|
MoveOrReplace(index, value as ViewModelInstance);
|
|
}
|
|
}
|
|
|
|
private void MoveOrReplace(int index, ViewModelInstance value)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null || value == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// If the instance already exists in the list, move it.
|
|
int existingIndex = -1;
|
|
for (int i = 0; i < prop.Count; i++)
|
|
{
|
|
if (ReferenceEquals(prop.GetInstanceAt(i), value))
|
|
{
|
|
existingIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (existingIndex == index)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (existingIndex >= 0)
|
|
{
|
|
prop.RemoveAt(existingIndex);
|
|
if (existingIndex < index)
|
|
{
|
|
index -= 1;
|
|
}
|
|
}
|
|
else if (index < prop.Count)
|
|
{
|
|
// Replace the current item at index if value not found elsewhere
|
|
prop.RemoveAt(index);
|
|
}
|
|
|
|
index = Mathf.Clamp(index, 0, prop.Count);
|
|
prop.Insert(value, index);
|
|
}
|
|
|
|
public void Add(ViewModelInstance item)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var toAdd = item ?? m_factory?.Invoke();
|
|
if (toAdd != null)
|
|
{
|
|
prop.Add(toAdd);
|
|
}
|
|
}
|
|
|
|
int IList.Add(object value)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
Add(value as ViewModelInstance);
|
|
return prop.Count - 1;
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = prop.Count - 1; i >= 0; i--)
|
|
{
|
|
prop.RemoveAt(i);
|
|
}
|
|
}
|
|
|
|
public bool Contains(ViewModelInstance item)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null || item == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < prop.Count; i++)
|
|
{
|
|
if (ReferenceEquals(prop.GetInstanceAt(i), item))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void CopyTo(ViewModelInstance[] array, int arrayIndex)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null || array == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int count = prop.Count;
|
|
for (int i = 0; i < count && arrayIndex + i < array.Length; i++)
|
|
{
|
|
array[arrayIndex + i] = prop.GetInstanceAt(i);
|
|
}
|
|
}
|
|
|
|
public IEnumerator<ViewModelInstance> GetEnumerator()
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null)
|
|
{
|
|
yield break;
|
|
}
|
|
|
|
int count = prop.Count;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
yield return prop.GetInstanceAt(i);
|
|
}
|
|
}
|
|
|
|
public int IndexOf(ViewModelInstance item)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null || item == null)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
for (int i = 0; i < prop.Count; i++)
|
|
{
|
|
if (ReferenceEquals(prop.GetInstanceAt(i), item))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public void Insert(int index, ViewModelInstance item)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var toInsert = item ?? m_factory?.Invoke();
|
|
if (toInsert == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
index = Mathf.Clamp(index, 0, prop.Count);
|
|
prop.Insert(toInsert, index);
|
|
}
|
|
|
|
void IList.Insert(int index, object value) => Insert(index, value as ViewModelInstance);
|
|
|
|
public bool Remove(ViewModelInstance item)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null || item == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
prop.Remove(item);
|
|
return true;
|
|
}
|
|
|
|
void IList.Remove(object value) => Remove(value as ViewModelInstance);
|
|
|
|
public void RemoveAt(int index)
|
|
{
|
|
var prop = Prop;
|
|
if (prop == null || index < 0 || index >= prop.Count)
|
|
{
|
|
return;
|
|
}
|
|
|
|
prop.RemoveAt(index);
|
|
}
|
|
|
|
bool IList.Contains(object value) => Contains(value as ViewModelInstance);
|
|
|
|
void ICollection.CopyTo(Array array, int index)
|
|
{
|
|
if (array == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var prop = Prop;
|
|
if (prop == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < prop.Count && index + i < array.Length; i++)
|
|
{
|
|
array.SetValue(prop.GetInstanceAt(i), index + i);
|
|
}
|
|
}
|
|
|
|
bool ICollection.IsSynchronized => false;
|
|
|
|
private readonly object m_syncRoot = new object();
|
|
object ICollection.SyncRoot => m_syncRoot;
|
|
|
|
int IList.IndexOf(object value) => IndexOf(value as ViewModelInstance);
|
|
|
|
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
|
|
}
|
|
|
|
public static void Open(RiveWidget widget)
|
|
{
|
|
var window = GetWindow<DataBindingPlaygroundWindow>();
|
|
window.titleContent = new GUIContent("Rive Data Binding Playground");
|
|
window.minSize = new Vector2(420, 360);
|
|
window.SetTarget(widget);
|
|
window.Show();
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
titleContent = new GUIContent("Rive Data Binding Playground");
|
|
minSize = new Vector2(420, 360);
|
|
BuildLayout();
|
|
EditorApplication.update += EditorUpdate;
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
EditorApplication.update -= EditorUpdate;
|
|
ClearTriggerBindings();
|
|
m_propertyBindings.Clear();
|
|
m_listBindings.Clear();
|
|
m_widget = null;
|
|
foreach (var selection in m_artboardSelectionCache.Values)
|
|
{
|
|
selection.DisposeAll();
|
|
}
|
|
m_artboardSelectionCache.Clear();
|
|
m_viewModelExpansion.Clear();
|
|
}
|
|
|
|
private void EditorUpdate()
|
|
{
|
|
// throttle refreshes to avoid unnecessary work
|
|
if (EditorApplication.timeSinceStartup < m_nextRefreshTime)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_nextRefreshTime = EditorApplication.timeSinceStartup + 0.25f;
|
|
UpdateVisibility();
|
|
RefreshValues();
|
|
}
|
|
|
|
private void BuildLayout()
|
|
{
|
|
var root = rootVisualElement;
|
|
root.Clear();
|
|
root.style.paddingLeft = 10;
|
|
root.style.paddingRight = 10;
|
|
root.style.paddingTop = 8;
|
|
root.style.paddingBottom = 10;
|
|
|
|
var subtitleRow = new VisualElement
|
|
{
|
|
style =
|
|
{
|
|
flexDirection = FlexDirection.Row,
|
|
alignItems = Align.Center,
|
|
marginBottom = 14
|
|
}
|
|
};
|
|
var subtitle = new Label("Inspect and tweak ViewModel instance properties for the selected RiveWidget.");
|
|
subtitle.style.flexGrow = 1;
|
|
subtitle.style.fontSize = 12;
|
|
subtitle.style.color = new UnityEngine.Color(0.8f, 0.8f, 0.8f, 0.95f);
|
|
|
|
var docsLink = new Label("View Data Binding Docs");
|
|
StyleLinkLabel(docsLink, InspectorDocLinks.UnityDataBinding);
|
|
|
|
subtitleRow.Add(subtitle);
|
|
subtitleRow.Add(docsLink);
|
|
root.Add(subtitleRow);
|
|
|
|
m_playModeHelpBox = new HelpBox(
|
|
"Play with data binding values for the selected RiveWidget while in Play Mode. " +
|
|
"Changes are applied to the widget's current ViewModel instance.",
|
|
HelpBoxMessageType.Info);
|
|
|
|
m_playModeHelpBox.style.marginBottom = 10;
|
|
root.Add(m_playModeHelpBox);
|
|
|
|
m_widgetField = new ObjectField("Widget")
|
|
{
|
|
objectType = typeof(RiveWidget),
|
|
allowSceneObjects = true
|
|
};
|
|
m_widgetField.RegisterValueChangedCallback(evt =>
|
|
{
|
|
SetTarget(evt.newValue as RiveWidget);
|
|
});
|
|
root.Add(m_widgetField);
|
|
|
|
m_interactiveContainer = new VisualElement();
|
|
m_interactiveContainer.style.flexDirection = FlexDirection.Column;
|
|
m_interactiveContainer.style.flexGrow = 1;
|
|
root.Add(m_interactiveContainer);
|
|
|
|
m_propertiesScroll = new ScrollView
|
|
{
|
|
style =
|
|
{
|
|
flexGrow = 1
|
|
}
|
|
};
|
|
m_interactiveContainer.Add(m_propertiesScroll);
|
|
|
|
UpdateVisibility();
|
|
}
|
|
|
|
private void SetTarget(RiveWidget widget)
|
|
{
|
|
m_widget = widget;
|
|
m_widgetField?.SetValueWithoutNotify(widget);
|
|
RefreshMetadata();
|
|
RebuildProperties();
|
|
UpdateVisibility();
|
|
RefreshValues();
|
|
}
|
|
|
|
private void RefreshMetadata()
|
|
{
|
|
m_fileMetadata = m_widget?.Asset?.EditorOnlyMetadata;
|
|
m_artboardMetadata = null;
|
|
|
|
if (m_fileMetadata == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var artboardName = !string.IsNullOrEmpty(m_widget?.ArtboardName)
|
|
? m_widget.ArtboardName
|
|
: m_fileMetadata.GetArtboardNames().FirstOrDefault();
|
|
|
|
if (!string.IsNullOrEmpty(artboardName))
|
|
{
|
|
m_artboardMetadata = m_fileMetadata.GetArtboard(artboardName);
|
|
}
|
|
}
|
|
|
|
private void RebuildProperties()
|
|
{
|
|
ClearTriggerBindings();
|
|
m_propertyBindings.Clear();
|
|
m_listBindings.Clear();
|
|
m_viewModelExpansion.Clear();
|
|
m_propertiesScroll.Clear();
|
|
|
|
if (m_widget == null)
|
|
{
|
|
m_propertiesScroll.Add(new Label("Select a RiveWidget to get started."));
|
|
return;
|
|
}
|
|
|
|
if (m_artboardMetadata == null)
|
|
{
|
|
m_propertiesScroll.Add(new HelpBox("No artboard metadata found for the selected widget.", HelpBoxMessageType.Warning));
|
|
return;
|
|
}
|
|
|
|
if (m_artboardMetadata.DefaultViewModel == null)
|
|
{
|
|
m_propertiesScroll.Add(new HelpBox("The current artboard does not have a default ViewModel.", HelpBoxMessageType.Warning));
|
|
return;
|
|
}
|
|
|
|
BuildViewModelSection(
|
|
m_artboardMetadata.DefaultViewModel,
|
|
string.Empty,
|
|
m_propertiesScroll,
|
|
0);
|
|
}
|
|
|
|
private FileMetadata.ViewModelMetadata FindViewModelMetadata(string viewModelName, FileMetadata metadataContext = null)
|
|
{
|
|
var metadata = metadataContext ?? m_fileMetadata;
|
|
if (metadata == null || string.IsNullOrEmpty(viewModelName))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return metadata.ViewModels.FirstOrDefault(vm => vm.Name == viewModelName);
|
|
}
|
|
|
|
private List<string> GetEnumOptions(FileMetadata.ViewModelPropertyMetadata property, FileMetadata metadataContext = null)
|
|
{
|
|
var metadata = metadataContext ?? m_fileMetadata;
|
|
if (metadata == null || metadata.Enums == null || string.IsNullOrEmpty(property.EnumTypeName))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var enumMeta = metadata.Enums.FirstOrDefault(e => e.Name == property.EnumTypeName);
|
|
return enumMeta?.Values?.ToList();
|
|
}
|
|
|
|
private void AddStringField(VisualElement parent, string path, string displayName, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
|
|
var field = new TextField();
|
|
field.RegisterValueChangedCallback(evt =>
|
|
{
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetStringProperty(path);
|
|
if (prop != null)
|
|
{
|
|
prop.Value = evt.newValue;
|
|
}
|
|
});
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = field,
|
|
Sync = instance =>
|
|
{
|
|
var current = instanceProvider();
|
|
var prop = current?.GetStringProperty(path);
|
|
field.SetEnabled(prop != null);
|
|
if (prop != null)
|
|
{
|
|
field.SetValueWithoutNotify(prop.Value ?? string.Empty);
|
|
}
|
|
}
|
|
});
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "String", GetDocUrl(ViewModelDataType.String),
|
|
null, field));
|
|
}
|
|
|
|
private void AddNumberField(VisualElement parent, string path, string displayName, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
|
|
var field = new FloatField();
|
|
field.RegisterValueChangedCallback(evt =>
|
|
{
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetNumberProperty(path);
|
|
if (prop != null)
|
|
{
|
|
prop.Value = evt.newValue;
|
|
}
|
|
});
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = field,
|
|
Sync = instance =>
|
|
{
|
|
var current = instanceProvider();
|
|
var prop = current?.GetNumberProperty(path);
|
|
field.SetEnabled(prop != null);
|
|
if (prop != null)
|
|
{
|
|
field.SetValueWithoutNotify(prop.Value);
|
|
}
|
|
}
|
|
});
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "Number", GetDocUrl(ViewModelDataType.Number),
|
|
null, field));
|
|
}
|
|
|
|
private void AddBooleanField(VisualElement parent, string path, string displayName, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
|
|
var toggle = new Toggle();
|
|
toggle.RegisterValueChangedCallback(evt =>
|
|
{
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetBooleanProperty(path);
|
|
if (prop != null)
|
|
{
|
|
prop.Value = evt.newValue;
|
|
}
|
|
});
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = toggle,
|
|
Sync = instance =>
|
|
{
|
|
var current = instanceProvider();
|
|
var prop = current?.GetBooleanProperty(path);
|
|
toggle.SetEnabled(prop != null);
|
|
if (prop != null)
|
|
{
|
|
toggle.SetValueWithoutNotify(prop.Value);
|
|
}
|
|
}
|
|
});
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "Boolean", GetDocUrl(ViewModelDataType.Boolean),
|
|
null, toggle));
|
|
}
|
|
|
|
private void AddColorField(VisualElement parent, string path, string displayName, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
|
|
var field = new ColorField();
|
|
field.RegisterValueChangedCallback(evt =>
|
|
{
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetColorProperty(path);
|
|
if (prop != null)
|
|
{
|
|
prop.Value = evt.newValue;
|
|
}
|
|
});
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = field,
|
|
Sync = instance =>
|
|
{
|
|
var current = instanceProvider();
|
|
var prop = current?.GetColorProperty(path);
|
|
field.SetEnabled(prop != null);
|
|
if (prop != null)
|
|
{
|
|
field.SetValueWithoutNotify(prop.Value);
|
|
}
|
|
}
|
|
});
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "Color", GetDocUrl(ViewModelDataType.Color),
|
|
null, field));
|
|
}
|
|
|
|
private void AddImageField(VisualElement parent, string path, string displayName, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
|
|
var field = new ObjectField
|
|
{
|
|
objectType = typeof(ImageOutOfBandAsset),
|
|
allowSceneObjects = false
|
|
};
|
|
|
|
field.RegisterValueChangedCallback(evt =>
|
|
{
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetImageProperty(path);
|
|
if (prop == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var asset = evt.newValue as ImageOutOfBandAsset;
|
|
if (asset == null)
|
|
{
|
|
m_imageSelectionCache[cacheKey] = null;
|
|
prop.Value = null;
|
|
return;
|
|
}
|
|
|
|
m_imageSelectionCache[cacheKey] = asset;
|
|
asset.Load();
|
|
prop.Value = asset;
|
|
asset.Unload();
|
|
});
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = field,
|
|
Sync = instance =>
|
|
{
|
|
var current = instanceProvider();
|
|
var prop = current?.GetImageProperty(path);
|
|
field.SetEnabled(prop != null);
|
|
// Reflect cached selection for UX (no getter available from runtime)
|
|
if (m_imageSelectionCache.TryGetValue(cacheKey, out var cached))
|
|
{
|
|
field.SetValueWithoutNotify(cached);
|
|
}
|
|
else
|
|
{
|
|
field.SetValueWithoutNotify(null);
|
|
}
|
|
}
|
|
});
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "Image", GetDocUrl(ViewModelDataType.AssetImage),
|
|
null, field));
|
|
}
|
|
|
|
private void AddEnumField(VisualElement parent, string path, FileMetadata.ViewModelPropertyMetadata property, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null, FileMetadata metadataContext = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
|
|
var options = GetEnumOptions(property, metadataContext) ?? new List<string>();
|
|
var defaultOption = options.Count > 0 ? options[0] : string.Empty;
|
|
var popup = new PopupField<string>(null, options, defaultOption);
|
|
|
|
popup.RegisterValueChangedCallback(evt =>
|
|
{
|
|
if (string.IsNullOrEmpty(evt.newValue))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetEnumProperty(path);
|
|
if (prop != null)
|
|
{
|
|
prop.Value = evt.newValue;
|
|
}
|
|
});
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = popup,
|
|
Sync = instance =>
|
|
{
|
|
var currentInstance = instanceProvider();
|
|
var prop = currentInstance?.GetEnumProperty(path);
|
|
bool hasProp = prop != null;
|
|
popup.SetEnabled(hasProp && popup.choices.Count > 0);
|
|
|
|
if (!hasProp)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var currentValue = prop.Value;
|
|
if (!options.Contains(currentValue))
|
|
{
|
|
options = prop.EnumValues?.Where(v => !string.IsNullOrEmpty(v)).ToList() ?? options;
|
|
popup.choices = options;
|
|
popup.SetEnabled(options.Count > 0);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(currentValue) && options.Contains(currentValue))
|
|
{
|
|
popup.SetValueWithoutNotify(currentValue);
|
|
}
|
|
else if (options.Count > 0)
|
|
{
|
|
popup.SetValueWithoutNotify(options[0]);
|
|
}
|
|
}
|
|
});
|
|
|
|
parent.Add(CreatePropertyCard(property.Name, pathLabelOverride ?? path, $"Enum ({property.EnumTypeName})", GetDocUrl(ViewModelDataType.Enum),
|
|
null, popup));
|
|
}
|
|
|
|
private ArtboardSelection GetOrCreateArtboardSelection(string path)
|
|
{
|
|
if (!m_artboardSelectionCache.TryGetValue(path, out var selection))
|
|
{
|
|
selection = new ArtboardSelection();
|
|
m_artboardSelectionCache[path] = selection;
|
|
}
|
|
return selection;
|
|
}
|
|
|
|
private void DisposeArtboardSelection(string path)
|
|
{
|
|
if (m_artboardSelectionCache.TryGetValue(path, out var selection))
|
|
{
|
|
selection.DisposeAll();
|
|
}
|
|
}
|
|
|
|
private void AddArtboardField(VisualElement parent, string path, string displayName, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
|
|
var selection = GetOrCreateArtboardSelection(cacheKey);
|
|
|
|
var assetField = new ObjectField
|
|
{
|
|
objectType = typeof(Asset),
|
|
allowSceneObjects = false,
|
|
label = "Rive File",
|
|
tooltip = "Select the Rive file containing the desired artboard to bind"
|
|
};
|
|
|
|
assetField.style.marginLeft = 0;
|
|
|
|
|
|
var artboardDropdown = new DropdownField
|
|
{
|
|
choices = new List<string>(),
|
|
label = "Artboard",
|
|
tooltip = "Select the artboard to bind from the selected Rive file",
|
|
value = null
|
|
};
|
|
|
|
artboardDropdown.style.marginLeft = 0;
|
|
|
|
var vmBindingModeOptions = new List<string> { "Use Existing Instance", "New Instance" };
|
|
var vmBindingModeDropdown = new DropdownField(
|
|
"View Model Binding",
|
|
vmBindingModeOptions,
|
|
vmBindingModeOptions[(int)selection.ViewModelBindingMode])
|
|
{
|
|
tooltip = "Select whether to bind using a named instance from the selected artboard's default ViewModel or create a new instance"
|
|
};
|
|
vmBindingModeDropdown.style.marginLeft = 0;
|
|
vmBindingModeDropdown.style.display = DisplayStyle.None;
|
|
|
|
var vmInstanceDropdown = new DropdownField
|
|
{
|
|
choices = new List<string>(),
|
|
label = "Instance",
|
|
tooltip = "Select a named instance from the artboard's default ViewModel",
|
|
value = null
|
|
};
|
|
vmInstanceDropdown.style.marginLeft = 0;
|
|
vmInstanceDropdown.style.display = DisplayStyle.None;
|
|
|
|
var vmHintHelpBox = new HelpBox(string.Empty, HelpBoxMessageType.Info);
|
|
vmHintHelpBox.style.display = DisplayStyle.None;
|
|
vmHintHelpBox.style.marginTop = 4;
|
|
|
|
var customVmContainer = new VisualElement();
|
|
customVmContainer.style.flexDirection = FlexDirection.Column;
|
|
customVmContainer.style.display = DisplayStyle.None;
|
|
customVmContainer.style.marginTop = 6;
|
|
|
|
FileMetadata.ArtboardMetadata GetSelectedArtboardMetadata()
|
|
{
|
|
var metadata = selection.Asset?.EditorOnlyMetadata;
|
|
if (metadata == null || string.IsNullOrEmpty(selection.ArtboardName))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return metadata.GetArtboard(selection.ArtboardName);
|
|
}
|
|
|
|
FileMetadata.ViewModelMetadata GetDefaultViewModelMetadata()
|
|
{
|
|
return GetSelectedArtboardMetadata()?.DefaultViewModel;
|
|
}
|
|
|
|
ViewModel GetDefaultViewModelFromFile()
|
|
{
|
|
var vmMeta = GetDefaultViewModelMetadata();
|
|
if (selection.File == null || vmMeta == null || string.IsNullOrEmpty(vmMeta.Name))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return selection.File.GetViewModelByName(vmMeta.Name);
|
|
}
|
|
|
|
void EnsureCustomViewModelInstance()
|
|
{
|
|
if (selection.CustomViewModelInstance != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var defaultVm = GetDefaultViewModelFromFile();
|
|
if (defaultVm == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
selection.CustomViewModelInstance = defaultVm.CreateInstance();
|
|
}
|
|
|
|
void RebuildCustomInstanceEditor()
|
|
{
|
|
selection.CustomBindings.Clear();
|
|
selection.CustomListBindings.Clear();
|
|
customVmContainer.Clear();
|
|
|
|
var defaultVmMeta = GetDefaultViewModelMetadata();
|
|
if (defaultVmMeta == null || selection.CustomViewModelInstance == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
BuildViewModelSection(
|
|
defaultVmMeta,
|
|
string.Empty,
|
|
customVmContainer,
|
|
0,
|
|
() => selection.CustomViewModelInstance,
|
|
displayPathPrefix: "custom-instance",
|
|
cachePathPrefix: $"{cacheKey}/custom-instance",
|
|
bindingList: selection.CustomBindings,
|
|
listBindingList: selection.CustomListBindings,
|
|
metadataContext: selection.Asset?.EditorOnlyMetadata,
|
|
viewModelResolver: name => string.IsNullOrEmpty(name) ? null : selection.File?.GetViewModelByName(name));
|
|
}
|
|
|
|
void ApplySelectionToProperty()
|
|
{
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetArtboardProperty(path);
|
|
if (prop == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (selection.File == null || string.IsNullOrEmpty(selection.ArtboardName))
|
|
{
|
|
prop.Value = null;
|
|
return;
|
|
}
|
|
|
|
BindableArtboard bindable = null;
|
|
var defaultVmMeta = GetDefaultViewModelMetadata();
|
|
bool hasDefaultVm = defaultVmMeta != null && !string.IsNullOrEmpty(defaultVmMeta.Name);
|
|
|
|
if (hasDefaultVm)
|
|
{
|
|
ViewModelInstance targetInstance = null;
|
|
if (selection.ViewModelBindingMode == ArtboardViewModelBindingMode.ExistingInstance)
|
|
{
|
|
var vm = GetDefaultViewModelFromFile();
|
|
if (vm != null && !string.IsNullOrEmpty(selection.ExistingViewModelInstanceName))
|
|
{
|
|
targetInstance = vm.CreateInstanceByName(selection.ExistingViewModelInstanceName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EnsureCustomViewModelInstance();
|
|
targetInstance = selection.CustomViewModelInstance;
|
|
}
|
|
|
|
bindable = selection.File.BindableArtboard(selection.ArtboardName, targetInstance);
|
|
}
|
|
else
|
|
{
|
|
bindable = selection.File.BindableArtboard(selection.ArtboardName);
|
|
}
|
|
|
|
if (bindable != null)
|
|
{
|
|
prop.Value = bindable;
|
|
}
|
|
}
|
|
|
|
void RefreshViewModelControls()
|
|
{
|
|
var defaultVmMeta = GetDefaultViewModelMetadata();
|
|
bool hasDefaultVm = defaultVmMeta != null && !string.IsNullOrEmpty(defaultVmMeta.Name);
|
|
|
|
vmBindingModeDropdown.style.display = hasDefaultVm ? DisplayStyle.Flex : DisplayStyle.None;
|
|
vmHintHelpBox.style.display = hasDefaultVm ? DisplayStyle.None : (selection.Asset == null ? DisplayStyle.None : DisplayStyle.Flex);
|
|
vmHintHelpBox.text = "This artboard doesn't support databinding.";
|
|
|
|
if (!hasDefaultVm)
|
|
{
|
|
vmInstanceDropdown.style.display = DisplayStyle.None;
|
|
customVmContainer.style.display = DisplayStyle.None;
|
|
selection.ExistingViewModelInstanceName = null;
|
|
selection.DisposeCustomViewModelInstance();
|
|
return;
|
|
}
|
|
|
|
var instanceNames = defaultVmMeta.InstanceNames ?? new List<string>();
|
|
vmInstanceDropdown.choices = instanceNames.ToList();
|
|
|
|
if (!string.IsNullOrEmpty(selection.ExistingViewModelInstanceName) &&
|
|
vmInstanceDropdown.choices.Contains(selection.ExistingViewModelInstanceName))
|
|
{
|
|
vmInstanceDropdown.SetValueWithoutNotify(selection.ExistingViewModelInstanceName);
|
|
}
|
|
else
|
|
{
|
|
selection.ExistingViewModelInstanceName = vmInstanceDropdown.choices.FirstOrDefault();
|
|
vmInstanceDropdown.SetValueWithoutNotify(selection.ExistingViewModelInstanceName);
|
|
}
|
|
|
|
vmBindingModeDropdown.SetValueWithoutNotify(vmBindingModeOptions[(int)selection.ViewModelBindingMode]);
|
|
bool isExistingMode = selection.ViewModelBindingMode == ArtboardViewModelBindingMode.ExistingInstance;
|
|
vmInstanceDropdown.style.display = isExistingMode ? DisplayStyle.Flex : DisplayStyle.None;
|
|
vmInstanceDropdown.SetEnabled(isExistingMode && vmInstanceDropdown.choices.Count > 0);
|
|
|
|
if (isExistingMode)
|
|
{
|
|
customVmContainer.style.display = DisplayStyle.None;
|
|
}
|
|
else
|
|
{
|
|
EnsureCustomViewModelInstance();
|
|
if (customVmContainer.childCount == 0)
|
|
{
|
|
RebuildCustomInstanceEditor();
|
|
}
|
|
customVmContainer.style.display = selection.CustomViewModelInstance != null
|
|
? DisplayStyle.Flex
|
|
: DisplayStyle.None;
|
|
}
|
|
}
|
|
|
|
void PopulateArtboards(Asset asset)
|
|
{
|
|
artboardDropdown.choices = new List<string>();
|
|
artboardDropdown.value = null;
|
|
selection.ArtboardName = null;
|
|
artboardDropdown.style.display = asset == null ? DisplayStyle.None : DisplayStyle.Flex;
|
|
|
|
if (asset == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var names = asset.EditorOnlyMetadata?.GetArtboardNames() ?? Array.Empty<string>();
|
|
artboardDropdown.choices = names.ToList();
|
|
|
|
if (names.Length > 0)
|
|
{
|
|
var chosenArtboard = selection.ArtboardName;
|
|
if (string.IsNullOrEmpty(chosenArtboard) || !names.Contains(chosenArtboard))
|
|
{
|
|
chosenArtboard = names[0];
|
|
}
|
|
selection.ArtboardName = chosenArtboard;
|
|
artboardDropdown.value = chosenArtboard;
|
|
}
|
|
}
|
|
|
|
assetField.RegisterValueChangedCallback(evt =>
|
|
{
|
|
var newAsset = evt.newValue as Asset;
|
|
if (!ReferenceEquals(selection.Asset, newAsset))
|
|
{
|
|
DisposeArtboardSelection(cacheKey);
|
|
selection.Asset = newAsset;
|
|
selection.File = null;
|
|
selection.ArtboardName = null;
|
|
}
|
|
|
|
PopulateArtboards(newAsset);
|
|
|
|
if (newAsset != null)
|
|
{
|
|
selection.File = File.Load(newAsset);
|
|
}
|
|
|
|
RefreshViewModelControls();
|
|
ApplySelectionToProperty();
|
|
});
|
|
|
|
artboardDropdown.RegisterValueChangedCallback(evt =>
|
|
{
|
|
selection.ArtboardName = evt.newValue;
|
|
selection.DisposeCustomViewModelInstance();
|
|
customVmContainer.Clear();
|
|
RefreshViewModelControls();
|
|
ApplySelectionToProperty();
|
|
});
|
|
|
|
vmBindingModeDropdown.RegisterValueChangedCallback(evt =>
|
|
{
|
|
selection.ViewModelBindingMode = evt.newValue == vmBindingModeOptions[(int)ArtboardViewModelBindingMode.CreateNewInstance]
|
|
? ArtboardViewModelBindingMode.CreateNewInstance
|
|
: ArtboardViewModelBindingMode.ExistingInstance;
|
|
|
|
if (selection.ViewModelBindingMode == ArtboardViewModelBindingMode.CreateNewInstance)
|
|
{
|
|
selection.DisposeCustomViewModelInstance();
|
|
customVmContainer.Clear();
|
|
}
|
|
|
|
RefreshViewModelControls();
|
|
ApplySelectionToProperty();
|
|
});
|
|
|
|
vmInstanceDropdown.RegisterValueChangedCallback(evt =>
|
|
{
|
|
selection.ExistingViewModelInstanceName = evt.newValue;
|
|
ApplySelectionToProperty();
|
|
});
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = artboardDropdown,
|
|
Sync = instance =>
|
|
{
|
|
var current = instanceProvider();
|
|
var prop = current?.GetArtboardProperty(path);
|
|
bool hasProp = prop != null;
|
|
assetField.SetEnabled(hasProp);
|
|
artboardDropdown.SetEnabled(hasProp && selection.Asset != null);
|
|
vmBindingModeDropdown.SetEnabled(hasProp);
|
|
artboardDropdown.style.display = selection.Asset == null ? DisplayStyle.None : DisplayStyle.Flex;
|
|
|
|
if (assetField.value != selection.Asset)
|
|
{
|
|
assetField.SetValueWithoutNotify(selection.Asset);
|
|
}
|
|
|
|
// Ensure file is loaded if we have an asset but no file yet
|
|
if (hasProp && selection.Asset != null && selection.File == null)
|
|
{
|
|
selection.File = File.Load(selection.Asset);
|
|
}
|
|
|
|
// Populate dropdown if empty but we have asset metadata
|
|
if (artboardDropdown.choices.Count == 0 && selection.Asset != null)
|
|
{
|
|
PopulateArtboards(selection.Asset);
|
|
}
|
|
|
|
// Keep dropdown selection in sync with cached choice
|
|
if (selection.ArtboardName != null && artboardDropdown.value != selection.ArtboardName)
|
|
{
|
|
artboardDropdown.SetValueWithoutNotify(selection.ArtboardName);
|
|
}
|
|
|
|
RefreshViewModelControls();
|
|
foreach (var customBinding in selection.CustomBindings)
|
|
{
|
|
customBinding.Sync?.Invoke(selection.CustomViewModelInstance);
|
|
}
|
|
foreach (var customListBinding in selection.CustomListBindings)
|
|
{
|
|
customListBinding.Sync?.Invoke(selection.CustomViewModelInstance);
|
|
}
|
|
}
|
|
});
|
|
|
|
var container = new VisualElement();
|
|
container.style.flexDirection = FlexDirection.Column;
|
|
container.Add(assetField);
|
|
container.Add(artboardDropdown);
|
|
container.Add(vmBindingModeDropdown);
|
|
container.Add(vmInstanceDropdown);
|
|
container.Add(vmHintHelpBox);
|
|
container.Add(customVmContainer);
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "Artboard", GetDocUrl(ViewModelDataType.Artboard),
|
|
null, container));
|
|
}
|
|
|
|
private void AddTriggerField(VisualElement parent, string path, string displayName, Func<ViewModelInstance> instanceProvider = null, string cacheKey = null, string pathLabelOverride = null, List<PropertyBinding> bindingList = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
bindingList ??= m_propertyBindings;
|
|
ViewModelInstanceTriggerProperty subscribedProp = null;
|
|
double lastTriggeredAt = -1d;
|
|
|
|
var button = new Button(() =>
|
|
{
|
|
var instance = instanceProvider();
|
|
var prop = instance?.GetTriggerProperty(path);
|
|
prop?.Trigger();
|
|
})
|
|
{
|
|
text = $"Fire Trigger"
|
|
};
|
|
|
|
var statusLabel = new Label("Fired");
|
|
statusLabel.style.unityTextAlign = TextAnchor.MiddleCenter;
|
|
statusLabel.style.paddingLeft = 8;
|
|
statusLabel.style.paddingRight = 8;
|
|
statusLabel.style.paddingTop = 2;
|
|
statusLabel.style.paddingBottom = 2;
|
|
statusLabel.style.marginLeft = 8;
|
|
statusLabel.style.borderTopLeftRadius = 4;
|
|
statusLabel.style.borderTopRightRadius = 4;
|
|
statusLabel.style.borderBottomLeftRadius = 4;
|
|
statusLabel.style.borderBottomRightRadius = 4;
|
|
statusLabel.style.display = DisplayStyle.None;
|
|
|
|
Action onTriggered = () =>
|
|
{
|
|
lastTriggeredAt = EditorApplication.timeSinceStartup;
|
|
statusLabel.text = "Fired";
|
|
statusLabel.style.color = new UnityEngine.Color(0.12f, 0.95f, 0.45f, 1f);
|
|
statusLabel.style.backgroundColor = new UnityEngine.Color(0.1f, 0.35f, 0.18f, 0.55f);
|
|
statusLabel.style.display = DisplayStyle.Flex;
|
|
};
|
|
|
|
void UpdateTriggerStatus(bool hasProp)
|
|
{
|
|
if (!hasProp)
|
|
{
|
|
statusLabel.style.display = DisplayStyle.None;
|
|
return;
|
|
}
|
|
|
|
bool recentlyFired = lastTriggeredAt >= 0d &&
|
|
EditorApplication.timeSinceStartup - lastTriggeredAt <= TriggerFiredHighlightSeconds;
|
|
statusLabel.style.display = recentlyFired ? DisplayStyle.Flex : DisplayStyle.None;
|
|
}
|
|
|
|
void DisposeSubscription()
|
|
{
|
|
if (subscribedProp != null)
|
|
{
|
|
subscribedProp.OnTriggered -= onTriggered;
|
|
subscribedProp = null;
|
|
}
|
|
}
|
|
|
|
m_triggerBindingDisposers.Add(DisposeSubscription);
|
|
|
|
bindingList.Add(new PropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = button,
|
|
Sync = instance =>
|
|
{
|
|
var current = instanceProvider();
|
|
var prop = current?.GetTriggerProperty(path);
|
|
button.SetEnabled(prop != null);
|
|
|
|
if (!ReferenceEquals(subscribedProp, prop))
|
|
{
|
|
DisposeSubscription();
|
|
subscribedProp = prop;
|
|
if (subscribedProp != null)
|
|
{
|
|
subscribedProp.OnTriggered += onTriggered;
|
|
}
|
|
}
|
|
|
|
UpdateTriggerStatus(prop != null);
|
|
}
|
|
});
|
|
|
|
var triggerControlRow = new VisualElement();
|
|
triggerControlRow.style.flexDirection = FlexDirection.Row;
|
|
triggerControlRow.style.alignItems = Align.Center;
|
|
triggerControlRow.Add(button);
|
|
triggerControlRow.Add(statusLabel);
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "Trigger", GetDocUrl(ViewModelDataType.Trigger),
|
|
null, triggerControlRow));
|
|
}
|
|
|
|
private void ClearTriggerBindings()
|
|
{
|
|
foreach (var dispose in m_triggerBindingDisposers)
|
|
{
|
|
dispose?.Invoke();
|
|
}
|
|
m_triggerBindingDisposers.Clear();
|
|
}
|
|
|
|
private void AddListField(
|
|
VisualElement parent,
|
|
string path,
|
|
string displayName,
|
|
Func<ViewModelInstance> instanceProvider = null,
|
|
string cacheKey = null,
|
|
string pathLabelOverride = null,
|
|
List<ListPropertyBinding> listBindingList = null,
|
|
FileMetadata metadataContext = null,
|
|
Func<string, ViewModel> viewModelResolver = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
cacheKey ??= path;
|
|
listBindingList ??= m_listBindings;
|
|
metadataContext ??= m_fileMetadata;
|
|
viewModelResolver ??= name => string.IsNullOrEmpty(name) ? null : m_widget?.File?.GetViewModelByName(name);
|
|
|
|
var listContainer = new VisualElement();
|
|
listContainer.style.flexDirection = FlexDirection.Column;
|
|
|
|
var vmNames = metadataContext?.ViewModels?
|
|
.Select(vm => vm.Name)
|
|
.Where(n => !string.IsNullOrEmpty(n))
|
|
.Distinct()
|
|
.ToList() ?? new List<string>();
|
|
|
|
var typeRow = new VisualElement { style = { flexDirection = FlexDirection.Row, alignItems = Align.Center } };
|
|
var initialType = vmNames.FirstOrDefault();
|
|
var typeDropdown = new DropdownField("New Item Type", vmNames, initialType)
|
|
{
|
|
tooltip = "Select the ViewModel type for newly added list items"
|
|
};
|
|
|
|
typeDropdown.style.flexGrow = 1;
|
|
typeDropdown.style.flexShrink = 1;
|
|
typeDropdown.style.marginRight = 6;
|
|
typeDropdown.style.marginBottom = 6;
|
|
|
|
|
|
typeRow.Add(typeDropdown);
|
|
typeRow.style.marginBottom = 4;
|
|
listContainer.Add(typeRow);
|
|
|
|
var itemBindings = new Dictionary<int, List<PropertyBinding>>();
|
|
|
|
ViewModelInstance CreateInstanceForList()
|
|
{
|
|
string targetType = typeDropdown.value;
|
|
var listProp = instanceProvider()?.GetListProperty(path);
|
|
if (string.IsNullOrEmpty(targetType))
|
|
{
|
|
targetType = listProp?.Count > 0 ? listProp.GetInstanceAt(0)?.ViewModelName : null;
|
|
}
|
|
|
|
var vm = !string.IsNullOrEmpty(targetType) ? viewModelResolver(targetType) : null;
|
|
return vm?.CreateInstance();
|
|
}
|
|
|
|
var listView = new ListView
|
|
{
|
|
reorderable = true,
|
|
showAddRemoveFooter = true,
|
|
virtualizationMethod = CollectionVirtualizationMethod.DynamicHeight,
|
|
selectionType = SelectionType.Single
|
|
};
|
|
listView.style.flexGrow = 1;
|
|
listView.style.minHeight = 80;
|
|
|
|
// Adapter that proxies directly to the live list property to avoid stale counts
|
|
var listAdapter = new ListPropertyAdapter(
|
|
() => instanceProvider()?.GetListProperty(path),
|
|
CreateInstanceForList);
|
|
listView.itemsSource = listAdapter;
|
|
|
|
listView.makeItem = () =>
|
|
{
|
|
var root = new VisualElement();
|
|
root.style.flexDirection = FlexDirection.Column;
|
|
root.style.paddingTop = 6;
|
|
root.style.paddingBottom = 6;
|
|
root.style.paddingLeft = 4;
|
|
root.style.paddingRight = 4;
|
|
root.style.borderBottomWidth = 1;
|
|
root.style.borderBottomColor = new UnityEngine.Color(0.25f, 0.25f, 0.25f, 0.25f);
|
|
return root;
|
|
};
|
|
|
|
listView.bindItem = (element, index) =>
|
|
{
|
|
element.Clear();
|
|
var bindings = new List<PropertyBinding>();
|
|
itemBindings[index] = bindings;
|
|
|
|
var listProp = instanceProvider()?.GetListProperty(path);
|
|
var instance = (listProp != null && index >= 0 && index < listProp.Count) ? listProp.GetInstanceAt(index) : null;
|
|
|
|
var header = new VisualElement { style = { flexDirection = FlexDirection.Row, alignItems = Align.Center } };
|
|
var title = new Label(instance?.ViewModelName ?? "Item");
|
|
title.style.unityFontStyleAndWeight = FontStyle.Bold;
|
|
title.style.flexGrow = 1;
|
|
//header.Add(title);
|
|
element.Add(header);
|
|
|
|
if (instance == null)
|
|
{
|
|
element.Add(new HelpBox("List item is null.", HelpBoxMessageType.Warning));
|
|
return;
|
|
}
|
|
|
|
var meta = FindViewModelMetadata(instance.ViewModelName, metadataContext);
|
|
if (meta == null)
|
|
{
|
|
element.Add(new HelpBox($"No metadata found for '{instance.ViewModelName}'.", HelpBoxMessageType.Warning));
|
|
return;
|
|
}
|
|
|
|
BuildViewModelSection(meta, string.Empty, element, 1, () => instance, $"{path}[{index}]", $"{path}[{index}]",
|
|
bindings, null, metadataContext, viewModelResolver);
|
|
};
|
|
|
|
listContainer.Add(listView);
|
|
|
|
var listBinding = new ListPropertyBinding
|
|
{
|
|
Path = cacheKey,
|
|
Control = listContainer,
|
|
};
|
|
|
|
listBinding.Sync = _ =>
|
|
{
|
|
var listProp = instanceProvider()?.GetListProperty(path);
|
|
bool hasProp = listProp != null;
|
|
listView.SetEnabled(hasProp);
|
|
typeDropdown.SetEnabled(hasProp);
|
|
|
|
if (!hasProp)
|
|
{
|
|
itemBindings.Clear();
|
|
listView.itemsSource = listAdapter;
|
|
listView.Rebuild();
|
|
listView.ClearSelection();
|
|
listBinding.LastItems.Clear();
|
|
listBinding.InitializedTypeSelection = false;
|
|
return;
|
|
}
|
|
|
|
// Detect structural changes to avoid unnecessary rebuilds that steal focus
|
|
var currentItems = new List<ViewModelInstance>(listProp.Count);
|
|
for (int i = 0; i < listProp.Count; i++)
|
|
{
|
|
currentItems.Add(listProp.GetInstanceAt(i));
|
|
}
|
|
|
|
bool structureChanged = currentItems.Count != listBinding.LastItems.Count;
|
|
if (!structureChanged)
|
|
{
|
|
for (int i = 0; i < currentItems.Count; i++)
|
|
{
|
|
if (!ReferenceEquals(currentItems[i], listBinding.LastItems[i]))
|
|
{
|
|
structureChanged = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (structureChanged)
|
|
{
|
|
itemBindings.Clear();
|
|
listView.itemsSource = listAdapter;
|
|
listView.Rebuild();
|
|
listView.ClearSelection();
|
|
listBinding.LastItems = currentItems;
|
|
}
|
|
else
|
|
{
|
|
listBinding.LastItems = currentItems;
|
|
if (listView.selectedIndex >= listProp.Count)
|
|
{
|
|
listView.ClearSelection();
|
|
}
|
|
}
|
|
|
|
|
|
string inferred = listProp.Count > 0 ? listProp.GetInstanceAt(0)?.ViewModelName : null;
|
|
|
|
if (!listBinding.InitializedTypeSelection)
|
|
{
|
|
if (!string.IsNullOrEmpty(inferred) && typeDropdown.choices.Contains(inferred))
|
|
{
|
|
typeDropdown.SetValueWithoutNotify(inferred);
|
|
}
|
|
else if (string.IsNullOrEmpty(typeDropdown.value) && typeDropdown.choices.Count > 0)
|
|
{
|
|
typeDropdown.SetValueWithoutNotify(typeDropdown.choices[0]);
|
|
}
|
|
|
|
listBinding.InitializedTypeSelection = true;
|
|
}
|
|
else
|
|
{
|
|
bool selectionMissing = string.IsNullOrEmpty(typeDropdown.value) || !typeDropdown.choices.Contains(typeDropdown.value);
|
|
if (selectionMissing && !string.IsNullOrEmpty(inferred) && typeDropdown.choices.Contains(inferred))
|
|
{
|
|
typeDropdown.SetValueWithoutNotify(inferred);
|
|
}
|
|
}
|
|
|
|
foreach (var kvp in itemBindings)
|
|
{
|
|
var idx = kvp.Key;
|
|
if (idx < 0 || idx >= listProp.Count)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var instance = listProp.GetInstanceAt(idx);
|
|
foreach (var binding in kvp.Value)
|
|
{
|
|
binding.Sync?.Invoke(instance);
|
|
}
|
|
}
|
|
};
|
|
|
|
listBindingList.Add(listBinding);
|
|
|
|
parent.Add(CreatePropertyCard(displayName, pathLabelOverride ?? path, "List", GetDocUrl(ViewModelDataType.List),
|
|
null, listContainer, false));
|
|
}
|
|
|
|
private void AddUnsupportedLabel(VisualElement parent, string name, ViewModelDataType type)
|
|
{
|
|
var label = new Label($"This property type is not configurable in the playground.");
|
|
label.style.color = new UnityEngine.Color(0.7f, 0.7f, 0.7f);
|
|
parent.Add(CreatePropertyCard(name, name, type.ToString(), GetDocUrl(type),
|
|
null, label));
|
|
}
|
|
|
|
private void RefreshValues()
|
|
{
|
|
if (m_isRefreshing)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_isRefreshing = true;
|
|
var instance = GetCurrentInstance();
|
|
try
|
|
{
|
|
foreach (var binding in m_propertyBindings.ToList())
|
|
{
|
|
binding.Sync?.Invoke(instance);
|
|
}
|
|
|
|
foreach (var listBinding in m_listBindings.ToList())
|
|
{
|
|
listBinding.Sync?.Invoke(instance);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
m_isRefreshing = false;
|
|
}
|
|
}
|
|
|
|
private void UpdateVisibility()
|
|
{
|
|
string message;
|
|
var state = GetPlaygroundState(out message);
|
|
bool ready = state == PlaygroundState.Ready;
|
|
|
|
if (m_playModeHelpBox != null)
|
|
{
|
|
m_playModeHelpBox.text = message;
|
|
m_playModeHelpBox.style.display = ready ? DisplayStyle.None : DisplayStyle.Flex;
|
|
}
|
|
|
|
if (m_widgetField != null)
|
|
{
|
|
// Only show the widget selector while in Play Mode
|
|
m_widgetField.style.display = EditorApplication.isPlaying ? DisplayStyle.Flex : DisplayStyle.None;
|
|
}
|
|
|
|
if (m_interactiveContainer != null)
|
|
{
|
|
m_interactiveContainer.style.display = ready ? DisplayStyle.Flex : DisplayStyle.None;
|
|
}
|
|
}
|
|
|
|
private PlaygroundState GetPlaygroundState(out string message)
|
|
{
|
|
if (!EditorApplication.isPlaying)
|
|
{
|
|
message = "Enter Play Mode to update values in the widget.";
|
|
return PlaygroundState.NotPlaying;
|
|
}
|
|
|
|
if (m_widget == null)
|
|
{
|
|
message = "Select a RiveWidget to get started.";
|
|
return PlaygroundState.NoWidget;
|
|
}
|
|
|
|
if (m_fileMetadata == null)
|
|
{
|
|
message = "Selected Rive file has no metadata yet. Reimport or select a Rive asset.";
|
|
return PlaygroundState.NoFileMetadata;
|
|
}
|
|
|
|
if (m_fileMetadata.ViewModels == null || m_fileMetadata.ViewModels.Count == 0)
|
|
{
|
|
message = "This Rive file has no ViewModels. Add data binding in the Rive Editor to use the playground.";
|
|
return PlaygroundState.NoViewModels;
|
|
}
|
|
|
|
if (m_artboardMetadata == null)
|
|
{
|
|
message = "No artboard metadata found for the selected widget.";
|
|
return PlaygroundState.NoArtboardMetadata;
|
|
}
|
|
|
|
if (m_artboardMetadata.DefaultViewModel == null)
|
|
{
|
|
message = "The current artboard has no default ViewModel.";
|
|
return PlaygroundState.NoDefaultViewModel;
|
|
}
|
|
|
|
if (m_widget.Status != WidgetStatus.Loaded || m_widget.StateMachine == null)
|
|
{
|
|
message = "Widget is not loaded yet.";
|
|
return PlaygroundState.WidgetNotLoaded;
|
|
}
|
|
|
|
if (m_widget.StateMachine.ViewModelInstance == null)
|
|
{
|
|
message = "No ViewModel instance bound to the state machine.";
|
|
return PlaygroundState.NoViewModelInstance;
|
|
}
|
|
|
|
message = string.Empty;
|
|
return PlaygroundState.Ready;
|
|
}
|
|
|
|
private Button CreateMoreActionsButton(string path, string displayName)
|
|
{
|
|
var button = new Button(() =>
|
|
{
|
|
var menu = new GenericMenu();
|
|
bool hasIndexPath = !string.IsNullOrEmpty(path) && path.Contains("[");
|
|
if (!string.IsNullOrEmpty(path) && !hasIndexPath)
|
|
{
|
|
menu.AddItem(new GUIContent("Copy Path"), false, () =>
|
|
{
|
|
EditorGUIUtility.systemCopyBuffer = path;
|
|
});
|
|
}
|
|
else
|
|
{
|
|
string label = hasIndexPath ? "Copy Path (not supported for list items)" : "Copy Path";
|
|
menu.AddDisabledItem(new GUIContent(label));
|
|
}
|
|
|
|
string nameOnly = !string.IsNullOrEmpty(path) ? path.Split('/').Last() : displayName;
|
|
menu.AddItem(new GUIContent("Copy Name"), false, () =>
|
|
{
|
|
EditorGUIUtility.systemCopyBuffer = nameOnly;
|
|
});
|
|
|
|
menu.ShowAsContext();
|
|
})
|
|
{
|
|
text = "⋮",
|
|
tooltip = "More actions",
|
|
};
|
|
button.style.width = 26;
|
|
button.style.marginLeft = 4;
|
|
button.style.height = 20;
|
|
button.style.backgroundColor = new UnityEngine.Color(0, 0, 0, 0);
|
|
button.style.borderLeftWidth = 0;
|
|
button.style.borderRightWidth = 0;
|
|
button.style.borderTopWidth = 0;
|
|
button.style.borderBottomWidth = 0;
|
|
button.style.fontSize = 14;
|
|
button.style.unityFontStyleAndWeight = FontStyle.Bold;
|
|
|
|
button.RegisterCallback<MouseEnterEvent>(_ =>
|
|
{
|
|
button.style.backgroundColor = new UnityEngine.Color(0.345f, 0.345f, 0.345f, 0.6f);
|
|
});
|
|
|
|
button.RegisterCallback<MouseLeaveEvent>(_ =>
|
|
{
|
|
button.style.backgroundColor = new UnityEngine.Color(0, 0, 0, 0);
|
|
});
|
|
|
|
return button;
|
|
}
|
|
|
|
private void StyleLinkLabel(Label label, string url)
|
|
{
|
|
label.style.fontSize = 11;
|
|
var linkColor = new UnityEngine.Color(0.55f, 0.78f, 1f, 1f);
|
|
label.style.color = linkColor;
|
|
label.style.marginLeft = 6;
|
|
// We keep the border width constant to avoid layout shift; toggle only the color.
|
|
label.style.borderBottomWidth = 1;
|
|
label.style.borderBottomColor = new StyleColor(new UnityEngine.Color(0, 0, 0, 0));
|
|
|
|
label.RegisterCallback<MouseEnterEvent>(_ =>
|
|
{
|
|
label.style.borderBottomColor = new StyleColor(linkColor);
|
|
});
|
|
|
|
label.RegisterCallback<MouseLeaveEvent>(_ =>
|
|
{
|
|
label.style.borderBottomColor = new StyleColor(new UnityEngine.Color(0, 0, 0, 0));
|
|
});
|
|
|
|
label.RegisterCallback<MouseUpEvent>(_ => Application.OpenURL(url));
|
|
}
|
|
|
|
private ViewModelInstance GetCurrentInstance()
|
|
{
|
|
return m_widget?.StateMachine?.ViewModelInstance;
|
|
}
|
|
|
|
private void BuildViewModelSection(
|
|
FileMetadata.ViewModelMetadata viewModel,
|
|
string accessPathPrefix,
|
|
VisualElement parent,
|
|
int depth,
|
|
Func<ViewModelInstance> instanceProvider = null,
|
|
string displayPathPrefix = null,
|
|
string cachePathPrefix = null,
|
|
List<PropertyBinding> bindingList = null,
|
|
List<ListPropertyBinding> listBindingList = null,
|
|
FileMetadata metadataContext = null,
|
|
Func<string, ViewModel> viewModelResolver = null)
|
|
{
|
|
instanceProvider ??= GetCurrentInstance;
|
|
bindingList ??= m_propertyBindings;
|
|
listBindingList ??= m_listBindings;
|
|
metadataContext ??= m_fileMetadata;
|
|
viewModelResolver ??= name => string.IsNullOrEmpty(name) ? null : m_widget?.File?.GetViewModelByName(name);
|
|
|
|
string resolvedDisplayPrefix = displayPathPrefix ?? accessPathPrefix;
|
|
string resolvedCachePrefix = cachePathPrefix ?? accessPathPrefix;
|
|
string expansionKey = string.IsNullOrEmpty(resolvedCachePrefix) ? "(root)" : resolvedCachePrefix;
|
|
|
|
string vmLabel = string.IsNullOrEmpty(accessPathPrefix)
|
|
? (string.IsNullOrEmpty(viewModel.Name) ? "Default ViewModel" : viewModel.Name)
|
|
: accessPathPrefix.Split('/').Last();
|
|
|
|
string viewModelNameLabel = string.IsNullOrEmpty(viewModel.Name) ? null : viewModel.Name;
|
|
string pathLabel = string.IsNullOrEmpty(resolvedDisplayPrefix) ? "(root)" : resolvedDisplayPrefix;
|
|
int childCount = viewModel.Properties?.Count ?? 0;
|
|
|
|
bool expanded = m_viewModelExpansion.TryGetValue(expansionKey, out var savedExpanded)
|
|
? savedExpanded
|
|
: depth == 0;
|
|
|
|
var header = new VisualElement { style = { flexDirection = FlexDirection.Row, alignItems = Align.Center } };
|
|
|
|
var expander = new Button();
|
|
expander.style.width = 20;
|
|
expander.style.height = 20;
|
|
expander.style.paddingLeft = 0;
|
|
expander.style.paddingRight = 0;
|
|
expander.style.marginRight = 3;
|
|
expander.text = expanded ? "▾" : "▸";
|
|
expander.tooltip = "Expand / collapse view model";
|
|
expander.style.fontSize = 30;
|
|
expander.style.backgroundColor = new UnityEngine.Color(0, 0, 0, 0);
|
|
expander.style.borderLeftWidth = 0;
|
|
expander.style.borderRightWidth = 0;
|
|
expander.style.borderTopWidth = 0;
|
|
expander.style.borderBottomWidth = 0;
|
|
|
|
var vmName = new Label(vmLabel) { style = { unityFontStyleAndWeight = FontStyle.Bold, flexGrow = 1 } };
|
|
|
|
var vmPill = new Label(string.IsNullOrEmpty(viewModelNameLabel)
|
|
? "View Model"
|
|
: $"View Model ({viewModelNameLabel})");
|
|
vmPill.style.unityTextAlign = TextAnchor.MiddleCenter;
|
|
vmPill.style.paddingLeft = 6;
|
|
vmPill.style.paddingRight = 6;
|
|
vmPill.style.paddingTop = 2;
|
|
vmPill.style.paddingBottom = 2;
|
|
vmPill.style.marginLeft = 4;
|
|
vmPill.style.borderTopLeftRadius = 4;
|
|
vmPill.style.borderTopRightRadius = 4;
|
|
vmPill.style.borderBottomLeftRadius = 4;
|
|
vmPill.style.borderBottomRightRadius = 4;
|
|
vmPill.style.backgroundColor = new UnityEngine.Color(0.25f, 0.25f, 0.35f, 0.9f);
|
|
vmPill.style.color = new UnityEngine.Color(0.9f, 0.9f, 1f, 1f);
|
|
|
|
var countLabel = new Label($"{childCount} properties");
|
|
countLabel.style.marginLeft = 6;
|
|
countLabel.style.fontSize = 11;
|
|
countLabel.style.color = new UnityEngine.Color(0.8f, 0.8f, 0.85f, 0.9f);
|
|
|
|
header.Add(expander);
|
|
header.Add(vmName);
|
|
header.Add(vmPill);
|
|
header.Add(countLabel);
|
|
header.Add(CreateMoreActionsButton(resolvedDisplayPrefix, vmLabel));
|
|
|
|
|
|
var container = new VisualElement();
|
|
container.style.marginLeft = 12;
|
|
container.style.marginTop = 8;
|
|
container.style.marginBottom = 8;
|
|
container.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None;
|
|
container.style.flexDirection = FlexDirection.Column;
|
|
|
|
foreach (var property in viewModel.Properties)
|
|
{
|
|
string propertyAccessPath = string.IsNullOrEmpty(accessPathPrefix)
|
|
? property.Name
|
|
: $"{accessPathPrefix}/{property.Name}";
|
|
string propertyDisplayPath = string.IsNullOrEmpty(resolvedDisplayPrefix)
|
|
? property.Name
|
|
: $"{resolvedDisplayPrefix}/{property.Name}";
|
|
string propertyCachePath = string.IsNullOrEmpty(resolvedCachePrefix)
|
|
? propertyAccessPath
|
|
: $"{resolvedCachePrefix}/{property.Name}";
|
|
|
|
switch (property.Type)
|
|
{
|
|
case ViewModelDataType.String:
|
|
AddStringField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList);
|
|
break;
|
|
case ViewModelDataType.Number:
|
|
AddNumberField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList);
|
|
break;
|
|
case ViewModelDataType.Boolean:
|
|
AddBooleanField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList);
|
|
break;
|
|
case ViewModelDataType.Color:
|
|
AddColorField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList);
|
|
break;
|
|
case ViewModelDataType.AssetImage:
|
|
AddImageField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList);
|
|
break;
|
|
case ViewModelDataType.Artboard:
|
|
AddArtboardField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList);
|
|
break;
|
|
case ViewModelDataType.Enum:
|
|
AddEnumField(container, propertyAccessPath, property, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList, metadataContext);
|
|
break;
|
|
case ViewModelDataType.Trigger:
|
|
AddTriggerField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath, bindingList);
|
|
break;
|
|
case ViewModelDataType.ViewModel:
|
|
var nestedMeta = FindViewModelMetadata(property.NestedViewModelName, metadataContext);
|
|
if (nestedMeta != null)
|
|
{
|
|
BuildViewModelSection(nestedMeta, propertyAccessPath, container, depth + 1, instanceProvider, propertyDisplayPath, propertyCachePath,
|
|
bindingList, listBindingList, metadataContext, viewModelResolver);
|
|
}
|
|
else
|
|
{
|
|
var missingLabel = new Label($"Nested view model '{property.NestedViewModelName}' not found.");
|
|
missingLabel.style.color = UnityEngine.Color.yellow;
|
|
container.Add(missingLabel);
|
|
}
|
|
break;
|
|
case ViewModelDataType.List:
|
|
AddListField(container, propertyAccessPath, property.Name, instanceProvider, propertyCachePath, propertyDisplayPath,
|
|
listBindingList, metadataContext, viewModelResolver);
|
|
break;
|
|
case ViewModelDataType.ListIndex:
|
|
AddUnsupportedLabel(container, property.Name, property.Type);
|
|
break;
|
|
default:
|
|
AddUnsupportedLabel(container, property.Name, property.Type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ToggleExpanded()
|
|
{
|
|
expanded = !expanded;
|
|
container.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None;
|
|
expander.text = expanded ? "▾" : "▸";
|
|
m_viewModelExpansion[expansionKey] = expanded;
|
|
}
|
|
|
|
expander.clicked += ToggleExpanded;
|
|
|
|
// wrap in a card for clarity
|
|
var vmCard = new VisualElement();
|
|
vmCard.style.marginTop = depth == 0 ? 8 : 4;
|
|
vmCard.style.paddingTop = 8;
|
|
vmCard.style.paddingBottom = 8;
|
|
vmCard.style.paddingLeft = 8;
|
|
vmCard.style.paddingRight = 8;
|
|
vmCard.style.borderTopWidth = 1;
|
|
vmCard.style.borderBottomWidth = 1;
|
|
vmCard.style.borderLeftWidth = 1;
|
|
vmCard.style.borderRightWidth = 1;
|
|
vmCard.style.borderTopColor = new UnityEngine.Color(0.344f, 0.344f, 0.349f, 0.5f);
|
|
vmCard.style.borderBottomColor = new UnityEngine.Color(0.344f, 0.344f, 0.349f, 0.5f);
|
|
vmCard.style.borderLeftColor = new UnityEngine.Color(0.344f, 0.344f, 0.349f, 0.5f);
|
|
vmCard.style.borderRightColor = new UnityEngine.Color(0.344f, 0.344f, 0.349f, 0.5f);
|
|
vmCard.style.backgroundColor = new UnityEngine.Color(0.145f, 0.145f, 0.152f, 0.55f);
|
|
vmCard.style.borderTopLeftRadius = 6;
|
|
vmCard.style.borderTopRightRadius = 6;
|
|
vmCard.style.borderBottomLeftRadius = 6;
|
|
vmCard.style.borderBottomRightRadius = 6;
|
|
|
|
vmCard.Add(header);
|
|
vmCard.Add(container);
|
|
|
|
parent.Add(vmCard);
|
|
}
|
|
|
|
private string GetDocUrl(ViewModelDataType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case ViewModelDataType.String:
|
|
return InspectorDocLinks.UnityDataBindingProperties;
|
|
case ViewModelDataType.Number:
|
|
return InspectorDocLinks.UnityDataBindingProperties;
|
|
case ViewModelDataType.Boolean:
|
|
return InspectorDocLinks.UnityDataBindingProperties;
|
|
case ViewModelDataType.Color:
|
|
return InspectorDocLinks.UnityDataBindingProperties;
|
|
case ViewModelDataType.Trigger:
|
|
return InspectorDocLinks.UnityDataBindingProperties;
|
|
case ViewModelDataType.Enum:
|
|
return InspectorDocLinks.UnityDataBindingEnums;
|
|
case ViewModelDataType.ViewModel:
|
|
return InspectorDocLinks.UnityDataBindingViewModel;
|
|
case ViewModelDataType.AssetImage:
|
|
return InspectorDocLinks.UnityDataBindingImages;
|
|
case ViewModelDataType.List:
|
|
return InspectorDocLinks.UnityDataBindingLists;
|
|
case ViewModelDataType.ListIndex:
|
|
return InspectorDocLinks.UnityDataBindingListViewModelIndex;
|
|
case ViewModelDataType.Artboard:
|
|
return InspectorDocLinks.UnityDataBindingArtboards;
|
|
default:
|
|
return InspectorDocLinks.UnityDataBinding;
|
|
}
|
|
}
|
|
|
|
private VisualElement CreatePropertyCard(string displayName, string path, string typeLabel, string docUrl, string description, VisualElement control, bool showTypePill = false)
|
|
{
|
|
var card = new VisualElement();
|
|
card.style.marginTop = 6;
|
|
card.style.paddingTop = 8;
|
|
card.style.paddingBottom = 8;
|
|
card.style.paddingLeft = 10;
|
|
card.style.paddingRight = 10;
|
|
card.style.borderTopLeftRadius = 6;
|
|
card.style.borderTopRightRadius = 6;
|
|
card.style.borderBottomLeftRadius = 6;
|
|
card.style.borderBottomRightRadius = 6;
|
|
card.style.borderBottomWidth = 1;
|
|
card.style.borderTopWidth = 1;
|
|
card.style.borderLeftWidth = 1;
|
|
card.style.borderRightWidth = 1;
|
|
card.style.borderBottomColor = new UnityEngine.Color(0.25f, 0.25f, 0.25f, 0.4f);
|
|
card.style.borderTopColor = new UnityEngine.Color(0.25f, 0.25f, 0.25f, 0.4f);
|
|
card.style.borderLeftColor = new UnityEngine.Color(0.25f, 0.25f, 0.25f, 0.4f);
|
|
card.style.borderRightColor = new UnityEngine.Color(0.25f, 0.25f, 0.25f, 0.4f);
|
|
card.style.backgroundColor = new UnityEngine.Color(0.12f, 0.12f, 0.12f, 0.45f);
|
|
|
|
var header = new VisualElement { style = { flexDirection = FlexDirection.Row, alignItems = Align.Center } };
|
|
var nameLabel = new Label(displayName);
|
|
nameLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
|
|
nameLabel.style.flexGrow = 1;
|
|
|
|
if (showTypePill && !string.IsNullOrEmpty(typeLabel))
|
|
{
|
|
var typePill = new Label(typeLabel);
|
|
typePill.style.unityTextAlign = TextAnchor.MiddleCenter;
|
|
typePill.style.paddingLeft = 6;
|
|
typePill.style.paddingRight = 6;
|
|
typePill.style.paddingTop = 2;
|
|
typePill.style.paddingBottom = 2;
|
|
typePill.style.marginLeft = 4;
|
|
typePill.style.borderTopLeftRadius = 4;
|
|
typePill.style.borderTopRightRadius = 4;
|
|
typePill.style.borderBottomLeftRadius = 4;
|
|
typePill.style.borderBottomRightRadius = 4;
|
|
typePill.style.backgroundColor = new UnityEngine.Color(0.25f, 0.25f, 0.25f, 0.8f);
|
|
typePill.style.color = new UnityEngine.Color(0.85f, 0.85f, 0.85f, 1f);
|
|
header.Add(typePill);
|
|
}
|
|
|
|
var menuButton = CreateMoreActionsButton(path, displayName);
|
|
|
|
// Remove potential parenthesis text to account for enum values. E.g. "Enum (MyEnum)" should be "Enum"
|
|
string strippedTypeLabel = typeLabel;
|
|
if (!string.IsNullOrEmpty(strippedTypeLabel))
|
|
{
|
|
int parenIndex = strippedTypeLabel.IndexOf(" (", StringComparison.Ordinal);
|
|
if (parenIndex > 0)
|
|
{
|
|
strippedTypeLabel = strippedTypeLabel.Substring(0, parenIndex);
|
|
}
|
|
}
|
|
|
|
string docLabel = string.IsNullOrEmpty(typeLabel) ? "Docs" : $"{strippedTypeLabel} Property Documentation";
|
|
var docButton = new Label(docLabel);
|
|
StyleLinkLabel(docButton, docUrl);
|
|
docButton.style.marginLeft = 6;
|
|
docButton.style.alignSelf = Align.Center;
|
|
docButton.style.display = DisplayStyle.None;
|
|
|
|
header.Add(nameLabel);
|
|
header.Add(docButton);
|
|
header.Add(menuButton);
|
|
|
|
card.Add(header);
|
|
|
|
card.RegisterCallback<MouseEnterEvent>(_ =>
|
|
{
|
|
docButton.style.display = DisplayStyle.Flex;
|
|
});
|
|
|
|
card.RegisterCallback<MouseLeaveEvent>(_ =>
|
|
{
|
|
docButton.style.display = DisplayStyle.None;
|
|
});
|
|
|
|
string pathLineText = null;
|
|
if (!showTypePill)
|
|
{
|
|
pathLineText = $"{typeLabel}";
|
|
}
|
|
else if (!string.IsNullOrEmpty(path))
|
|
{
|
|
pathLineText = $"Path: {path}";
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(pathLineText))
|
|
{
|
|
var pathLabel = new Label(pathLineText);
|
|
pathLabel.style.fontSize = 11;
|
|
pathLabel.style.color = new UnityEngine.Color(0.75f, 0.75f, 0.75f, 0.9f);
|
|
pathLabel.style.marginTop = 2;
|
|
card.Add(pathLabel);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(description))
|
|
{
|
|
var desc = new Label(description);
|
|
desc.style.fontSize = 11;
|
|
desc.style.color = new UnityEngine.Color(0.8f, 0.8f, 0.8f, 0.95f);
|
|
desc.style.marginTop = 4;
|
|
card.Add(desc);
|
|
}
|
|
|
|
control.style.marginTop = 6;
|
|
card.Add(control);
|
|
|
|
return card;
|
|
}
|
|
}
|
|
}
|
|
|