示例#1
1
        public void LoadFromStream(Stream stream)
        {
            var parser = new StylesheetParser ();

            parser.Parse(stream);

            Stylesheet = parser.Stylesheet;
        }
示例#2
0
        public void LoadFromString(string content)
        {
            var parser = new StylesheetParser();

            parser.Parse (content);

            Stylesheet = parser.Stylesheet;
        }
示例#3
0
 public static void Css()
 {
     var parser = new StylesheetParser();
     var stylesheet = parser.Parse(".someClass{color: red; background-image: url('/images/logo.png')");
     //var noo = stylesheet.RuleSets.First().Selectors.First().SimpleSelectors.First().
     //var imageUrl = stylesheet.RuleSets
     //									 .SelectMany(r => r.Declarations).First().
     //									 .SelectMany(d => d.Expression.Terms).First(t => t.Type == TermType.Url); // Finds the '/images/logo.png' image
 }
 private static void AddExCssStyle(this IXLWorksheet worksheet, int rowId, int colId, HtmlNode cell)
 {
     var css = cell.GetAttributeValue("style", "");
     var parser = new StylesheetParser();
     var stylesheet = parser.Parse(css);
     SimpleSelector color =
         stylesheet.RuleSets.SelectMany(x => x.Selectors)
                   .SelectMany(x => x.SimpleSelectors)
                   .FirstOrDefault(x => x.ElementName == "color");
     string thing = (color == null) ? "" : color.Child.Pseudo;
     worksheet.Cell(rowId, colId).Style.Font.FontColor = XLColor.FromName(thing);
 }
示例#5
0
        public static IDictionary<string, BaseStyle> ParceCss(string content)
        {
            var parser = new StylesheetParser();

            var styles = parser.Parse(content);
            var rules = styles.RuleSets.ToArray();

            var result = rules.ToDictionary(
                rule => rule.Selectors.First().SimpleSelectors.First().Class,
                rule => new StyleFactory(rule.Declarations).Style);

            return result;
        }
        private async Task ProcessCss(IDotvvmRequestContext context)
        {
            Modified = false;
            var getCodeTasks = resources.Select(t => GetCode(t, context)).ToArray();

            Task.WaitAll(getCodeTasks);
            var strings = getCodeTasks.Select(t => t.Result).ToArray();
            var code    = string.Join(string.Empty, strings);

            if (string.IsNullOrWhiteSpace(code))
            {
                ampCustomCode    = string.Empty;
                ampKeyFramesCode = string.Empty;
                return;
            }

            CheckStyleCodeForPrematureEnding(code);

            var parser     = new ExCSS.StylesheetParser(true, true, true, true, true);
            var stylesheet = await parser.ParseAsync(code);

            var styleRules    = new StringBuilder();
            var keyframeRules = new StringBuilder();

            ampValidator.CheckStylesheet(stylesheet);

            foreach (var styleRule in stylesheet.Children)
            {
                if (configuration.StyleRemoveForbiddenImportant)
                {
                    foreach (var property in GetAllProperties(styleRule))
                    {
                        property.IsImportant = false;
                    }
                }

                if (styleRule is IKeyframeRule keyframe)
                {
                    keyframeRules.Append(keyframe.ToCss());
                }
                else
                {
                    styleRules.Append(styleRule.ToCss());
                }
            }

            ampCustomCode    = MinifiCss(styleRules.ToString());
            ampKeyFramesCode = MinifiCss(keyframeRules.ToString());
        }
