make single layers toggleable

Author: Yatekii

.DS_Store

@@ -1,3 +1,4 @@
 /target
 /cache
-**/*.rs.bk
+**/*.rs.bk
+.DS_Store

.gitignore

@@ -21,6 +21,7 @@ use osm::css::CSSValue;
 use osm::css::Color;
 use osm::css::Number;
 use osm::css::Rule;
+use osm::css::Selector;
 use wgpu::SurfaceConfiguration;
 
 use crate::app_state::AppState;
@@ -181,15 +182,15 @@ fn add_slider_float(ui: &mut Ui, rule: &mut Rule, attribute: &str) {
         .insert(attribute.to_string(), CSSValue::Number(Number::Px(value)));
 }
 
-fn add_display_none(ui: &mut Ui, rule: &mut Rule) {
+fn add_display_none(ui: &mut Ui, rule: &mut Rule, label: &str) {
     let attribute = "display";
     let mut value = if let Some(CSSValue::String(value)) = rule.kvs.get(attribute) {
         !matches!(&value[..], "none")
     } else {
         true
     };
 
-    ui.checkbox(&mut value, WidgetText::from(attribute));
+    ui.checkbox(&mut value, WidgetText::from(label));
 
     if !value {
         rule.kvs
@@ -326,7 +327,7 @@ impl MainWindow {
                                 add_color_picker(ui, rule, "border-color");
                                 add_slider_float(ui, rule, "border-width");
                                 add_slider_float(ui, rule, "line-width");
-                                add_display_none(ui, rule);
+                                add_display_none(ui, rule, "display");
                             });
                         }
                     } else {
@@ -409,46 +410,10 @@ impl SidePanel {
             .show(ctx, |ui| {
                 ScrollArea::vertical().max_height(800.0).show(ui, |ui| {
                     let feature_collection = app_state.feature_collection();
-                    let css_cache = app_state.css_cache_mut();
                     let mut features = feature_collection.write().unwrap();
-                    let features = features.features_mut();
-                    for feature in features {
-                        let mut rules = css_cache.get_matching_rules_mut(&feature.selector);
-
-                        println!("{}", feature.selector);
-                        // assert!(rules.len() <= 1);
-                        let rule = rules.first_mut();
-                        if rule.is_none() {
-                            css_cache.add_rule(Rule {
-                                selector: feature.selector.clone(),
-                                kvs: BTreeMap::new(),
-                            });
-                        }
-                        let mut rules = css_cache.get_matching_rules_mut(&feature.selector);
-                        // TODO: Ugly!
-                        let rule = rules.first_mut().unwrap();
-                        let value = rule
-                            .kvs
-                            .entry("display".to_string())
-                            .or_insert(CSSValue::String("block".to_string()));
-                        let mut display_mut = false;
-                        match &value {
-                            CSSValue::String(value) => match &value[..] {
-                                "none" => display_mut = false,
-                                _ => display_mut = true,
-                            },
-                            value => log::info!(
-                                "The value '{:?}' is currently not supported for 'display'.",
-                                value
-                            ),
-                        }
-
-                        ui.checkbox(&mut display_mut, feature.selector.to_string());
-                        if display_mut {
-                            *value = CSSValue::String("block".to_string());
-                        } else {
-                            *value = CSSValue::String("none".to_string());
-                        }
+                    let layers = features.layers_mut();
+                    for layer in layers {
+                        ui.checkbox(&mut layer.display, &layer.name);
                     }
                 })
             });

src/bin/drawing/ui/mod.rs

@@ -6,15 +6,26 @@ use super::{Feature, FeatureStyle};
 pub struct FeatureCollection {
     features: Vec<Feature>,
     n_features_max: u32,
-    layers: Vec<(usize, String)>,
+    layers: Vec<LayerInfo>,
+}
+
+#[derive(Debug, Clone)]
+pub struct LayerInfo {
+    pub id: usize,
+    pub name: String,
+    pub display: bool,
 }
 
 impl FeatureCollection {
     pub fn new(n_features_max: u32) -> Self {
         Self {
             features: vec![],
             n_features_max,
-            layers: vec![],
+            layers: vec![LayerInfo {
+                id: 0,
+                name: "background".to_string(),
+                display: true,
+            }],
         }
     }
 
@@ -26,12 +37,12 @@ impl FeatureCollection {
         &mut self.features
     }
 
-    pub fn layers(&self) -> &Vec<(usize, String)> {
+    pub fn layers(&self) -> &Vec<LayerInfo> {
         &self.layers
     }
 
-    pub fn set_layers(&mut self, layers: Vec<(usize, String)>) {
-        self.layers = layers
+    pub fn layers_mut(&mut self) -> &mut Vec<LayerInfo> {
+        &mut self.layers
     }
 
     fn get_feature_id(&mut self, selector: &crate::css::Selector) -> Option<u32> {
@@ -49,11 +60,11 @@ impl FeatureCollection {
         self.features.len() as u32 - 1
     }
 
-    pub fn ensure_feature(&mut self, selector: &Selector) -> u32 {
+    pub fn ensure_feature(&mut self, selector: &Selector, layer_id: usize) -> u32 {
         if let Some(feature_id) = self.get_feature_id(selector) {
             feature_id
         } else {
-            self.add_feature(Feature::new(selector.clone(), 0))
+            self.add_feature(Feature::new(selector.clone(), layer_id))
         }
     }
 
@@ -84,7 +95,15 @@ impl FeatureCollection {
 
     pub fn load_styles(&mut self, zoom: f32, css_cache: &mut RulesCache) {
         for feature in &mut self.features {
-            feature.load_style(zoom, css_cache)
+            feature.load_style(
+                zoom,
+                css_cache,
+                self.layers
+                    .iter()
+                    .find(|l| l.id == feature.layer_id)
+                    .map(|l| l.display)
+                    .unwrap_or_default(),
+            )
         }
     }
 

src/lib/feature/collection.rs

@@ -34,13 +34,13 @@ pub struct FeatureStyle {
 #[derive(Debug, Clone, Default)]
 pub struct Feature {
     pub selector: Selector,
-    pub layer_id: u32,
+    pub layer_id: usize,
     pub id: u32,
     pub style: FeatureStyle,
 }
 
 impl Feature {
-    pub fn new(selector: Selector, layer_id: u32) -> Self {
+    pub fn new(selector: Selector, layer_id: usize) -> Self {
         Self {
             selector,
             layer_id,
@@ -50,7 +50,7 @@ impl Feature {
         }
     }
 
-    pub fn load_style(&mut self, zoom: f32, css_cache: &mut RulesCache) {
+    pub fn load_style(&mut self, zoom: f32, css_cache: &mut RulesCache, display_override: bool) {
         let rules = css_cache.get_matching_rules(
             &self
                 .selector
@@ -159,6 +159,8 @@ impl Feature {
             self.style.display = true;
         }
 
+        self.style.display = self.style.display && display_override;
+
         let line_width = rules
             .iter()
             .filter_map(|r| r.kvs.get("line-width"))

src/lib/feature/mod.rs

@@ -1,5 +1,6 @@
 use crate::*;
 use egui::TextBuffer;
+use feature::collection::LayerInfo;
 use glyphon::{
     Attrs, Buffer, Color, Family, FontSystem, Metrics, Shaping, TextArea, TextBounds, Weight,
 };
@@ -132,7 +133,6 @@ impl Tile {
         let extent = tile.layers[0].extent as u16;
         let mut features = vec![];
         let mut text = vec![];
-        let mut layers = vec![];
 
         // Add a background feature to the tile data.
         let (mut current_feature_id, object, range) =
@@ -142,13 +142,25 @@ impl Tile {
 
         // Transform all features of the tile.
         for layer in tile.layers {
+            let mut fc = feature_collection.write().unwrap();
+            let layers = fc.layers_mut();
             let mut map: std::collections::HashMap<Selector, Vec<(GeomType, Vec<Path>)>> =
                 HashMap::new();
             let layer_name = layer.name.to_string();
-            if !layers.contains(&(0, layer_name.clone())) {
+            let layer_id = if let Some(layer) = layers.iter().find(|l| l.name == layer_name) {
+                layer.id
+            } else {
                 println!("{}", layer.name);
-                layers.push((0, layer_name));
-            }
+                let id = layers.len();
+                let value = LayerInfo {
+                    id,
+                    name: layer_name,
+                    display: true,
+                };
+                layers.push(value);
+                id
+            };
+            drop(fc);
 
             // Preevaluate the selectors and group features by the selector they belong to.
             for feature in &layer.features {
@@ -198,7 +210,7 @@ impl Tile {
                     current_feature_id = {
                         // Scope the lock guard real tight to ensure it's released quickly.
                         let mut feature_collection = feature_collection.write().unwrap();
-                        feature_collection.ensure_feature(&selector)
+                        feature_collection.ensure_feature(&selector, layer_id)
                     };
                     builder.set_current_feature_id(current_feature_id);
 
@@ -220,10 +232,6 @@ impl Tile {
             features.extend(inner_features);
         }
 
-        let mut feature_collection = feature_collection.write().unwrap();
-        feature_collection.set_layers(layers);
-        drop(feature_collection);
-
         let collider = Arc::new(RwLock::new(TileCollider::new()));
         let _collider_keep = collider.clone();
         let objects = Arc::new(RwLock::new(objects));
@@ -340,7 +348,7 @@ impl Tile {
         let current_feature_id = {
             // Scope the lock guard real tight to ensure it's released quickly.
             let mut feature_collection = feature_collection.write().unwrap();
-            feature_collection.ensure_feature(&selector)
+            feature_collection.ensure_feature(&selector, 0)
         };
         builder.set_current_feature_id(current_feature_id);