fixes

Author: MrSrsen

.gitignore

@@ -1,3 +1,5 @@
+.idea
+
 # Sensitive or work-in-progress staff that should not be committed
 /samples/
 /research/

CHANGELOG.md

@@ -6,6 +6,30 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+### Added
+
+- **SQL-expression fields.** Decodes `{%name}` SQL-expression field references.
+- **Dynamic parameters.** Recognises dynamic (list-of-values) parameters and reports their editing flags accordingly.
+- **Top N / Bottom N group sorts.** Decodes group summary sorts and renders their summary sort expression and direction.
+- **Percentage summaries.** Decodes percentage summaries (`PercentOfSum (…)`, etc.).
+- **Running-total conditions.** Decodes running-total reset and evaluation conditions (`OnChangeOfField` / `OnFormula`).
+- **Cross-section boxes.** Resolves a box that spans into a later section, reporting its end section and bottom edge.
+- **Dynamic image locations.** Decodes a picture object's dynamic graphic-location formula, and its `EnableCanGrow` flag.
+- **Subreport on-demand flag.** Decodes a subreport's `EnableOnDemand` flag.
+
+### Fixed
+
+- **Table aliases with spaces.** Aliases whose table name contains spaces (which Crystal substitutes with underscores)
+  now match correctly, fixing the alias and the field long-names and formula forms derived from it.
+- **Range parameter current values.** A range (non-discrete) current value now sets `HasCurrentValue`.
+- **Summary result types.** `Maximum` / `Minimum` summaries report the summarized field's own type; a Currency running
+  total reports a Number result, matching the engine.
+- **Negative line heights.** A line drawn bottom-to-top reports its height as a magnitude.
+- **Cross-tab keep-together.** A cross-tab no longer inherits the object-level keep-together flag.
+- **Field use counts.** Corrects use-count totals for summary-sorted groups.
+
+## [0.0.0]
+
 The initial release: a pure-Rust reader for SAP Crystal Reports `.rpt` files, with no dependency on the SAP runtime, a
 database connection, or any Windows component.
 

README.md

@@ -1,5 +1,9 @@
 # rpt-rs
 