示例#7
0
        public static Rule CreateRule(this StylesheetParser parser, RuleType type)
        {
            switch (type)
            {
            case RuleType.Charset:
                return(new CharsetRule(parser));

            case RuleType.Document:
                return(new DocumentRule(parser));

            case RuleType.FontFace:
                return(new FontFaceRule(parser));

            case RuleType.Import:
                return(new ImportRule(parser));

            case RuleType.Keyframe:
                return(new KeyframeRule(parser));

            case RuleType.Keyframes:
                return(new KeyframesRule(parser));

            case RuleType.Media:
                return(new MediaRule(parser));

            case RuleType.Namespace:
                return(new NamespaceRule(parser));

            case RuleType.Page:
                return(new PageRule(parser));

            case RuleType.Style:
                return(new StyleRule(parser));

            case RuleType.Supports:
                return(new SupportsRule(parser));

            case RuleType.Viewport:
                return(new ViewportRule(parser));

            case RuleType.Unknown:
            case RuleType.RegionStyle:
            case RuleType.FontFeatureValues:
            case RuleType.CounterStyle:
            default:
                return(null);
            }
        }
        public static void ConvertRelativeUrlsToAbsolute(CombinatorResource resource, Uri baseUrl)
        {
            if (String.IsNullOrEmpty(resource.Content)) return;

            var stylesheet = new StylesheetParser().Parse(resource.Content);

            // Modifying relative urls (because when saved, local urls were converted to unified relative ones) to point to the original domain
            ProcessUrls(
                resource,
                stylesheet,
                (ruleSet, urlTerm) =>
                {
                    if (Uri.IsWellFormedUriString(urlTerm.Value, UriKind.Absolute)) return;

                    urlTerm.Value = new Uri(baseUrl, urlTerm.Value).ToProtocolRelative();
                });
        }
        public void ProcessResource(CombinatorResource resource, StringBuilder combinedContent, ICombinatorSettings settings)
        {
            if (resource.IsCdnResource && !settings.CombineCDNResources)
            {
                resource.IsOriginal = true;
                return;
            }

            var absoluteUrlString = resource.AbsoluteUrl.ToString();

            _resourceFileService.LoadResourceContent(resource);

            _eventHandler.OnContentLoaded(resource);

            if (String.IsNullOrEmpty(resource.Content)) return;

            if (resource.Type == ResourceType.Style)
            {
                var stylesheet = new StylesheetParser().Parse(resource.Content);
                AdjustRelativePaths(resource, stylesheet);

                if (settings.EmbedCssImages && (settings.EmbedCssImagesStylesheetExcludeFilter == null || !settings.EmbedCssImagesStylesheetExcludeFilter.IsMatch(absoluteUrlString)))
                {
                    EmbedImages(resource, stylesheet, settings.EmbeddedImagesMaxSizeKB);
                }

                resource.Content = stylesheet.ToString();
            }

            if (settings.MinifyResources && (settings.MinificationExcludeFilter == null || !settings.MinificationExcludeFilter.IsMatch(absoluteUrlString)))
            {
                MinifyResourceContent(resource);
                if (String.IsNullOrEmpty(resource.Content)) return;
            }

            _eventHandler.OnContentProcessed(resource);

            combinedContent.Append(resource.Content);
        }
        /// <summary> Gets the CSS classes. </summary>
        /// <returns> The CSS classes. </returns>
        public static StyleSheet GetStyleSheet()
        {
            string pdfStyleSheet = OutputSettings.Instance.StyleSheet;

            if (string.IsNullOrWhiteSpace(pdfStyleSheet))
            {
                return null;
            }

            StylesheetParser ssp = new StylesheetParser();
            string css = File.ReadAllText(HttpContext.Current.Server.MapPath(pdfStyleSheet));
            Stylesheet stylesheet = ssp.Parse(css);

            StyleSheet styles = new StyleSheet();

            foreach (RuleSet ruleSet in stylesheet.RuleSets)
            {
                Dictionary<string, string> attributes =
                    ruleSet.Declarations.ToDictionary(
                        declaration => declaration.Name,
                        declaration => declaration.Expression.ToString());

                foreach (Selector selector in ruleSet.Selectors)
                {
                    if (selector.ToString().StartsWith(".", StringComparison.OrdinalIgnoreCase))
                    {
                        styles.LoadStyle(selector.ToString(), attributes);
                    }
                    else
                    {
                        styles.LoadTagStyle(selector.ToString(), attributes);
                    }
                }
            }

            return styles;
        }
示例#11
0
        public IEnumerable <ElementStyle> ParseStyles(string css)
        {
            var parser     = new ExCSS.StylesheetParser();
            var stylesheet = parser.Parse(css);

            foreach (var child in stylesheet.Children)
            {
                if (child is Rule rule)
                {
                    if (rule.Type == RuleType.Style)
                    {
                        var style = new ElementStyle();

                        foreach (var ruleChild in rule.Children)
                        {
                            if (ruleChild is ISelector selector)
                            {
                                style.Keys.Add(selector.Text);
                            }

                            else if (ruleChild is StyleDeclaration declaration)
                            {
                                foreach (var prop in declaration.Children)
                                {
                                    if (prop is Property property)
                                    {
                                        style.Properties.Add(property);
                                    }
                                }
                            }
                        }

                        yield return(style);
                    }
                }
            }
        }
