public void SetTheme(string name)
{
ITheme theme;
if (!_themesMap.TryGetValue(name, out theme)) return;
var newTheme = new SharedResourceDictionary { Source = theme.ResourcePack };
_resourceDictionary.MergedDictionaries.Add(newTheme);
_activeTheme.OnNext(theme);
}
public void ThrowsForRelativeSourceUriWithoutBaseUri()
{
var dict = new SharedResourceDictionary();
var source = new Uri("RelativeFile.xaml", UriKind.Relative);
var ex = Record.Exception(() => dict.Source = source);
Assert.NotNull(ex);
Assert.IsType <InvalidOperationException>(ex);
}
protected override SharedResourceDictionary <TKey, TValue> Deserialize(IntermediateReader input,
ContentSerializerAttribute format,
SharedResourceDictionary <TKey, TValue> existingInstance)
{
if (existingInstance == null)
{
existingInstance = new SharedResourceDictionary <TKey, TValue>();
}
int i = 0;
while (input.MoveToElement(Keyformat.ElementName))
{
input.ReadSharedResource <TKey>(Keyformat, delegate(TKey item)
{
mKeys.Add(i, item);
if (mValues.ContainsKey(i))
{
existingInstance.Add(mKeys[i], mValues[i]);
}
});
if (input.MoveToElement(Valueformat.ElementName))
{
if (default(TValue) is ValueType)
{
TValue value = input.ReadObject <TValue>(Valueformat);
mValues.Add(i, value);
}
else
{
input.ReadSharedResource <TValue>(Valueformat, delegate(TValue item)
{
mValues.Add(i, item);
if (mKeys.ContainsKey(i))
{
existingInstance.Add(mKeys[i], mValues[i]);
}
});
}
}
i++;
}
return(existingInstance);
}
public void LoadsRelativeUris()
{
// For testing if the dictionary can load relative URIs, it needs a BaseUri
// (to simulate where it is located).
// Set this BaseUri to the dictionary's folder.
// We can then test if the dict can load the relative "FileName.xaml" URI.
var baseUri = GetSampleDictionaryDirectoryUri();
var dict = new SharedResourceDictionary();
var fileNameUri = new Uri(
SampleDictionaryKeys.DictionaryUri.Segments.Last(),
UriKind.Relative);
((IUriContext)dict).BaseUri = baseUri;
dict.Source = fileNameUri;
Assert.NotEmpty(dict);
Assert.Equal(SampleDictionaryKeys.DictionaryUri, dict.Source);
}
protected override void Serialize(IntermediateWriter output,
SharedResourceDictionary <TKey, TValue> value,
ContentSerializerAttribute format)
{
foreach (TKey item in value.Keys)
{
output.WriteSharedResource <TKey>(item, Keyformat);
if (default(TValue) is ValueType)
{
output.WriteObject <TValue>(value[item], Valueformat);
}
else
{
output.WriteSharedResource <TValue>(value[item], Valueformat);
}
}
}
internal static void AddExtraResourceDictionary(
ResourceDictionary resourceDictionary,
Theme theme,
Color accentColor,
Color contrastColor,
Color semitransparentContrastColor)
{
if (!resourceDictionary.MergedDictionaries.Any(x => x.Source == ElysiumExtraDictionaryUri))
{
SharedResourceDictionary sharedResourceDictionary = new SharedResourceDictionary()
{
Source = ElysiumExtraDictionaryUri.ToString()
};
UpdateTheme(sharedResourceDictionary, theme);
UpdateAccentColor(sharedResourceDictionary, accentColor);
UpdateContrastColor(sharedResourceDictionary, contrastColor);
UpdateSemitransparentContrastColor(sharedResourceDictionary, semitransparentContrastColor);
resourceDictionary.MergedDictionaries.Add(sharedResourceDictionary);
}
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Первоначальная инициализация диспетчера управления подсистемой чертежной графики
/// </summary>
//---------------------------------------------------------------------------------------------------------
public static void Init()
{
#if USE_WINDOWS
XWindowsColorManager.Init();
if (mGraphicsResources == null)
{
mGraphicsResources = new SharedResourceDictionary();
mGraphicsResources.Source = new Uri(XCadManager.UriGraphicsResources, UriKind.Absolute);
}
#endif
mEditor = new CCadEditor();
//XManager.Init();
XCadBrushManager.Init();
XCadPenStyleManager.Init();
XCadPenManager.Init();
XCadLayerManager.Init();
XCadFontManager.Init();
XCadPaperManager.Init();
//XManager.Editor = mEditor;
}
private void ChangeLanguage(string val)
{
var resources = new ResourceDictionary();
if (val == SharedResourceDictionary.AvailableLanguages[0])
{
resources.Source = new Uri("..\\Resources\\Resources.en-US.xaml", System.UriKind.Relative);
SharedResourceDictionary.ChangeLanguage(SharedResourceDictionary.dictionary_EN);
}
else if (val == SharedResourceDictionary.AvailableLanguages[1])
{
resources.Source = new Uri("..\\Resources\\Resources.it-IT.xaml", System.UriKind.Relative);
SharedResourceDictionary.ChangeLanguage(SharedResourceDictionary.dictionary_IT);
}
var current = Application.Current.Resources.MergedDictionaries.FirstOrDefault(
m => m.Source.OriginalString.Contains("Resources"));
if (current != null)
{
Application.Current.Resources.MergedDictionaries.Remove(current);
}
Application.Current.Resources.MergedDictionaries.Add(resources);
}
protected override SharedResourceDictionary <TKey, TValue> Read(
ContentReader input,
SharedResourceDictionary <TKey, TValue> existingInstance)
{
if (existingInstance == null)
{
existingInstance = new SharedResourceDictionary <TKey, TValue>();
}
int nbElement = 0;
nbElement = input.ReadObject <int>();
int i = 0;
while (i < nbElement)
{
if (default(TKey) is ValueType)
{
TKey key = input.ReadObject <TKey>();
mKeys.Add(key);
}
else
{
input.ReadSharedResource(delegate(TKey item)
{
mKeys.Add(item);
if (mKeys.Count == mNumberOfItem && mValues.Count == mNumberOfItem)
{
for (int j = 0; j < mNumberOfItem; j++)
{
existingInstance.Add(mKeys[j], mValues[j]);
}
}
});
}
if (default(TValue) is ValueType)
{
TValue value = input.ReadObject <TValue>();
mValues.Add(value);
}
else
{
input.ReadSharedResource(delegate(TValue item)
{
mValues.Add(item);
if (mKeys.Count == mNumberOfItem && mValues.Count == mNumberOfItem)
{
for (int j = 0; j < mNumberOfItem; j++)
{
existingInstance.Add(mKeys[j], mValues[j]);
}
}
});
}
mNumberOfItem++;
i++;
}
return(existingInstance);
}
