上传代码；

chr

2026-04-05 fe750b791d5b517cc4e9bc8e99a9a75139a0cfba

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
 
namespace OpenTap
{
    class MixinBuilderUiTypeData : ITypeData
    {
        readonly ImmutableArray<IMemberData> members;
 
        class WrappedMemberInfo : IMemberData
        {
            public override string ToString() => Name;
            readonly Attribute[] attributes;
            readonly object src;
            readonly IMemberData member;
            readonly object[] memberAttributes;
 
            public WrappedMemberInfo(object src, IMemberData member, params Attribute[] attributes)
            {
                this.attributes = attributes;
                this.src = src;
                this.member = member;
                Name = GetTransformedName(member);
 
                memberAttributes = member.Attributes.Select(TransformAttribute).ToArray();
            }
            
            class Enabled2 : EnabledIfAttribute
            {
                readonly EnabledIfAttribute wrapped;
                readonly object source;
 
                public Enabled2(object source, EnabledIfAttribute wrapped, string propertyName, params object[] propertyValues) : base(propertyName, propertyValues)
                {
                    this.wrapped = wrapped;
                    this.source = source;
                }
 
                internal override (bool enabled, bool hidden) IsEnabled(object instance, ITypeData instanceType, out IMemberData dependentProp)
                {
                    return wrapped.IsEnabled(source, TypeData.GetTypeData(source), out dependentProp);
                }
            }
 
            object TransformAttribute(object obj)
            {
                if (obj is EnabledIfAttribute e)
                {
                    return new Enabled2(src, e, e.PropertyName.Replace(member.Name, Name), e.Values);
                }
                if (obj is AvailableValuesAttribute av)
                {
                    return new AvailableValuesAttribute(member.DeclaringType.Name + "." + av.PropertyName);
                }
                return obj;
            }
            
            public IEnumerable<object> Attributes => attributes.Concat(memberAttributes);
            public string Name { get; }
        
            public ITypeData DeclaringType => member.DeclaringType;
            public ITypeData TypeDescriptor => member.TypeDescriptor;
            public bool Writable => member.Writable;
            public bool Readable => member.Readable;
            public void SetValue(object owner, object value) => member.SetValue(src, value);
            public object GetValue(object owner) => member.GetValue(src);
        }
        
        public MixinBuilderUiTypeData(MixinBuilderUi builder)
        {
            var members = new List<IMemberData>();
            foreach (var item in builder.Items)
            {
                foreach (var member in TypeData.GetTypeData(item).GetMembers())
                {
                    var em = new EnabledIfAttribute(nameof(MixinBuilderUi.SelectedItem), item) {HideIfDisabled = true};
                    var newMember = new WrappedMemberInfo(item, member, em);
                    members.Add(newMember);
                }
            }
 
            this.members = members.ToImmutableArray();
        }
 
        public IEnumerable<object> Attributes => BaseType.Attributes;
        public string Name => "Mixin";
        public ITypeData BaseType { get; } = TypeData.FromType(typeof(MixinBuilderUi));
        public IEnumerable<IMemberData> GetMembers() => members.Concat(BaseType.GetMembers());
 
        public IMemberData GetMember(string name) => members.FirstOrDefault(x => x.Name == name) ?? BaseType.GetMember(name);
        
        public object CreateInstance(object[] arguments) => throw new NotSupportedException();
        
 
        public bool CanCreateInstance => false;
        
        internal static string GetTransformedName(IMemberData member)
        {
            return member.DeclaringType.Name + "." + member.Name;
        }
    }
}