Esempio n. 1
0
        public static string serializeCSSStyleRule(CSSStyleRule Rule)
        {
            string returnstring = string.Empty;

            returnstring += "\r\n" + Rule.selectorText + "\r\n";
            returnstring += "{\r\n";
            returnstring += Rule.style.cssText;
            returnstring += "\r\n}\r\n";
            return(returnstring);
        }
Esempio n. 2
0
        /// <summary>
        /// update or insert a new CSSStyleRule.
        /// </summary>
        /// <param name="newRule"></param>
        private void updateStyleRule(CSSStyleRule newRule, bool updateCssText)
        {
            string selectorText = newRule.selectorText.ToLower();

            // search to update exsiting records
            for (int i = 0; i < cssRules.length; i++)
            {
                if (cssRules.item[i].type == newRule.type)
                {
                    CSSStyleRule existingRule = (CSSStyleRule)cssRules.item[i];

                    if (existingRule.selectorText.ToLower() == selectorText)
                    {
                        existingRule.style.merge(newRule.style);

                        if (updateCssText)
                        {
                            // after merge, we need to update the cssText
                            int startSearchingPosition = _cssText.IndexOf(existingRule.selectorText);

                            // this must have value, otherwise, there is an error parsing.
                            if (startSearchingPosition > 0)
                            {
                                int firstBracket  = _cssText.IndexOf("{", startSearchingPosition);
                                int secondBracket = _cssText.IndexOf("}", firstBracket);

                                string firstString  = _cssText.Substring(0, firstBracket + 1);
                                string secondString = _cssText.Substring(secondBracket);
                                _cssText = firstString + existingRule.cssText + secondString;
                            }
                            else
                            {
                                //TODO: error check.
                            }
                        }
                    }
                }
            }

            // not found existing, insert a new one.
            cssRules.insertRule(newRule, -1);

            if (updateCssText)
            {
                /// append the text to the end of csstext.
                _cssText = _cssText + CSS.CSSSerializer.serializeCSSStyleRule(newRule);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// apply css rules to current document.
        /// </summary>
        /// <param name="dom"></param>
        /// <param name="rulelist"></param>
        /// <param name="mediadeviceInfo"></param>
        public void ApplyCssRules(CSS.CSSRuleList rulelist, string mediadeviceInfo)
        {
            if (rulelist == null)
            {
                return;
            }

            foreach (var item in rulelist.item)
            {
                if (item.type == CSS.enumCSSRuleType.STYLE_RULE)
                {
                    CSS.CSSStyleRule stylerule = item as CSS.CSSStyleRule;

                    foreach (var elemntitem in this.Select(stylerule.selectorText).item)
                    {
                        elemntitem.StyleRules.Add(stylerule);
                    }
                }
                else if (item.type == CSS.enumCSSRuleType.MEDIA_RULE)
                {
                    CSS.CSSMediaRule mediarule = item as CSS.CSSMediaRule;

                    if (string.IsNullOrEmpty(mediadeviceInfo))
                    {
                        ApplyCssRules(mediarule.cssRules, string.Empty);
                    }
                    else
                    {
                        if (MediaQuery.isMatch(mediarule.media, mediadeviceInfo))
                        {
                            ApplyCssRules(mediarule.cssRules, string.Empty);
                        }
                    }
                }
                else if (item.type == enumCSSRuleType.IMPORT_RULE)
                {
                    CSS.CSSImportRule importrule = item as CSS.CSSImportRule;

                    if (importrule.stylesheet != null && importrule.stylesheet.cssRules != null)
                    {
                        if (MediaQuery.isMatch(importrule.media, mediadeviceInfo))
                        {
                            ApplyCssRules(importrule.stylesheet.cssRules, mediadeviceInfo);
                        }
                    }
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        ///  desrialized rule list. ImportRule is at the beginning of file, and should be ignored.
        /// </summary>
        /// <param name="cssText"></param>
        /// <param name="basehref">the base href for import rule. </param>
        /// <returns></returns>
        public static CSSRuleList deserializeRuleList(string cssText, string basehref)
        {
            CSSRuleList rules = new CSSRuleList();

            CSSFileScanner filescanner = new CSSFileScanner(cssText);

            CSSFileScannerResult result = filescanner.ReadNext();

            while (result != null)
            {
                if (result.type == enumCSSRuleType.STYLE_RULE)
                {
                    CSSStyleRule stylerule = deserializeCSSStyleRule(result.cssText);
                    if (stylerule != null)
                    {
                        rules.appendRule(stylerule);
                    }
                }
                else if (result.type == enumCSSRuleType.IMPORT_RULE)
                {
                    CSSImportRule importrule = deserializeCSSImportRule(result.cssText, basehref);
                    if (importrule != null)
                    {
                        rules.appendRule(importrule);
                    }
                }
                else if (result.type == enumCSSRuleType.MEDIA_RULE)
                {
                    CSSMediaRule mediarule = deserializeCSSMediaRule(result.cssText);
                    if (mediarule != null)
                    {
                        rules.appendRule(mediarule);
                    }
                }
                else
                {
                    //TODO: other rules are not implemented now.
                }

                result = filescanner.ReadNext();
            }

            return(rules);
        }
Esempio n. 5
0
        /// <summary>
        /// deserialize a CSSstyle rule.
        /// Example
        /// h1, h2
        /// {
        /// font-color:green;
        /// }
        /// </summary>
        /// <param name="cssText"></param>
        /// <returns></returns>
        public static CSSStyleRule deserializeCSSStyleRule(string cssText)
        {
            int firstBracket = cssText.IndexOf("{");
            int nextBracket  = cssText.IndexOf("}");

            if (firstBracket <= 0 && nextBracket <= 0 && firstBracket > nextBracket)
            {
                // failed, did not find it.
                return(null);
            }

            string selector = cssText.Substring(0, firstBracket).Trim();

            if (string.IsNullOrEmpty(selector))
            {
                return(null);
            }

            string innerCssText = cssText.Substring(firstBracket + 1, nextBracket - firstBracket - 1);

            CSSStyleDeclaration declartaion = deserializeDeclarationBlock(innerCssText);

            if (declartaion.item.Count == 0)
            {
                return(null);
            }

            CSSStyleRule rule = new CSSStyleRule();

            rule.selectorText = selector;

            rule.cssText = innerCssText;

            rule.style = declartaion;

            return(rule);
        }
Esempio n. 6
0
 /// <summary>
 ///  This append rule does not cause an update of csstext property.
 /// </summary>
 /// <param name="rule"></param>
 public void appendStyleRule(CSSStyleRule rule)
 {
     updateStyleRule(rule, false);
 }