/// <summary>
/// Loads a theme from a System.IO.Stream instance.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static XmlTheme LoadFromStram(Stream stream)
{
XmlSerializer ser = new XmlSerializer(typeof(XmlTheme));
XmlTheme xmlTheme = (XmlTheme)ser.Deserialize(stream);
return(xmlTheme);
}
/// <summary>
/// Loads a theme from a XML reader.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static XmlTheme LoadFromReader(XmlReader reader)
{
XmlSerializer ser = new XmlSerializer(typeof(XmlTheme));
XmlTheme xmlTheme = (XmlTheme)ser.Deserialize(reader);
return(xmlTheme);
}
/// <summary>
/// Loads the theme from the file resource specified and registers it into ThemeResolutionService. Thais method is called
/// immediately when correct ThemeLocation and StorageType are specified.
/// </summary>
public virtual void ReloadThemeFromStorage()
{
//check for file load redundancy, only if it's not in Designmode
bool checkFileLoadRedundancy = this.OwnerThemeManager == null || !this.OwnerThemeManager.IsDesignMode;
if (callingAssembly == null)
{
callingAssembly = Assembly.GetCallingAssembly();
}
if (checkFileLoadRedundancy)
{
if (locationsAlreadyLoaded[this.callingAssembly.FullName + this.ThemeLocation] == locationLoadedMarker)
{
return;
}
}
XmlTheme theme = new XmlTheme();
theme.LoadPartiallyFromStorage(this);
Theme.Deserialize(theme);
if (checkFileLoadRedundancy && this.loadSucceeded)
{
locationsAlreadyLoaded[this.callingAssembly.FullName + this.ThemeLocation] = locationLoadedMarker;
}
}
private void openToolStripButton_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog(this) == DialogResult.OK)
{
using (XmlReader reader = XmlReader.Create(openFileDialog1.FileName))
{
XmlTheme xmlTheme = XmlTheme.LoadFromReader(reader);
if (xmlTheme != null)
{
if (this.CurrentTheme.BuilderRegistrations.Length > 0)
{
DialogResult res = MessageBox.Show("Theme already contains styles for controls. Merge loaded with existing?", "Load theme", MessageBoxButtons.YesNoCancel);
if (res == DialogResult.Yes)
{
this.MergerWithTheme(xmlTheme);
this.CurrentFileName = openFileDialog1.FileName;
}
else
if (res == DialogResult.No)
{
this.LoadTheme(xmlTheme);
this.CurrentFileName = openFileDialog1.FileName;
}
}
}
}
}
}
public XmlTheme GetXmlThemeObject()
{
if (callingAssembly == null)
{
callingAssembly = Assembly.GetCallingAssembly();
}
XmlTheme theme = new XmlTheme();
theme.LoadPartiallyFromStorage(this);
Theme.Deserialize(theme);
return(theme);
}
/// <summary>
/// Deserializes a theme from a given %XmlTheme:Telerik.WinControls.XmlTheme%
/// instance. Resulting theme is registered within ThemeReolutionService and can be obtained using the following
/// ThemeResolutionService.GetTheme(xmlTheme.ThemeName)
/// </summary>
/// <param name="xmlTheme">An instance of the <see cref="XmlTheme"/>class
/// which is deserialized.</param>
/// <param name="registerBuildersWithThemeResService">Defines whether new <see cref="StyleBuilderRegistration"/>
/// instances are added in the <see cref="ThemeResolutionService"/>.</param>
public static void Deserialize(XmlTheme xmlTheme, bool registerBuildersWithThemeResService)
{
//ThemeResolutionService.BeginEditTheme(xmlTheme.ThemeName);
if (string.IsNullOrEmpty(xmlTheme.ThemeName))
{
return;
}
ThemeResolutionService.SuspendThemeChange();
try
{
//Copy theme parameters
ThemeResolutionService.EnsureThemeRegistered(xmlTheme.ThemeName);
Theme themeInstance = ThemeResolutionService.GetTheme(xmlTheme.ThemeName);
foreach (KeyValuePair <string, object> dictionaryEntry in xmlTheme.ThemeProperties)
{
themeInstance.ThemeProperties[dictionaryEntry.Key] = dictionaryEntry.Value;
}
string[] themeNames = xmlTheme.ThemeName.Split(',', ';');
if (xmlTheme.HasRepository)
{
foreach (string themeName in themeNames)
{
//If a repository for this theme already exists, both are merged.
ThemeResolutionService.RegisterThemeRepository(xmlTheme.StyleRepository, themeName.Trim());
}
}
//Register StyleBuilders
if (registerBuildersWithThemeResService && xmlTheme.BuilderRegistrations != null)
{
foreach (XmlStyleBuilderRegistration registration in xmlTheme.BuilderRegistrations)
{
foreach (string themeName in themeNames)
{
ThemeResolutionService.RegisterStyleBuilder(registration.GetRegistration(), themeName.Trim());
}
}
}
}
finally
{
ThemeResolutionService.ResumeThemeChange();
}
}
private void MergerWithTheme(XmlTheme theme)
{
//this.tbThemeName.Text = theme.ThemeName;
this.tvBuilders.Nodes.Clear();
this.tvPropertySettingGroups.Nodes.Clear();
ArrayList mergedBuildersList = new ArrayList();
mergedBuildersList.AddRange(this.CurrentTheme.BuilderRegistrations);
mergedBuildersList.AddRange(theme.BuilderRegistrations);
this.CurrentTheme = theme;
theme.BuilderRegistrations = new XmlStyleBuilderRegistration[mergedBuildersList.Count];
mergedBuildersList.CopyTo(theme.BuilderRegistrations, 0);
this.LoadTheme(this.CurrentTheme);
}
public void LoadTheme(XmlTheme theme)
{
this.tbThemeName.Text = theme.ThemeName;
this.tvBuilders.Nodes.Clear();
this.tvPropertySettingGroups.Nodes.Clear();
this.CurrentTheme = theme;
foreach (XmlStyleBuilderRegistration reg in theme.BuilderRegistrations)
{
TreeNode node = new TreeNode(GetBuilderString(reg));
node.Tag = reg;
this.tvBuilders.Nodes.Add(node);
//MessageBox.Show("" + ((XmlStyleSheet)reg.BuilderData).PropertySettingGroups.Count);
}
if (this.tvBuilders.Nodes.Count > 0)
{
this.tvBuilders.SelectedNode = this.tvBuilders.Nodes[0];
}
}
public void SaveXML(string themeName, string fileName)
{
using (XmlTextWriter xmlTextWriter = new XmlTextWriter(fileName, Encoding.UTF8))
{
xmlTextWriter.Formatting = Formatting.Indented;
XmlTheme xmlTheme = new XmlTheme();
xmlTheme.ThemeName = themeName;
xmlTheme.ThemeVersion = "2.0";
XmlStyleSheet xmlStyleSheet = new XmlStyleSheet();
foreach (PropertySettingGroup propertySettingGroup in this.PropertySettingGroups)
{
xmlStyleSheet.PropertySettingGroups.Add(new XmlPropertySettingGroup(propertySettingGroup));
}
xmlTheme.BuilderRegistrations = new XmlStyleBuilderRegistration[1]
{
new XmlStyleBuilderRegistration(this)
{
BuilderData = (XmlBuilderData)xmlStyleSheet
}
};
xmlTheme.SaveToWriter((XmlWriter)xmlTextWriter);
}
}
private XmlElementSelector CreateSelector(ElementSelector selector)
{
XmlSelectorBase xmlSelectorBase = (XmlSelectorBase)null;
WrapSelector wrapSelector = selector as WrapSelector;
if (wrapSelector != null)
{
TypeSelector internalSelector1 = wrapSelector.InternalSelector as TypeSelector;
if (internalSelector1 != null)
{
return((XmlElementSelector) new XmlTypeSelector(XmlTheme.SerializeType(internalSelector1.ElementType)));
}
ClassSelector internalSelector2 = wrapSelector.InternalSelector as ClassSelector;
if (internalSelector2 != null)
{
return((XmlElementSelector) new XmlClassSelector(internalSelector2.ElementClass));
}
}
if (selector.Type == ElementSelectorTypes.VisualStateSelector)
{
xmlSelectorBase = (XmlSelectorBase) new XmlVisualStateSelector(selector.Value);
}
else if (selector.Type == ElementSelectorTypes.TypeSelector)
{
xmlSelectorBase = (XmlSelectorBase) new XmlTypeSelector(selector.Value);
}
else if (selector.Type == ElementSelectorTypes.ClassSelector)
{
xmlSelectorBase = (XmlSelectorBase) new XmlClassSelector(selector.Value);
}
if (selector.ChildSelector != null)
{
xmlSelectorBase.ChildSelector = this.CreateSelector(selector.ChildSelector);
}
return((XmlElementSelector)xmlSelectorBase);
}
protected override IElementSelector CreateInstance()
{
return((IElementSelector) new TypeSelector(XmlTheme.DeserializeType(this.ElementType)));
}
protected override XmlElementSelector CreateSerializableInstance()
{
return(new XmlTypeSelector(XmlTheme.SerializeType(this.ElementType)));
}
/// <summary>
/// Merges the original theme given as the first parameter with the theme of the
/// current instance and writes the union to an XMLWriter.
/// </summary>
/// <param name="originalTheme"></param>
/// <param name="writer"></param>
public void SaveMergeToWriter(XmlTheme originalTheme, XmlWriter writer)
{
if (originalTheme.BuilderRegistrations != null)
{
List <XmlStyleBuilderRegistration> resList = new List <XmlStyleBuilderRegistration>(originalTheme.BuilderRegistrations);
foreach (XmlStyleBuilderRegistration available in this.BuilderRegistrations)
{
int foundIndex = 0;
bool found = false;
foreach (XmlStyleBuilderRegistration currOriginalReg in originalTheme.BuilderRegistrations)
{
//test if this is the stylesheet
foreach (RadStylesheetRelation relation in available.StylesheetRelations)
{
foreach (RadStylesheetRelation originalRelation in currOriginalReg.StylesheetRelations)
{
if (originalRelation.RegistrationType == relation.RegistrationType &&
this.CompareRelationAttributes(originalRelation.ElementType, relation.ElementType) &&
this.CompareRelationAttributes(originalRelation.ElementName, relation.ElementName) &&
this.CompareRelationAttributes(originalRelation.ControlName, relation.ControlName) &&
this.CompareRelationAttributes(originalRelation.ControlType, relation.ControlType))
{
found = true;
break;
}
}
if (found)
{
break;
}
}
if (found)
{
//Now get the relations from the existing theme and merge them with the new one
foreach (RadStylesheetRelation originalRelation in currOriginalReg.StylesheetRelations)
{
bool relationFound = false;
foreach (RadStylesheetRelation relation in available.StylesheetRelations)
{
if (originalRelation.RegistrationType == relation.RegistrationType &&
this.CompareRelationAttributes(originalRelation.ElementType, relation.ElementType) &&
this.CompareRelationAttributes(originalRelation.ElementName, relation.ElementName) &&
this.CompareRelationAttributes(originalRelation.ControlName, relation.ControlName) &&
this.CompareRelationAttributes(originalRelation.ControlType, relation.ControlType))
{
relationFound = true;
break;
}
}
if (!relationFound)
{
available.StylesheetRelations.Add(originalRelation);
}
}
//break searching the stylesheet
break;
}
foundIndex++;
}
if (found)
{
resList[foundIndex] = available;
}
else
{
resList.Add(available);
}
}
this.BuilderRegistrations = new XmlStyleBuilderRegistration[resList.Count];
resList.CopyTo(this.BuilderRegistrations, 0);
}
this.SaveToWriter(writer);
}
public XmlAnimationStep(object actualStep)
{
this.StepType = XmlTheme.SerializeType(actualStep.GetType());
this.Value = XmlAnimatedPropertySetting.ConvertValueToString(actualStep);
}
/// <summary>
/// Deserializes a theme from a given %XmlTheme:Telerik.WinControls.XmlTheme%
/// instance. Resulting theme is registered within ThemeReolutionService and can be obtained using the following
/// ThemeResolutionService.GetTheme(xmlTheme.ThemeName)
/// </summary>
/// <param name="xmlTheme">An instance of the <see cref="XmlTheme"/>class
/// which is deserialized.</param>
public static void Deserialize(XmlTheme xmlTheme)
{
Deserialize(xmlTheme, true);
}
protected override IElementSelector CreateInstance()
{
Type type = XmlTheme.DeserializeType(this.ElementType);
return(new TypeSelector(type));
}
