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 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()); }