public CircularReferenceElement(BindingContextElement root, IProperty property, T value, PropertyPath path, PropertyPath pathToReference)
{
binding = this;
m_Root = root;
m_Path = path;
m_PathToReference = pathToReference;
m_Value = value;
name = m_PathToReference.ToString();
style.flexDirection = FlexDirection.Row;
Resources.Templates.CircularReference.Clone(this);
var label = this.Q <Label>(className: UssClasses.CircularReferenceElement.Label);
label.text = GuiFactory.GetDisplayName(property);
label.AddManipulator(
new ContextualMenuManipulator(evt =>
{
var prop = GetProperty();
if (null == prop)
{
return;
}
var inspectorOptions = property.GetAttribute <InspectorOptionsAttribute>();
if (property.IsReadOnly || true == inspectorOptions?.HideResetToDefault)
{
return;
}
evt.menu.AppendAction(
"Reset to default",
p => ReloadWithInstance(default),
public CustomInspectorElement(PropertyPath basePath, IInspector inspector, BindingContextElement root)
{
m_Root = root;
binding = this;
m_BasePath = basePath;
name = TypeUtility.GetTypeDisplayName(inspector.Type);
Inspector = inspector;
try
{
m_Content = Inspector.Build();
if (null == m_Content)
{
return;
}
HasInspector = true;
// If `IInspector.Build` was not overridden, it returns this element as its content.
if (this != m_Content)
{
Add(m_Content);
RegisterBindings(m_Content);
RegisterSearchHandlers(m_Content);
}
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
public InspectorContext(
BindingContextElement root,
PropertyPath propertyPath,
IProperty property,
IEnumerable <Attribute> attributes = null
)
{
Root = root;
PropertyPath = propertyPath;
BasePath = new PropertyPath();
BasePath.PushPath(PropertyPath);
if (BasePath.PartsCount > 0)
{
BasePath.Pop();
}
Name = property.Name;
Part = PropertyPath.PartsCount > 0 ? PropertyPath[PropertyPath.PartsCount - 1] : default;
var attributeList = new List <Attribute>(attributes ?? property.GetAttributes());
Attributes = attributeList;
Tooltip = property.GetAttribute <TooltipAttribute>()?.tooltip;
DisplayName = GuiFactory.GetDisplayName(property);
IsDelayed = property.HasAttribute <DelayedAttribute>();
IsReadOnly = property.IsReadOnly;
}
internal static void SetCallbacks <TValue>(
ref TValue value,
PropertyPath path,
BindingContextElement root,
Label label)
{
label.text = TypeConversion.TryConvert(ref value, out string strValue) ? strValue : value.ToString();
label.binding = new LabelBinding <TValue>(label, root, path);
}
public NullElement(BindingContextElement root, IProperty property, PropertyPath path)
{
m_PotentialTypes = new List <Type> {
typeof(Null)
};
binding = this;
m_Root = root;
m_Path = path;
name = m_Path.ToString();
TypeUtility.GetAllConstructableTypes <T>(m_PotentialTypes);
if (typeof(T).IsArray)
{
Resources.Templates.NullStringField.Clone(this);
this.Q <Label>().text = GuiFactory.GetDisplayName(property);
var button = this.Q <Button>();
button.text = $"Null ({GetTypeName(typeof(T))})";
button.clickable.clicked += ReloadWithArrayType;
if (property.IsReadOnly)
{
button.SetEnabledSmart(false);
}
return;
}
if (m_PotentialTypes.Count == 2)
{
Resources.Templates.NullStringField.Clone(this);
this.Q <Label>().text = GuiFactory.GetDisplayName(property);
var button = this.Q <Button>();
button.text = $"Null ({GetTypeName(typeof(T))})";
button.clickable.clicked += ReloadWithFirstType;
if (property.IsReadOnly)
{
button.SetEnabledSmart(false);
}
return;
}
var typeSelector = new PopupField <Type>(
GuiFactory.GetDisplayName(property),
m_PotentialTypes,
typeof(Null),
GetTypeName,
GetTypeName);
typeSelector.RegisterValueChangedCallback(OnCreateItem);
if (property.IsReadOnly)
{
typeSelector.pickingMode = PickingMode.Ignore;
typeSelector.Q(className: UssClasses.Unity.BasePopupFieldInput).SetEnabledSmart(false);
}
Add(typeSelector);
}
internal static void SetCallbacks <TValue>(
ref TValue value,
PropertyPath path,
BindingContextElement root,
BindableElement element)
{
if (!TypeConversion.TryConvert(ref value, out Texture2D texture))
{
return;
}
element.style.backgroundImage = texture;
element.binding = new TextureBinding <TValue>(element, root, path);
}
internal static void SetCallbacks <TFieldType, TValue>(
ref TValue value,
PropertyPath path,
BindingContextElement root,
BaseField <TFieldType> field)
{
if (TypeConversion.TryConvert(ref value, out TFieldType fieldValue))
{
field.SetValueWithoutNotify(fieldValue);
field.binding = new Binding <TFieldType, TValue>(field, root, path);
}
field.RegisterCallback <ChangeEvent <TFieldType>, PropertyPath>(ValueChanged <TFieldType, TValue>, path);
}
internal static void SetCallbacks <TValue>(
ref TValue value,
PropertyPath path,
BindingContextElement root,
BindingContextElement 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);
};
}
public InspectorContext(BindingContextElement root)
{
Root = root;
m_ParentStack = new Stack <VisualElement>();
m_References = new InspectedReferences();
}
void OnValueChanged(BindingContextElement element, PropertyPath path)
{
DictionaryElement.SetAtKey(m_Key.GetTarget <KeyContainer>().Key, m_Value.GetTarget <ValueContainer>().Value);
}
void IContextElement.SetContext(BindingContextElement root, PropertyPath path)
{
Root = root;
Path = path;
OnContextReady();
}
internal ChangeContext(BindingContextElement binding)
{
m_Binding = binding;
}
public TextureBinding(BindableElement element, BindingContextElement root, PropertyPath path) : base(element, root, path)
{
}
static void RegisterBindings(IInspector inspector, PropertyPath pathToValue, VisualElement toBind, BindingContextElement root)
{
var fullPath = new PropertyPath();
fullPath.PushPath(inspector.PropertyPath);
fullPath.PushPath(pathToValue);
root.RegisterBindings(fullPath, toBind);
}
public PropertyBinding(BindingContextElement element, BindingContextElement root, PropertyPath path) : base(element, root, path)
{
}
static void TrySetCallbacksThroughReflection <TValue>(VisualElement element, ref TValue value, PropertyPath path, BindingContextElement root)
{
var type = element.GetType();
var baseFieldType = GetBaseFieldType(type);
if (null == baseFieldType)
{
return;
}
var fieldType = baseFieldType.GenericTypeArguments[0];
var key = new TypePairKey(fieldType, typeof(TValue));
if (!s_RegistrationMethods.TryGetValue(key, out var method))
{
s_RegistrationMethods[key] = method = BaseBinderMethod.MakeGenericMethod(fieldType, typeof(TValue));
}
method.Invoke(null, new object[] { value, element, path, root });
}
public static void Bind <TValue>(VisualElement element, ref TValue value, PropertyPath path, BindingContextElement root)
{
switch (element)
{
case BindingContextElement propertyElement:
GuiFactory.SetCallbacks(ref value, path, root, propertyElement);
break;
case BaseField <TValue> field:
GuiFactory.SetCallbacks(ref value, path, root, field);
break;
case Label label:
GuiFactory.SetCallbacks(ref value, path, root, label);
break;
case BindableElement bindable when element.GetType() == typeof(BindableElement) && TypeConversion.TryConvert(ref value, out Texture2D _):
GuiFactory.SetCallbacks(ref value, path, root, bindable);
break;
default:
// Use reflection to figure out if we can map it.
TrySetCallbacksThroughReflection(element, ref value, path, root);
break;
}
}
public override void Reset()
{
base.Reset();
Binding = null;
Element = null;
}
public Binding(BaseField <TFieldType> element, BindingContextElement root, PropertyPath path) : base(element, root, path)
{
}
protected UIBinding(TElement element, BindingContextElement root, PropertyPath path)
{
Element = element;
Root = root;
Path = path;
}
static void SetCallbacks <TFieldType, TValue>(ref TValue value, BaseField <TFieldType> field, PropertyPath path, BindingContextElement root)
{
GuiFactory.SetCallbacks(ref value, path, root, field);
}
public InspectorVisitor(BindingContextElement root)
{
Context = new InspectorContext(root);
}
public LabelBinding(Label element, BindingContextElement root, PropertyPath path) : base(element, root, path)
{
}
