diff --git a/crates/engine/src/cmd/qgis.rs b/crates/engine/src/cmd/qgis.rs
index dee40c793..3eef1e4b8 100644
--- a/crates/engine/src/cmd/qgis.rs
+++ b/crates/engine/src/cmd/qgis.rs
@@ -188,7 +188,9 @@ fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, has_dir: bool, report:
             return Ok(None);
         }
         Source::Other { provider } => {
-            report.skipped(name, format!("the layer: RustGIS doesn't read QGIS's {provider} sources"));
+            // A layer of no provider (an annotation layer, a group layer) is told by its kind.
+            let what = if provider.is_empty() { format!("{} layers", layer.kind) } else { format!("{provider} sources") };
+            report.skipped(name, format!("the layer: RustGIS doesn't read QGIS's {what}"));
             return Ok(None);
         }
     }
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 53b676bbc..c9364b356 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -715,6 +715,11 @@ fn a_qgis_project_opens_as_a_map_and_a_qgis_style_styles_a_layer() {
     let t = s.map().tiles.iter().find(|t| t.name == "Tiles").unwrap();
     assert!(t.overlay);
     assert_eq!(t.blend, rustgis_map::effects::Blend::Multiply);
+    // A layer of no provider (QGIS's annotation layer) is noted by its kind.
+    let qgs = r#"<qgis version="3.42.0"><title>Notes</title><projectlayers><maplayer type="annotation"><id>a</id><layername>Notes</layername></maplayer></projectlayers></qgis>"#;
+    let out = s.run("project.importQgis", &json!({"text": qgs})).unwrap();
+    let text = serde_json::to_string(&out["notes"]).unwrap();
+    assert!(text.contains("doesn't read QGIS's annotation layers"), "{text}");
     // A project given as text with no folder: a relative path is noted, not looked for in the
     // working directory.
     let rel = r#"<qgis version="3.42.0"><projectlayers><maplayer type="vector"><id>a</id><datasource>./data/roads.geojson</datasource><layername>Rel</layername><provider>ogr</provider></maplayer></projectlayers></qgis>"#;
diff --git a/crates/map/src/qgis/labels.rs b/crates/map/src/qgis/labels.rs
index f0c61dcf9..ba5999e14 100644
--- a/crates/map/src/qgis/labels.rs
+++ b/crates/map/src/qgis/labels.rs
@@ -5,7 +5,7 @@
 
 use roxmltree::Node;
 
-use super::{QGIS_SCALE, Report, child, color, expr};
+use super::{QGIS_SCALE, Report, child, color, data_defined_on, expr, prop, props};
 use crate::Rgba;
 use crate::symbology::{DEFAULT_LABEL_CLASS, LABEL_SIZE, LabelClass, LabelPlacement, Labeling, MAX_LABEL_CLASSES};
 
@@ -191,6 +191,12 @@ fn class(
         report.approximated(layer, "label letter spacing, left out");
     }
     let halo = child(text, "text-buffer").is_some_and(|b| b.attribute("bufferDraw") == Some("1"));
+    if halo {
+        report.approximated(
+            layer,
+            "label halos in their own colour and width, drawn as RustGIS's (thin, white or dark by the text's colour)",
+        );
+    }
     if child(text, "background").is_some_and(|b| b.attribute("shapeDraw") == Some("1")) {
         report.approximated(layer, "label backgrounds (shapes behind the text), left out");
     }
@@ -198,6 +204,7 @@ fn class(
         report.approximated(layer, "label shadows, left out");
     }
     let placement = child(settings, "placement").map_or(LabelPlacement::Auto, |p| placement(p, layer, report));
+    unread(settings, layer, report);
     // The settings' own scale range, else the rule's.
     let rendering = child(settings, "rendering");
     let (mut min_scale, mut max_scale) = scales;
@@ -224,6 +231,36 @@ fn class(
     })
 }
 
