public CircularReferenceElement(PropertyElement 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 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; } }
protected override void VisitPath <TContainer, TValue>(Property <TContainer, TValue> property, ref TContainer container, ref TValue value) { switch (Element) { case BaseField <TValue> field: GuiFactory.SetCallbacks(ref value, Path, Root, field); break; case Label label when TypeConversion.TryConvert(value, out string _): GuiFactory.SetCallbacks(ref value, Path, Root, label); break; case BindableElement bindable when TypeConversion.TryConvert(value, out Texture2D _): GuiFactory.SetCallbacks(ref value, Path, Root, bindable); break; default: // Use reflection to figure out if we can map it. TrySetCallbacksThroughReflection(ref value); break; } }
protected override void VisitSet <TContainer, TSet, TValue>(Property <TContainer, TSet> property, ref TContainer container, ref TSet value) { AddToPath(property); try { var path = GetCurrentPath(); using (var references = VisitorContext.MakeVisitedReferencesScope(this, ref value, path)) { if (references.VisitedOnCurrentBranch) { VisitorContext.Parent.Add(new CircularReferenceElement <TSet>(VisitorContext.Root, property, value, path, references.GetReferencePath())); return; } var element = GuiFactory.SetFoldout <TContainer, TSet, TValue>(property, path, VisitorContext); VisitorContext.Parent.contentContainer.Add(element); using (VisitorContext.MakeParentScope(element)) { element.Reload(property); } } } finally { RemoveFromPath(property); } }
bool VisitEnum <TContainer, TValue>( InspectorContext inspectorContext, IProperty <TContainer> property, ref TValue value, PropertyPath path, bool isWrapper) { var inspector = GetCustomInspector(property, ref value, path, isWrapper); if (null == inspector) { if (RuntimeTypeInfoCache <TValue> .IsEnumFlags) { GuiFactory.FlagsField(property, ref value, path, inspectorContext); } else { GuiFactory.EnumField(property, ref value, path, inspectorContext); } } else { using (inspectorContext.MakeIgnoreInspectorScope()) { var customInspector = new CustomInspectorElement(path, inspector, inspectorContext.Root); inspectorContext.Parent.contentContainer.Add(customInspector); } } return(true); }
public InspectorContext( PropertyElement 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>(); }
public NullElement(PropertyElement root, IProperty property, PropertyPath path) { m_PotentialTypes = new List <Type> { typeof(Null) }; binding = this; m_Root = root; m_Path = path; name = m_Path.ToString(); TypeConstruction.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); }
void IListPropertyVisitor.Visit <TContainer, TList, TElement>( Property <TContainer, TList> property, ref TContainer container, ref TList list) { var path = Context.CopyCurrentPath(); var foldout = GuiFactory.Foldout <TList, TElement>(property, path, Context); using (Context.MakeParentScope(foldout)) foldout.Reload(property); }
public void Visit <TContainer, TDictionary, TKey, TValue>( Property <TContainer, TDictionary> property, ref TContainer container, ref TDictionary dictionary) where TDictionary : IDictionary <TKey, TValue> { var path = Context.CopyCurrentPath(); var foldout = GuiFactory.Foldout <TDictionary, TKey, TValue>(property, path, Context); using (Context.MakeParentScope(foldout)) foldout.Reload(property); }
void ISetPropertyVisitor.Visit <TContainer, TSet, TValue>( Property <TContainer, TSet> property, ref TContainer container, ref TSet set) { var path = Context.CopyCurrentPath(); var foldout = GuiFactory.SetFoldout <TSet, TValue>(property, path, Context); using (Context.MakeParentScope(foldout)) foldout.Reload(property); }
void ICollectionPropertyVisitor.Visit <TContainer, TCollection, TElement>( Property <TContainer, TCollection> property, ref TContainer container, ref TCollection collection) { var path = Context.CopyCurrentPath(); var foldout = GuiFactory.Foldout <TCollection>(property, path, Context); using (Context.MakeParentScope(foldout)) PropertyContainer.TryAccept(this, ref collection); }
void DefaultSetVisit <TSet, TValue>(IProperty property, ref TSet value, PropertyPath path) where TSet : ISet <TValue> { var element = GuiFactory.SetFoldout <TSet, TValue>(property, path, VisitorContext); VisitorContext.Parent.contentContainer.Add(element); using (VisitorContext.MakeParentScope(element)) { element.Reload(property); } }
void DefaultDictionaryVisit <TDictionary, TKey, TValue>( IProperty property, ref TDictionary value, PropertyPath path) where TDictionary : IDictionary <TKey, TValue> { var element = GuiFactory.Foldout <TDictionary, TKey, TValue>(property, path, VisitorContext); VisitorContext.Parent.contentContainer.Add(element); using (VisitorContext.MakeParentScope(element)) { element.Reload(property); } }
void DefaultListVisit <TList, TElement>( IProperty property, ref TList value, PropertyPath path) where TList : IList <TElement> { var element = GuiFactory.Foldout <TList, TElement>(property, path, VisitorContext); VisitorContext.Parent.contentContainer.Add(element); using (VisitorContext.MakeParentScope(element)) { element.Reload(property); } }
public void RecurseProperty <TValue>(ref TValue value, IProperty property, PropertyPath path) { if (path.PartsCount > 0) { var foldout = GuiFactory.Foldout <TValue>(property, path, VisitorContext); using (VisitorContext.MakeParentScope(foldout)) { property.Visit(this, ref value); } } else { property.Visit(this, ref value); } }
public void DefaultPropertyVisit <TValue>( IProperty property, ref TValue value, PropertyPath path) { if (path.PartsCount > 0) { if (string.IsNullOrEmpty(GuiFactory.GetDisplayName(property))) { property.Visit(this, ref value); } else { var foldout = GuiFactory.Foldout <TValue>(property, path, VisitorContext); using (VisitorContext.MakeParentScope(foldout)) property.Visit(this, ref value); } } else { property.Visit(this, ref value); } }
void IPropertyVisitor.Visit <TContainer, TValue>( Property <TContainer, TValue> property, ref TContainer container) { if (IsExcluded(property)) { return; } var value = property.GetValue(ref container); var isWrapper = container is PropertyWrapper <TValue>; Context.IsRootObject = isWrapper; // Null values if (RuntimeTypeInfoCache <TValue> .CanBeNull && ShouldBeTreatedAsNull(property, ref container, ref value) && ShouldStayNull(property, ref container, ref value)) { using (Context.MakePathScope(property)) { if (VisitNull(Context, property, ref value, Context.CopyCurrentPath())) { return; } } } foreach (var adapter in m_AdapterOverrides) { if (!(adapter is IInspectorVisit <TValue> partiallyTyped)) { continue; } using (Context.MakePathScope(property)) { if (partiallyTyped.Visit(Context, property, ref value, Context.CopyCurrentPath())) { return; } } } // Primitives if (this is IInspectorVisit <TValue> typed) { using (Context.MakePathScope(property)) { if (typed.Visit(Context, property, ref value, Context.CopyCurrentPath())) { return; } } } // UnityEngine.Object if (this is IInspectorContravariantVisit <TValue> contravariant) { using (Context.MakePathScope(property)) { if (contravariant.Visit(Context, property, value, Context.CopyCurrentPath())) { return; } } } // Enums if (RuntimeTypeInfoCache <TValue> .IsEnum) { using (Context.MakePathScope(property)) { if (VisitEnum(Context, property, ref value, Context.CopyCurrentPath(), isWrapper)) { return; } } } try { // Regular visit if (!isWrapper) { Context.AddToPath(property); } var path = Context.CopyCurrentPath(); using (var references = Context.MakeVisitedReferencesScope(ref value, path)) { if (references.VisitedOnCurrentBranch) { Context.Parent.Add(new CircularReferenceElement <TValue>(Context.Root, property, value, path, references.GetReferencePath())); return; } var inspector = GetCustomInspector(property, ref value, path, isWrapper); if (null != inspector) { var customInspector = new CustomInspectorElement(path, inspector, Context.Root); Context.Parent.contentContainer.Add(customInspector); return; } if (path.PartsCount > 0) { if (string.IsNullOrEmpty(GuiFactory.GetDisplayName(property))) { PropertyContainer.TryAccept(this, ref value); } else { // Give a chance for different property bags to handle themselves if (PropertyBagStore.TryGetPropertyBagForValue(ref value, out var valuePropertyBag)) { switch (valuePropertyBag) { case IDictionaryPropertyAccept <TValue> accept: accept.Accept(this, property, ref container, ref value); break; case IListPropertyAccept <TValue> accept: accept.Accept(this, property, ref container, ref value); break; case ISetPropertyAccept <TValue> accept: accept.Accept(this, property, ref container, ref value); break; case ICollectionPropertyAccept <TValue> accept: accept.Accept(this, property, ref container, ref value); break; default: var foldout = GuiFactory.Foldout <TValue>(property, path, Context); using (Context.MakeParentScope(foldout)) PropertyContainer.TryAccept(this, ref value); break; } } } } else { PropertyContainer.TryAccept(this, ref value); } } } finally { if (!isWrapper) { Context.RemoveFromPath(property); } } }
void SetCallbacks <TFieldType, TValue>(ref TValue value, BaseField <TFieldType> field) { GuiFactory.SetCallbacks(ref value, Path, Root, field); }
static void SetCallbacks <TFieldType, TValue>(ref TValue value, BaseField <TFieldType> field, PropertyPath path, BindingContextElement root) { GuiFactory.SetCallbacks(ref value, path, root, field); }