public string Convert(string html, DisplayBox document)
{
CSSParser parser = new CSSParser();
var doc = parser.ParseText(File.ReadAllText(document.StylesheetUri.OriginalString.Substring(8)));
return(ParseSubtext(html.Replace(Environment.NewLine, string.Empty), doc));
}
private static ColorPalette DeriveFromCss(string css)
{
CSSParser parser = new CSSParser();
CSSDocument cssDoc = parser.ParseText(css);
ColorPalette palette = new ColorPalette();
Action <Term> termAction = (t) =>
{
if (t.Type == TermType.Hex)
{
palette.Add(t.ToString());
}
};
Action <Declaration> declarationAction = (d) =>
{
if (d.Expression != null)
{
foreach (Term term in d.Expression.Terms)
{
termAction(term);
}
}
};
Action <RuleSet> rulesetAction = (r) =>
{
ForEachDeclarationIn(r, declarationAction);
};
ForEachRuleSetIn(cssDoc, rulesetAction);
return(palette);
}
public void AddCSS(string cssString)
{
if (string.IsNullOrEmpty(cssString))
{
return;
}
Dictionary <string, Dictionary <string, string> > currentStyle = CSSParser.Parse(cssString);
if (currentStyle == null || currentStyle.Count == 0)
{
return;
}
foreach (KeyValuePair <string, Dictionary <string, string> > element in currentStyle)
{
if (this._cssStyle.ContainsKey(element.Key))
{
this._cssStyle[element.Key] = element.Value;
}
else
{
this._cssStyle.Add(element.Key, element.Value);
}
}
}
public void GetNodesAndDeclarations_Important_Declaration_Should_Override_Specificity()
{
var html = @"
<html>
<head>
<title>test</title>
</head>
<body>
<div id=""myDiv"">
</div>
</body>
</html>";
var document = new HtmlDocument();
document.LoadHtml(html);
var css = @"
#myDiv { font-family: Arial, Helvetica, sans-serif; }
div { font-family: Times New Roman !important; }";
var ruleSets = new CSSParser().ParseText(css).RuleSets;
var cssRewriter = new CSSInliner();
var nodesAndDeclarations = cssRewriter.GetMatchedNodes(document, ruleSets).ToList();
Assert.Equal(nodesAndDeclarations.Count(), 1);
Assert.Equal(nodesAndDeclarations.First().Item1.Id, "myDiv");
Assert.Equal(nodesAndDeclarations.First().Item2.Expression.ToString(), "Times New Roman");
}
public void SetDataSourceStream(Stream value, ViewableDocumentStyle style = null)
{
if (_datasourceStream != null)
{
_datasourceStream.Dispose();
_datasourceStream = null;
}
switch (View.Name)
{
case "PLAIN":
case "HTML":
case "XSLXML":
case "XML":
string content = new StreamReader(value).ReadToEnd();
DataSource = content;
break;
case "JSON":
_datasourceStream = new MemoryStream();
value.CopyTo(_datasourceStream);
value.Flush();
_datasourceStream.Position = 0;
DataSource = _datasourceStream;
break;
case "DATASET":
DataSet dataSet = new DataSet();
dataSet.ReadXml(value, XmlReadMode.Auto);
//PMN-623-DMC: Results View Scrolling laterally. Set the column-width to fit the content of all cells including header cells.
((DataGridView)View).AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
((DataGridView)View).DataSource = dataSet.Tables.Count > 0 ? dataSet.Tables[0] : null;
lblNoResults.Visible = dataSet.Tables.Count <= 0 || dataSet.Tables[0].Rows.Count <= 0;
lblNoResults.BringToFront();
// Changing row color
if (style != null)
{
CSSParser parser = new CSSParser();
parser.Read(style.Css);
foreach (int rn in style.StyledRows)
{
DataGridViewRow row = ((DataGridView)View).Rows[rn];
ApplyStyle(row, parser.Classes["StyledRows"]);
}
}
break;
default:
break;
}
}
private void GetHtmlAndCSS(ref string input, out string html, out StyleSheet styles)
{
var css = string.Empty;
CSSParser.SeparateHtmlAndCss(input, out html, out css);
styles = new StyleSheet();
var parser = new CSSParser(css);
parser.ApplyStyles(styles);
}
public void GivenACSSDocument_WhenCreatingAnInstanceOfCSSSource_RulesetsShouldBePopulatedFromTheDocument()
{
const string css = @"
#myDiv { font-family: Arial, Helvetica, sans-serif; }
div { font-family: Times New Roman, sans-serif; }";
var cssDocument = new CSSParser().ParseText(css);
var cssSource = new CSSSource(cssDocument);
Assert.Equal(cssDocument.RuleSets, cssSource.Rulesets);
}
public ImageLayerInterpreter(CSSParser parser)
: base(parser, new Regex(
"layer-[0-" + (StyleSheet.STYLE_LAYERS - 1) + "]"
//add more ImageLayer properties here as the needs for them in CSS grows
))
{
ValueInterpreters.Add(new ImageLayerRGBAInterpreter(parser));
ValueInterpreters.Add(new ImageLayerHSLAInterpreter(parser));
ValueInterpreters.Add(new ImageLayerHexInterpreter(parser));
ValueInterpreters.Add(new ImageLayerKeywordInterpreter(parser));
ValueInterpreters.Add(new ImageLayerURIInterpreter(parser));
}
public List <SelectorProperty> Parser()
{
FileIO io = new FileIO();
SelectorProperty selectorProperty = new SelectorProperty();
CSSParser cSSParser = new CSSParser();
/*ResourceManager reader = new ResourceManager(typeof(CSSParserWindowsFormsApp.Properties.Resources));
* Console.Out.WriteLine(reader.GetString("inputFilePath"));*/
io.InputFilePath = cssParserView.InputFilePathText;
io.OutputFilePath = cssParserView.OutputFilePathText;
return(cSSParser.Parser(io));
}
public DimensionInterpreter(CSSParser parser)
: base(parser, new Regex(
"left"
+ "|top"
+ "|(?:ref-)?width"
+ "|(?:ref-)?height"
+ "|right"
+ "|bottom"
//add more dimension properties here as the needs for them in CSS grows
))
{
ValueInterpreters.Add(new NumberValueInterpreter(parser, new Regex(CSSConstants.NUM + "(px)")));
}
private static IEnumerable<string> GetCssClasses(string location)
{
var cssParser = new CSSParser();
CSSDocument cssDocument = null;
if (location.StartsWith("http", true, CultureInfo.InvariantCulture))
{
BasedOnVerbosity(
() => Console.WriteLine("{0} requested...\n", location), Verbosity.Loud);
var webClient = new WebClient();
webClient.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
string css = webClient.DownloadString(location);
cssDocument = cssParser.ParseText(css);
}
else
{
cssDocument = cssParser.ParseFile(location);
}
BasedOnVerbosity(() =>
{
if (cssParser.Errors.Any())
{
Console.WriteLine("Error parsing: {0}", location);
foreach (var error in cssParser.Errors)
{
Console.WriteLine(error);
}
}
else
{
Console.WriteLine("Successfully parsed: {0}", location);
}
}, Verbosity.Loud);
return cssDocument.RuleSets
.Where(x => x.Selectors != null)
.SelectMany(x => x.Selectors)
.Where(x => x.SimpleSelectors != null)
.SelectMany(x => x.SimpleSelectors)
.SelectMany(ExtractClassFromSimpleSelector)
.SelectMany(x => x)
.Distinct();
}
public PercentageInterpreter(CSSParser parser)
: base(parser, new Regex(
"alpha"
+ "|tint-strength"
+ "|layer-[0-" + (StyleSheet.STYLE_LAYERS - 1) + "]-alpha"
+ "|left"
+ "|top"
+ "|width"
+ "|height"
+ "|right"
+ "|bottom"
//add more percentage properties here as the needs for them in CSS grows
))
{
ValueInterpreters.Add(new NumberValueInterpreter(parser, new Regex(CSSConstants.NUM + "([%])")));
}
public void TestCSSParser()
{
string source = "class{ name = Vitalya; age = \"19\"; }";
CSSParser parser = new CSSParser();
parser.Parse(source);
var result = parser.cssResult;
Assert.AreEqual("class", result.First().Key);
Assert.AreEqual("name", result.Values.First().First().Key);
Assert.AreEqual("Vitalya", result.Values.First().First().Value);
Assert.AreEqual("age", result.Values.First().Last().Key);
Assert.AreEqual("19", result.Values.First().Last().Value);
}
public StringBuilder InlineCss(StringBuilder styleElementHtml)
{
if (styleElementHtml == null)
{
return(new StringBuilder());
}
if (!styleElementHtml.ToString().ToLower().Contains(styleTagStart))
{
return(styleElementHtml);
}
try
{
var html = styleElementHtml.ToString();
var originalImagesFromHtml = GetImageSrcsFromHtml(html);
var cssParser = new CSSParser();
var cssDocument = cssParser.ParseHTMLPage(html);
var htmlDocument = new HtmlDocument();
var htmlWithoutStyleSection = GetHtmlWithoutStyleSection(html);
using (var htmlReader = new StringReader(htmlWithoutStyleSection))
{
htmlDocument.Load(htmlReader);
}
SetHtmlNodesToLowerCase(htmlDocument);
ProcessCssDocument(htmlDocument, cssDocument);
var inlineHtml = htmlDocument.DocumentNode.WriteContentTo();
foreach (var imageSrc in originalImagesFromHtml)
{
if (inlineHtml.IndexOf(imageSrc, StringComparison.OrdinalIgnoreCase) >= 0)
{
inlineHtml = inlineHtml.Replace(imageSrc.ToLower(), imageSrc);
}
}
return(new StringBuilder(inlineHtml));
}
catch (Exception)
{
return(styleElementHtml);
}
}
public void GivenACSSSource_WhenMergingAnotherCSSSource_AUnionOfRulesInBothSourcesShouldBeReturnedWhenRulesDoNotConflict()
{
const string css1 = @"#myDiv { font-family: Arial, Helvetica, sans-serif; }";
var cssDocument1 = new CSSParser().ParseText(css1);
var cssSource1 = new CSSSource(cssDocument1);
const string css2 = @"div { font-family: Arial, Helvetica, sans-serif; }";
var cssDocument2 = new CSSParser().ParseText(css2);
var cssSource2 = new CSSSource(cssDocument2);
var cssSource3 = cssSource1.Merge(cssSource2);
Assert.Equal(cssSource3.Rulesets.Count(), 2);
Assert.Equal(cssSource3.Rulesets.First().Selectors[0].ToString(), "#myDiv");
Assert.Equal(cssSource3.Rulesets.First().Declarations[0].ToString(), "font-family: Arial, Helvetica, sans-serif");
Assert.Equal(cssSource3.Rulesets.Last().Selectors[0].ToString(), "div");
Assert.Equal(cssSource3.Rulesets.Last().Declarations[0].ToString(), "font-family: Arial, Helvetica, sans-serif");
}
public void Add(XElement xe, UriResolver urSource, UriResolver urTarget )
{
string uri = urSource.ToAbsolute( xe.Attribute("href").Value );
if (!_sm.Validate(uri))
return;
CssInfo ci = new CssInfo();
ci.Element = xe;
ci.SourceUriResolver = urSource;
ci.TargetUriResolver = urTarget;
CSSParser parser = new CSSParser();
ci.CSS = parser.ParseStream( _sm.GetTextStream(uri));
_cssElements.Add(ci);
//
UriResolver SourceUriResolver = new UriResolver(uri, false);
UriResolver TargetUriResolver = new UriResolver(urTarget.ToAbsolute("images\\"), true);
_cim.AddFromCSS(ci.CSS, SourceUriResolver, TargetUriResolver);
}
public void GivenACSSSource_WhenMergingAnotherCssSource_RulesInTheOriginalCSSSourceShouldHavePrecedence()
{
const string css1 = @"
#myDiv { font-family: Arial, Helvetica, sans-serif; }
div { font-family: Times New Roman, sans-serif; }";
var cssDocument1 = new CSSParser().ParseText(css1);
var cssSource1 = new CSSSource(cssDocument1);
const string css2 = @"
#myDiv { font-family: Times New Roman, sans-serif; }
div { font-family: Arial, Helvetica, sans-serif; }";
var cssDocument2 = new CSSParser().ParseText(css2);
var cssSource2 = new CSSSource(cssDocument2);
var cssSource3 = cssSource1.Merge(cssSource2);
Assert.Equal(cssSource3.Rulesets.Count(), 2);
Assert.Equal(cssSource3.Rulesets.First().Selectors[0].ToString(), "#myDiv");
Assert.Equal(cssSource3.Rulesets.First().Declarations[0].ToString(), "font-family: Arial, Helvetica, sans-serif");
Assert.Equal(cssSource3.Rulesets.Last().Selectors[0].ToString(), "div");
Assert.Equal(cssSource3.Rulesets.Last().Declarations[0].ToString(), "font-family: Times New Roman, sans-serif");
}
public void GetNodesAndDeclarations_Important_Declarations_Have_Priority_Over_Declarations_Defined_Inline()
{
var html = @"
<html>
<head>
<title>test</title>
</head>
<body>
<div id=""myDiv"" style=""font-family: Comic Sans MS;"">
</div>
</body>
</html>";
var document = new HtmlDocument();
document.LoadHtml(html);
var css = @"#myDiv { font-family: Arial, Helvetica, sans-serif !important; }";
var ruleSets = new CSSParser().ParseText(css).RuleSets;
var cssRewriter = new CSSInliner();
var nodesAndDeclarations = cssRewriter.GetMatchedNodes(document, ruleSets).ToList();
Assert.Equal(nodesAndDeclarations.Count(), 1);
Assert.Equal(nodesAndDeclarations.First().Item2.Expression.ToString(), "Arial, Helvetica, sans-serif");
}
public BluValueInterpreter(CSSParser parser, Regex regex)
: base(parser, regex)
{
this.parser = parser as BluCSSParser;
}
public void UpdateInlineStyleForElement_Should_Update_Existing_Declaration()
{
var css = @"#myDiv { font-family: Arial, Helvetica, sans-serif; }";
var declaration = new CSSParser().ParseText(css).RuleSets.First().Declarations.First();
var node = HtmlNode.CreateNode(@"<div style=""font-weight: bold; font-family: Comic Sans MS; font-height: 14px;""/>");
CSSInliner.UpdateInlineStyleForElement(node, declaration);
Assert.Equal(node.Attributes["style"].Value, "font-weight: bold; font-family: Arial, Helvetica, sans-serif; font-height: 14px;");
}
public ImageLayerKeywordInterpreter(CSSParser parser)
: base(parser)
{
}
public void ReadContent()
{
string name;
if (IsWhitespace(Peek()))
{
HandleWhitespaces();
}
if (Peek() == '<')
{
Read();
switch (Peek())
{
case '!': // declarations
Read();
if (Peek() == '[')
{
Read();
if (ReadName() != "CDATA")
{
throw Error("Invalid declaration markup");
}
Expect('[');
ReadCDATASection();
return;
}
else if (Peek() == '-')
{
ReadComment();
return;
}
else if (ReadName() != "DOCTYPE")
{
throw Error("Invalid declaration markup.");
}
else
{
ReadUntil('>', false);
return;
}
case '?': // PIs
buffer.Length = 0;
Read();
name = ReadName();
SkipWhitespaces();
string text = String.Empty;
if (Peek() != '?')
{
while (true)
{
text += ReadUntil('?', false);
if (Peek() == '>')
{
break;
}
text += "?";
}
}
Expect('>');
return;
case '/': // end tags
buffer.Length = 0;
if (elementNames.Count == 0)
{
throw UnexpectedEndError();
}
Read();
name = ReadName();
SkipWhitespaces();
string expected = (string)elementNames.Pop();
if (name != expected)
{
throw Error(String.Format("End tag mismatch: expected {0} but found {1}", expected, name));
}
handler.OnEndElement(name);
Expect('>');
return;
default: // start tags (including empty tags)
buffer.Length = 0;
name = ReadName();
switch (name.ToLower())
{
case "style":
while (Peek() != '>' && Peek() != '/')
{
ReadAttribute(ref attributes);
}
SkipWhitespaces();
if (Peek() == '/')
{
Read();
}
ReadUntil('>', false);
// Begin CSS
string cssData = ReadUntil('<', false);
cssData = CSSParser.CleanCSS(cssData);
if (string.IsNullOrEmpty(cssData))
{
cssData = ReadUntil('<', false);
}
if (!string.IsNullOrEmpty(cssData))
{
cssData = cssData.Replace("![CDATA[", "");
cssData = cssData.Replace("]]>", "");
cssData = CSSParser.CleanCSS(cssData);
}
handler.OnStyleElement(name, attributes, cssData);
// End CSS
attributes.Clear();
ReadUntil('>', false);
return;
}
while (Peek() != '>' && Peek() != '/')
{
ReadAttribute(ref attributes);
}
SkipWhitespaces();
if (Peek() == '/')
{
handler.OnInlineElement(name, attributes);
Read();
}
else
{
handler.OnStartElement(name, attributes);
elementNames.Push(name);
}
attributes.Clear();
Expect('>');
return;
}
}
else
{
ReadCharacters();
}
}
public ImageLayerHSLAInterpreter(CSSParser parser)
: base(parser)
{
}
public BorderInterpreter(CSSParser parser)
: base(parser, new Regex("border"))
{
ValueInterpreters.Add(new BorderValueInterpreter(parser));
}
public void GetNodesAndDeclarations_Should_Pick_Class_Rule_Over_Element_Rule()
{
var html = @"
<html>
<head>
<title>test</title>
</head>
<body>
<div class=""myDiv"">
</div>
</body>
</html>";
var document = new HtmlDocument();
document.LoadHtml(html);
var css = @"
.myDiv { font-family: Arial, Helvetica, sans-serif; }
div { font-family: Times New Roman, sans-serif; }";
var ruleSets = new CSSParser().ParseText(css).RuleSets;
var cssRewriter = new CSSInliner();
var nodesAndDeclarations = cssRewriter.GetMatchedNodes(document, ruleSets).ToList();
Assert.Equal(nodesAndDeclarations.Count(), 1);
Assert.Equal(nodesAndDeclarations.First().Item1.Attributes["class"].Value, "myDiv");
Assert.Equal(nodesAndDeclarations.First().Item2.Expression.ToString(), "Arial, Helvetica, sans-serif");
}
public string[] ChooseSelectorSet(SelectorProperty obj)
{
string[] array = CSSParser.ChooseSelectorSet(obj.List);
return(array);
}
public void SetRandomIcon()
{
name = CSSParser.GetRandomIconKey();
UpdateIcon();
}
public BorderValueInterpreter(CSSParser parser)
: base(parser, new Regex("([0-9]+)(?:px)?[ \t]+(none|dotted|dashed|double|solid|hidden)[ \t]+(" + CSSConstants.COLOUR + ")"))
{
}
public void UpdateInlineStyleForElement_Should_Update_Color_And_BackgroundColor()
{
var css = @"#myDiv { background-color: white; color: black; }";
var declarations = new CSSParser().ParseText(css).RuleSets.SelectMany(x => x.Declarations);
var node = HtmlNode.CreateNode(@"<div />");
foreach (var declaration in declarations)
{
CSSInliner.UpdateInlineStyleForElement(node, declaration);
}
Assert.Equal(node.Attributes["style"].Value, "background-color: white; color: black;");
}
public void GetNodesAndDeclarations_NodeAndDeclaration_Should_Not_Be_Returned_When_Node_Has_Declaration_Defined_Inline()
{
var html = @"
<html>
<head>
<title>test</title>
</head>
<body>
<div id=""myDiv"" style=""font-family: Comic Sans MS;"">
</div>
</body>
</html>";
var document = new HtmlDocument();
document.LoadHtml(html);
var css = @"
#myDiv { font-family: Arial, Helvetica, sans-serif; }
div { font-family: Times New Roman; }";
var ruleSets = new CSSParser().ParseText(css).RuleSets;
var cssRewriter = new CSSInliner();
var nodesAndDeclarations = cssRewriter.GetMatchedNodes(document, ruleSets).ToList();
Assert.Empty(nodesAndDeclarations);
}
public static void ParseSiteStyleSheet(Page page, Repository.SiteDb SiteDb)
{
var dom = page.Dom;
string pageRelativeUrl = Kooboo.Sites.Service.ObjectService.GetObjectRelativeUrl(SiteDb, page);
string pageAbsoluteUrl = UrlHelper.Combine(SiteDb.WebSite.BaseUrl(), pageRelativeUrl);
HTMLCollection styletags = dom.getElementsByTagName("link, style");
HTMLCollection availablesheets = new HTMLCollection();
foreach (var item in styletags.item)
{
if (item.tagName == "style")
{
availablesheets.Add(item);
}
else if (item.hasAttribute("type"))
{
if (item.getAttribute("type").ToLower().Contains("css"))
{
availablesheets.Add(item);
}
}
else if (item.hasAttribute("rel"))
{
if (item.getAttribute("rel").ToLower().Contains("stylesheet"))
{
availablesheets.Add(item);
}
}
}
foreach (var item in availablesheets.item)
{
if (item.tagName == "link")
{
string href = item.getAttribute("href");
if (string.IsNullOrEmpty(href))
{
continue;
}
string cssrelativeUrl = UrlHelper.Combine(pageRelativeUrl, href);
cssrelativeUrl = UrlHelper.RelativePath(cssrelativeUrl);
var route = Sites.Routing.ObjectRoute.GetRoute(SiteDb, cssrelativeUrl);
if (route == null || route.DestinationConstType != ConstObjectType.Style)
{
continue;
}
string cssText = SiteDb.Styles.Get(route.objectId).Body;
string cssabsoluteUrl = UrlHelper.Combine(pageAbsoluteUrl, cssrelativeUrl);
if (string.IsNullOrEmpty(cssText))
{
continue;
}
CSSStyleSheet newStyleSheet = CSSParser.ParseCSSStyleSheet(cssText, cssabsoluteUrl, true);
newStyleSheet.ownerNode = item;
if (newStyleSheet != null)
{
newStyleSheet.ownerNode = item;
string media = item.getAttribute("media");
if (!string.IsNullOrEmpty(media))
{
string[] medialist = media.Split(',');
foreach (var mediaitem in medialist)
{
newStyleSheet.Medialist.appendMedium(mediaitem);
}
}
dom.StyleSheets.appendStyleSheet(newStyleSheet);
}
}
else if (item.tagName == "style")
{
string cssText = item.InnerHtml;
CSSStyleSheet newStyleSheet = CSSParser.ParseCSSStyleSheet(cssText, pageAbsoluteUrl, true);
newStyleSheet.ownerNode = item;
string media = item.getAttribute("media");
if (!string.IsNullOrEmpty(media))
{
string[] medialist = media.Split(',');
foreach (var mediaitem in medialist)
{
newStyleSheet.Medialist.appendMedium(mediaitem);
}
}
dom.StyleSheets.appendStyleSheet(newStyleSheet);
}
}
dom.hasParseCSS = true;
}
public void ConvertCSS(string cssString)
{
string paresedCss = CSSParser.ToJSon(cssString);
Debug.Log("New jSon object:\n" + paresedCss);
_CSSObject = JsonUtility.FromJson <CSSObject>(paresedCss);
RectTransform rectTransform = GetComponent <RectTransform>();
Image image = GetComponent <Image>();
Text text = GetComponent <Text>();
Transform originalParent = transform.parent;
int positionInHierarchy = transform.GetSiblingIndex();
Transform canvasRoot = GetComponentInParent <Canvas>().transform;
transform.SetParent(canvasRoot, false);
float left = rectTransform.anchoredPosition.x;
float top = rectTransform.anchoredPosition.y;
float width = rectTransform.sizeDelta.x;
float height = rectTransform.sizeDelta.y;
rectTransform.pivot = new Vector2(0.5f, 0.5f);
rectTransform.anchorMax = Vector2.up;
rectTransform.anchorMin = Vector2.up;
if (!string.IsNullOrEmpty(_CSSObject.width))
{
width = GetLayoutPropety(_CSSObject.width);
}
if (!string.IsNullOrEmpty(_CSSObject.height))
{
height = GetLayoutPropety(_CSSObject.height);
}
rectTransform.sizeDelta = new Vector2(width, height);
if (!string.IsNullOrEmpty(_CSSObject.left))
{
left = GetLayoutPropety(_CSSObject.left);
}
if (!string.IsNullOrEmpty(_CSSObject.top))
{
top = GetLayoutPropety(_CSSObject.top);
}
rectTransform.anchoredPosition = new Vector2(left + (width / 2), -top - (height / 2));
transform.SetParent(originalParent, true);
transform.SetSiblingIndex(positionInHierarchy);
if (anchorsToCorners)
{
AnchorsToCorners(rectTransform);
}
if (image != null)
{
if (preserveImageAspect)
{
image.preserveAspect = true;
}
if (!string.IsNullOrEmpty(_CSSObject.background_color))
{
Color newColor = new Color();
ColorUtility.TryParseHtmlString(_CSSObject.background_color, out newColor);
image.color = newColor;
}
if (!string.IsNullOrEmpty(_CSSObject.opacity))
{
float newOpacity = float.Parse(_CSSObject.opacity);
Color newColor = image.color;
newColor.a = newOpacity;
image.color = newColor;
}
}
if (text != null)
{
if (!string.IsNullOrEmpty(_CSSObject.color))
{
Color newColor = new Color();
ColorUtility.TryParseHtmlString(_CSSObject.color, out newColor);
text.color = newColor;
}
if (!string.IsNullOrEmpty(_CSSObject.text_align))
{
switch (_CSSObject.text_align)
{
case "left":
text.alignment = TextAnchor.MiddleLeft;
break;
case "center":
text.alignment = TextAnchor.MiddleCenter;
break;
case "right":
text.alignment = TextAnchor.MiddleRight;
break;
default:
text.alignment = TextAnchor.MiddleCenter;
break;
}
}
string fontFamily = "";
int fontSize = 0;
string fontStyle = "";
float lineSpacing = 0f;
if (!string.IsNullOrEmpty(_CSSObject.font))
{
string[] fontParts = _CSSObject.font.Split(new char[] { '_', ' ' });
Debug.Log(fontParts.Length);
if (fontParts.Length == 3)
{
fontStyle = fontParts[0];
fontFamily = fontParts[2];
string fontparam = fontParts[1].Replace("px", "");
string[] fontparams = fontparam.Split('/');
if (fontparams.Length == 2)
{
if (!string.IsNullOrEmpty(fontparams[0]))
{
fontSize = int.Parse(fontparams[0]);
}
if (!string.IsNullOrEmpty(fontparams[1]))
{
lineSpacing = float.Parse(fontparams[1]) / fontSize;
}
}
}
}
else
{
if (!string.IsNullOrEmpty(_CSSObject.font_family))
{
fontFamily = _CSSObject.font_family;
}
if (!string.IsNullOrEmpty(_CSSObject.font_style))
{
fontStyle = _CSSObject.font_style;
}
if (!string.IsNullOrEmpty(_CSSObject.font_size))
{
_CSSObject.font_size = _CSSObject.font_size.Replace("px", "");
fontSize = int.Parse(_CSSObject.font_size);
}
if (!string.IsNullOrEmpty(_CSSObject.line_height))
{
_CSSObject.line_height = _CSSObject.line_height.Replace("px", "");
lineSpacing = float.Parse(_CSSObject.line_height);
}
}
if (!string.IsNullOrEmpty(fontFamily))
{
Font[] allFonts = Resources.FindObjectsOfTypeAll <Font>();
foreach (Font font in allFonts)
{
string[] fontParts = font.name.Split(new char[] { '-', ' ' });
if (fontParts.Length == 1)
{
if (fontParts[0].Equals(fontFamily, System.StringComparison.OrdinalIgnoreCase))
{
text.font = font;
}
}
else if (fontParts.Length == 2 && !string.IsNullOrEmpty(fontStyle))
{
if (fontParts[0].Equals(fontFamily, System.StringComparison.OrdinalIgnoreCase) &&
fontParts[1].Equals(fontStyle, System.StringComparison.OrdinalIgnoreCase))
{
text.font = font;
}
}
}
}
if (fontSize > 0)
{
text.fontSize = fontSize;
text.resizeTextForBestFit = true;
text.resizeTextMaxSize = fontSize;
}
if (lineSpacing > 0f)
{
text.lineSpacing = lineSpacing;
}
if (!string.IsNullOrEmpty(_CSSObject.text_transform))
{
switch (_CSSObject.text_transform)
{
case "uppercase":
text.text = text.text.ToUpper();
break;
case "lowercase":
text.text = text.text.ToLower();
break;
}
}
}
}