+> ⚠️This entire project has unstable API and is very experimental! Expect major refactorings and breaking changes moving
+> forward. If you need stability - fork this project. There is even a chance that I will lost interest in this. You are
+> always welcome to fork this repo and work on it on your own.
+
 [![License: MPL-2.0](https://img.shields.io/badge/license-MPL--2.0-blue.svg)](LICENSE)
 ![Rust 1.85+](https://img.shields.io/badge/rust-1.85%2B-orange.svg)
 

crates/rpt-engine/src/lib.rs

@@ -361,11 +361,26 @@ pub fn summary_fields(report: &Report) -> Vec<SummaryFieldDef> {
                 "CrystalDecisions.CrystalReports.Engine.DatabaseFieldDefinition"
             }
             .to_string();
+            // The Operation is the base aggregation. A percentage summary leads with `PercentOf<Op>`
+            // but its Operation is the underlying op (`Sum`) — percentage is a display mode, not a
+            // distinct SummaryOperation.
+            let op_token = p.ds.split(" (").next().unwrap_or("").trim();
+            let operation = op_token
+                .strip_prefix("PercentOf")
+                .unwrap_or(op_token)
+                .to_string();
+            // Maximum / Minimum return the summarized field's own type (the result is one of the
+            // input values), unlike Sum/Average which coerce to Number/Currency. Use the summarized
+            // DB field's declared type (the placed object's value_type reports the coerced Number).
+            let vt = match operation.as_str() {
+                "Maximum" | "Minimum" => summarized_db_field_type(&groups, report).unwrap_or(p.vt),
+                _ => p.vt,
+            };
             SummaryFieldDef {
                 formula_name: p.ds.to_string(),
-                operation: p.ds.split(" (").next().unwrap_or("").trim().to_string(),
-                value_type: format!("{:?}Field", p.vt),
-                number_of_bytes: summary_number_of_bytes(p.vt, &groups, report),
+                operation,
+                value_type: format!("{vt:?}Field"),
+                number_of_bytes: summary_number_of_bytes(vt, &groups, report),
                 summarized_field_type,
                 grouped: !p.scope.is_empty(),
                 named: p.named,
@@ -393,6 +408,22 @@ fn brace_groups(s: &str) -> Vec<&str> {
     out
 }
 
+/// The declared type of the summary's summarized field (`groups[0]`, e.g. `{Command.days}`) when it
+/// is a database field; `None` for a formula operand or an unresolved field.
+fn summarized_db_field_type(groups: &[&str], report: &Report) -> Option<FieldValueType> {
+    let name = groups
+        .first()?
+        .trim_start_matches('{')
+        .trim_end_matches('}');
+    report
+        .database
+        .tables
+        .iter()
+        .flat_map(|t| &t.data_fields)
+        .find(|f| f.long_name.as_deref().unwrap_or(&f.name) == name)
+        .map(|f| f.value_type)
+}
+
 /// `NumberOfBytes` for a summary's result type: the intrinsic width, except a string result uses the
 /// summarized field's declared length (the result record's length byte is unreliable for strings).
 fn summary_number_of_bytes(vt: FieldValueType, groups: &[&str], report: &Report) -> i32 {
@@ -537,7 +568,55 @@ fn count_report(counts: &mut HashMap<String, i32>, field_refs: &[String], r: &Re
     for g in &r.data_definition.groups {
         let key = format!("{{{}}}", g.condition_field);
         if field_refs.contains(&key) {
-            *counts.entry(key).or_default() += 1;
+            // A group registers its DB condition field twice: as the group condition and as the
+            // group sort (both from the same `0xe5`). The sort is normally counted via `record_sorts`
+            // below. A Top N / Bottom N group sorts by a summary expression instead, so its
+            // `record_sorts` entry no longer names the field — count the sort reference here when the
+            // sort field differs.
+            *counts.entry(key.clone()).or_default() += 1;
+            // A summary-sorted group holds, on its condition field, the group-sort reference plus one
+            // reference per group-scoped construct: the group-name definition, each placed GroupName
+            // field object, and each group summary whose group-by (2nd) arg is this field. A plain
+            // group does not reach here.
+            if g.sort.field != g.condition_field {
+                // The group-sort reference held on the condition field (condition + sort).
+                *counts.entry(key.clone()).or_default() += 1;
+                *counts.entry(key.clone()).or_default() += 1; // GroupName definition
+                let gn_ds = format!("GroupName ({key})");
+                let placed_group_names = r
+                    .report_definition
+                    .areas
+                    .iter()
+                    .flat_map(|a| &a.sections)
+                    .flat_map(|s| &s.objects)
+                    .filter(
+                        |o| matches!(&o.kind, ReportObjectKind::Field(f) if f.data_source == gn_ds),
+                    )
+                    .count();
+                let summary_suffix = format!(", {key})");
+                let group_summaries = summary_fields(r)
+                    .iter()
+                    .filter(|s| s.formula_name.ends_with(&summary_suffix))
+                    .count();
+                *counts.entry(key).or_default() += (placed_group_names + group_summaries) as i32;
+
+                // The Top N sort basis is a summary (`g.sort.field`) referencing its summarized
+                // (1st-arg) field. If the group displays that same summary it is already counted via
+                // `summary_fields`; if it displays a different one (e.g. a percentage, while the sort
+                // basis stays a plain `Sum`), that sort-basis summary is a separate, otherwise
+                // uncounted reference → +1.
+                let sort_summary = g.sort.field.as_str();
+                let already_counted = summary_fields(r)
+                    .iter()
+                    .any(|s| s.formula_name == sort_summary);
+                if !already_counted {
+                    if let Some(first) = brace_groups(sort_summary).into_iter().next() {
+                        if let Some(fr) = field_refs.iter().find(|fr| fr.as_str() == first) {
+                            *counts.entry(fr.clone()).or_default() += 1;
+                        }
+                    }
+                }
+            }
         }
     }
     for s in &r.data_definition.record_sorts {
@@ -633,7 +712,14 @@ fn count_report(counts: &mut HashMap<String, i32>, field_refs: &[String], r: &Re
                     if let Some(g) = r.data_definition.groups.first() {
                         let key = format!("{{{}}}", g.condition_field);
                         if field_refs.contains(&key) {
-                            *counts.entry(key).or_default() += 1;
+                            // A reused-group chart adds +1 over a plain group. On a summary-sorted
+                            // group it instead binds a full category (condition + sort) → +2.
+                            let n = if g.sort.field != g.condition_field {
+                                2
+                            } else {
+                                1
+                            };
+                            *counts.entry(key).or_default() += n;
                         }
                     }
                 }

crates/rpt-to-xml/src/objects.rs

@@ -8,7 +8,7 @@ use crate::colors::{write_color, BLACK};
 use crate::util::{b, escape, escape_text};
 
 /// `<ObjectFormatConditionFormulas>` attribute order (subset of the SDK enum we decode).
-const OBJECT_COND_ORDER: &[&str] = &["EnableSuppress", "DisplayString"];
+const OBJECT_COND_ORDER: &[&str] = &["EnableSuppress", "DisplayString", "GraphicLocation"];
 /// `<SectionAreaConditionFormulas>` attribute order (SDK enum order).
 const SECTION_COND_ORDER: &[&str] = &["EnableSuppress", "EnableNewPageAfter", "BackgroundColor"];
 /// `<FontColorConditionFormulas>` attribute order (SDK enum order).
@@ -152,7 +152,9 @@ pub(crate) fn write_object(o: &mut String, obj: &ReportObject, section_name: &st
             r.top.0,
             r.left.0,
             r.width.0,
-            r.height.0
+            // A line drawn bottom-to-top stores a negative (signed `0x9e`) height; the engine reports
+            // the magnitude. Every other object has a non-negative height, so `abs` is a no-op there.
+            r.height.0.abs()
         )
     };
     // A plain text object's default alignment renders as LeftAlign; a field object keeps
@@ -228,8 +230,18 @@ pub(crate) fn write_object(o: &mut String, obj: &ReportObject, section_name: &st
             // same element shape: degenerate-rectangle attrs plus shape format children.
             let is_box = matches!(&obj.kind, ReportObjectKind::Box(_));
             let tag = if is_box { "BoxObject" } else { "LineObject" };
-            let bottom = r.top.0 + r.height.0;
             let right = r.left.0 + r.width.0;
+            // A cross-section box uses its resolved end section, and its Bottom is the opener's
+            // end-relative value (not top+height, which would span sections). A normal box/line ends
+            // in its own section with Bottom = top + height.
+            let (end_section, bottom) = match &obj.kind {
+                ReportObjectKind::Box(bx) if !bx.end_section_name.is_empty() => {
+                    (bx.end_section_name.as_str(), bx.shape.bottom.0)
+                }
+                // A bottom-to-top line (negative height) ends at its anchor top, so its Bottom is
+                // the top; `max(0)` keeps the normal `top + height` for non-negative heights.
+                _ => (section_name, r.top.0 + r.height.0.max(0)),
+            };
             // LineThickness (twips) is decoded from `0xec` byte 21; line and box are separate
             // model variants so the shape is read from whichever applies.
             let (line_thickness, extend_to_bottom) = match &obj.kind {
@@ -248,7 +260,7 @@ pub(crate) fn write_object(o: &mut String, obj: &ReportObject, section_name: &st
                 "{pad}<{tag} {} Bottom=\"{bottom}\" EnableExtendToBottomOfSection=\"{}\" EndSectionName=\"{}\" LineStyle=\"{}\" LineThickness=\"{line_thickness}\" Right=\"{right}\">",
                 head(tag),
                 b(extend_to_bottom),
-                escape(section_name),
+                escape(end_section),
                 shape_line_style(&obj.border),
             );
             if is_box {
@@ -358,11 +370,22 @@ fn write_plain_object(
     let pad = "  ".repeat(depth);
     let _ = writeln!(o, "{pad}<{tag} {head}>");
     write_border(o, &obj.border, depth + 1);
+    // EnableCanGrow is decoded (a dynamic/CanGrow picture sets it True); the rest stay at the
+    // plain-object defaults.
     let _ = writeln!(
         o,
-        "{pad}  <ObjectFormat CssClass=\"\" EnableCanGrow=\"False\" EnableCloseAtPageBreak=\"True\" EnableKeepTogether=\"True\" EnableSuppress=\"False\" HorizontalAlignment=\"{align}\" />"
+        "{pad}  <ObjectFormat CssClass=\"\" EnableCanGrow=\"{}\" EnableCloseAtPageBreak=\"True\" EnableKeepTogether=\"True\" EnableSuppress=\"False\" HorizontalAlignment=\"{align}\" />",
+        b(obj.format.can_grow)
+    );
+    // A PictureObject's dynamic graphic-location formula (and any other decoded object-format
+    // condition) is carried here; empty for plain pictures/charts.
+    write_condition_formulas(
+        o,
+        &format!("{pad}  "),
+        "ObjectFormatConditionFormulas",
+        OBJECT_COND_ORDER,
+        &obj.format.condition_formulas,
     );
-    let _ = writeln!(o, "{pad}  <ObjectFormatConditionFormulas />");
     let _ = writeln!(o, "{pad}</{tag}>");
 }
 

crates/rpt-to-xml/src/xml.rs

@@ -209,12 +209,18 @@ fn write_report_core(
     } else {
         o.push_str("    <SortFields>\n");
         for s in &dd.record_sorts {
+            // A plain field reference is brace-wrapped (`{Table.Field}`); a Top N / Bottom N group
+            // sort already holds a full summary expression (`Sum ({…}, {…})`) — detected by its
+            // parenthesis — and must not be re-wrapped.
+            let field = if s.field.contains('(') {
+                escape(&s.field)
+            } else {
+                format!("{{{}}}", escape(&s.field))
+            };
             let _ = writeln!(
                 o,
-                "      <SortField Field=\"{{{}}}\" SortDirection=\"{:?}\" SortType=\"{:?}\" />",
-                escape(&s.field),
-                s.direction,
-                s.kind
+                "      <SortField Field=\"{}\" SortDirection=\"{:?}\" SortType=\"{:?}\" />",
+                field, s.direction, s.kind
             );
         }
         o.push_str("    </SortFields>\n");

crates/rpt/src/model/enums.rs

@@ -39,8 +39,8 @@ sdk_enum!(
     }, Other);
 
 sdk_enum!(
-    /// SDK: `SortDirection`.
-    SortDirection { AscendingOrder, DescendingOrder, NoSortOrder }, Other);
+    /// SDK: `SortDirection`. `TopNOrder`/`BottomNOrder` are group Top N / Bottom N sort directions.
+    SortDirection { AscendingOrder, DescendingOrder, NoSortOrder, TopNOrder, BottomNOrder }, Other);
 
 sdk_enum!(
     /// XML `@SortType` — which collection a sort came from.

crates/rpt/src/model/objects.rs

@@ -71,6 +71,8 @@ pub enum FieldRefKind {
     RunningTotal,
     /// A parameter field — `{?name}`.
     Parameter,
+    /// A SQL expression field — `{%name}`.
+    SqlExpression,
     /// Anything else; the raw reference is used verbatim.
     Unknown,
 }
@@ -86,6 +88,7 @@ impl FieldRefKind {
             0x04 => Self::GroupName,
             0x06 => Self::Parameter,
             0x09 => Self::RunningTotal,
+            0x0a => Self::SqlExpression,
             _ => Self::Unknown,
         }
     }