public void PropertyElement_Target_CanBeSetAndGet()
{
var element = new PropertyElement();
Assert.That(element.TryGetTarget(out UIContainer _), Is.False);
Assert.Throws <InvalidOperationException>(() => element.GetTarget <UIContainer>());
var container = new UIContainer();
Assert.DoesNotThrow(() => element.SetTarget(container));
Assert.That(element.TryGetTarget(out UIContainer _), Is.True);
Assert.DoesNotThrow(() => element.GetTarget <UIContainer>());
Assert.DoesNotThrow(() => element.SetTarget((object)container));
Assert.That(element.TryGetTarget(out UIContainer _), Is.True);
Assert.DoesNotThrow(() => element.GetTarget <UIContainer>());
Assert.DoesNotThrow(() => element.SetTarget(container));
Assert.That(element.TryGetTarget(out object _), Is.True);
Assert.DoesNotThrow(() => element.GetTarget <object>());
var container2 = new ComplexUIContainer();
Assert.That(element.TryGetTarget(out ComplexUIContainer _), Is.False);
Assert.Throws <InvalidCastException>(() => element.GetTarget <ComplexUIContainer>());
Assert.DoesNotThrow(() => element.SetTarget(container2));
Assert.That(element.TryGetTarget(out ComplexUIContainer _), Is.True);
Assert.DoesNotThrow(() => element.GetTarget <ComplexUIContainer>());
var container3 = new ComplexUIChildContainer();
Assert.DoesNotThrow(() => element.SetTarget(container3));
Assert.That(element.TryGetTarget(out ComplexUIContainer _), Is.True);
Assert.DoesNotThrow(() => element.GetTarget <ComplexUIContainer>());
}
public void TypeWithCustomInspector_WhenNoSpecializedInspectorExists_UsesDeclaredTypeInspector()
{
var element = new PropertyElement();
var instance = new ASD();
instance.Type = new NoInspectorDerivedType();
element.SetTarget(instance);
Assert.That(element.Q <Label>(className: BaseType.Label).text, Is.EqualTo(nameof(BaseType)));
element.ClearTarget();
instance.Type = new HasInspectorDerivedType();
element.SetTarget(instance);
Assert.That(element.Q <Label>(className: BaseType.Label).text, Is.EqualTo(nameof(HasInspectorDerivedType)));
}
public void DefaultInspector_ForField_MimicsGenericInspector()
{
var fieldInspector = new PropertyElement();
fieldInspector.SetTarget(new Types.DefaultFieldInspector()
{
NoInspectorType = new Types.NoInspectorType(),
DefaultInspectorType = new Types.DefaultInspectorType()
});
var noInspector =
fieldInspector.Q <Foldout>(nameof(Types.DefaultFieldInspector.NoInspectorType));
Assert.That(noInspector.Query <CustomInspectorElement>().ToList().Count, Is.EqualTo(0));
Assert.That(noInspector.childCount, Is.EqualTo(3));
var customInspectorElements = fieldInspector.Query <CustomInspectorElement>().ToList();
Assert.That(customInspectorElements.Count, Is.EqualTo(1));
var customInspectorElement = customInspectorElements[0].Q <Foldout>(nameof(Types.DefaultFieldInspector.DefaultInspectorType));
Assert.That(customInspectorElement.childCount, Is.EqualTo(3));
for (var i = 0; i < 3; ++i)
{
var lhs = noInspector.ElementAt(i);
var rhs = customInspectorElement.ElementAt(i);
Assert.That(lhs.GetType(), Is.EqualTo(rhs.GetType()));
Assert.That(lhs.childCount, Is.EqualTo(rhs.childCount));
Assert.That((lhs as BindableElement)?.bindingPath, Is.EqualTo((rhs as BindableElement)?.bindingPath));
}
}
public void CustomInspector_CallingDefaultOnEachField_MimicsGenericInspector()
{
var noInspector = new PropertyElement();
noInspector.SetTarget(new Types.NoInspectorType());
Assert.That(noInspector.Query <CustomInspectorElement>().ToList().Count, Is.EqualTo(0));
Assert.That(noInspector.childCount, Is.EqualTo(3));
var allDefaultInspector = new PropertyElement();
allDefaultInspector.SetTarget(new Types.AllDefaultInspectorType());
var customInspectorElements = allDefaultInspector.Query <CustomInspectorElement>().ToList();
Assert.That(customInspectorElements.Count, Is.EqualTo(1));
var customInspectorElement = customInspectorElements[0].ElementAt(0);
Assert.That(customInspectorElement.childCount, Is.EqualTo(3));
for (var i = 0; i < 3; ++i)
{
var lhs = noInspector.ElementAt(i);
var rhs = customInspectorElement.ElementAt(i);
Assert.That(lhs.GetType(), Is.EqualTo(rhs.GetType()));
Assert.That(lhs.childCount, Is.EqualTo(rhs.childCount));
Assert.That((lhs as BindableElement)?.bindingPath, Is.EqualTo((rhs as BindableElement)?.bindingPath));
}
}
public void CodeInspector_WithBindings_GetsValuesSet()
{
var fieldInspector = new PropertyElement();
fieldInspector.SetTarget(new Types.CodeInspectorType()
{
Float = 25.0f,
Int = 15,
String = "Yup"
});
var customInspectorElements = fieldInspector.Query <CustomInspectorElement>().ToList();
Assert.That(customInspectorElements.Count, Is.EqualTo(1));
var customInspectorElement = customInspectorElements[0].ElementAt(0);
Assert.That(customInspectorElement.childCount, Is.EqualTo(3));
var floatField = customInspectorElement.ElementAt(0) as FloatField;
Assert.That(floatField.value, Is.EqualTo(25.0f));
var intField = customInspectorElement.ElementAt(1) as IntegerField;
Assert.That(intField.value, Is.EqualTo(15));
var stringField = customInspectorElement.ElementAt(2) as TextField;
Assert.That(stringField.value, Is.EqualTo("Yup"));
}
protected PropertyElement CreateContent <TValue>(IComponentProperty property, ref TValue value)
{
Resources.Templates.Inspector.InspectorStyle.AddStyles(this);
AddToClassList(UssClasses.Resources.Inspector);
AddToClassList(UssClasses.Resources.ComponentIcons);
InspectorUtility.CreateComponentHeader(this, property.Type, DisplayName);
var foldout = this.Q <Foldout>(className: UssClasses.Inspector.Component.Header);
var toggle = foldout.Q <Toggle>();
var container = Container;
toggle.AddManipulator(new ContextualMenuManipulator(evt => { OnPopulateMenu(evt.menu); }));
var componentMenu = this.Q <VisualElement>(className: UssClasses.Inspector.Component.Menu);
var content = new PropertyElement();
foldout.contentContainer.Add(content);
content.AddContext(Context);
content.SetTarget(value);
content.OnChanged += OnComponentChanged;
foldout.contentContainer.AddToClassList(UssClasses.Inspector.Component.Container);
if (container.IsReadOnly)
{
SetReadonly(foldout);
foldout.RegisterCallback <ClickEvent, EntityInspectorContext>(OnClicked, Context, TrickleDown.TrickleDown);
}
return(content);
}
public override VisualElement Build()
{
m_Root = new VisualElement();
Resources.Templates.KeyValuePairElement.Clone(m_Root);
m_Root.AddToClassList(UssClasses.KeyValuePairElement.KeyValuePair);
m_Key = m_Root.Q <PropertyElement>(className: UssClasses.KeyValuePairElement.Key);
m_Key.SetTarget(new KeyContainer(Target.Key));
if (m_Key.contentContainer.Q <Foldout>() is Foldout foldout)
{
foldout.SetEnabled(true);
foldout.contentContainer.SetEnabled(false);
}
else
{
m_Key.contentContainer.SetEnabled(false);
}
var remove = m_Root.Q <Button>(className: UssClasses.KeyValuePairElement.RemoveButton);
remove.clickable.clicked += () =>
{
DictionaryElement.RemoveAtKey(m_Key.GetTarget <KeyContainer>().Key);
};
m_Value = m_Root.Q <PropertyElement>(className: UssClasses.KeyValuePairElement.Value);
m_Value.SetTarget(new ValueContainer(Target.Value));
m_Value.OnChanged += OnValueChanged;
return(m_Root);
}
void ElementOnOnChanged(PropertyElement element)
{
m_Container.SetComponent(element.GetTarget <T>());
element.SetTarget(m_Container.GetComponent <T>());
SetBorderColor();
OnChanged();
}
private void OnEnable()
{
var propertyElement = new PropertyElement();
propertyElement.SetTarget(paramValue);
rootVisualElement.Add(propertyElement);
}
public void PropertyElement_IsPathValid_ReturnsTrueForValidPath()
{
var element = new PropertyElement();
var container = GetContainer();
element.SetTarget(container);
var path = new PropertyPath();
{
path.Clear();
path.PushName(nameof(ComplexUIContainer.FloatField));
Assert.That(element.IsPathValid(path), Is.True);
}
{
path.Clear();
path.PushName(nameof(ComplexUIContainer.IntField));
Assert.That(element.IsPathValid(path), Is.True);
}
{
path.Clear();
path.PushName(nameof(ComplexUIContainer.StringField));
Assert.That(element.IsPathValid(path), Is.True);
}
{
path.Clear();
path.PushName(nameof(ComplexUIContainer.IntListField));
Assert.That(element.IsPathValid(path), Is.True);
for (var i = 0; i < container.IntListField.Count; ++i)
{
path.PushIndex(i);
Assert.That(element.IsPathValid(path), Is.True);
path.Pop();
}
}
{
path.Clear();
path.PushName(nameof(ComplexUIContainer.IntIntDictionary));
Assert.That(element.IsPathValid(path), Is.True);
foreach (var kvp in container.IntIntDictionary.ToList())
{
path.PushKey(kvp.Key);
Assert.That(element.IsPathValid(path), Is.True);
path.PushName("Key");
Assert.That(element.IsPathValid(path), Is.True);
path.Pop();
path.PushName("Value");
Assert.That(element.IsPathValid(path), Is.True);
path.Pop();
path.Pop();
}
}
}
public void ResettingTargets_FromCustomInspector_ShouldNotThrow()
{
var value = new NestedPropertyElementWithInterfaces();
var element = new PropertyElement();
Assert.DoesNotThrow(() => element.SetTarget(value));
Assert.DoesNotThrow(() => element.Query <CustomInspectorElement>().ForEach(i => (i as IBinding).Update()));
}
public void NullElement_WithUnderlyingDataNotNullAnymore_UpdatesCorrectly()
{
var container = new Container();
var element = new PropertyElement();
element.SetTarget(container);
var someTypes = new List <NullElement <SomeType> >();
element.Query <NullElement <SomeType> >().ToList(someTypes);
Assert.That(someTypes.Count, Is.EqualTo(1));
var someOtherTypes = new List <NullElement <SomeOtherType> >();
element.Query <NullElement <SomeOtherType> >().ToList(someOtherTypes);
Assert.That(someOtherTypes.Count, Is.EqualTo(1));
container.NonNullFieldWithNestedNullField.NestedField = new SomeOtherType();
foreach (IBinding binding in someTypes)
{
binding.Update();
}
foreach (IBinding binding in someOtherTypes)
{
binding.Update();
}
someTypes.Clear();
someOtherTypes.Clear();
element.Query <NullElement <SomeType> >().ToList(someTypes);
Assert.That(someTypes.Count, Is.EqualTo(1));
element.Query <NullElement <SomeOtherType> >().ToList(someOtherTypes);
Assert.That(someOtherTypes.Count, Is.EqualTo(0));
container.NullField = new SomeType {
NestedField = new SomeOtherType()
};
foreach (IBinding binding in someTypes)
{
binding.Update();
}
foreach (IBinding binding in someOtherTypes)
{
binding.Update();
}
someTypes.Clear();
someOtherTypes.Clear();
element.Query <NullElement <SomeType> >().ToList(someTypes);
Assert.That(someTypes.Count, Is.EqualTo(0));
element.Query <NullElement <SomeOtherType> >().ToList(someOtherTypes);
Assert.That(someOtherTypes.Count, Is.EqualTo(0));
}
public void PropertyElement_WithNullFields_CreatesNullElement()
{
var container = new Container();
var element = new PropertyElement();
element.SetTarget(container);
Assert.That(element.Query <NullElement <SomeType> >().ToList().Count, Is.EqualTo(1));
Assert.That(element.Query <NullElement <SomeOtherType> >().ToList().Count, Is.EqualTo(1));
}
public void PropertyElement_FieldWithHideInInspector_AreNotShown()
{
var withHideInInspectorField = new PropertyElement();
withHideInInspectorField.SetTarget(new Types.FieldWithHideInInspector());
var customInspectorElements = withHideInInspectorField.Query <CustomInspectorElement>().ToList();
Assert.That(customInspectorElements.Count, Is.EqualTo(0));
Assert.That(withHideInInspectorField.childCount, Is.EqualTo(2));
Assert.That(withHideInInspectorField.Query <IntegerField>().First(), Is.Null);
}
public void NullInspector_ForRootType_HasNoChildren()
{
var noOverrideInspector = new PropertyElement();
noOverrideInspector.SetTarget(new Types.NullInspectorType());
var customInspectorElements = noOverrideInspector.Query <CustomInspectorElement>().ToList();
Assert.That(customInspectorElements.Count, Is.EqualTo(1));
var customInspectorElement = customInspectorElements[0];
Assert.That(customInspectorElement.childCount, Is.EqualTo(0));
}
public override void OnActivate(string searchContext, VisualElement rootElement)
{
// TODO: Switch to use uxml/uss for this.
var root = new VisualElement();
rootElement.Add(root);
var title = new Label(Title);
title.style.unityFontStyleAndWeight = FontStyle.Bold;
title.style.marginTop = 1;
title.style.fontSize = 19;
title.style.unityTextAlign = TextAnchor.MiddleLeft;
title.style.height = 26;
root.Add(title);
Resources.Templates.Settings.AddStyles(rootElement);
foreach (var kvp in s_Settings)
{
if (kvp.Value.All(w => w.Internal) && !Unsupported.IsDeveloperMode())
{
continue;
}
var label = new Label {
text = kvp.Key
};
label.style.unityFontStyleAndWeight = FontStyle.Bold;
root.Add(label);
foreach (var wrapper in kvp.Value)
{
if (wrapper.Internal && !Unsupported.IsDeveloperMode())
{
continue;
}
var setting = wrapper.Setting;
var element = new PropertyElement();
element.style.marginLeft = -3;
element.SetAttributeFilter(AttributeFilter);
element.SetTarget(setting);
element.OnChanged += (propertyElement, path) => setting.OnSettingChanged(path);
root.Add(element);
element.RegisterCallback <GeometryChangedEvent>(evt =>
StylingUtility.AlignInspectorLabelWidth(element));
}
}
root.AddToClassList("unity-inspector-element");
root.style.paddingLeft = 10;
base.OnActivate(searchContext, rootElement);
}
public void NullElement_WithStringField_CreatesAButton()
{
var container = new TypeWithString();
var element = new PropertyElement();
element.SetTarget(container);
var stringField = element.Q <NullElement <string> >();
Assert.That(stringField, Is.Not.Null);
Assert.That(stringField.Q <Button>(), Is.Not.Null);
Assert.That(stringField.Q <PopupField <Type> >(), Is.Null);
}
public void EnumFields_WhenUnderlyingTypeIsLong_AreSkipped()
{
var element = new PropertyElement();
element.SetTarget(new TypeWithLargeEnums());
#if !UNITY_2020_2_OR_NEWER
Assert.That(element.Query <EnumField>().ToList().Count, Is.EqualTo(0));
Assert.That(element.Query <EnumFlagsField>().ToList().Count, Is.EqualTo(0));
#else
Assert.That(element.Query <EnumField>().ToList().Count, Is.EqualTo(1));
Assert.That(element.Query <EnumFlagsField>().ToList().Count, Is.EqualTo(1));
#endif
element.SetTarget(new TypeWithLargeAndRegularEnums());
#if !UNITY_2020_2_OR_NEWER
Assert.That(element.Query <EnumField>().ToList().Count, Is.EqualTo(1));
Assert.That(element.Query <EnumFlagsField>().ToList().Count, Is.EqualTo(1));
#else
Assert.That(element.Query <EnumField>().ToList().Count, Is.EqualTo(2));
Assert.That(element.Query <EnumFlagsField>().ToList().Count, Is.EqualTo(2));
#endif
}
public void NullElement_WithSingleConstructableType_CreatesAButton()
{
var container = new SomeType();
var element = new PropertyElement();
element.SetTarget(container);
var stringField = element.Q <NullElement <SomeOtherType> >();
Assert.That(stringField, Is.Not.Null);
Assert.That(stringField.Q <Button>(), Is.Not.Null);
Assert.That(stringField.Q <PopupField <Type> >(), Is.Null);
}
public void NullElement_WithMultipleConstructableTypes_CreatesAPopup()
{
var container = new TypeWithDerivableField();
var element = new PropertyElement();
element.SetTarget(container);
var stringField = element.Q <NullElement <MultipleDerivedTypes> >();
Assert.That(stringField, Is.Not.Null);
Assert.That(stringField.Q <Button>(), Is.Null);
Assert.That(stringField.Q <PopupField <Type> >(), Is.Not.Null);
}
public void DefaultInspector_ForCollectionField_MimicsGenericInspector()
{
var fieldInspector = new PropertyElement();
fieldInspector.SetTarget(new Types.TypeWithCollections());
var customInspectorElements = fieldInspector.Query <CustomInspectorElement>().ToList();
Assert.That(customInspectorElements[0].childCount, Is.EqualTo(1));
Assert.That(customInspectorElements[0][0], Is.TypeOf <Label>());
Assert.That(customInspectorElements[1].childCount, Is.EqualTo(1));
Assert.That(customInspectorElements[1][0], Is.TypeOf <CustomInspectorElement.DefaultInspectorElement>());
Assert.That(customInspectorElements[2].childCount, Is.EqualTo(0));
}
public void Update()
{
if (m_Container.HasComponent <T>())
{
m_Element.style.display = DisplayStyle.Flex;
m_MissingComponentLabel.style.display = DisplayStyle.None;
m_Element.SetTarget(m_Container.GetComponent <T>());
}
else
{
m_Element.style.display = DisplayStyle.None;
m_MissingComponentLabel.style.display = DisplayStyle.Flex;
}
}
void RemoveComponent()
{
m_Container.RemoveComponent(m_Type);
if (m_Container.HasComponent(m_Type))
{
m_Element?.SetTarget(m_Container.GetComponent <T>());
SetBorderColor();
}
else
{
RemoveFromHierarchy();
}
OnChanged();
}
void IBinding.Update()
{
var container = Container;
if (!Context.World.IsCreated || !Context.EntityManager.Exists(Container.Entity))
{
RemoveFromHierarchy();
return;
}
if (PropertyContainer.TryGetValue <EntityContainer, TComponent>(ref container, Path, out var component))
{
m_Content.SetTarget(component);
}
}
public void PropertyElement_WithAttributeFilter_FiltersHierarchyGeneration()
{
var element = new PropertyElement();
element.SetTarget(new FilterByAttribute());
Assert.That(element.contentContainer.childCount, Is.EqualTo(4));
Assert.That(element[0], Is.InstanceOf <IntegerField>());
Assert.That(element[1], Is.InstanceOf <TextField>());
Assert.That(element[2], Is.InstanceOf <DoubleField>());
Assert.That(element[3], Is.InstanceOf <FloatField>());
element.SetAttributeFilter(attributes => null == attributes.OfType <HideAttribute>().FirstOrDefault());
Assert.That(element.contentContainer.childCount, Is.EqualTo(1));
Assert.That(element[0], Is.InstanceOf <FloatField>());
}
public void NullInspector_ForField_HasNoChildren()
{
var fieldInspector = new PropertyElement();
fieldInspector.SetTarget(new Types.NullFieldInspector
{
NullInspectorType = new Types.NullInspectorType()
});
var customInspectorElements = fieldInspector.Query <CustomInspectorElement>().ToList();
Assert.That(customInspectorElements.Count, Is.EqualTo(1));
var customInspectorElement = customInspectorElements[0];
Assert.That(customInspectorElement.childCount, Is.EqualTo(0));
}
VisualElement Build()
{
if (m_Root == null)
{
m_Root = new VisualElement();
}
if (Source != null && Source && Target != null && Target)
{
var configRoot = new PropertyElement();
configRoot.SetTarget(new BuildConfigurationInspectorData(Source, Target));
configRoot.AddContext(new BuildConfigurationContext(this));
m_Root.contentContainer.Add(configRoot);
}
m_Root.contentContainer.Add(new IMGUIContainer(ApplyRevertGUI));
return(m_Root);
}
public HierarchicalComponentContainerElement(HierarchicalComponentContainer <TContainer, TComponent> container, T component, bool optional)
{
this.AddStyleSheetAndVariant(ClassNames.BaseClassName);
m_Container = container;
m_IsOptional = optional;
AddToClassList(ClassNames.BaseClassName);
var componentContainerName = component.GetType().Name;
var foldout = new Foldout {
text = ObjectNames.NicifyVariableName(componentContainerName)
};
foldout.AddToClassList(ClassNames.Component);
foldout.AddToClassList(componentContainerName);
Add(foldout);
var toggle = foldout.Q <Toggle>();
toggle.AddToClassList(ClassNames.Header);
m_AddButton = new Button(AddComponent);
m_AddButton.AddToClassList(ClassNames.AddComponent);
toggle.Add(m_AddButton);
m_RemoveButton = new Button(RemoveComponent);
m_RemoveButton.AddToClassList(ClassNames.RemoveComponent);
toggle.Add(m_RemoveButton);
m_Element = new PropertyElement();
m_Element.OnChanged += ElementOnOnChanged;
m_Element.SetTarget(component);
foldout.contentContainer.Add(m_Element);
foldout.contentContainer.AddToClassList(ClassNames.Fields);
m_MissingComponentLabel = new Label($"Component of type {typeof(T).Name} is missing");
m_MissingComponentLabel.style.display = DisplayStyle.None;
foldout.contentContainer.Add(m_MissingComponentLabel);
SetStyle();
}
void Initialize(EntitySelectionProxy proxy)
{
m_Context.SetContext(proxy);
m_Root.Clear();
var header = new PropertyElement();
header.AddContext(m_Context);
header.SetTarget(new EntityHeader(m_Context));
m_Root.Add(header);
m_SearchField = header.Q <ToolbarSearchField>();
m_SearchField.RegisterValueChangedCallback(evt =>
{
m_Filters.Clear();
var value = evt.newValue.Trim();
var matches = value.Split(' ');
foreach (var match in matches)
{
m_Filters.Add(match);
}
SearchChanged();
});
m_Settings = m_Root.Q <ToolbarMenu>();
// TODO: Remove once we have menu items.
m_Settings.Hide();
m_ComponentsRoot = new VisualElement();
m_Root.Add(m_ComponentsRoot);
Resources.Templates.Inspector.ComponentsRoot.AddStyles(m_ComponentsRoot);
m_ComponentsRoot.AddToClassList("entity-inspector__components-root");
m_ComponentsRoot.RegisterCallback <GeometryChangedEvent>(OnGeometryChanged);
m_TagsRoot = new TagComponentContainer(m_Context);
m_ComponentsRoot.Add(m_TagsRoot);
m_InspectorVisitor = new EntityInspectorVisitor(m_ComponentsRoot, m_TagsRoot, m_Context);
PropertyContainer.Visit(m_Context.EntityContainer, m_InspectorVisitor);
m_Root.ForceUpdateBindings();
}
internal static void SetCallbacks <TValue>(
ref TValue value,
PropertyPath path,
PropertyElement root,
PropertyElement field)
{
field.SetRoot(root);
field.SetTarget(value);
field.binding = new PropertyBinding <TValue>(field, root, path);
var r = root;
var p = path;
field.OnChanged += (element, propertyPath) =>
{
r.SetValue(p, element.GetTarget <TValue>());
element.SetTarget(r.GetValue <TValue>(p));
var fullPath = new PropertyPath();
fullPath.PushPath(p);
fullPath.PushPath(propertyPath);
r.NotifyChanged(fullPath);
};
}
