示例#1
0
        private bool AddTerm(Term value)
        {
            var added = true;

            if (_isFraction)
            {
                if (_terms.Length > 0)
                {
                    value = new PrimitiveTerm(UnitType.Unknown, _terms[_terms.Length - 1] + "/" + value);
                }
                _terms.SetLastTerm(value);
                _isFraction = false;
            }
            else if (_functionBuffers.Count > 0)
            {
                _functionBuffers.Peek().TermList.Add(value);
            }
            else if (_terms.Length == 0)
            {
                _terms.AddTerm(value);
            }
            else if (_parsingContext == ParsingContext.InSingleValue)
            {
                _terms.AddTerm(value);
            }
            else
            {
                added = false;
            }

            return(added);
        }
示例#2
0
 public GenericFunction(string name, IEnumerable<Term> arguments)
 {
     Name = name;
     var list = new TermList();
     foreach (var term in arguments)
     {
         list.AddTerm(term);
     }
     Arguments = list;
 }
示例#3
0
    public static IEnumerable<Property> Expand(this Property style, bool leftToRight)
    {
      Dictionary<string, Property> children;
      PrimitiveTerm prim;
      Term current;
      TermList list;
      IList<Term> terms;

      switch(style.Name.ToLowerInvariant())
      {
        case "background":
          children = new Dictionary<string, Property>()
          {
            {"background-color",    new Property("background-color")    { Term = new InitialTerm() }},
            {"background-image",    new Property("background-image")    { Term = new InitialTerm() }},
            {"background-repeat",   new Property("background-repeat")   { Term = new InitialTerm() }},
            {"background-position", new Property("background-position") { Term = new InitialTerm() }}
          };

          foreach (var term in GetEnumerable(style.Term))
          {
            if (term is HtmlColor)
            {
              children["background-color"].Term = term;
            }
            else
            {
              prim = term as PrimitiveTerm;
              if (prim != null)
              {
                if (prim.PrimitiveType == UnitType.Uri)
                {
                  children["background-image"].Term = term;
                }
                else if (prim.PrimitiveType == UnitType.Ident)
                {
                  switch (prim.Value.ToString())
                  {
                    case "repeat-x":
                    case "repeat-y":
                    case "repeat":
                    case "space":
                    case "round":
                    case "no-repeat":
                      current = children["background-repeat"].Term;
                      list = current as TermList;
                      if (list != null)
                      {
                        list.AddTerm(prim);
                      }
                      else if (current is InitialTerm)
                      {
                        children["background-repeat"].Term = prim;
                      }
                      else
                      {
                        list = new TermList();
                        list.AddTerm(current);
                        list.AddTerm(prim);
                        children["background-repeat"].Term = list;
                      }
                      break;
                  }
                }
              }
            }
          }

          foreach (var val in children.Values) yield return val;
          break;
        case "font":
          children = new Dictionary<string, Property>()
          {
            {"font-style",    new Property("font-style")    { Term = new InitialTerm() }},
            {"font-weight",   new Property("font-weight")   { Term = new InitialTerm() }},
            {"font-size",     new Property("font-size")     { Term = new InitialTerm() }},
            {"line-height",   new Property("line-height")   { Term = new InitialTerm() }},
            {"font-family",   new Property("font-family")   { Term = new InitialTerm() }}
          };

          foreach (var term in GetEnumerable(style.Term))
          {
            prim = term as PrimitiveTerm;
            if (prim != null)
            {
              if (prim.PrimitiveType == UnitType.Number)
              {
                switch (prim.Value.ToString())
                {
                  case "100":
                  case "200":
                  case "300":
                  case "400":
                  case "500":
                  case "600":
                  case "700":
                  case "800":
                  case "900":
                    children["font-weight"].Term = term;
                    break;
                  default:
                    children["line-height"].Term = term;
                    break;
                }
              }
              else if (prim.PrimitiveType == UnitType.Ident)
              {
                switch (prim.Value.ToString())
                {
                  case "italic":
                  case "oblique":
                    children["font-style"].Term = term;
                    break;
                  case "bold":
                  case "bolder":
                  case "lighter":
                    children["font-weight"].Term = term;
                    break;
                  default:
                    list = term as TermList;
                    if (list != null)
                    {
                      list.AddTerm(prim);
                    }
                    else if (term is InitialTerm)
                    {
                      children["font-family"].Term = prim;
                    }
                    else
                    {
                      list = new TermList();
                      list.AddTerm(term);
                      list.AddTerm(prim);
                      children["font-family"].Term = list;
                    }
                    break;
                }
              }
              else
              {
                children["font-size"].Term = term;
              }
            }
          }

          foreach (var val in children.Values) yield return val;
          break;
        case "border":
          children = new Dictionary<string, Property>()
          {
            {"border-width",    new Property("border-width")    { Term = new InitialTerm() }},
            {"border-style",    new Property("border-style")    { Term = new InitialTerm() }},
            {"border-color",    new Property("border-color")    { Term = new InitialTerm() }},
          };

          foreach (var term in GetEnumerable(style.Term))
          {
            if (term is HtmlColor)
            {
              children["border-color"].Term = term;
            }
            else
            {
              prim = term as PrimitiveTerm;
              if (prim != null)
              {
                if (prim.PrimitiveType == UnitType.Ident)
                {
                  children["border-style"].Term = term;
                }
                else
                {
                  children["border-width"].Term = term;
                }
              }
            }
          }

          foreach (var val in children.Values) yield return val;
          break;
        case "margin":
          terms = GetEnumerable(style.Term).ToList();
          switch (terms.Count)
          {
            case 1:
              yield return new Property("margin-top")    { Term = terms[0] };
              yield return new Property("margin-right")  { Term = terms[0] };
              yield return new Property("margin-bottom") { Term = terms[0] };
              yield return new Property("margin-left")   { Term = terms[0] };
              break;
            case 2:
              yield return new Property("margin-top")    { Term = terms[0] };
              yield return new Property("margin-right")  { Term = terms[1] };
              yield return new Property("margin-bottom") { Term = terms[0] };
              yield return new Property("margin-left")   { Term = terms[1] };
              break;
            case 3:
              yield return new Property("margin-top")    { Term = terms[0] };
              yield return new Property("margin-right")  { Term = terms[1] };
              yield return new Property("margin-bottom") { Term = terms[2] };
              yield return new Property("margin-left")   { Term = terms[1] };
              break;
            case 4:
              yield return new Property("margin-top")    { Term = terms[0] };
              yield return new Property("margin-right")  { Term = terms[1] };
              yield return new Property("margin-bottom") { Term = terms[2] };
              yield return new Property("margin-left")   { Term = terms[3] };
              break;
            default:
              throw new InvalidOperationException();
          }

          break;
        case "padding":
          terms = GetEnumerable(style.Term).ToList();
          switch (terms.Count)
          {
            case 1:
              yield return new Property("padding-top")    { Term = terms[0] };
              yield return new Property("padding-right")  { Term = terms[0] };
              yield return new Property("padding-bottom") { Term = terms[0] };
              yield return new Property("padding-left")   { Term = terms[0] };
              break;
            case 2:
              yield return new Property("padding-top")    { Term = terms[0] };
              yield return new Property("padding-right")  { Term = terms[1] };
              yield return new Property("padding-bottom") { Term = terms[0] };
              yield return new Property("padding-left")   { Term = terms[1] };
              break;
            case 3:
              yield return new Property("padding-top")    { Term = terms[0] };
              yield return new Property("padding-right")  { Term = terms[1] };
              yield return new Property("padding-bottom") { Term = terms[2] };
              yield return new Property("padding-left")   { Term = terms[1] };
              break;
            case 4:
              yield return new Property("padding-top")    { Term = terms[0] };
              yield return new Property("padding-right")  { Term = terms[1] };
              yield return new Property("padding-bottom") { Term = terms[2] };
              yield return new Property("padding-left")   { Term = terms[3] };
              break;
            default:
              throw new InvalidOperationException();
          }

          break;
        case "-webkit-margin-start":
        case "-moz-margin-start":
          if (leftToRight) yield return new Property("margin-left") { Term = style.Term };
          if (!leftToRight) yield return new Property("margin-right") { Term = style.Term };
          break;
        case "-webkit-padding-start":
        case "-moz-padding-start":
          if (leftToRight) yield return new Property("padding-left") { Term = style.Term };
          if (!leftToRight) yield return new Property("padding-right") { Term = style.Term };
          break;
        case "-webkit-margin-end":
        case "-moz-margin-end":
          if (leftToRight) yield return new Property("margin-right") { Term = style.Term };
          if (!leftToRight) yield return new Property("margin-left") { Term = style.Term };
          break;
        case "-webkit-padding-end":
        case "-moz-padding-end":
          if (leftToRight) yield return new Property("padding-right") { Term = style.Term };
          if (!leftToRight) yield return new Property("padding-left") { Term = style.Term };
          break;
        default:
          yield return style;
          break;
      }
    }