Esempio n. 1
0
        private ITreeStringNode addReadonlyNodeToTree(IProperty property, ITreeStringNode parent)
        {
            IInspectorPropertyEditor editor = new StringPropertyEditor(_factory, false, _actions, _model);
            ITreeStringNode          node   = new InspectorTreeNode(property, editor, _font);

            addToTree(node, parent);
            if (property.Object is INotifyPropertyChanged propertyChanged)
            {
                PropertyChangedEventHandler onPropertyChanged = (sender, e) =>
                {
                    if (e.PropertyName != property.Name)
                    {
                        return;
                    }
                    bool isExpanded = _treeView.IsCollapsed(node) == false;
                    if (isExpanded)
                    {
                        _treeView.Collapse(node);
                    }
                    ObjectTypeDescriptor.RefreshChildrenProperties(property);
                    node.TreeNode.Children.Clear();
                    addChildrenToTree(node, property);

                    //todo: we'd like to enable expanding a node that was previously expanded however there's a bug that needs to be investigated before that, to reproduce:
                    //In the demo game, show the inspector for the character and expand its current room. Then move to another room.
                    //For some reason this results in endless boundin box/matrix changes until stack overflow is reached.
                    //if (isExpanded)
                    //  _treeView.Expand(node);
                };
                propertyChanged.PropertyChanged += onPropertyChanged;
                _cleanup.Add(() => propertyChanged.PropertyChanged -= onPropertyChanged);
            }
            return(node);
        }
Esempio n. 2
0
        public Dictionary <InspectorCategory, List <IProperty> > GetProperties()
        {
            var parameters = _method.GetParameters();

            if (parameters.Length == 0)
            {
                return(_props);
            }

            InspectorCategory cat = new InspectorCategory("General");

            _props[cat] = new List <IProperty>();
            foreach (var parameter in parameters)
            {
                if (_hideProperties.Contains(parameter.Name))
                {
                    continue;
                }

                _overrideDefaults.TryGetValue(parameter.Name, out var overrideDefault);
                var param = new MethodParam(parameter, null, overrideDefault);
                _props[cat].Add(param);
                ObjectTypeDescriptor.RefreshChildrenProperties(param);
            }
            return(_props);
        }
 public Dictionary <InspectorCategory, List <IProperty> > GetProperties()
 {
     foreach (var component in _entity)
     {
         InspectorCategory cat = new InspectorCategory(component.Name.Humanize());
         ObjectTypeDescriptor.AddProperties(cat, component, _props);
     }
     addEntityProps(_entity);
     return(_props);
 }
        private void addEntityProps(IEntity entity)
        {
            InspectorCategory cat = new InspectorCategory("Hotspot");
            var prop = entity.GetType().GetProperty(nameof(IEntity.DisplayName));
            InspectorProperty property = ObjectTypeDescriptor.AddProperty(entity, null, null, prop, ref cat);

            if (property == null)
            {
                return;
            }
            _props.GetOrAdd(cat, () => new List <IProperty>()).Add(property);
        }