private static void AddValues(StyleSheetBuilderHelper helper, List <Value> values)
{
foreach (var value in values)
{
switch (value.ValueType)
{
case StyleValueType.Keyword:
helper.builder.AddValue(value.AsKeyword());
break;
case StyleValueType.Color:
helper.builder.AddValue(value.AsColor());
break;
case StyleValueType.Float:
helper.builder.AddValue(value.AsFloat());
break;
case StyleValueType.Enum:
case StyleValueType.String:
case StyleValueType.ResourcePath:
helper.builder.AddValue(value.AsString(), value.ValueType);
break;
default:
throw new Exception("Unhandled value type: " + value.ValueType);
}
}
}
public static void AddSkin(StyleSheetBuilderHelper helper, GUISkin skin)
{
AddGlobalFont(helper, skin.font);
// Builtin GUIStyle
skin.ForEachGUIStyleProperty((name, style) =>
{
AddStyle(helper, name.Capitalize(), style);
});
// Custom Styles
foreach (var style in skin.customStyles)
{
// GUISkin when instantiated have a null customStyle
if (style == null)
{
continue;
}
var customStyleName = ConverterUtils.ToGUIStyleSelectorName(style.name);
AddStyle(helper, customStyleName, style);
}
AddSettings(helper, skin.settings);
}
public static void PopulateSheet(StyleSheet sheet, IEnumerable <Rule> rules, ResolvingOptions options = null)
{
options = options ?? new ResolvingOptions();
var helper = new StyleSheetBuilderHelper();
if (options.SortRules)
{
rules = rules.OrderBy(rule => rule.SelectorName);
}
foreach (var rule in rules)
{
helper.BeginRule(string.Empty, rule.LineNumber);
StyleSheetBuilderHelper.BuildSelector(rule.Selector, helper);
var propertyValues = rule.Properties.Values.ToList();
if (options.SortProperties)
{
propertyValues.Sort((p1, p2) => p1.Name.CompareTo(p2.Name));
}
foreach (var property in propertyValues)
{
helper.builder.BeginProperty(property.Name);
AddValues(helper, property.Values);
helper.builder.EndProperty();
}
helper.EndRule();
}
helper.PopulateSheet(sheet);
}
private static void AddProperty(StyleSheetBuilderHelper helper, string name, string suffix, RectOffset offset, RectOffset defaultValue, string comment = "")
{
// Note: Same order as CSS which is NOT the same order as the RectOffset constructor
if (helper.options.exportDefaultValues || offset.left != defaultValue.left)
{
helper.AddProperty(ConverterUtils.ToUssPropertyName(name, "left", suffix), offset.left, comment);
comment = "";
}
if (helper.options.exportDefaultValues || offset.right != defaultValue.right)
{
helper.AddProperty(ConverterUtils.ToUssPropertyName(name, "right", suffix), offset.right, comment);
comment = "";
}
if (helper.options.exportDefaultValues || offset.top != defaultValue.top)
{
helper.AddProperty(ConverterUtils.ToUssPropertyName(name, "top", suffix), offset.top, comment);
comment = "";
}
if (helper.options.exportDefaultValues || offset.bottom != defaultValue.bottom)
{
helper.AddProperty(ConverterUtils.ToUssPropertyName(name, "bottom", suffix), offset.bottom, comment);
}
}
public static StyleSheet ConvertToStyleSheet(IEnumerable <Rule> rules, Dictionary <string, Property> variables = null, ResolvingOptions options = null)
{
options = options ?? new ResolvingOptions();
variables = variables ?? new Dictionary <string, Property>();
var helper = new StyleSheetBuilderHelper();
if (options.SortRules)
{
rules = rules.OrderBy(rule => rule.SelectorName);
}
foreach (var rule in rules)
{
helper.BeginRule();
StyleSheetBuilderHelper.BuildSelector(rule.Selector, helper);
var propertyValues = rule.Properties.Values.ToList();
if (options.SortProperties)
{
propertyValues.Sort((p1, p2) => p1.Name.CompareTo(p2.Name));
}
foreach (var property in propertyValues)
{
helper.builder.BeginProperty(property.Name);
// Try to resolve variable
var values = ResolveValues(property, variables, options);
AddValues(helper, values);
helper.builder.EndProperty();
}
helper.EndRule();
}
helper.PopulateSheet();
return(helper.sheet);
}
private static void AddProperty(StyleSheetBuilderHelper helper, FontStyle style, string comment)
{
string fontStyle, fontWeight;
ConverterUtils.GetFontStylePropertyValues(style, out fontStyle, out fontWeight);
helper.AddProperty(ConverterUtils.k_FontStyle, fontStyle, comment);
helper.AddProperty(ConverterUtils.k_FontWeight, fontWeight);
}
public static StyleSheet ToStyleSheet(GUIStyle style, string name, UssExportOptions options = null)
{
var builder = new StyleSheetBuilderHelper(options);
AddStyle(builder, name, style);
builder.PopulateSheet();
return(builder.sheet);
}
public static StyleSheet ToStyleSheet(GUISkin skin, UssExportOptions options = null)
{
var builder = new StyleSheetBuilderHelper(options);
AddSkin(builder, skin);
builder.PopulateSheet();
return(builder.sheet);
}
private static void AddValues(StyleSheetBuilderHelper helper, IEnumerable <Value> values)
{
foreach (var value in values)
{
switch (value.ValueType)
{
case StyleValueType.Keyword:
helper.builder.AddValue(value.AsKeyword());
break;
case StyleValueType.Color:
helper.builder.AddValue(value.AsColor());
break;
case StyleValueType.Float:
helper.builder.AddValue(value.AsFloat());
break;
case StyleValueType.Dimension:
helper.builder.AddValue(value.AsDimension());
break;
case StyleValueType.Enum:
case StyleValueType.Variable:
case StyleValueType.String:
case StyleValueType.ResourcePath:
helper.builder.AddValue(value.AsString(), value.ValueType);
break;
case StyleValueType.Function:
// First param: function name
// Second param: number of arguments
// Rest of args: must be saved as values.
var functionValue = value as Function;
helper.builder.AddValue(StyleValueFunctionExtension.FromUssString(functionValue.AsString()));
var nbArgs = functionValue.args.Count - 1;
for (var argIndex = 0; argIndex < functionValue.args.Count; ++argIndex)
{
nbArgs += functionValue.args[argIndex].Length;
}
helper.builder.AddValue(nbArgs);
for (var argIndex = 0; argIndex < functionValue.args.Count; ++argIndex)
{
AddValues(helper, functionValue.args[argIndex]);
if (argIndex < functionValue.args.Count - 1)
{
helper.builder.AddValue(value.AsString(), StyleValueType.FunctionSeparator);
}
}
break;
default:
throw new Exception("Unhandled value type: " + value.ValueType);
}
}
}
public static void BuildSelector(StyleComplexSelector complexSelector, StyleSheetBuilderHelper helper)
{
using (helper.builder.BeginComplexSelector(complexSelector.specificity))
{
foreach (var selector in complexSelector.selectors)
{
helper.builder.AddSimpleSelector(selector.parts, selector.previousRelationship);
}
}
}
public SplitSheetData Split(StyleSheet s1, StyleSheet s2, UssComments s1SrcComments = null, UssComments s2SrcComments = null)
{
s1Cache = new StyleSheetCache(s1);
s1Comments = s1SrcComments ?? new UssComments();
s2Cache = new StyleSheetCache(s2);
s2Comments = s2SrcComments ?? new UssComments();
s1Builder = new StyleSheetBuilderHelper();
s2Builder = new StyleSheetBuilderHelper();
commonBuilder = new StyleSheetBuilderHelper();
var allSelectors = new HashSet <string>(s1Cache.selectors.Keys);
allSelectors.UnionWith(s2Cache.selectors.Keys);
foreach (var selectorStr in allSelectors)
{
StyleComplexSelector complexSelector1;
s1Cache.selectors.TryGetValue(selectorStr, out complexSelector1);
StyleComplexSelector complexSelector2;
s2Cache.selectors.TryGetValue(selectorStr, out complexSelector2);
if (complexSelector1 != null)
{
if (complexSelector2 != null)
{
// Common rules, write common properties
Split(complexSelector1, complexSelector2);
}
else
{
// Rules only existing in S1: copy it straight
StyleSheetBuilderHelper.CopySelector(s1, s1Comments, complexSelector1, s1Builder);
}
}
else
{
// Rules only existing in S2: copy it straight
StyleSheetBuilderHelper.CopySelector(s2, s2Comments, complexSelector2, s2Builder);
}
}
commonBuilder.PopulateSheet();
s1Builder.PopulateSheet();
s2Builder.PopulateSheet();
var result = new SplitSheetData {
common = commonBuilder.sheet, s1 = s1Builder.sheet, s2 = s2Builder.sheet
};
return(result);
}
private static void AddPropertyResource(StyleSheetBuilderHelper helper, string name, Object resource, string comment = "")
{
if (resource != null)
{
var resourcePath = EditorResources.GetAssetPath(resource);
helper.AddPropertyResource(name, resourcePath, comment);
}
else
{
helper.AddProperty(name, StyleValueKeyword.None);
}
}
public static void AddGlobalFont(StyleSheetBuilderHelper helper, Font font)
{
// Global Font
helper.BeginRule("GUISkin globals");
using (helper.builder.BeginComplexSelector(0))
{
helper.builder.AddSimpleSelector(new[] { StyleSelectorPart.CreateWildCard() }, StyleSelectorRelationship.None);
}
if (font != null)
{
AddPropertyResource(helper, ConverterUtils.k_Font, font, "GUISkin.font");
}
helper.EndRule();
}
private static void AddState(StyleSheetBuilderHelper helper, string stateRuleSelector, GUIStyleState state, string stateId, GUIStyleState defaultStyle)
{
// All common Style property
helper.BeginRule("GUIStyle." + stateId);
using (helper.builder.BeginComplexSelector(0))
{
// Construct rule according to the GUIStyle -> is it custom? is it bound on a type?
helper.builder.AddSimpleSelector(ConverterUtils.GetStateRuleSelectorParts(stateRuleSelector, stateId), StyleSelectorRelationship.None);
}
AddState(helper, state, defaultStyle);
helper.EndRule();
}
public static void AddSettings(StyleSheetBuilderHelper helper, GUISettings settings)
{
// Settings
helper.BeginRule("GUISkin.settings - GUISettings");
using (helper.builder.BeginComplexSelector(0))
{
helper.builder.AddSimpleSelector(new[] { StyleSelectorPart.CreateClass(ConverterUtils.k_GUISettingsSelector.Replace(".", "")) }, StyleSelectorRelationship.None);
}
helper.AddProperty(ConverterUtils.k_SelectionColor, settings.selectionColor, "GUISettings.selectionColor");
helper.AddProperty(ConverterUtils.k_CursorColor, settings.cursorColor, "GUISettings.cursorColor");
helper.AddProperty(ConverterUtils.k_CursorFlashSpeed, settings.cursorFlashSpeed, "GUISettings.cursorFlashSpeed");
helper.AddProperty(ConverterUtils.k_DoubleClickSelectsWord, settings.doubleClickSelectsWord, "GUISettings.doubleClickSelectsWord");
helper.AddProperty(ConverterUtils.k_TripleClickSelectsLine, settings.tripleClickSelectsLine, "GUISettings.tripleClickSelectsLine");
helper.EndRule();
}
private static void AddState(StyleSheetBuilderHelper helper, GUIStyleState state, GUIStyleState defaultStyle)
{
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(state.textColor, defaultStyle.textColor))
{
helper.AddProperty("color", state.textColor, "GUIState.textColor");
}
if (helper.options.exportDefaultValues || state.background != defaultStyle.background)
{
AddPropertyResource(helper, ConverterUtils.k_BackgroundImage, state.background, "GUIState.background");
}
var scaledBackground = state.scaledBackgrounds.Length > 0 ? state.scaledBackgrounds[0] : null;
var defaultScaledBackground = defaultStyle.scaledBackgrounds.Length > 0 ? defaultStyle.scaledBackgrounds[0] : null;
if (helper.options.exportDefaultValues || scaledBackground != defaultScaledBackground)
{
AddPropertyResource(helper, ConverterUtils.k_ScaledBackground, scaledBackground, "GUIState.scaledBackgrounds");
}
}
// Public API to serialize GUIStyle and GUISkin
public static void AddStyle(StyleSheetBuilderHelper helper, string name, GUIStyle style, GUIStyle defaultStyle = null, string extendName = null)
{
defaultStyle = defaultStyle ?? GUIStyle.none;
// All common Style property
helper.BeginRule();
using (helper.builder.BeginComplexSelector(0))
{
// Construct rule according to the GUIStyle -> is it custom? is it bound on a type?
helper.builder.AddSimpleSelector(new[] { ConverterUtils.CreateSelectorPart(name) }, StyleSelectorRelationship.None);
}
if (!string.IsNullOrEmpty(extendName))
{
helper.AddPropertyString(ConverterUtils.k_Extend, extendName);
}
// Loop for each GUIStyle property
if (helper.options.exportDefaultValues || style.alignment != defaultStyle.alignment)
{
helper.AddProperty(ConverterUtils.k_TextAlignment, ConverterUtils.ToUssString(style.alignment), "GUIStyle.alignment");
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.border, defaultStyle.border))
{
AddProperty(helper, ConverterUtils.k_Border, "", style.border, defaultStyle.border, "GUIStyle.border");
}
if (helper.options.exportDefaultValues || style.clipping != defaultStyle.clipping)
{
helper.AddProperty(ConverterUtils.k_Clipping, ConverterUtils.ToUssString(style.clipping), "GUIStyle.clipping");
}
if (helper.options.exportDefaultValues || style.contentOffset != defaultStyle.contentOffset)
{
helper.AddProperty(ConverterUtils.k_ContentOffset, style.contentOffset, "GUIStyle.contentOffset");
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.fixedHeight, defaultStyle.fixedHeight))
{
helper.AddProperty(ConverterUtils.k_Height, style.fixedHeight, "GUIStyle.fixedHeight");
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.fixedWidth, defaultStyle.fixedWidth))
{
helper.AddProperty(ConverterUtils.k_Width, style.fixedWidth, "GUIStyle.fixedWidth");
}
if (helper.options.exportDefaultValues || style.font != defaultStyle.font)
{
AddPropertyResource(helper, ConverterUtils.k_Font, style.font, "GUIStyle.font");
}
if (helper.options.exportDefaultValues || style.fontSize != defaultStyle.fontSize)
{
helper.AddProperty(ConverterUtils.k_FontSize, style.fontSize, "GUIStyle.fontSize");
}
if (helper.options.exportDefaultValues || style.fontStyle != defaultStyle.fontStyle)
{
AddProperty(helper, style.fontStyle, "GUIStyle.fontSize");
}
if (helper.options.exportDefaultValues || style.imagePosition != defaultStyle.imagePosition)
{
helper.AddProperty(ConverterUtils.k_ImagePosition, ConverterUtils.ToUssString(style.imagePosition), "GUIStyle.imagePosition");
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.margin, defaultStyle.margin))
{
AddProperty(helper, ConverterUtils.k_Margin, null, style.margin, defaultStyle.margin, "GUIStyle.margin");
}
// Always export name:
helper.AddPropertyString(ConverterUtils.k_Name, style.name, "GUIStyle.name");
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.overflow, defaultStyle.overflow))
{
AddProperty(helper, ConverterUtils.k_Overflow, null, style.overflow, defaultStyle.overflow, "GUIStyle.overflow");
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.padding, defaultStyle.padding))
{
AddProperty(helper, ConverterUtils.k_Padding, null, style.padding, defaultStyle.padding, "GUIStyle.padding");
}
if (helper.options.exportDefaultValues || style.richText != defaultStyle.richText)
{
helper.AddProperty(ConverterUtils.k_RichText, style.richText, "GUIStyle.richText");
}
if (helper.options.exportDefaultValues || style.stretchHeight != defaultStyle.stretchHeight)
{
helper.AddProperty(ConverterUtils.k_StretchHeight, style.stretchHeight, "GUIStyle.stretchHeight");
}
if (helper.options.exportDefaultValues || style.stretchWidth != defaultStyle.stretchWidth)
{
helper.AddProperty(ConverterUtils.k_StretchWidth, style.stretchWidth, "GUIStyle.stretchWidth");
}
if (helper.options.exportDefaultValues || style.wordWrap != defaultStyle.wordWrap)
{
helper.AddProperty(ConverterUtils.k_WordWrap, style.wordWrap, "GUIStyle.wordWrap");
}
// Add Normal state properties
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.normal, defaultStyle.normal))
{
AddState(helper, style.normal, defaultStyle.normal);
}
helper.EndRule();
// Add one rule for each GUIStyleState (other than normal)
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.active, defaultStyle.active))
{
AddState(helper, name, style.active, "active", defaultStyle.active);
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.focused, defaultStyle.focused))
{
AddState(helper, name, style.focused, "focused", defaultStyle.focused);
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.hover, defaultStyle.hover))
{
AddState(helper, name, style.hover, "hover", defaultStyle.hover);
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.onActive, defaultStyle.onActive))
{
AddState(helper, name, style.onActive, "onActive", defaultStyle.onActive);
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.onFocused, defaultStyle.onFocused))
{
AddState(helper, name, style.onFocused, "onFocused", defaultStyle.onFocused);
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.onHover, defaultStyle.onHover))
{
AddState(helper, name, style.onHover, "onHover", defaultStyle.onHover);
}
if (helper.options.exportDefaultValues || !GUISkinCompare.CompareTo(style.onNormal, defaultStyle.onNormal))
{
AddState(helper, name, style.onNormal, "onNormal", defaultStyle.onNormal);
}
}
private static void AddProperty(StyleSheetBuilderHelper helper, FontStyle style, string comment)
{
helper.AddProperty(ConverterUtils.k_FontStyle, style == FontStyle.Italic || style == FontStyle.BoldAndItalic ? "italic" : "normal", comment);
helper.AddProperty(ConverterUtils.k_FontWeight, style == FontStyle.Bold || style == FontStyle.BoldAndItalic ? "bold" : "normal");
}
private static void PopulateStyle(StyleSheetCache cache, StyleComplexSelector complexSelector, GUIStyle style, bool throwIfIncomplete = false)
{
var rule = complexSelector.rule;
var complexSelectorStr = StyleSheetToUss.ToUssSelector(complexSelector);
var sheet = cache.sheet;
// GUIStyle.alignment
GetProperty(rule, ConverterUtils.k_TextAlignment, throwIfIncomplete, property =>
{
style.alignment = ConverterUtils.ToTextAnchor(sheet.ReadEnum(property.values[0]));
});
// GUIStyle.border
ReadRectOffset(cache, rule, ConverterUtils.k_Border, "", throwIfIncomplete, style.border);
// GUIStyle.clipping
GetProperty(rule, ConverterUtils.k_Clipping, throwIfIncomplete, property =>
{
style.clipping = ConverterUtils.ToTextClipping(sheet.ReadEnum(property.values[0]));
});
// GUIStyle.contentOffset
GetProperty(rule, ConverterUtils.k_ContentOffset, throwIfIncomplete, property =>
{
style.contentOffset = StyleSheetBuilderHelper.ReadVector2(sheet, property);
});
// GUIStyle.fixedHeight
GetProperty(rule, ConverterUtils.k_Height, throwIfIncomplete, property =>
{
style.fixedHeight = sheet.ReadFloat(property.values[0]);
});
// GUIStyle.fixedWidth
GetProperty(rule, ConverterUtils.k_Width, throwIfIncomplete, property =>
{
style.fixedWidth = sheet.ReadFloat(property.values[0]);
});
// GUIStyle.font
GetProperty(rule, ConverterUtils.k_Font, false, property =>
{
style.font = ReadResource <Font>(sheet, property);
});
// GUIStyle.fixedWidth
GetProperty(rule, ConverterUtils.k_FontSize, throwIfIncomplete, property =>
{
style.fontSize = (int)sheet.ReadFloat(property.values[0]);
});
// GUIStyle.fontStyle
ReadFontStyle(sheet, rule, throwIfIncomplete, style);
// GUIStyle.imagePosition
GetProperty(rule, ConverterUtils.k_ImagePosition, throwIfIncomplete, property =>
{
style.imagePosition = ConverterUtils.ToImagePosition(sheet.ReadEnum(property.values[0]));
});
// GUIStyle.margin
ReadRectOffset(cache, rule, ConverterUtils.k_Margin, null, throwIfIncomplete, style.margin);
// GUIStyle.name
GetProperty(rule, ConverterUtils.k_Name, throwIfIncomplete, property =>
{
style.name = sheet.ReadString(property.values[0]);
});
// GUIStyle.overflow
ReadRectOffset(cache, rule, ConverterUtils.k_Overflow, null, throwIfIncomplete, style.overflow);
// GUIStyle.padding
ReadRectOffset(cache, rule, ConverterUtils.k_Padding, null, throwIfIncomplete, style.padding);
// GUIStyle.richText
GetProperty(rule, ConverterUtils.k_RichText, throwIfIncomplete, property =>
{
style.richText = ReadBool(sheet, property);
});
// GUIStyle.stretchHeight
GetProperty(rule, ConverterUtils.k_StretchHeight, throwIfIncomplete, property =>
{
style.stretchHeight = ReadBool(sheet, property);
});
// GUIStyle.stretchWidth
GetProperty(rule, ConverterUtils.k_StretchWidth, throwIfIncomplete, property =>
{
style.stretchWidth = ReadBool(sheet, property);
});
// GUIStyle.wordWrap
GetProperty(rule, ConverterUtils.k_WordWrap, throwIfIncomplete, property =>
{
style.wordWrap = ReadBool(sheet, property);
});
ReadState(cache, rule, style.normal, throwIfIncomplete);
ReadState(cache, complexSelectorStr, style.active, "active", throwIfIncomplete);
ReadState(cache, complexSelectorStr, style.focused, "focused", throwIfIncomplete);
ReadState(cache, complexSelectorStr, style.hover, "hover", throwIfIncomplete);
ReadState(cache, complexSelectorStr, style.onActive, "onActive", throwIfIncomplete);
ReadState(cache, complexSelectorStr, style.onFocused, "onFocused", throwIfIncomplete);
ReadState(cache, complexSelectorStr, style.onHover, "onHover", throwIfIncomplete);
ReadState(cache, complexSelectorStr, style.onNormal, "onNormal", throwIfIncomplete);
}
public static void CopyProperty(StyleSheet sheet, UssComments comments, StyleProperty property, StyleSheetBuilderHelper helper)
{
var propertyCopy = helper.builder.BeginProperty(property.name);
helper.options.comments.AddComment(propertyCopy, comments.Get(property));
foreach (var value in property.values)
{
switch (value.valueType)
{
case StyleValueType.Color:
helper.builder.AddValue(sheet.ReadColor(value));
break;
case StyleValueType.Enum:
helper.builder.AddValue(sheet.ReadEnum(value), StyleValueType.Enum);
break;
case StyleValueType.Float:
helper.builder.AddValue(sheet.ReadFloat(value));
break;
case StyleValueType.Dimension:
helper.builder.AddValue(sheet.ReadDimension(value));
break;
case StyleValueType.Keyword:
helper.builder.AddValue(sheet.ReadKeyword(value));
break;
case StyleValueType.ResourcePath:
helper.builder.AddValue(sheet.ReadResourcePath(value), StyleValueType.ResourcePath);
break;
case StyleValueType.String:
helper.builder.AddValue(sheet.ReadString(value), StyleValueType.String);
break;
}
}
helper.builder.EndProperty();
}
public static void CopySelector(StyleSheet sheet, UssComments comments, StyleComplexSelector complexSelector, StyleSheetBuilderHelper helper)
{
helper.BeginRule(comments.Get(complexSelector.rule));
BuildSelector(complexSelector, helper);
foreach (var property in complexSelector.rule.properties)
{
CopyProperty(sheet, comments, property, helper);
}
helper.EndRule();
}
private void Split(StyleComplexSelector complexSelector1, StyleComplexSelector complexSelector2)
{
var comment1 = s1Comments.Get(complexSelector1.rule);
s1Builder.BeginRule(comment1);
StyleSheetBuilderHelper.BuildSelector(complexSelector1, s1Builder);
var comment2 = s2Comments.Get(complexSelector2.rule);
s2Builder.BeginRule(comment2);
StyleSheetBuilderHelper.BuildSelector(complexSelector2, s2Builder);
commonBuilder.BeginRule(string.IsNullOrEmpty(comment1) ? comment2 : comment1);
StyleSheetBuilderHelper.BuildSelector(complexSelector2, commonBuilder);
// This is a common selector to both s1 and s2, for each properties determine what is common:
var properties = new Dictionary <string, PropertyPair>();
StyleSheetBuilderHelper.PopulateProperties(complexSelector1.rule.properties, properties, true);
StyleSheetBuilderHelper.PopulateProperties(complexSelector2.rule.properties, properties, false);
foreach (var propertyPair in properties.Values)
{
if (propertyPair.p1 != null)
{
if (propertyPair.p2 != null)
{
// Extend needs to be in common, s1 and s2:
if (propertyPair.p1.name == ConverterUtils.k_Extend)
{
StyleSheetBuilderHelper.CopyProperty(s1Cache.sheet, s1Comments, propertyPair.p1, commonBuilder);
StyleSheetBuilderHelper.CopyProperty(s1Cache.sheet, s1Comments, propertyPair.p1, s1Builder);
StyleSheetBuilderHelper.CopyProperty(s2Cache.sheet, s2Comments, propertyPair.p2, s2Builder);
}
// Possibly common property
else if (CompareProperty(propertyPair.p1, propertyPair.p2))
{
StyleSheetBuilderHelper.CopyProperty(s1Cache.sheet, s1Comments, propertyPair.p1, commonBuilder);
}
else
{
StyleSheetBuilderHelper.CopyProperty(s1Cache.sheet, s1Comments, propertyPair.p1, s1Builder);
StyleSheetBuilderHelper.CopyProperty(s2Cache.sheet, s2Comments, propertyPair.p2, s2Builder);
}
}
else
{
// Only in s1: copy straight
StyleSheetBuilderHelper.CopyProperty(s1Cache.sheet, s1Comments, propertyPair.p1, s1Builder);
}
}
else
{
// Only in s2: copy straight
StyleSheetBuilderHelper.CopyProperty(s2Cache.sheet, s2Comments, propertyPair.p2, s2Builder);
}
}
s1Builder.EndRule();
s2Builder.EndRule();
commonBuilder.EndRule();
}
