public override Node Evaluate(Env env)
{
env.Rule = this;
var rule = new Rule(Name, Value.Evaluate(env)) {Index = Index};
env.Rule = null;
return rule;
}
public override Node Evaluate(Env env)
{
env.Rule = this;
if (Value == null)
{
throw new ParsingException("No value found for rule " + Name, Index);
}
var rule = new Rule(Name, Value.Evaluate(env)) {Index = Index};
env.Rule = null;
return rule;
}
public override Node Evaluate(Env env)
{
env.Rule = this;
if (Value == null)
{
throw new ParsingException("No value found for rule " + Name, Location);
}
var rule = new Rule(Name, Value.Evaluate(env)).ReducedFrom<Rule>(this);
rule.IsSemiColonRequired = this.IsSemiColonRequired;
rule.PostNameComments = this.PostNameComments;
env.Rule = null;
return rule;
}
private Rule MakeRuleImportant(Rule rule)
{
var valueNode = rule.Value;
var value = valueNode as Value;
value = value != null
? new Value(value.Values, "!important").ReducedFrom<Value>(value)
: new Value(new NodeList {valueNode}, "!important");
var importantRule = new Rule(rule.Name, value).ReducedFrom<Rule>(rule);
return importantRule;
}
public Rule ReverseRule(Rule rule)
{
rule.Accept(this);
// we have the values.. now we can reverse it
string content = _textContent.ToString();
string important = "";
var value = rule.Value as Value;
if (value != null)
{
important = value.Important;
}
bool valueChanged = false;
if (_nodeContent.Count > 1)
{
if (_nodeContent.Count == 4)
{
Node tmp = _nodeContent[1];
_nodeContent[1] = _nodeContent[3];
_nodeContent[3] = tmp;
return new Rule(rule.Name, new Expression(_nodeContent)).ReducedFrom<Rule>(rule);
}
}
else
{
if (content == "left")
{
content = ("right " + important).TrimEnd();
valueChanged = true;
}
else if (content == "right")
{
content = ("left " + important).TrimEnd();
valueChanged = true;
}
else
{
string[] items = content.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (items.Length == 4)
{
string temp = items[1];
items[1] = items[3];
items[3] = temp;
content = String.Join(" ", items);
valueChanged = true;
}
}
if (valueChanged)
{
return new Rule(rule.Name, new TextNode(content)).ReducedFrom<Rule>(rule);
}
}
return rule;
}
public override Node Evaluate(Env env)
{
var found = false;
var closures = env.FindRulesets(Selector);
if (closures == null)
{
throw new ParsingException(Selector.ToCSS(env).Trim() + " is undefined", Location);
}
env.Rule = this;
var rules = new NodeList();
if (PreComments)
{
rules.AddRange(PreComments);
}
foreach (var closure in closures)
{
var ruleset = closure.Ruleset;
var matchType = ruleset.MatchArguments(Arguments, env);
if (matchType == MixinMatch.ArgumentMismatch)
{
continue;
}
found = true;
if (matchType == MixinMatch.GuardFail)
{
continue;
}
if (ruleset is MixinDefinition)
{
try
{
var mixin = ruleset as MixinDefinition;
rules.AddRange(mixin.Evaluate(Arguments, env, closure.Context).Rules);
}
catch (ParsingException e)
{
throw new ParsingException(e.Message, e.Location, Location);
}
}
else
{
if (ruleset.Rules != null)
{
var nodes = new NodeList(ruleset.Rules);
NodeHelper.ExpandNodes <MixinCall>(env, nodes);
rules.AddRange(nodes);
}
}
}
if (PostComments)
{
rules.AddRange(PostComments);
}
env.Rule = null;
if (!found)
{
var message = String.Format("No matching definition was found for `{0}({1})`",
Selector.ToCSS(env).Trim(),
Arguments.Select(a => a.Value.ToCSS(env)).JoinStrings(env.Compress ? "," : ", "));
throw new ParsingException(message, Location);
}
if (Important)
{
var importantRules = new NodeList();
foreach (Node node in rules)
{
Rule r = node as Rule;
if (r != null)
{
var valueNode = r.Value;
var value = valueNode as Value;
value = value != null
? new Value(value.Values, "!important").ReducedFrom <Value>(value)
: new Value(new NodeList {
valueNode
}, "!important");
importantRules.Add((new Rule(r.Name, value)).ReducedFrom <Rule>(r));
}
else
{
importantRules.Add(node);
}
}
return(importantRules);
}
return(rules);
}
private static void CreateSymbolizers(Rule rule, Dictionary<string, Dictionary<string, CartoRule>> symbolizers, Env env, ICartoTranslator cartoTranslator)
{
// Sort symbolizers by the index of their first property definition
List<KeyValuePair<string, int>> symOrder = new List<KeyValuePair<string, int>>();
List<int> indexes = new List<int>();
foreach (string key in symbolizers.Keys)
{
int minIdx = int.MaxValue;
var props = symbolizers[key];
foreach (var prop in props)
{
int index = props[prop.Key].Index;
if (index < minIdx)
minIdx = index;
}
symOrder.Add(new KeyValuePair<string, int>(key, minIdx));
}
// Get a simple list of the symbolizers, in order
symOrder.Sort(delegate (KeyValuePair<string, int> a, KeyValuePair<string, int> b) { return a.Value.CompareTo(b.Value); });
foreach (KeyValuePair<string, int> kv in symOrder)
{
var attributes = symbolizers[kv.Key];
var symbolizer = kv.Key.Split('/')[1];
// Skip the magical * symbolizer which is used for universal properties
// which are bubbled up to Style elements intead of Symbolizer elements.
if (symbolizer == "*")
continue;
// Check if we have all required properties
string[] properties = attributes.Keys.ToArray();
string[] values = new string[properties.Length];
string missingProperty = null;
bool succ = cartoTranslator.HasRequiredProperties(symbolizer, properties, ref missingProperty);
if (!succ)
{
NodeLocation loc = attributes[missingProperty].Location;
throw new Exception(string.Format("A required property '{0}' is missing. Location: Index = {1} ; Source = {2}", missingProperty, loc.Index, loc.Source));
}
int i = 0;
foreach (string propName in attributes.Keys)
{
CartoRule cartoRule = attributes[propName];
values[i] = cartoRule.Value.GetValueAsString(env);
i++;
}
Symbolizer sym = cartoTranslator.ToSymbolizer(symbolizer, properties, values);
if (sym != null && sym.Enabled)
rule.Symbolizers.Add(sym);
}
}
/// <summary>
/// Creates rules
/// </summary>
/// <param name="style"></param>
/// <param name="def"></param>
/// <param name="env"></param>
/// <param name="existingFilters"></param>
/// <param name="cartoTranslator"></param>
private static void CreateRules(FeatureTypeStyle style, CartoDefinition def, Env env, Dictionary<string, int> existingFilters, ICartoTranslator cartoTranslator)
{
string filter = def.Filters.ToString();
if (!(existingFilters.ContainsKey(filter)))
existingFilters[filter] = 0x7FFFFF;
int available = 0x7FFFFF;
ZoomStruct zooms = new ZoomStruct();
zooms.Available = available;
NodeList<CartoRule> rules = def.Rules;
for (int i = 0; i < rules.Count; i++)
{
CartoRule cartoRule = rules[i];
zooms.Rule = cartoRule.Zoom;
if ((existingFilters[filter] & zooms.Rule) == 0)
continue;
while (((zooms.Current = zooms.Rule) & available) != 0)
{
Dictionary<string, Dictionary<string, CartoRule>> symbolizers = CollectSymbolizers(def, zooms, i, env, cartoTranslator);
if (symbolizers != null && symbolizers.Count > 0)
{
if ((existingFilters[filter] & zooms.Current) == 0)
continue;
int zoom = existingFilters[filter] & zooms.Current;
int startZoom = -1, endZoom = 0;
for (int zi = 0; zi <= 22; zi++)
{
if ((zoom & (1 << zi)) != 0)
{
if (startZoom == -1)
startZoom = zi;
endZoom = zi;
}
}
Rule rule = new Rule();
rule.Filter = ConvertUtility.ToFilter(def.Filters, cartoTranslator);
rule.Name = cartoRule.Instance;
if (startZoom > 0)
rule.MaxScale = ConvertUtility.ToScaleDenominator(startZoom);
if (endZoom > 0)
rule.MinScale = ConvertUtility.ToScaleDenominator(endZoom + 1);
CreateSymbolizers(rule, symbolizers, env, cartoTranslator);
existingFilters[filter] &= ~zooms.Current;
// Check whether the rule has at least one visible symbolizer
if (rule.Symbolizers.Count > 0 && rule.Symbolizers.Any(s => s.Enabled == true))
style.Rules.Add(rule);
}
}
}
//style.Rules.Sort(new RuleComparer());
}
