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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Xamarin.PropertyEditing.Drawing;
namespace Xamarin.PropertyEditing.Tests
{
public class MockResourceProvider
: IResourceProvider
{
public bool CanCreateResources => true;
public Task<ResourceCreateError> CheckNameErrorsAsync (object target, ResourceSource source, string name)
{
ResourceCreateError error = null;
if (this.resources[source].Any (r => r.Name == name)) {
error = new ResourceCreateError ("Name in use", isWarning: false);
} else {
var order = new List<ResourceSourceType> {
ResourceSourceType.Document,
ResourceSourceType.ResourceDictionary,
ResourceSourceType.Application,
ResourceSourceType.System,
};
// Simplistic example of hierarchy override checking
for (int i = order.IndexOf (source.Type)+1; i < order.Count; i++) {
if (this.resources.Where (ig => ig.Key.Type == order[i]).SelectMany (ig => ig).Any (r => r.Name == name)) {
error = new ResourceCreateError ("Resource would override another resource", isWarning: true);
break;
}
}
}
return Task.FromResult (error);
}
public Task<Resource> CreateResourceAsync<T> (ResourceSource source, string name, T value)
{
var r = new Resource<T> (source, name, value);
((ObservableLookup<ResourceSource, Resource>)this.resources).Add (source, r);
return Task.FromResult<Resource> (r);
}
public Task<IReadOnlyList<Resource>> GetResourcesAsync (object target, IPropertyInfo property, CancellationToken cancelToken)
{
return Task.FromResult<IReadOnlyList<Resource>> (this.resources.SelectMany (g => g)
.Where (r => property.Type.IsAssignableFrom (r.GetType().GetGenericArguments()[0]) && (!(r.Source is ObjectResourceSource ors) || ReferenceEquals (target, ors.Target)))
.ToList());
}
public Task<IReadOnlyList<ResourceSource>> GetResourceSourcesAsync (object target, IPropertyInfo property)
{
return Task.FromResult<IReadOnlyList<ResourceSource>> (new[] { SystemResourcesSource, ApplicationResourcesSource, Resources, Window, new ObjectResourceSource (target, target.GetType ().Name, ResourceSourceType.Document) });
}
public Task<string> SuggestResourceNameAsync (IReadOnlyCollection<object> targets, IPropertyInfo property)
{
return SuggestResourceNameAsync (targets, property.RealType);
}
public Task<string> SuggestResourceNameAsync (IReadOnlyCollection<object> targets, ITypeInfo resourceType)
{
int i = 1;
string key;
do {
key = resourceType.Name + i++;
} while (this.resources[ApplicationResourcesSource].Any (r => r.Name == key));
return Task.FromResult (key);
}
private class ObjectResourceSource
: ResourceSource
{
public ObjectResourceSource (object target, string name, ResourceSourceType type)
: base (name, type)
{
if (target == null)
throw new ArgumentNullException (nameof(target));
this.target = target;
}
public object Target => this.target;
public override int GetHashCode ()
{
int hashCode = base.GetHashCode ();
unchecked {
hashCode = (hashCode * 397) ^ this.target.GetHashCode();
}
return hashCode;
}
public override bool Equals (ResourceSource other)
{
if (!base.Equals (other))
return false;
return (other is ObjectResourceSource ors && ReferenceEquals (ors.target, this.target));
}
private readonly object target;
}
internal static readonly ResourceSource SystemResourcesSource = new ResourceSource ("System Resources", ResourceSourceType.System);
internal static readonly ResourceSource ApplicationResourcesSource = new ResourceSource ("App resources", ResourceSourceType.Application);
private static readonly ResourceSource Resources = new ResourceSource ("Resources.xaml", ResourceSourceType.ResourceDictionary);
private static readonly ResourceSource Window = new ResourceSource ("Window: <no name>", ResourceSourceType.Document);
private readonly ILookup<ResourceSource, Resource> resources = new ObservableLookup<ResourceSource, Resource> {
new ObservableGrouping<ResourceSource, Resource> (SystemResourcesSource) {
new Resource<CommonSolidBrush> (SystemResourcesSource, "ControlTextBrush", new CommonSolidBrush (0, 0, 0)),
new Resource<CommonSolidBrush> (SystemResourcesSource, "HighlightBrush", new CommonSolidBrush (51, 153, 255)),
new Resource<CommonSolidBrush> (SystemResourcesSource, "TransparentBrush", new CommonSolidBrush (0, 0, 0, 0)),
new Resource<CommonColor> (SystemResourcesSource, "ControlTextColor", new CommonColor (0, 0, 0)),
new Resource<CommonColor> (SystemResourcesSource, "HighlightColor", new CommonColor (51, 153, 255))
},
new ObservableGrouping<ResourceSource, Resource> (ApplicationResourcesSource) {
new Resource<CommonSolidBrush> (SystemResourcesSource, "CustomHighlightBrush", new CommonSolidBrush (255, 165, 0)),
}
};
}
}
|