示例#12
0
        static void Main(string[] args)
        {
            restore();
            Environment.Exit(0);

            List <FileInformation> AllCssFiles = getFileList();

            backup(AllCssFiles);
            Console.WriteLine("目前一共" + AllCssFiles.Count.ToString() + "个主题样式!");
            foreach (FileInformation item in AllCssFiles)
            {
                Console.WriteLine("正在处理:" + item.FullName);
                ExCSS.Stylesheet css        = new ExCSS.StylesheetParser().Parse(item.Content);
                StyleRule        stagestyle = css.Children.Single(x => ((StyleRule)x).SelectorText == "stage") as StyleRule;
                if (stagestyle != null)
                {
                    string aa = stagestyle.Style.FontFamily;
                    string pp = stagestyle.Style.FontSize;
                    stagestyle.Style.SetPropertyValue("font-family", "Microsoft YaHei");
                    stagestyle.Style.SetPropertyValue("font-size", "12pt");

                    try {
                        using (TextWriter writer = File.CreateText(item.FullName)) {
                            writer.Write(css.ToCss());
                        }
                    } catch (System.Exception e) {
                        if (e is System.UnauthorizedAccessException)
                        {
                            Console.ForegroundColor = ConsoleColor.Red;
                            Console.WriteLine("修改:" + item.FullName + " 时,执行权限不够,请提权后重试!");
                            System.Environment.Exit(0);
                        }
                    }
                }
            }
        }
示例#13
0
 internal DeclarationRule(RuleType type, string name, StylesheetParser parser)
     : base(type, parser)
 {
     _name = name;
 }
示例#14
0
 internal SupportsRule(StylesheetParser parser)
     : base(RuleType.Supports, parser)
 {
 }
示例#15
0
 public StylesheetComposer(Lexer lexer, StylesheetParser parser)
 {
     _lexer  = lexer;
     _parser = parser;
     _nodes  = new Stack <StylesheetNode>();
 }
示例#16
0
 internal DocumentRule(StylesheetParser parser)
     : base(RuleType.Document, parser)
 {
 }
示例#17
0
 internal MediaRule(StylesheetParser parser) : base(RuleType.Media, parser)
 {
     AppendChild(new MediaList(parser));
 }
