/// <summary> Adds the given <paramref name="variant"/> to this style keyed by name. </summary> /// <param name="variant"> The variant to add. </param> public void AddVariant(StyleVariant variant) { // Add the variant to the dictionary using its name. if (!styleVariantsByName.ContainsKey(variant.Name)) { styleVariantsByName.Add(variant.Name, variant); } else { throw new Exception($"Style variant with name {variant.Name} has already been defined for style {Name}."); } }
private StyleVariant(StyleVariant original) { if (original == null) { throw new ArgumentNullException(nameof(original)); } Name = original.Name; // Copy each attribute. foreach (IStyleAttribute attribute in original.styleAttributesByTypeAndName.Values) { AddAttribute(attribute.CreateCopy()); } }
public void CombineOverBase(StyleVariant baseVariant) { // Go over each attribute in the base. foreach (IStyleAttribute baseAttribute in baseVariant.styleAttributesByTypeAndName.Values) { // If this variant does not have the attribute, take a copy of it as it is. string key = calculateKey(baseAttribute.GetType(), baseAttribute); if (!styleAttributesByTypeAndName.TryGetValue(key, out IStyleAttribute derivedAttribute)) { AddAttribute(baseAttribute.CreateCopy()); } // Otherwise; combine the derived attribute over the base attribute. else { derivedAttribute.OverrideBaseAttribute(baseAttribute); } } }
/// <summary> Creates a style from the given <paramref name="styleNode"/>. </summary> /// <param name="styleNode"> The <see cref="XmlNode"/> that contains the element style. </param> public Style(ResourceManager resourceManager, ConstructorCache <IStyleAttribute> attributeCache, XmlNode styleNode) { // Set the name of this style based on the name of the node. Name = styleNode.Name; // Create attributes from this style node. IReadOnlyAttributes attributes = new AttributeCollection(styleNode); // Set the name of the base style if one was given. BaseStyleName = attributes.GetAttributeOrDefault(BaseVariantName, string.Empty); // Hold collections of the loaded variants and attributes. List <StyleVariant> variants = new List <StyleVariant>(); List <IStyleAttribute> styleAttributes = new List <IStyleAttribute>(); // Read each child node. foreach (XmlNode childNode in styleNode) { // If the child node has children, load it as a variant. if (childNode.HasChildNodes) { variants.Add(new StyleVariant(childNode, resourceManager, attributeCache)); } // Otherwise; dynamically create the style attribute and add it to the list. else { styleAttributes.Add(attributeCache.CreateInstance(childNode.Name, resourceManager, new AttributeCollection(childNode))); } } // Create the base variant using the loaded attributes. BaseVariant = new StyleVariant(BaseVariantName, styleAttributes); AddVariant(BaseVariant); // Create the derived variants using the base variant. foreach (StyleVariant variant in variants) { // Combine the variant with the base. variant.CombineOverBase(BaseVariant); // Add the variant to the dictionary using its name. AddVariant(variant); } }
private Style(Style original) { if (original == null) { throw new ArgumentNullException(nameof(original)); } Name = original.Name; BaseStyleName = original.BaseStyleName; // Copy each variant over. foreach (StyleVariant variant in original.styleVariantsByName.Values) { AddVariant(variant.CreateCopy()); } // Set the base variant to the base variant from the newly populated dictionary, ensuring it's the new copy and not the original. BaseVariant = styleVariantsByName[BaseVariantName]; }
public void CombineWithBase(Style baseStyle) { // Go over each style variant in the base style. foreach (StyleVariant baseVariant in baseStyle.styleVariantsByName.Values) { // Try get the variant from this style, if it exists, override the base with it. if (styleVariantsByName.TryGetValue(baseVariant.Name, out StyleVariant derivedVariant)) { derivedVariant.CombineOverBase(baseVariant); } // Otherwise; copy it from the base to the derived style as-is. else { // Copy the variant from the base style. StyleVariant baseVariantCopy = baseVariant.CreateCopy(); // Combine the copy with the base variant of this style, filling in any gaps. baseVariantCopy.CombineOverBase(BaseVariant); // Add the new copy. AddVariant(baseVariantCopy); } } }