+/// Notes the label settings RustGIS has no place for, where they are set off QGIS's defaults.
+fn unread(settings: Node, layer: &str, report: &mut Report) {
+    let num =
+        |n: Option<Node>, k: &str| n.and_then(|n| n.attribute(k)).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite());
+    let p = child(settings, "placement");
+    if num(p, "dist").is_some_and(|d| d != 0.0) {
+        report.approximated(layer, "label distances from their features, left out");
+    }
+    if num(p, "xOffset").is_some_and(|d| d != 0.0) || num(p, "yOffset").is_some_and(|d| d != 0.0) {
+        report.approximated(layer, "label offsets, left out");
+    }
+    if num(p, "repeatDistance").is_some_and(|d| d > 0.0) {
+        report.approximated(layer, "labels repeated along lines, drawn once");
+    }
+    if num(p, "priority").is_some_and(|d| d != 5.0) {
+        report.approximated(layer, "label priorities, left out");
+    }
+    let format = child(settings, "text-format");
+    if format.and_then(|f| f.attribute("wrapChar")).is_some_and(|w| !w.is_empty()) || num(format, "autoWrapLength").is_some_and(|w| w > 0.0)
+    {
+        report.approximated(layer, "wrapped labels, drawn on one line");
+    }
+    if child(settings, "callout").is_some_and(|c| prop(&props(c), "enabled") == Some("1")) {
+        report.skipped(layer, "label callouts (lines from a label to its feature)");
+    }
+    if data_defined_on(settings) {
+        report.skipped(layer, "data-defined label settings (from fields or expressions)");
+    }
+}
+
 /// QGIS's label placement, as RustGIS's.
 fn placement(p: Node, layer: &str, report: &mut Report) -> LabelPlacement {
     let quad = |q: Option<&str>| match q {
diff --git a/crates/map/src/qgis/mod.rs b/crates/map/src/qgis/mod.rs
index 44c1c0d10..0b09db0e0 100644
--- a/crates/map/src/qgis/mod.rs
+++ b/crates/map/src/qgis/mod.rs
@@ -169,6 +169,8 @@ pub struct ProjectLayer {
     pub source: Source,
     /// Its coordinate system (`EPSG:…`), when QGIS records one.
     pub crs: Option<String>,
+    /// QGIS's kind of layer (`vector`, `raster`, `vector-tile`, `annotation`, `mesh`, …).
+    pub kind: String,
     /// A vector layer (`false`: raster, mesh, point cloud and the like).
     pub vector: bool,
     /// Checked in the layer tree, and every group holding it too.
@@ -186,21 +188,30 @@ pub fn read_project(text: &str, dir: &str, report: &mut Report) -> Result<Projec
     if !root.has_tag_name("qgis") {
         return Err("not a QGIS project (.qgs): its root element isn't <qgis>".into());
     }
+    // The main map canvas: its view, and (before QGIS 3) the project's coordinate system.
+    let canvas = root.children().find(|c| c.has_tag_name("mapcanvas") && c.attribute("name").is_none_or(|n| n == "theMapCanvas"));
+    let crs = child(root, "projectCrs")
+        .and_then(crs_of)
+        .or_else(|| canvas.and_then(|c| child(c, "destinationsrs")).and_then(crs_of))
+        .or_else(|| {
+            let p = child(root, "properties").and_then(|p| child(p, "SpatialRefSys")).and_then(|s| child(s, "ProjectCrs"))?;
+            p.text().map(str::trim).filter(|t| t.contains(':')).map(str::to_string)
+        });
     let mut project = Project {
         title: child(root, "title").and_then(|t| t.text()).map(str::trim).unwrap_or_default().to_string(),
-        crs: child(root, "projectCrs").and_then(crs_of),
-        extent: None,
+        crs,
+        extent: canvas.and_then(|c| child(c, "extent")).and_then(extent_of),
         layers: Vec::new(),
     };
-    // The main map canvas's view.
-    let canvas = root.children().find(|c| c.has_tag_name("mapcanvas") && c.attribute("name").is_none_or(|n| n == "theMapCanvas"));
-    project.extent = canvas.and_then(|c| child(c, "extent")).and_then(extent_of);
-    // The layer tree: the order layers draw in (top first) and which are checked.
-    let tree = child(root, "layer-tree-group");
+    // The layer tree (QGIS 2's legend before it): the order layers draw in (top first) and which
+    // are checked.
     let mut order: Vec<(String, bool)> = Vec::new();
-    if let Some(t) = tree {
+    if let Some(t) = child(root, "layer-tree-group") {
         tree_layers(t, true, &mut order, 0);
+    } else if let Some(l) = child(root, "legend") {
+        legend_layers(l, true, &mut order, 0);
     }
+    project_notes(root, report);
     let maplayers: Vec<Node> =
         child(root, "projectlayers").map(|p| p.children().filter(|c| c.has_tag_name("maplayer")).collect()).unwrap_or_default();
     if maplayers.len() > MAX_LAYERS {
@@ -216,7 +227,8 @@ pub fn read_project(text: &str, dir: &str, report: &mut Report) -> Result<Projec
         let provider = child(ml, "provider").and_then(|n| n.text()).unwrap_or_default().trim().to_string();
         let datasource = child(ml, "datasource").and_then(|n| n.text()).unwrap_or_default().trim().to_string();
         let source = source::read(&provider, &datasource, dir);
-        let vector = ml.attribute("type") == Some("vector");
+        let kind = ml.attribute("type").unwrap_or_default().to_string();
+        let vector = kind == "vector";
         let definition_query = match &source {
             Source::File { subset: Some(q), .. } => match expr::to_sql(q) {
                 Some(sql) => Some(sql),
@@ -236,6 +248,7 @@ pub fn read_project(text: &str, dir: &str, report: &mut Report) -> Result<Projec
                 provider,
                 source,
                 crs: child(ml, "srs").and_then(crs_of),
+                kind,
                 vector,
                 visible: checked,
                 definition_query,
@@ -262,8 +275,12 @@ pub fn read_style(text: &str, layer: &str, report: &mut Report) -> Result<Style,
 /// A layer's style from its `<maplayer>` (a project's) or a style file's `<qgis>` root.
 fn read_style_node(node: Node, layer: &str, report: &mut Report) -> Style {
     let mut style = Style::default();
-    let opacity = child(node, "layerOpacity").and_then(|n| n.text()).and_then(|t| t.trim().parse::<f32>().ok());
-    if let Some(o) = opacity.filter(|o| o.is_finite()) {
+    let number = |tag: &str| child(node, tag).and_then(|n| n.text()).and_then(|t| t.trim().parse::<f32>().ok()).filter(|v| v.is_finite());
+    // Its opacity: 0 to 1; QGIS 2's transparency 0 to 100; QGIS 1's opacity 0 to 255.
+    let opacity = number("layerOpacity")
+        .or_else(|| number("layerTransparency").map(|t| 1.0 - t / 100.0))
+        .or_else(|| number("transparencyLevelInt").map(|o| o / 255.0));
+    if let Some(o) = opacity {
         style.transparency = Some(((1.0 - o.clamp(0.0, 1.0)) * 100.0).round());
     }
     if let Some(mode) = child(node, "blendMode").and_then(|n| n.text()).and_then(|t| t.trim().parse::<i32>().ok()) {
@@ -273,11 +290,18 @@ fn read_style_node(node: Node, layer: &str, report: &mut Report) -> Style {
         }));
     }
     if node.attribute("hasScaleBasedVisibilityFlag") == Some("1") {
-        // QGIS's minScale is the out-beyond limit (the larger number), maxScale the in-beyond.
+        // QGIS's minScale is the out-beyond limit (the larger number), maxScale the in-beyond;
+        // before QGIS 3 they were maximumScale and minimumScale.
         let scale = |k: &str| node.attribute(k).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite() && *v > 0.0);
-        style.min_scale = Some(scale("minScale").map(|s| s * QGIS_SCALE));
-        style.max_scale = Some(scale("maxScale").map(|s| s * QGIS_SCALE));
+        let (out, inside) = if node.attribute("minScale").is_some() || node.attribute("maxScale").is_some() {
+            (scale("minScale"), scale("maxScale"))
+        } else {
+            (scale("maximumScale"), scale("minimumScale"))
+        };
+        style.min_scale = Some(out.map(|s| s * QGIS_SCALE));
+        style.max_scale = Some(inside.map(|s| s * QGIS_SCALE));
     }
+    layer_notes(node, layer, report);
     if let Some(r) = child(node, "renderer-v2") {
         renderer::read(r, layer, &mut style, report);
     }
@@ -295,10 +319,108 @@ fn read_style_node(node: Node, layer: &str, report: &mut Report) -> Style {
             l.enabled &= !off;
             l
         });
+    } else if old_labels(node) {
+        report.skipped(layer, "its labels, in the format of QGIS 2 and before");
     }
     style
 }
 
+/// Whether a layer has labels switched on in QGIS 2's way (its custom properties) or QGIS 1's
+/// (`<label>1</label>`).
+fn old_labels(node: Node) -> bool {
+    let custom = child(node, "customproperties").is_some_and(|c| {
+        c.children()
+            .any(|p| p.has_tag_name("property") && p.attribute("key") == Some("labeling/enabled") && p.attribute("value") == Some("true"))
+    });
+    custom || child(node, "label").and_then(|n| n.text()).is_some_and(|t| t.trim() == "1")
+}
+
+/// Notes a layer's settings RustGIS has no place for (a project's `<maplayer>` or a style's root).
+fn layer_notes(node: Node, layer: &str, report: &mut Report) {
+    if child(node, "temporal").is_some_and(|t| t.attribute("enabled") == Some("1")) {
+        report.skipped(layer, "its time settings");
+    }
+    let diagrams = node
+        .children()
+        .filter(|c| c.tag_name().name().ends_with("DiagramRenderer"))
+        .any(|r| r.descendants().any(|d| d.has_tag_name("DiagramCategory") && d.attribute("enabled") == Some("1")));
+    if diagrams {
+        report.skipped(layer, "its diagrams");
+    }
+    if let Some(m) = child(node, "map-layer-style-manager") {
+        let current = m.attribute("current").unwrap_or_default();
+        let others: Vec<&str> = m
+            .children()
+            .filter(|s| s.has_tag_name("map-layer-style"))
+            .filter_map(|s| s.attribute("name"))
+            .filter(|n| *n != current)
+            .take(8)
+            .collect();
+        if !others.is_empty() {
+            report.skipped(layer, format!("its other styles ({}): only the current one is carried over", others.join(", ")));
+        }
+    }
+    let count = |list: &str, item: &str| child(node, list).map_or(0, |l| l.children().filter(|c| c.has_tag_name(item)).count());
+    if count("vectorjoins", "join") > 0 {
+        report.skipped(layer, "its joins to other layers' fields");
+    }
+    if count("expressionfields", "field") > 0 {
+        report.skipped(layer, "its virtual fields (fields computed from an expression)");
+    }
+    if node.attribute("type") == Some("vector-tile") && child(node, "renderer").is_some() {
+        report.approximated(layer, "its vector tile style, drawn in RustGIS's own");
+    }
+}
+
+/// Notes the project's parts RustGIS has no place for: print layouts, annotations, bookmarks,
+/// map themes and relations.
+fn project_notes(root: Node, report: &mut Report) {
+    let count = |list: &str, item: &str| child(root, list).map_or(0, |l| l.children().filter(|c| c.has_tag_name(item)).count());
+    let layouts = count("Layouts", "Layout") + root.children().filter(|c| c.has_tag_name("Composer")).count();
+    if layouts > 0 {
+        report.skipped("", format!("its print layouts ({layouts})"));
+    }
+    let items = child(root, "main-annotation-layer")
+        .and_then(|a| child(a, "items"))
+        .map_or(0, |i| i.children().filter(|c| c.has_tag_name("item")).count());
+    if items > 0 {
+        report.skipped("", format!("its annotations ({items}: text, shapes and pictures on the map)"));
+    }
+    let bookmarks = count("Bookmarks", "Bookmark");
+    if bookmarks > 0 {
+        report.skipped("", format!("its bookmarks ({bookmarks})"));
+    }
+    let themes = count("visibility-presets", "visibility-preset");
+    if themes > 0 {
+        report.skipped("", format!("its map themes ({themes})"));
+    }
+    let relations = count("relations", "relation");
+    if relations > 0 {
+        report.skipped("", format!("its relations between layers ({relations})"));
+    }
+}
+
+/// Whether `node` (a symbol layer, a renderer) has a draw effect on: a shadow, glow, blur or the
+/// like, not only the plain drawing QGIS's effect stack starts with.
+pub(crate) fn has_effect(node: Node) -> bool {
+    let Some(top) = node.children().find(|c| c.has_tag_name("effect")) else { return false };
+    if top.attribute("enabled") != Some("1") {
+        return false;
+    }
+    top.descendants().filter(|e| e.has_tag_name("effect")).any(|e| {
+        let kind = e.attribute("type").unwrap_or_default();
+        kind != "effectStack" && kind != "drawSource" && prop(&props(e), "enabled").is_none_or(|on| on == "1")
+    })
+}
+
+/// Whether `node` (a symbol layer, label settings) has a data-defined setting switched on: one
+/// taken from a field or an expression.
+pub(crate) fn data_defined_on(node: Node) -> bool {
+    node.children().filter(|c| c.has_tag_name("data_defined_properties") || c.has_tag_name("dd_properties")).any(|dd| {
+        dd.descendants().any(|o| o.has_tag_name("Option") && o.attribute("name") == Some("active") && o.attribute("value") == Some("true"))
+    })
+}
+
 /// The layers in a layer tree group, top first, each with whether it is checked (and every
 /// group above it). Groups are walked to a bounded depth.
 fn tree_layers(group: Node, checked: bool, out: &mut Vec<(String, bool)>, depth: usize) {
@@ -317,6 +439,26 @@ fn tree_layers(group: Node, checked: bool, out: &mut Vec<(String, bool)>, depth:
     }
 }
 
+/// The layers in QGIS 2's legend (`<legend>`, before the layer tree), top first, each with
+/// whether it is checked (and its group). Groups are walked to a bounded depth.
+fn legend_layers(group: Node, checked: bool, out: &mut Vec<(String, bool)>, depth: usize) {
+    if depth > 64 || out.len() > MAX_LAYERS * 4 {
+        return;
+    }
+    let on = |n: Node| n.attribute("checked").is_none_or(|c| c == "Qt::Checked" || c == "Qt::PartiallyChecked");
+    for c in group.children().filter(Node::is_element) {
+        if c.has_tag_name("legendlayer") {
+            for f in c.descendants().filter(|f| f.has_tag_name("legendlayerfile")) {
+                if let Some(id) = f.attribute("layerid") {
+                    out.push((id.to_string(), checked && on(c)));
+                }
+            }
+        } else if c.has_tag_name("legendgroup") {
+            legend_layers(c, checked && on(c), out, depth + 1);
+        }
+    }
+}
+
 /// QGIS's blending modes (`QPainter::CompositionMode`) RustGIS has.
 fn blend_of(mode: i32) -> Option<Blend> {
     Some(match mode {
diff --git a/crates/map/src/qgis/renderer.rs b/crates/map/src/qgis/renderer.rs
index 90f2d5511..72a48b859 100644
--- a/crates/map/src/qgis/renderer.rs
+++ b/crates/map/src/qgis/renderer.rs
@@ -8,7 +8,7 @@ use std::collections::BTreeMap;
 use roxmltree::Node;
 
 use super::symbol::{self, Converted};
-use super::{QGIS_SCALE, Report, Style, child, expr};
+use super::{QGIS_SCALE, Report, Style, child, expr, has_effect};
 use crate::color::Ramp;
 use crate::symbology::{ClassMethod, LineStroke, Renderer, Symbol};
 
@@ -30,6 +30,12 @@ fn read_depth(r: Node, layer: &str, style: &mut Style, report: &mut Report, dept
     if r.attribute("symbollevels") == Some("1") {
         style.stroke_levels = Some(true);
     }
+    if r.attribute("enableorderby") == Some("1") {
+        report.approximated(layer, "features drawn in the order QGIS's order-by sets, drawn in the data's order");
+    }
+    if has_effect(r) {
+        report.skipped(layer, "draw effects (shadows, glows, blurs and the like)");
+    }
     // The symbols the renderer names, by name.
     let symbols: BTreeMap<String, Node> = child(r, "symbols")
         .map(|s| {
@@ -103,10 +109,11 @@ fn categorized(r: Node, layer: &str, style: &mut Style, report: &mut Report, sym
         if cat.attribute("render") == Some("false") {
             c = Converted { symbol: symbol::hidden(), strokes: Vec::new() };
         }
-        // A category of several values (QGIS's merged categories) lists them as <val>s.
+        // A category of several values (QGIS's merged categories) lists them as <val>s, or as a
+        // list <Option>.
         let mut values: Vec<String> = cat
             .descendants()
-            .filter(|v| v.has_tag_name("Option") && v.attribute("type") == Some("QString"))
+            .filter(|v| v.has_tag_name("val") || (v.has_tag_name("Option") && v.attribute("type") == Some("QString")))
             .filter_map(|v| v.attribute("value").map(str::to_string))
             .collect();
         if values.is_empty() {
diff --git a/crates/map/src/qgis/symbol.rs b/crates/map/src/qgis/symbol.rs
index b8a33eb85..333d5d26d 100644
--- a/crates/map/src/qgis/symbol.rs
+++ b/crates/map/src/qgis/symbol.rs
@@ -5,9 +5,16 @@
 
 use roxmltree::Node;
 
-use super::{Report, color, points, prop, props};
+use super::{Report, color, data_defined_on, has_effect, points, prop, props};
 use crate::Rgba;
-use crate::symbology::{LineCap, LineJoin, LineStroke, MAX_STROKES, Marker, Symbol};
+use crate::symbology::{Dash, LineCap, LineJoin, LineStroke, MAX_DASH_STEPS, MAX_STROKES, Marker, Symbol};
+
+/// A symbol layer's settings by name.
+type Props = Vec<(String, String)>;
+
+/// The setting that stands for QGIS 1's symbol-wide unit (`<symbol outputUnit>`), for sizes a
+/// layer gives no unit of its own. No symbol layer setting is named so.
+const SYMBOL_UNIT: &str = "(symbol unit)";
 
 /// A QGIS symbol in RustGIS's terms: the symbol, and a line's strokes bottom first (each simple
 /// line of it; empty for fills and markers, and for a line with none).
@@ -19,9 +26,9 @@ pub(super) struct Converted {
 
 impl Converted {
     /// Whether the strokes say more than the symbol's single line does: more than one, or one
-    /// shifted sideways.
+    /// shifted sideways or dashed.
     pub fn stacked(&self) -> bool {
-        self.strokes.len() > 1 || self.strokes.iter().any(|s| s.offset != 0.0)
+        self.strokes.len() > 1 || self.strokes.iter().any(|s| s.offset != 0.0 || s.dash.is_some())
     }
 }
 
@@ -36,9 +43,20 @@ pub(super) fn hidden() -> Symbol {
 pub(super) fn read(sym: Node, reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
     let alpha = sym.attribute("alpha").and_then(|a| a.trim().parse::<f32>().ok()).filter(|a| a.is_finite()).unwrap_or(1.0).clamp(0.0, 1.0);
     let fade = |c: Rgba| c.with_alpha((f32::from(c.a()) * alpha).round() as u8);
-    let layers: Vec<Node> = sym.children().filter(|c| c.has_tag_name("layer") && c.attribute("enabled") != Some("0")).take(64).collect();
-    for l in &layers {
-        data_defined(*l, layer, report);
+    let unit = sym.attribute("outputUnit");
+    let layers: Vec<(Node, Props)> = sym
+        .children()
+        .filter(|c| c.has_tag_name("layer") && c.attribute("enabled") != Some("0"))
+        .take(64)
+        .map(|l| (l, settings(l, unit)))
+        .collect();
+    for (l, _) in &layers {
+        if data_defined_on(*l) {
+            report.skipped(layer, "data-defined symbol settings (from fields or expressions)");
+        }
+        if has_effect(*l) {
+            report.skipped(layer, "draw effects (shadows, glows, blurs and the like)");
+        }
     }
     let mut out = match sym.attribute("type") {
         Some("fill") => fill(&layers, reference, layer, report),
@@ -53,22 +71,98 @@ pub(super) fn read(sym: Node, reference: Option<f64>, layer: &str, report: &mut
     out
 }
 
+/// A symbol layer's settings, with those QGIS 2 named otherwise also under today's names (where
+/// the layer has only the old), and the symbol's own unit (QGIS 1) for sizes without one.
+fn settings(l: Node, unit: Option<&str>) -> Props {
+    let mut p = props(l);
+    let renamed: &[(&str, &str)] = match l.attribute("class") {
+        Some("SimpleLine") => {
+            &[("color", "line_color"), ("width", "line_width"), ("width_unit", "line_width_unit"), ("penstyle", "line_style")]
+        }
+        Some("SimpleFill") => &[
+            ("color_border", "outline_color"),
+            ("width_border", "outline_width"),
+            ("border_width_unit", "outline_width_unit"),
+            ("style_border", "outline_style"),
+        ],
+        Some("SimpleMarker") => &[("color_border", "outline_color")],
+        _ => &[],
+    };
+    for (old, new) in renamed {
+        if prop(&p, new).is_none()
+            && let Some(v) = prop(&p, old).map(str::to_string)
+        {
+            p.push((new.to_string(), v));
+        }
+    }
+    if let Some(u) = unit {
+        p.push((SYMBOL_UNIT.to_string(), u.to_string()));
+    }
+    p
+}
+
 /// A size setting `k` (with its `k_unit`) of a symbol layer, in points.
 fn size(p: &[(String, String)], k: &str, reference: Option<f64>, layer: &str, report: &mut Report) -> Option<f32> {
     let v = prop(p, k)?.trim().parse::<f64>().ok().filter(|v| v.is_finite())?;
-    let unit = prop(p, &format!("{k}_unit"));
+    let unit = prop(p, &format!("{k}_unit")).or(prop(p, SYMBOL_UNIT));
     Some(points(v, unit, reference, layer, report))
 }
 
-fn fill(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
+/// Whether a line style (`line_style`, `outline_style`) is dashed or dotted.
+fn dashed(style: Option<&str>) -> bool {
+    !matches!(style, None | Some("solid" | "no"))
+}
+
+/// A simple line's dash pattern in points: its own (`use_custom_dash`, in its unit), or Qt's for
+/// a named pen style (in line widths, as Qt sizes them). `None` for a solid line, and for a
+/// pattern RustGIS can't draw (noted).
+fn dash(p: &[(String, String)], width: f32, reference: Option<f64>, layer: &str, report: &mut Report) -> Option<Dash> {
+    let style = prop(p, "line_style").unwrap_or("solid");
+    let steps: Vec<f32> = if prop(p, "use_custom_dash") == Some("1") {
+        let unit = prop(p, "customdash_unit").or(prop(p, SYMBOL_UNIT));
+        let parsed: Option<Vec<f64>> = prop(p, "customdash")
+            .unwrap_or_default()
+            .split(';')
+            .filter(|s| !s.trim().is_empty())
+            .take(MAX_DASH_STEPS + 2)
+            .map(|s| s.trim().parse::<f64>().ok().filter(|v| v.is_finite()))
+            .collect();
+        let mut v = parsed.unwrap_or_default();
+        // An odd pattern ending in a step of no length: that step adds nothing.
+        if v.len() % 2 == 1 && v.last() == Some(&0.0) {
+            v.pop();
+        }
+        v.into_iter().map(|s| points(s, unit, reference, layer, report)).collect()
+    } else {
+        let qt: &[f32] = match style {
+            "solid" | "no" => return None,
+            "dash" => &[4.0, 2.0],
+            "dot" => &[1.0, 2.0],
+            "dash dot" => &[4.0, 2.0, 1.0, 2.0],
+            "dash dot dot" => &[4.0, 2.0, 1.0, 2.0, 1.0, 2.0],
+            _ => &[],
+        };
+        // Qt takes a line thinner than a pixel as a pixel wide for its pattern.
+        qt.iter().map(|s| s * width.max(1.0)).collect()
+    };
+    let d = Dash::new(&steps);
+    if d.is_none() {
+        report.approximated(layer, "dashed lines whose pattern RustGIS can't draw, drawn solid");
+    }
+    if d.is_some() && prop(p, "dash_pattern_offset").and_then(|o| o.trim().parse::<f64>().ok()).is_some_and(|o| o != 0.0) {
+        report.approximated(layer, "dash patterns' offsets along the line, left out");
+    }
+    d
+}
+
+fn fill(layers: &[(Node, Props)], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
     let none = Rgba::new(0, 0, 0, 0);
     let (mut fill, mut stroke, mut width) = (None::<Rgba>, None::<Rgba>, 0.0f32);
-    for l in layers {
-        let p = props(*l);
+    for (l, p) in layers {
         match l.attribute("class").unwrap_or_default() {
             "SimpleFill" => {
-                let c = prop(&p, "color").and_then(color).unwrap_or(none);
-                fill = Some(match prop(&p, "style").unwrap_or("solid") {
+                let c = prop(p, "color").and_then(color).unwrap_or(none);
+                fill = Some(match prop(p, "style").unwrap_or("solid") {
                     "solid" => c,
                     "no" => fill.unwrap_or(none),
                     _ => {
@@ -76,26 +170,32 @@ fn fill(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Repor
                         tint(c)
                     }
                 });
-                if prop(&p, "outline_style") != Some("no") {
-                    stroke = prop(&p, "outline_color").and_then(color).or(stroke);
-                    width = size(&p, "outline_width", reference, layer, report).unwrap_or(0.26 * 96.0 / 25.4);
+                if prop(p, "outline_style") != Some("no") {
+                    if dashed(prop(p, "outline_style")) {
+                        report.approximated(layer, "dashed polygon outlines, drawn solid");
+                    }
+                    stroke = prop(p, "outline_color").and_then(color).or(stroke);
+                    width = size(p, "outline_width", reference, layer, report).unwrap_or(0.26 * 96.0 / 25.4);
                 }
             }
             "SimpleLine" => {
-                if prop(&p, "line_style") != Some("no") {
-                    stroke = prop(&p, "line_color").and_then(color).or(stroke);
-                    width = size(&p, "line_width", reference, layer, report).unwrap_or(width);
+                if prop(p, "line_style") != Some("no") {
+                    if dashed(prop(p, "line_style")) || prop(p, "use_custom_dash") == Some("1") {
+                        report.approximated(layer, "dashed polygon outlines, drawn solid");
+                    }
+                    stroke = prop(p, "line_color").and_then(color).or(stroke);
+                    width = size(p, "line_width", reference, layer, report).unwrap_or(width);
                 }
             }
             "GradientFill" | "ShapeburstFill" => {
                 report.approximated(layer, "gradient fills, drawn in their first colour");
-                fill = prop(&p, "color").or(prop(&p, "color1")).and_then(color).or(fill);
+                fill = prop(p, "color").or(prop(p, "color1")).and_then(color).or(fill);
             }
             class @ ("LinePatternFill" | "PointPatternFill" | "SVGFill" | "RasterFill" | "RandomMarkerFill") => {
                 // The pattern's own symbol's colour, as a tint over what's below.
                 let sub = l.children().find(|c| c.has_tag_name("symbol")).map(|s| read(s, reference, layer, &mut Report::default()));
                 let c = sub.map(|s| if s.symbol.stroke.a() > 0 && s.symbol.fill.a() == 0 { s.symbol.stroke } else { s.symbol.fill });
-                if let Some(c) = c.or_else(|| prop(&p, "color").and_then(color)) {
+                if let Some(c) = c.or_else(|| prop(p, "color").and_then(color)) {
                     fill = Some(tint(c));
                 }
                 report.approximated(layer, format!("{} fills, drawn as a light tint of their colour", pattern_name(class)));
@@ -109,39 +209,36 @@ fn fill(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Repor
     Converted { symbol, strokes: Vec::new() }
 }
 
-fn line(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
+fn line(layers: &[(Node, Props)], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
     let mut strokes = Vec::new();
-    for l in layers {
-        let p = props(*l);
+    for (l, p) in layers {
         match l.attribute("class").unwrap_or_default() {
             "SimpleLine" => {
-                let style = prop(&p, "line_style").unwrap_or("solid");
-                let Some(c) = prop(&p, "line_color").and_then(color) else { continue };
+                let style = prop(p, "line_style").unwrap_or("solid");
+                let Some(c) = prop(p, "line_color").and_then(color) else { continue };
                 if style == "no" || c.a() == 0 {
                     continue;
                 }
-                if style != "solid" || prop(&p, "use_custom_dash") == Some("1") {
-                    report.approximated(layer, "dashed lines, drawn solid");
-                }
                 let pass = l.attribute("pass").and_then(|v| v.trim().parse::<u8>().ok());
+                let width = size(p, "line_width", reference, layer, report).unwrap_or(0.26 * 96.0 / 25.4);
                 strokes.push(
                     LineStroke {
                         color: Some(c),
-                        width: Some(size(&p, "line_width", reference, layer, report).unwrap_or(0.26 * 96.0 / 25.4)),
+                        width: Some(width),
                         // Positive to the right of the line's direction on the screen, in both.
-                        offset: size(&p, "offset", reference, layer, report).unwrap_or(0.0),
-                        cap: match prop(&p, "capstyle") {
+                        offset: size(p, "offset", reference, layer, report).unwrap_or(0.0),
+                        cap: match prop(p, "capstyle") {
                             Some("flat") => LineCap::Butt,
                             Some("square") => LineCap::Square,
                             _ => LineCap::Round,
                         },
-                        join: match prop(&p, "joinstyle") {
+                        join: match prop(p, "joinstyle") {
                             Some("miter") => LineJoin::Miter,
                             Some("bevel") => LineJoin::Bevel,
                             _ => LineJoin::Round,
                         },
                         level: pass,
-                        dash: None,
+                        dash: dash(p, width, reference, layer, report),
                     }
                     .clamped(),
                 );
@@ -167,17 +264,16 @@ fn line(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Repor
     Converted { symbol, strokes }
 }
 
-fn marker(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
+fn marker(layers: &[(Node, Props)], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
     let mut symbol = hidden();
-    for l in layers {
-        let p = props(*l);
+    for (l, p) in layers {
         let class = l.attribute("class").unwrap_or_default();
-        let fill = prop(&p, "color").and_then(color);
-        let outline = prop(&p, "outline_color").and_then(color);
-        let sz = size(&p, "size", reference, layer, report).unwrap_or(2.0 * 96.0 / 25.4);
+        let fill = prop(p, "color").and_then(color);
+        let outline = prop(p, "outline_color").and_then(color);
+        let sz = size(p, "size", reference, layer, report).unwrap_or(2.0 * 96.0 / 25.4);
         let shape = match class {
             "SimpleMarker" => {
-                let name = prop(&p, "name").unwrap_or("circle");
+                let name = prop(p, "name").unwrap_or("circle");
                 shape_of(name).unwrap_or_else(|| {
                     report.approximated(layer, format!("{name} markers, drawn as circles"));
                     Marker::Circle
@@ -196,12 +292,12 @@ fn marker(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Rep
                 continue;
             }
         };
-        if prop(&p, "angle").and_then(|a| a.trim().parse::<f32>().ok()).is_some_and(|a| a != 0.0) {
+        if prop(p, "angle").and_then(|a| a.trim().parse::<f32>().ok()).is_some_and(|a| a != 0.0) {
             report.approximated(layer, "turned markers, drawn upright");
         }
         let fill = fill.unwrap_or(Rgba::new(0, 0, 0, 0));
         // A font marker's character is all fill; an outline of no width draws none.
-        let width = if class == "FontMarker" { 0.0 } else { size(&p, "outline_width", reference, layer, report).unwrap_or(0.0) };
+        let width = if class == "FontMarker" { 0.0 } else { size(p, "outline_width", reference, layer, report).unwrap_or(0.0) };
         // Each layer drawn over the one before: the top one's look, the biggest size.
         symbol = Symbol {
             fill,
@@ -249,13 +345,3 @@ fn marker_name(class: &str) -> &'static str {
         _ => "filled",
     }
 }
-
-/// Notes a symbol layer's data-defined settings (from fields or expressions), which are left out.
-fn data_defined(l: Node, layer: &str, report: &mut Report) {
-    let Some(dd) = l.children().find(|c| c.has_tag_name("data_defined_properties")) else { return };
-    let active =
-        dd.descendants().any(|o| o.has_tag_name("Option") && o.attribute("name") == Some("active") && o.attribute("value") == Some("true"));
-    if active {
-        report.skipped(layer, "data-defined symbol settings (from fields or expressions)");
-    }
-}
diff --git a/crates/map/src/qgis/tests.rs b/crates/map/src/qgis/tests.rs
index ed2abd146..acc881dcb 100644
--- a/crates/map/src/qgis/tests.rs
+++ b/crates/map/src/qgis/tests.rs
@@ -271,3 +271,152 @@ fn paths_on_a_drive_are_told_apart_from_absolute_ones() {
     }
     assert!(is_relative("./data/x.shp") && is_relative("data/x.shp") && !is_drive_relative("data/x.shp"));
 }
+
+#[test]
+fn merged_categories_and_dashes_carry_over() {
+    // QGIS 4 writes a category of several values as <val>s; an empty value is all the others.
+    let qml = r#"<qgis version="4.2.3"><renderer-v2 type="categorizedSymbol" attr="kind">
+      <categories>
+        <category value="a" symbol="0" render="true"/>
+        <category label="c or d" symbol="1" render="true"><val type="string" value="c"/><val type="string" value="d"/></category>
+        <category value="" symbol="2" label="other" render="true"/>
+      </categories>
+      <symbols>
+        <symbol type="line" name="0" alpha="1"><layer class="SimpleLine" enabled="1"><Option type="Map">
+          <Option name="line_color" value="10,0,0,255"/><Option name="line_width" value="1"/><Option name="capstyle" value="flat"/>
+          <Option name="use_custom_dash" value="1"/><Option name="customdash" value="2.5;0.5;0"/><Option name="customdash_unit" value="MM"/></Option></layer></symbol>
+        <symbol type="line" name="1" alpha="1"><layer class="SimpleLine" enabled="1"><Option type="Map">
+          <Option name="line_color" value="20,0,0,255"/><Option name="line_width" value="3"/><Option name="line_width_unit" value="Pixel"/><Option name="line_style" value="dot"/></Option></layer></symbol>
+        <symbol type="line" name="2" alpha="1"><layer class="SimpleLine" enabled="1"><Option type="Map"><Option name="line_color" value="30,0,0,255"/></Option></layer></symbol>
+      </symbols></renderer-v2></qgis>"#;
+    let mut report = Report::default();
+    let s = read_style(qml, "Paths", &mut report).unwrap();
+    let Some(Renderer::Unique { classes, class_strokes, class_labels, other, .. }) = &s.renderer else { panic!("{:?}", s.renderer) };
+    let values: Vec<&str> = classes.iter().map(|c| c.0.as_str()).collect();
+    assert_eq!(values, ["a", "c", "d"], "both values of the merged category, not \"all others\"");
+    assert_eq!((classes[1].1.stroke, classes[2].1.stroke), (Rgba::rgb(20, 0, 0), Rgba::rgb(20, 0, 0)));
+    assert_eq!(other.stroke, Rgba::rgb(30, 0, 0));
+    assert_eq!(class_labels.get("c").map(String::as_str), Some("c or d"));
+    // A custom dash in millimetres (its odd trailing step of nothing dropped); Qt's dots in widths.
+    let mm = 96.0 / 25.4;
+    let dash = class_strokes["a"][0].dash.unwrap();
+    assert_eq!(dash.steps().len(), 2);
+    assert!((dash.steps()[0] - 2.5 * mm).abs() < 1e-3 && (dash.steps()[1] - 0.5 * mm).abs() < 1e-3, "{:?}", dash.steps());
+    assert_eq!(class_strokes["c"][0].dash.unwrap().steps(), &[3.0, 6.0]);
+    assert!(!report.notes.iter().any(|n| n.text.contains("dash")), "{:?}", report.notes);
+}
+
+#[test]
+fn files_of_qgis_1_and_2_read_by_their_old_names() {
+    // Before QGIS 3: no layer tree but a legend, the canvas's coordinate system, scale limits named
+    // the other way round, opacity as transparency, and QGIS 2's names for line and fill settings.
+    let qgs = r#"<qgis projectname="" version="2.14.6-Essen"><title>Old</title>
+      <mapcanvas><units>meters</units><extent><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></extent>
+        <destinationsrs><spatialrefsys><authid>EPSG:21781</authid></spatialrefsys></destinationsrs></mapcanvas>
+      <legend updateDrawingOrder="true">
+        <legendlayer checked="Qt::Checked" name="roads"><filegroup><legendlayerfile layerid="roads1" visible="1"/></filegroup></legendlayer>
+        <legendgroup checked="Qt::Unchecked" name="base">
+          <legendlayer checked="Qt::Checked" name="land"><filegroup><legendlayerfile layerid="land1" visible="1"/></filegroup></legendlayer>
+        </legendgroup>
+      </legend>
+      <projectlayers>
+        <maplayer type="vector" minimumScale="1000" maximumScale="50000" hasScaleBasedVisibilityFlag="1">
+          <id>land1</id><datasource>/d/land.shp</datasource><layername>land</layername><provider>ogr</provider>
+          <renderer-v2 type="singleSymbol"><symbols><symbol type="fill" name="0" alpha="1" outputUnit="MM"><layer class="SimpleFill" pass="0" locked="0">
+            <prop k="color" v="200,200,150,255"/><prop k="color_border" v="10,20,30,255"/><prop k="style" v="solid"/><prop k="style_border" v="dash"/><prop k="width_border" v="0.5"/>
+          </layer></symbol></symbols></renderer-v2>
+          <layerTransparency>40</layerTransparency>
+          <customproperties><property key="labeling/enabled" value="true"/><property key="labeling/fieldName" value="name"/></customproperties>
+        </maplayer>
+        <maplayer type="vector">
+          <id>roads1</id><datasource>/d/roads.shp</datasource><layername>roads</layername><provider>ogr</provider>
+          <renderer-v2 type="singleSymbol"><symbols><symbol type="line" name="0" alpha="1" outputUnit="Pixel"><layer class="SimpleLine" pass="0" locked="0">
+            <prop k="color" v="40,40,40,255"/><prop k="width" v="2"/><prop k="penstyle" v="dash"/><prop k="capstyle" v="flat"/>
+          </layer></symbol></symbols></renderer-v2>
+          <transparencyLevelInt>255</transparencyLevelInt>
+        </maplayer>
+      </projectlayers></qgis>"#;
+    let mut report = Report::default();
+    let p = read_project(qgs, "", &mut report).unwrap();
+    assert_eq!(p.crs.as_deref(), Some("EPSG:21781"), "the canvas's");
+    let names: Vec<(&str, bool)> = p.layers.iter().map(|l| (l.name.as_str(), l.visible)).collect();
+    assert_eq!(names, [("roads", true), ("land", false)], "the legend's order; land's group is unchecked");
+    let (roads, land) = (&p.layers[0].style, &p.layers[1].style);
+    // maximumScale was the out-beyond limit, minimumScale the in-beyond.
+    let (min, max) = (land.min_scale.flatten().unwrap(), land.max_scale.flatten().unwrap());
+    assert!((min - 50_000.0 * QGIS_SCALE).abs() < 1e-6 && (max - 1000.0 * QGIS_SCALE).abs() < 1e-6);
+    assert_eq!((land.transparency, roads.transparency), (Some(40.0), Some(0.0)));
+    let Some(Renderer::Single(fill)) = &land.renderer else { panic!() };
+    assert_eq!((fill.fill, fill.stroke), (Rgba::rgb(200, 200, 150), Rgba::rgb(10, 20, 30)));
+    assert!((fill.stroke_width - 0.5 * 96.0 / 25.4).abs() < 1e-4);
+    // The line, in the symbol's unit (pixels), dashed as Qt dashes: 4 and 2 widths.
+    let Some(Renderer::Single(line)) = &roads.renderer else { panic!() };
+    assert_eq!((line.stroke, line.stroke_width), (Rgba::rgb(40, 40, 40), 2.0));
+    let strokes = roads.line_strokes.as_deref().unwrap();
+    assert_eq!((strokes.len(), strokes[0].dash.map(|d| d.steps().to_vec())), (1, Some(vec![8.0, 4.0])));
+    let said = |layer: &str, part: &str| report.notes.iter().any(|n| n.layer == layer && n.text.contains(part));
+    assert!(said("land", "dashed polygon outlines"));
+    assert!(said("land", "format of QGIS 2"));
+}
+
+#[test]
+fn what_rustgis_has_no_place_for_is_noted() {
+    let effect = r#"<effect enabled="1" type="effectStack"><effect type="drawSource"><Option type="Map"><Option name="enabled" value="1"/></Option></effect>
+        <effect type="dropShadow"><Option type="Map"><Option name="enabled" value="1"/></Option></effect></effect>"#;
+    let plain = r#"<effect enabled="1" type="effectStack"><effect type="drawSource"><Option type="Map"><Option name="enabled" value="1"/></Option></effect>
+        <effect type="outerGlow"><Option type="Map"><Option name="enabled" value="0"/></Option></effect></effect>"#;
+    let qgs = format!(
+        r#"<qgis version="3.42.0">
+      <projectlayers>
+        <maplayer type="vector" labelsEnabled="1"><id>a</id><datasource>/d/a.shp</datasource><layername>A</layername><provider>ogr</provider>
+          <temporal enabled="1" mode="1" startField="day"/>
+          <map-layer-style-manager current="default"><map-layer-style name="default"/><map-layer-style name="night"/></map-layer-style-manager>
+          <vectorjoins><join joinLayerId="b"/></vectorjoins>
+          <expressionfields><field name="twice" expression="&quot;v&quot; * 2"/></expressionfields>
+          <SingleCategoryDiagramRenderer diagramType="Pie"><DiagramCategory enabled="1"/></SingleCategoryDiagramRenderer>
+          <renderer-v2 type="singleSymbol" enableorderby="1">{effect}<symbols><symbol type="marker" name="0" alpha="1">
+            <layer class="SimpleMarker" enabled="1"><Option type="Map"><Option name="color" value="1,2,3,255"/></Option>{plain}</layer></symbol></symbols></renderer-v2>
+          <labeling type="simple"><settings calloutType="simple">
+            <text-style fieldName="name"><text-buffer bufferDraw="1" bufferSize="1" bufferColor="255,255,255,255"/></text-style>
+            <text-format wrapChar="" autoWrapLength="12"/>
+            <placement placement="1" dist="2" xOffset="1" yOffset="0" repeatDistance="0" priority="8"/>
+            <dd_properties><Option type="Map"><Option name="properties" type="Map"><Option name="Size" type="Map"><Option name="active" value="true"/><Option name="field" value="size"/></Option></Option></Option></dd_properties>
+            <callout type="simple"><Option type="Map"><Option name="enabled" value="1"/></Option></callout>
+          </settings></labeling>
+        </maplayer>
+      </projectlayers>
+      <main-annotation-layer><items><item type="pointtext"/><item type="linetext"/></items></main-annotation-layer>
+      <Layouts><Layout name="One"/></Layouts>
+      <Bookmarks><Bookmark name="Here"/></Bookmarks>
+      <visibility-presets><visibility-preset name="Only points"/></visibility-presets>
+      <relations><relation id="r"/></relations>
+    </qgis>"#
+    );
+    let mut report = Report::default();
+    read_project(&qgs, "", &mut report).unwrap();
+    let said = |layer: &str, part: &str| report.notes.iter().any(|n| n.layer == layer && n.text.contains(part));
+    for part in ["print layouts (1)", "annotations (2", "bookmarks (1)", "map themes (1)", "relations between layers (1)"] {
+        assert!(said("", part), "{part}: {:?}", report.notes);
+    }
+    for part in [
+        "time settings",
+        "other styles (night)",
+        "joins",
+        "virtual fields",
+        "diagrams",
+        "order-by",
+        "draw effects",
+        "label halos",
+        "wrapped labels",
+        "label distances",
+        "label offsets",
+        "label priorities",
+        "callouts",
+        "data-defined label settings",
+    ] {
+        assert!(said("A", part), "{part}: {:?}", report.notes);
+    }
+    // The renderer's effect is noted once; the symbol layer's, only plain drawing, isn't an effect.
+    assert_eq!(report.notes.iter().find(|n| n.text.contains("draw effects")).map(|n| n.count), Some(1));
+    assert!(!said("A", "repeated"), "a repeat distance of 0 is none");
+}
diff --git a/docs/user-guide/workspace.md b/docs/user-guide/workspace.md
index c2feec1cd..077ebde55 100644
--- a/docs/user-guide/workspace.md
+++ b/docs/user-guide/workspace.md
@@ -36,8 +36,8 @@ Each layer keeps its look:
   rule-based where every rule picks values of one field (an else rule the rest); point cluster,
   displacement and other renderers that wrap one are drawn by the one inside.
 - **Symbols**: simple fills, lines and markers with their colours, widths in any unit, offsets,
-  caps, joins and the symbol's opacity; a line's simple lines as stacked strokes, its rendering
-  passes as their levels when the renderer draws in symbol levels.
+  caps, joins, dashes and the symbol's opacity; a line's simple lines as stacked strokes, its
+  rendering passes as their levels when the renderer draws in symbol levels.
 - **Layer settings**: opacity, blending, visibility range, filter (subset string), and the
   reference scale.
 - **Labels**: simple and rule-based, each rule a label class whose SQL clause is its filter and
@@ -46,14 +46,20 @@ Each layer keeps its look:
   font), its buffer as a halo, its placement (Parallel and Curved along lines,
   around and over points) and its scale range.
 
+Projects and styles from QGIS 1 and 2 read too: their legend gives the layers' order, and the
+older names of the same settings are read.
+
 QGIS expressions carry over where they are SQL: fields compared with values, `LIKE`, `IN`,
 `IS NULL`, joined by `AND`, `OR` and `NOT`. What RustGIS doesn't draw as QGIS does is drawn as
 near as it can, or left out, and said: the import's notes list, layer by layer, what was
 approximated (pattern fills drawn as a tint of their colour, font and SVG markers as circles,
-dashed lines solid, values outside a graduated renderer's ranges in its first or last class,
-file options such as `layerid` that RustGIS doesn't read) and what was skipped (marker lines,
-data-defined settings, labels from expressions, raster colouring, PostGIS, WFS and other sources
-RustGIS doesn't read). A database password in a project never reaches the notes.
+dashed polygon outlines solid, label halos in RustGIS's own colour and width, label offsets and
+wrapping, values outside a graduated renderer's ranges in its first or last class, file options
+such as `layerid` that RustGIS doesn't read) and what was skipped (marker lines, data-defined
+settings, draw effects, label callouts, labels from expressions, raster colouring, PostGIS, WFS
+and other sources RustGIS doesn't read, diagrams, joins, virtual fields, a layer's other styles,
+and the project's print layouts, annotations, bookmarks, map themes and relations). A database
+password in a project never reaches the notes.
 
 A QGIS layer style (`.qml`) styles the selected layer the same way: **Import QGIS Style…** in
 the Symbology pane (`style.importQgis={"layer": "Roads", "path": "…/roads.qml"}`).