示例#18
0
 internal KeyframeRule(StylesheetParser parser)
     : base(RuleType.Keyframe, parser)
 {
     AppendChild(new StyleDeclaration(this));
 }
        public void ReplaceCssImagesWithSprite(CombinatorResource resource)
        {
            Func<RuleSet, Term, bool> noSprite =
                (ruleSet, url) =>
                {
                    if (url.Value.Contains("no-sprite")
                        || ruleSet.Selectors.Any(selector => selector.SimpleSelectors.Any(simpleSelector => simpleSelector.Class == "no-sprite"))) return true;

                    // Images with a background position are not suitable for sprite generation if they aren't top-left
                    if (ruleSet.Declarations.Any(declaration => declaration.Name == "background-position"
                        && (declaration.Expression.Terms.Count() != 2
                                || !declaration.Expression.Terms.Any(term => term.Value == "top")
                                || !declaration.Expression.Terms.Any(term => term.Value == "left")))) return true;

                    // Images with a background size are not suitable for sprite generation
                    if (ruleSet.Declarations.Any(declaration => declaration.Name == "background-size")) return true;

                    // Images with a background repeat are not suitable for sprite generation
                    if (ruleSet.Declarations.Any(declaration => declaration.Name == "background-repeat"
                        && (declaration.Expression.Terms.Count() != 1 || declaration.Expression.Terms.First().Value != "no-repeat"))) return true;

                    var backgroundTerms =
                        ruleSet.Declarations
                            .Where(declaration => declaration.Name == "background")
                            .SelectMany(declaration => declaration.Expression.Terms);

                    // Sized backgrounds are not suitable either
                    // LineHeightTerm is filled with a value when if in the shorthand background declaration there's the background size specified, e.g.:
                    // background: url(url-to-img) 300px 400px / 500px 600px no-repeat;
                    // Now there will be a term for 400px, having LineHeightTerm specified for 500px.
                    if (backgroundTerms.Any(term => term.LineHeightTerm != null)) return true;

                    var backgroundTermValues = backgroundTerms.Select(term => term.Value);

                    // Positioned backgrounds are not suitable either, except top-left ones
                    if (backgroundTerms
                        .Any(term =>
                            term.Value == "center" ||
                            term.Value == "top" ||
                            term.Value == "right" ||
                            term.Value == "bottom" ||
                            term.Unit != null) &&
                            !(backgroundTermValues.Contains("top") && backgroundTermValues.Contains("left"))) return true;

                    if (backgroundTermValues.Any(value => value == "repeat-x" || value == "repeat-y" || value == "repeat")) return true;

                    return false;
                };

            var images = new Dictionary<string, CssImage>();
            var stylesheet = new StylesheetParser().Parse(resource.Content);

            ProcessImageUrls(
                resource,
                stylesheet,
                (ruleSet, urlTerm) =>
                {
                    var url = urlTerm.Value;

                    if (noSprite(ruleSet, urlTerm)) return;

                    var imageContent = _resourceFileService.GetImageContent(InlineUriFactory(resource, url), 5000);

                    if (imageContent != null)
                    {
                        images[url] = new CssImage { Content = imageContent };
                    }
                });

            if (images.Count == 0) return;

            _cacheFileService.WriteSpriteStream(
                resource.Content.GetHashCode() + ".jpg",
                (stream, publicUrl) =>
                {
                    using (var sprite = new Sprite(images.Values.Select(image => image.Content)))
                    {
                        var imageEnumerator = images.Values.GetEnumerator();
                        foreach (var backgroundImage in sprite.Generate(stream, ImageFormat.Jpeg))
                        {
                            imageEnumerator.MoveNext();
                            imageEnumerator.Current.BackgroundImage = backgroundImage;
                            imageEnumerator.Current.BackgroundImage.Url = InlineUriFactory(resource, publicUrl);
                        }
                    }
                });

            ProcessImageUrls(
                resource,
                stylesheet,
                (ruleSet, urlTerm) =>
                {
                    var url = urlTerm.Value;

                    if (images.ContainsKey(url))
                    {
                        var backgroundImage = images[url].BackgroundImage;

                        var imageDeclaration = new Declaration
                        {
                            Name = "background-image",
                            Expression = new Expression
                            {
                                Terms = new List<Term>
                                        {
                                            new Term { Type = TermType.Url, Value = backgroundImage.Url.ToProtocolRelative() }
                                        }
                            }
                        };
                        ruleSet.Declarations.Add(imageDeclaration);

                        var bgPosition = backgroundImage.Position;
                        var positionDeclaration = new Declaration
                        {
                            Name = "background-position",
                            Expression = new Expression
                            {
                                Terms = new List<Term>
                                        {
                                            new Term { Type = TermType.Number, Value = bgPosition.X.ToString(), Unit = Unit.Px },
                                            new Term { Type = TermType.Number, Value = bgPosition.Y.ToString(), Unit = Unit.Px }
                                        }
                            }
                        };
                        ruleSet.Declarations.Add(positionDeclaration);
                    }
                });

            resource.Content = stylesheet.ToString();
        }
示例#20
0
 internal ImportRule(StylesheetParser parser) : base(RuleType.Import, parser)
 {
     AppendChild(new MediaList(parser));
 }
示例#21
0
 internal PageRule(StylesheetParser parser)
     : base(RuleType.Page, parser)
 {
     AppendChild(SimpleSelector.All);
     AppendChild(new StyleDeclaration(this));
 }
示例#22
0
 public UnknownRule(string name, StylesheetParser parser)
     : base(RuleType.Unknown, parser)
 {
     Name = name;
 }
示例#23
0
 internal CharsetRule(StylesheetParser parser)
     : base(RuleType.Charset, parser)
 {
 }
示例#24
0
 internal Stylesheet(StylesheetParser parser)
 {
     _parser = parser;
     Rules   = new RuleList(this);
 }
示例#25
0
 internal MediaList(StylesheetParser parser)
 {
     _parser = parser;
 }
示例#26
0
 internal NamespaceRule(StylesheetParser parser)
     : base(RuleType.Namespace, parser)
 {
 }
示例#27
0
 internal KeyframesRule(StylesheetParser parser)
     : base(RuleType.Keyframes, parser)
 {
     Rules = new RuleList(this);
 }