public CartoDefinition(CartoDefinition def, CartoFilterSet filters, Env env)
{
m_rules = CreateCopy(def.Rules);
m_elements = new NodeList<CartoElement>(def.m_elements);
m_ruleIndex = new List<string>(def.m_ruleIndex);
m_filters = filters != null ? filters : (CartoFilterSet)def.Filters.Clone(env);
m_attachment = def.Attachment;
m_zoom = def.m_zoom;
m_specificity = def.m_specificity;
}
public CartoDefinition(CartoDefinition def, CartoFilterSet filters, Env env)
{
m_rules = CreateCopy(def.Rules);
m_elements = new NodeList <CartoElement>(def.m_elements);
m_ruleIndex = new List <string>(def.m_ruleIndex);
m_filters = filters != null ? filters : (CartoFilterSet)def.Filters.Clone(env);
m_attachment = def.Attachment;
m_zoom = def.m_zoom;
m_specificity = def.m_specificity;
}
/// <summary>
/// Removes dead style definitions that can never be reached
/// when filter-mode="first". The style is modified in-place
/// and returned. The style must be sorted.
/// </summary>
public void Fold(Env env)
{
for (int i = 0; i < Definitions.Count; i++)
{
CartoDefinition defI = Definitions[i];
for (int j = Definitions.Count - 1; j > i; j--)
{
// if (Definitions[j].Filters.CloneWith(defI.Filters, env) == null) // Runge: replace with a bit faster version
if (Definitions[j].Filters.CanCloneWith(defI.Filters, env) == false)
{
Definitions.RemoveAt(j);
}
}
}
}
public object Clone(CartoFilterSet filters, Env env)
{
CartoDefinition clone = new CartoDefinition(this, filters, env);
return clone;
}
public object Clone(Env env)
{
CartoDefinition clone = new CartoDefinition(this, null, env);
return clone;
}
public object Clone(CartoFilterSet filters, Env env)
{
CartoDefinition clone = new CartoDefinition(this, filters, env);
return(clone);
}
public object Clone(Env env)
{
CartoDefinition clone = new CartoDefinition(this, null, env);
return(clone);
}
public CartoStyle(CartoDefinition def)
{
Definitions = new List <CartoDefinition>();
Definitions.Add(def);
}
public void Add(CartoDefinition def)
{
Definitions.Add(def);
}
public void Add(CartoDefinition def)
{
Definitions.Add(def);
}
public CartoStyle(CartoDefinition def)
{
Definitions = new List<CartoDefinition>();
Definitions.Add(def);
}
private static List<CartoDefinition> AddRules(List<CartoDefinition> current, CartoDefinition definition, SortedDictionary<string, CartoDefinition> byFilter, Env env)
{
var newFilters = definition.Filters;
var newRules = definition.Rules;
object updatedFilters;
CartoDefinition clone, previous;
// The current definition might have been split up into
// multiple definitions already.
for (var k = 0; k < current.Count; k++)
{
updatedFilters = current[k].Filters.CloneWith(newFilters, env);
if (updatedFilters is CartoFilterSet)
{
string filtersString = (updatedFilters as CartoFilterSet).ToString();
if (!byFilter.TryGetValue(filtersString, out previous))
previous = null;
if (previous != null)
{
// There's already a definition with those exact
// filters. Add the current definitions' rules
// and stop processing it as the existing rule
// has already gone down the inheritance chain.
previous.AddRules(newRules);
}
else
{
clone = (CartoDefinition)current[k].Clone((CartoFilterSet)updatedFilters, env);
// Make sure that we're only maintaining the clone
// when we did actually add rules. If not, there's
// no need to keep the clone around.
if (clone.AddRules(newRules) > 0)
{
// We inserted an element before this one, so we need
// to make sure that in the next loop iteration, we're
// not performing the same task for this element again,
// hence the k++.
byFilter.Add(filtersString, clone);
current.Insert(k, clone);
k++;
}
}
}
else if (updatedFilters == null)
{
// if updatedFilters is null, then adding the filters doesn't
// invalidate or split the selector, so we addRules to the
// combined selector
// Filters can be added, but they don't change the
// filters. This means we don't have to split the
// definition.
//
// this is cloned here because of shared classes, see
// sharedclass.mss
current[k] = (CartoDefinition)current[k].Clone(env);
current[k].AddRules(newRules);
}
// if updatedFeatures is false, then the filters split the rule,
// so they aren't the same inheritance chain
}
return current;
}
private static Dictionary<string, Dictionary<string, CartoRule>> CollectSymbolizers(CartoDefinition def, ZoomStruct zooms, int i, Env env, ICartoTranslator cartoTranslator)
{
Dictionary<string, Dictionary<string, CartoRule>> symbolizers = new Dictionary<string, Dictionary<string, CartoRule>>();
NodeList<CartoRule> rules = def.Rules;
for (int j = i; j < rules.Count; j++)
{
CartoRule child = rules[j];
string symName = cartoTranslator.GetSymbolizerName(child.Name);
string key = child.Instance + "/" + symName;
if ((zooms.Current & child.Zoom) != 0 &&
(!(symbolizers.ContainsKey(key)) || (symbolizers[key] != null && !(symbolizers[key].ContainsKey(child.Name)))))
{
zooms.Current &= child.Zoom;
if (!(symbolizers.ContainsKey(key)))
symbolizers[key] = new Dictionary<string, CartoRule>();
symbolizers[key][child.Name] = child;
}
}
if (symbolizers.Count > 0)
{
zooms.Rule &= (zooms.Available &= ~zooms.Current);
return symbolizers;
}
return null;
}
/// <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());
}
