static object RecurseDictionaries(ResourceDictionary dictionary, string name)
{
if (dictionary.Contains(name)) return dictionary[name];
return dictionary.MergedDictionaries
.Select(child => RecurseDictionaries(child, name))
.FirstOrDefault(candidate => candidate != null);
}
private static void AdjustResourceColor(ResourceDictionary resources, string sourceKey, string targetKey, float factor)
{
if (!resources.Contains(sourceKey))
return;
var sourceColor = (Color)resources[sourceKey];
var targetColor = sourceColor.ToBrightened(factor);
if (resources.Contains(targetKey))
{
resources[targetKey] = targetColor;
}
else
{
resources.Add(targetKey, targetColor);
}
}
private void ChangeRd(ResourceDictionary rd, string newKey, object newValue)
{
if (!rd.Contains(newKey))
{
rd.Add(newKey, newValue);
SaveChange();
}
}
private static DataTemplate TryFindDataTemplate(ResourceDictionary resourceDictionary, string contentTypeName)
{
DataTemplate dataTemplate = null;
if (resourceDictionary.Contains(contentTypeName))
{
dataTemplate = resourceDictionary[contentTypeName] as DataTemplate;
}
return dataTemplate;
}
private static bool TryGetValue(ResourceDictionary dict, string key, out object val)
{
val = null;
if (!dict.Contains(key))
{
return false;
}
val = dict[key];
return true;
}
private static void ApplyResourceDictionary(ResourceDictionary newRd, ResourceDictionary oldRd)
{
foreach (DictionaryEntry r in newRd)
{
if (oldRd.Contains(r.Key))
oldRd.Remove(r.Key);
oldRd.Add(r.Key, r.Value);
}
}
private object GetValueFromDictionary(string key, ResourceDictionary dictionary)
{
if (dictionary.Contains(key))
{
return dictionary[key];
}
foreach (var resourceDictionary in dictionary.MergedDictionaries)
{
var result = GetValueFromDictionary(key, resourceDictionary);
if (result != null) return result;
}
return null;
}
public BitmapSource GetIcon(string pResourceName, string pModule)
{
var resourceDictionaryUri = new Uri(
string.Format("/{0};component/{1}/Images.xaml", GetType().Assembly.GetName().Name, pModule),
UriKind.RelativeOrAbsolute);
var resourceDictionary = new ResourceDictionary { Source = resourceDictionaryUri };
if (!resourceDictionary.Contains(pResourceName))
{
throw new ArgumentException(string.Format("the resource {0} could not be found on resource dictionary {1}", pResourceName, resourceDictionaryUri));
}
var resource = resourceDictionary[pResourceName];
return resource as BitmapSource;
}
public object this[object key] {
get {
if (!(key is string || key is Type))
{
throw new ArgumentException("Key must be a string or Type");
}
// check our cache
if (managedDict != null && managedDict.ContainsKey(key))
{
return(managedDict[key]);
}
// now iterate over the merged dictionaries
PresentationFrameworkCollection <ResourceDictionary> col = MergedDictionaries;
for (int i = col.Count - 1; i >= 0; i--)
{
ResourceDictionary rd = col[i];
if (rd.Contains(key))
{
return(rd[key]);
}
}
return(null);
}
set {
// this setter only permits string
// keys. since unmanaged needs to
// access them we send it along to
// unmanaged as well as update our
// cache.
var str_key = ToStringKey(key);
using (var val = Value.FromObject(value, true)) {
var v = val;
if (NativeMethods.resource_dictionary_set(native, str_key, ref v))
{
if (managedDict == null)
{
managedDict = new Dictionary <object, object> ();
}
managedDict.Add(str_key, value);
}
}
}
}
private static void ChangeTheme(ResourceDictionary resources, Tuple<Theme, Accent> oldThemeInfo, Accent accent, Theme newTheme)
{
if (oldThemeInfo != null)
{
var oldAccent = oldThemeInfo.Item2;
if (oldAccent != null && oldAccent.Name != accent.Name)
{
var accentResource = resources.MergedDictionaries.FirstOrDefault(d => d.Source == oldAccent.Resources.Source);
if (accentResource != null) {
var ok = resources.MergedDictionaries.Remove(accentResource);
// really need this???
foreach (DictionaryEntry r in accentResource)
{
if (resources.Contains(r.Key))
resources.Remove(r.Key);
}
resources.MergedDictionaries.Add(accent.Resources);
}
}
var oldTheme = oldThemeInfo.Item1;
if (oldTheme != null && oldTheme != newTheme)
{
var oldThemeResource = (oldTheme == Theme.Light) ? LightResource : DarkResource;
var md = resources.MergedDictionaries.FirstOrDefault(d => d.Source == oldThemeResource.Source);
if (md != null)
{
var ok = resources.MergedDictionaries.Remove(md);
var newThemeResource = (newTheme == Theme.Light) ? LightResource : DarkResource;
// really need this???
foreach (DictionaryEntry r in oldThemeResource)
{
if (resources.Contains(r.Key))
resources.Remove(r.Key);
}
resources.MergedDictionaries.Add(newThemeResource);
}
}
}
else
{
ChangeTheme(resources, accent, newTheme);
}
}
static Transitions() {
var dict = new ResourceDictionary {
Source = typeof(Transitions).Assembly.ToPackUri("Mpcr.Core.Wpf.Transitions/Primitives/TransitionStoryboards.xaml")
};
foreach (var prop in typeof(Transitions).GetStaticProperties(true, true)) {
var propKey = "@{0}".Substitute(prop.Name);
Assumption.IsTrue(dict.Contains(propKey), "Standard transition '{0}' is not defined", prop.Name);
var transition = dict[propKey] as Transition;
Assumption.IsA(transition, prop.PropertyType, "Standard transition '{0}' is not of the expected type '{1}'", prop.Name, prop.PropertyType);
if (transition is StoryboardTransition2D) {
var stb = (StoryboardTransition2D)transition;
if (stb.NewContentStyle != null) stb.NewContentStyle.Seal();
if (stb.OldContentStyle != null) stb.OldContentStyle.Seal();
}
transition.Freeze();
prop.SetValue(null, transition, null);
}
}
public static void BeginElementStoryboard(ResourceDictionary resources, UIElement target, string subTargetName, string StoryboardName, PropertyPath propertyPath, EventHandler completedHandler)
{
if (!resources.Contains(StoryboardName))
{
throw new ArgumentException(string.Format("Resource with name {0} not found!", StoryboardName));
}
if (!string.IsNullOrEmpty(subTargetName))
{
target = (target as FrameworkElement).FindName(subTargetName) as UIElement;
}
Storyboard sbAlpha = resources[StoryboardName] as Storyboard;
Storyboard sb = CloneStoryboard(sbAlpha);
Storyboard.SetTarget(sb, target);
Storyboard.SetTargetProperty(sb, propertyPath);
if (completedHandler != null)
{
sb.Completed += completedHandler;
}
sb.Begin();
}
// Token: 0x06000865 RID: 2149 RVA: 0x0001B4E8 File Offset: 0x000196E8
private ResourceDictionary FindTheResourceDictionary(IServiceProvider serviceProvider, bool isDeferredContentSearch)
{
IXamlSchemaContextProvider xamlSchemaContextProvider = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (xamlSchemaContextProvider == null)
{
throw new InvalidOperationException(SR.Get("MarkupExtensionNoContext", new object[]
{
base.GetType().Name,
"IXamlSchemaContextProvider"
}));
}
IAmbientProvider ambientProvider = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (ambientProvider == null)
{
throw new InvalidOperationException(SR.Get("MarkupExtensionNoContext", new object[]
{
base.GetType().Name,
"IAmbientProvider"
}));
}
XamlSchemaContext schemaContext = xamlSchemaContextProvider.SchemaContext;
XamlType xamlType = schemaContext.GetXamlType(typeof(FrameworkElement));
XamlType xamlType2 = schemaContext.GetXamlType(typeof(Style));
XamlType xamlType3 = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlType xamlType4 = schemaContext.GetXamlType(typeof(Application));
XamlType xamlType5 = schemaContext.GetXamlType(typeof(FrameworkContentElement));
XamlMember member = xamlType5.GetMember("Resources");
XamlMember member2 = xamlType.GetMember("Resources");
XamlMember member3 = xamlType2.GetMember("Resources");
XamlMember member4 = xamlType2.GetMember("BasedOn");
XamlMember member5 = xamlType3.GetMember("Resources");
XamlMember member6 = xamlType4.GetMember("Resources");
XamlType[] types = new XamlType[]
{
schemaContext.GetXamlType(typeof(ResourceDictionary))
};
IEnumerable <AmbientPropertyValue> allAmbientValues = ambientProvider.GetAllAmbientValues(null, isDeferredContentSearch, types, new XamlMember[]
{
member,
member2,
member3,
member4,
member5,
member6
});
List <AmbientPropertyValue> list = allAmbientValues as List <AmbientPropertyValue>;
for (int i = 0; i < list.Count; i++)
{
AmbientPropertyValue ambientPropertyValue = list[i];
if (ambientPropertyValue.Value is ResourceDictionary)
{
ResourceDictionary resourceDictionary = (ResourceDictionary)ambientPropertyValue.Value;
if (resourceDictionary.Contains(this.ResourceKey))
{
return(resourceDictionary);
}
}
if (ambientPropertyValue.Value is Style)
{
Style style = (Style)ambientPropertyValue.Value;
ResourceDictionary resourceDictionary2 = style.FindResourceDictionary(this.ResourceKey);
if (resourceDictionary2 != null)
{
return(resourceDictionary2);
}
}
}
return(null);
}
public void InterfaceTest ()
{
IDictionary<object, object> d = new ResourceDictionary ();
Assert.Throws<ArgumentException> (delegate {
d.Add (new KeyValuePair<object, object> (new object (), new object ()));
}, "#1");
d.Add (new KeyValuePair<object, object> ("bob", new object ()));
Assert.Throws<NotImplementedException> (delegate {
int a = d.Count;
GC.KeepAlive (a);
}, "#2");
Assert.AreEqual (1, ((ResourceDictionary) d).Count, "#3");
Assert.Throws<ArgumentException> (delegate {
d.Add (new object (), new object ());
}, "#4");
d.Add ("str", new object ());
Assert.AreEqual (2, ((ResourceDictionary) d).Count, "#5");
Assert.Throws<ArgumentException> (delegate {
d.ContainsKey (new object ());
}, "#6");
Assert.IsTrue (d.Contains (new KeyValuePair<object, object> ("str", new object ())), "#7");
d.Clear ();
Assert.AreEqual (0, ((ResourceDictionary) d).Count, "#8");
// this doesn't throw in SL4 for any runtime version
d.GetEnumerator ();
Assert.Throws<NotImplementedException> (delegate {
var v = d.Keys;
GC.KeepAlive (v);
}, "#10");
Assert.Throws<NotImplementedException> (delegate {
var v = d.Values;
GC.KeepAlive (v);
}, "#11");
Assert.IsFalse (d.IsReadOnly, "#12");
Assert.Throws<NotImplementedException> (delegate {
d.CopyTo (new KeyValuePair<object, object> [10], 0);
}, "#13");
}
public void Contains_TypeAndStringInResourceDictionary_TypeSecond()
{
var rd = new ResourceDictionary();
rd.Add("System.Windows.Controls.Button", "System.Windows.Controls.Button");
Assert.IsTrue(rd.Contains("System.Windows.Controls.Button"), "#1");
Assert.IsFalse (rd.Contains(typeof (Button)), "#2");
Assert.Throws<ArgumentException>(() => {
rd.Add(typeof(Button), new Style { TargetType = typeof(Button) });
}, "#3");
}
public void Contains_TypeAndStringInResourceDictionary_TypeFirst()
{
var rd = new ResourceDictionary();
rd.Add(typeof(Button), new Style { TargetType = typeof(Button) });
rd.Add("System.Windows.Controls.Button", "System.Windows.Controls.Button");
Assert.IsTrue(rd.Contains(typeof(Button)), "#1");
Assert.IsTrue(rd.Contains("System.Windows.Controls.Button"), "#2");
rd.Remove(typeof(Button));
Assert.IsFalse(rd.Contains(typeof(Button)), "#3");
Assert.IsTrue(rd.Contains("System.Windows.Controls.Button"), "#4");
}
public void Contains_TypeNameAsKeyStyleWithTargetTypeSet_ReturnsFalse ()
{
ResourceDictionary rd = new ResourceDictionary ();
Style s = new Style () {
TargetType = typeof (Button),
};
rd.Add (typeof (Button), s);
bool contains = rd.Contains ("System.Windows.Controls.Button");
Assert.IsFalse (contains);
}
/// <summary>
/// Creates style forwarders for default styles. This means that all styles found in the theme that are
/// name like Default[CONTROLNAME]Style (i.e. "DefaultButtonStyle") will be used as default style for the
/// control.
/// This method will use the passed resources.
/// </summary>
/// <param name="rootResourceDictionary">The root resource dictionary.</param>
/// <param name="sourceResources">Resource dictionary to read the keys from (thus that contains the default styles).</param>
/// <param name="targetResources">Resource dictionary where the forwarders will be written to.</param>
/// <param name="forceForwarders">if set to <c>true</c>, styles will not be completed but only forwarders are created.</param>
/// <param name="defaultPrefix">The default prefix, uses to determine the styles as base for other styles.</param>
/// <param name="recreateStylesBasedOnTheme">if set to <c>true</c>, the styles will be recreated with BasedOn on the current theme.</param>
/// <exception cref="ArgumentNullException">The <paramref name="rootResourceDictionary" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="sourceResources" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="targetResources" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The <paramref name="defaultPrefix" /> is <c>null</c> or whitespace.</exception>
public static void CreateStyleForwardersForDefaultStyles(ResourceDictionary rootResourceDictionary, ResourceDictionary sourceResources,
ResourceDictionary targetResources, bool forceForwarders, string defaultPrefix = DefaultKeyPrefix, bool recreateStylesBasedOnTheme = false)
{
Argument.IsNotNull("rootResourceDictionary", rootResourceDictionary);
Argument.IsNotNull("sourceResources", sourceResources);
Argument.IsNotNull("targetResources", targetResources);
Argument.IsNotNullOrWhitespace("defaultPrefix", defaultPrefix);
#region If forced, use old mechanism
if (forceForwarders)
{
// Get all keys from this resource dictionary
var keys = (from key in sourceResources.Keys as ICollection<object>
where key is string &&
((string)key).StartsWith(defaultPrefix, StringComparison.Ordinal) &&
((string)key).EndsWith(DefaultKeyPostfix, StringComparison.Ordinal)
select key).ToList();
foreach (string key in keys)
{
var style = sourceResources[key] as Style;
if (style != null)
{
Type targetType = style.TargetType;
if (targetType != null)
{
try
{
#if NET
var styleForwarder = new Style(targetType, style);
#else
var styleForwarder = new Style(targetType);
styleForwarder.BasedOn = style;
#endif
targetResources.Add(targetType, styleForwarder);
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to create style forwarder for '{0}'", key);
}
}
}
}
foreach (var resourceDictionary in sourceResources.MergedDictionaries)
{
CreateStyleForwardersForDefaultStyles(rootResourceDictionary, resourceDictionary, targetResources, forceForwarders, defaultPrefix);
}
return;
}
#endregion
var defaultStyles = FindDefaultStyles(sourceResources, defaultPrefix);
foreach (var defaultStyle in defaultStyles)
{
try
{
var targetType = defaultStyle.TargetType;
if (targetType != null)
{
bool hasSetStyle = false;
var resourceDictionaryDefiningStyle = FindResourceDictionaryDeclaringType(targetResources, targetType);
if (resourceDictionaryDefiningStyle != null)
{
var style = resourceDictionaryDefiningStyle[targetType] as Style;
if (style != null)
{
Log.Debug("Completing the style info for '{0}' with the additional info from the default style definition", targetType);
resourceDictionaryDefiningStyle[targetType] = CompleteStyleWithAdditionalInfo(style, defaultStyle);
hasSetStyle = true;
}
}
if (!hasSetStyle)
{
Log.Debug("Couldn't find style definition for '{0}', creating style forwarder", targetType);
#if NET
var style = new Style(targetType, defaultStyle);
if (!targetResources.Contains(targetType))
{
targetResources.Add(targetType, style);
}
#else
var targetStyle = new Style(targetType);
targetStyle.BasedOn = defaultStyle;
targetResources.Add(targetType, targetStyle);
#endif
}
}
}
catch (Exception)
{
Log.Warning("Failed to complete the style for '{0}'", defaultStyle);
}
}
#if NET
if (recreateStylesBasedOnTheme)
{
RecreateDefaultStylesBasedOnTheme(rootResourceDictionary, targetResources, defaultPrefix);
}
#endif
IsStyleForwardingEnabled = true;
}
/// <summary>
/// Loads the standard activity icons from System.Activities.Presentation.
/// Accepts various forms of input including 'short name' i.e. toolbox display name, and 'Type.FullName' - and tries to fix them automatically.
/// </summary>
private static object ExtractIconResource(string iconOrtypeName)
{
iconsDict = iconsDict ?? new ResourceDictionary
{
Source = new Uri("pack://application:,,,/System.Activities.Presentation;component/themes/icons.xaml")
};
string resourceKey = GetResourceName(iconOrtypeName);
object resource = iconsDict.Contains(resourceKey) ? iconsDict[resourceKey] : null;
if (!(resource is DrawingBrush))
{
resource = iconsDict["GenericLeafActivityIcon"];
}
return resource;
}
/// <summary>
/// Replaces a certain entry anywhere in the parent dictionary and its merged dictionaries
/// </summary>
/// <param name="entryName">The entry to replace</param>
/// <param name="newValue">The new entry value</param>
/// <param name="parentDictionary">The root dictionary to start searching at. Null means using Application.Current.Resources</param>
private static void ReplaceEntry(object entryName, object newValue, ResourceDictionary parentDictionary = null)
{
if (parentDictionary == null)
parentDictionary = Application.Current.Resources;
if (parentDictionary.Contains(entryName))
{
var brush = parentDictionary[entryName] as SolidColorBrush;
if (brush != null && !brush.IsFrozen)
{
var animation = new ColorAnimation
{
From = ((SolidColorBrush)parentDictionary[entryName]).Color,
To = ((SolidColorBrush)newValue).Color,
Duration = new Duration(TimeSpan.FromMilliseconds(300))
};
brush.BeginAnimation(SolidColorBrush.ColorProperty, animation);
}
else
parentDictionary[entryName] = newValue; //Set value normally
}
foreach (var dictionary in parentDictionary.MergedDictionaries)
ReplaceEntry(entryName, newValue, dictionary);
}
private static bool SetItem(ResourceDictionary dictionary, object key, object item)
{
if (dictionary.Contains(key))
return false;
dictionary.Add(key, item);
return true;
}
/// <summary>
/// Создаёт объект языка на основе словаря ресурсов
/// </summary>
/// <param name="rdOneLanguage">Словарь ресурсов на основании которого будет создан новый объект языка</param>
/// <returns></returns>
public OneLanguage CreateOneLanguage(ResourceDictionary rdOneLanguage)
{
OneLanguage lang = new OneLanguage();
lang.ResourceDictionary = rdOneLanguage;
if (rdOneLanguage.Contains("LanguageDisplayName"))
{
lang.Name = (string)rdOneLanguage["LanguageDisplayName"];
}
if (rdOneLanguage.Contains("LanguageCulture"))
{
string cult = (string)rdOneLanguage["LanguageCulture"];
foreach (var c in CultureInfo.GetCultures(CultureTypes.AllCultures))
{
if (c.Name == cult)
{
lang.Culture = new CultureInfo(c.Name);
}
}
}
return lang;
}
/// <summary>
/// Replaces a certain entry anywhere in the parent dictionary and its merged dictionaries
/// </summary>
/// <param name="entryName">The entry to replace</param>
/// <param name="newValue">The new entry value</param>
/// <param name="parentDictionary">The root dictionary to start searching at. Null means using Application.Current.Resources</param>
/// <returns>Weather the value was replaced (true) or not (false)</returns>
private static bool ReplaceEntry(object entryName, object newValue, ResourceDictionary parentDictionary = null)
{
if (parentDictionary == null)
parentDictionary = Application.Current.Resources;
if (parentDictionary.Contains(entryName))
{
parentDictionary[entryName] = newValue;
return true;
}
foreach (var dictionary in parentDictionary.MergedDictionaries)
{
if (ReplaceEntry(entryName, newValue, dictionary))
return true;
}
return false;
}
public void Contains_TypeAsKeyStyleWithTargetTypeSet_ReturnsTrue ()
{
ResourceDictionary rd = new ResourceDictionary ();
Style s = new Style () {
TargetType = typeof (Button),
};
rd.Add (typeof (Button), s);
bool contains = rd.Contains (typeof (Button));
Assert.IsTrue (contains);
}
public void MergedDictionary_Contains ()
{
// 'Contains' looks up the merged dictionaries too
var d1 = new ResourceDictionary ();
var d2 = new ResourceDictionary ();
d2.Add ("string", "string2");
d1.MergedDictionaries.Add (d2);
Assert.IsTrue(d1.Contains ("string"), "#1");
}
/// <summary>
/// Gets a <see cref="FrameworkTemplate"/> based on the specified parameters.
/// </summary>
/// <param name="xmlElement">The xml element to get template xaml from.</param>
/// <param name="parentObject">The <see cref="XamlObject"/> to use as source for resources and contextual information.</param>
/// <returns>A <see cref="FrameworkTemplate"/> based on the specified parameters.</returns>
public static FrameworkTemplate GetFrameworkTemplate(XmlElement xmlElement, XamlObject parentObject)
{
var nav = xmlElement.CreateNavigator();
var ns = new Dictionary<string, string>();
while (true)
{
var nsInScope = nav.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
foreach (var ak in nsInScope)
{
if (!ns.ContainsKey(ak.Key) && ak.Key != "")
ns.Add(ak.Key, ak.Value);
}
if (!nav.MoveToParent())
break;
}
xmlElement = (XmlElement)xmlElement.CloneNode(true);
foreach (var dictentry in ns.ToList())
{
var value = dictentry.Value;
if (value.StartsWith("clr-namespace") && !value.Contains(";assembly=")) {
if (!string.IsNullOrEmpty(parentObject.OwnerDocument.CurrentProjectAssemblyName)) {
value += ";assembly=" + parentObject.OwnerDocument.CurrentProjectAssemblyName;
}
}
xmlElement.SetAttribute("xmlns:" + dictentry.Key, value);
}
var keyAttrib = xmlElement.GetAttribute("Key", XamlConstants.XamlNamespace);
if (string.IsNullOrEmpty(keyAttrib)) {
xmlElement.SetAttribute("Key", XamlConstants.XamlNamespace, "$$temp&&§§%%__");
}
var xaml = xmlElement.OuterXml;
xaml = "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/netfx/2007/xaml/presentation\" xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\">" + xaml + "</ResourceDictionary>";
StringReader stringReader = new StringReader(xaml);
XmlReader xmlReader = XmlReader.Create(stringReader);
var xamlReader = new XamlXmlReader(xmlReader, parentObject.ServiceProvider.SchemaContext);
var seti = new XamlObjectWriterSettings();
var resourceDictionary = new ResourceDictionary();
var obj = parentObject;
while (obj != null)
{
if (obj.Instance is ResourceDictionary)
{
var r = obj.Instance as ResourceDictionary;
foreach (var k in r.Keys)
{
if (!resourceDictionary.Contains(k))
resourceDictionary.Add(k, r[k]);
}
}
else if (obj.Instance is FrameworkElement)
{
var r = ((FrameworkElement)obj.Instance).Resources;
foreach (var k in r.Keys)
{
if (!resourceDictionary.Contains(k))
resourceDictionary.Add(k, r[k]);
}
}
obj = obj.ParentObject;
}
seti.BeforePropertiesHandler = (s, e) =>
{
if (seti.BeforePropertiesHandler != null)
{
var rr = e.Instance as ResourceDictionary;
rr.MergedDictionaries.Add(resourceDictionary);
seti.BeforePropertiesHandler = null;
}
};
var writer = new XamlObjectWriter(parentObject.ServiceProvider.SchemaContext, seti);
XamlServices.Transform(xamlReader, writer);
var result = (ResourceDictionary)writer.Result;
var enr = result.Keys.GetEnumerator();
enr.MoveNext();
var rdKey = enr.Current;
var template = result[rdKey] as FrameworkTemplate;
result.Remove(rdKey);
return template;
}
void UpdateSupports( ResourceDictionary skin )
{
if (skin.Contains("Supports"))
CurrentSupports = (string)skin["Supports"];
else
CurrentSupports = "";
// CheckSupports
if (options != null)
options.Supports = CurrentSupports;
}
public void Contains_TypeAsKey_DoesNotThrow ()
{
ResourceDictionary rd = new ResourceDictionary ();
rd.Contains (typeof (TextBlock));
}
private static Brush GetBrush(ResourceDictionary properties)
{
if (properties == null)
return Brushes.Transparent;
if (properties.Contains(EditorFormatDefinition.BackgroundColorId))
{
var color = (Color)properties[EditorFormatDefinition.BackgroundColorId];
var brush = new SolidColorBrush(color);
if (brush.CanFreeze)
{
brush.Freeze();
}
return brush;
}
if (properties.Contains(EditorFormatDefinition.BackgroundBrushId))
{
var brush = (Brush)properties[EditorFormatDefinition.BackgroundBrushId];
if (brush.CanFreeze)
{
brush.Freeze();
}
return brush;
}
return Brushes.Transparent;
}
public void Contains_IntAsKey_Throws ()
{
ResourceDictionary rd = new ResourceDictionary ();
Assert.Throws<ArgumentException> (() => rd.Contains (35));
}
public void Contains_ObejctAsKey_Throws ()
{
ResourceDictionary rd = new ResourceDictionary ();
Assert.Throws<ArgumentException> (() => rd.Contains (new object ()));
}
private static object GetTemplate(string key)
{
string assemblyName = Assembly.GetExecutingAssembly().GetName().Name;
string resourcePath = string.Format("{0};component/Templates/Template.xaml", assemblyName);
var templateDictionary = new ResourceDictionary();
templateDictionary.Source = new Uri(resourcePath, UriKind.Relative);
if (!templateDictionary.Contains(key))
{
return null;
}
object item = templateDictionary[key];
return item;
}