fix bugs

layout-engine/src/sizing.rs

@@ -0,0 +1,222 @@
+use dreport_core::models::{ContainerElement, PositionMode, SizeConstraint, SizeValue};
+use taffy::prelude::*;
+
+/// 1mm = 72/25.4 pt (kesin değer)
+const MM_TO_PT_F64: f64 = 72.0 / 25.4;
+
+pub fn mm_to_pt(mm: f64) -> f32 {
+    (mm * MM_TO_PT_F64) as f32
+}
+
+pub fn pt_to_mm(pt: f32) -> f64 {
+    (pt as f64) / MM_TO_PT_F64
+}
+
+/// SizeValue → taffy Dimension (width veya height için)
+fn size_value_to_dimension(sv: &SizeValue) -> Dimension {
+    match sv {
+        SizeValue::Fixed { value } => Dimension::Length(mm_to_pt(*value)),
+        SizeValue::Auto => Dimension::Auto,
+        // Fr için dimension Auto, flex_grow ayrıca set edilir
+        SizeValue::Fr { .. } => Dimension::Auto,
+    }
+}
+
+/// SizeValue → taffy LengthPercentage (min/max constraint'ler için)
+fn mm_to_length(mm: f64) -> Dimension {
+    Dimension::Length(mm_to_pt(mm))
+}
+
+/// Fr değerini döndür (yoksa 0)
+fn fr_value(sv: &SizeValue) -> f32 {
+    match sv {
+        SizeValue::Fr { value } => *value as f32,
+        _ => 0.0,
+    }
+}
+
+/// SizeConstraint'ten taffy Style'a flex_grow ayarını da dahil ederek dönüştür.
+/// `main_axis` parametresi parent container'ın direction'ına göre
+/// hangi eksenin flex_grow kullanacağını belirler.
+pub fn apply_size_to_style(
+    style: &mut Style,
+    size: &SizeConstraint,
+    parent_direction: Option<&str>,
+) {
+    style.size = Size {
+        width: size_value_to_dimension(&size.width),
+        height: size_value_to_dimension(&size.height),
+    };
+
+    // Min/max constraint'ler
+    if let Some(min_w) = size.min_width {
+        style.min_size.width = mm_to_length(min_w);
+    }
+    if let Some(min_h) = size.min_height {
+        style.min_size.height = mm_to_length(min_h);
+    }
+    if let Some(max_w) = size.max_width {
+        style.max_size.width = mm_to_length(max_w);
+    }
+    if let Some(max_h) = size.max_height {
+        style.max_size.height = mm_to_length(max_h);
+    }
+
+    // Fr → flex_grow (main axis'e göre)
+    let main_fr = match parent_direction {
+        Some("row") => fr_value(&size.width),
+        Some("column") | _ => fr_value(&size.height),
+    };
+
+    // Cross axis fr: row'da height fr, column'da width fr
+    let cross_fr = match parent_direction {
+        Some("row") => fr_value(&size.height),
+        Some("column") | _ => fr_value(&size.width),
+    };
+
+    // Eğer main axis fr ise, flex_grow ayarla ve flex_basis 0 yap
+    if main_fr > 0.0 {
+        style.flex_grow = main_fr;
+        style.flex_shrink = 1.0;
+        style.flex_basis = Dimension::Length(0.0);
+
+        // min-width: 0 (row) veya min-height: 0 (column) ayarla —
+        // taffy'de min_size default Auto = içerik boyutunun altına küçülemez.
+        // Fr elemanların içerik taşırması engellemek için min_size 0 olmalı.
+        match parent_direction {
+            Some("row") => {
+                if size.min_width.is_none() {
+                    style.min_size.width = Dimension::Length(0.0);
+                }
+            }
+            _ => {
+                if size.min_height.is_none() {
+                    style.min_size.height = Dimension::Length(0.0);
+                }
+            }
+        }
+    }
+
+    // Cross axis fr ise, align_self stretch yeterli
+    // (taffy'de cross axis flex_grow doğrudan yok, stretch ile çözülür)
+    if cross_fr > 0.0 {
+        style.align_self = Some(AlignSelf::Stretch);
+    }
+}
+
+/// ContainerElement → taffy Style
+pub fn container_to_style(el: &ContainerElement, parent_direction: Option<&str>) -> Style {
+    let mut style = Style {
+        display: Display::Flex,
+        flex_direction: match el.direction.as_str() {
+            "row" => FlexDirection::Row,
+            _ => FlexDirection::Column,
+        },
+        gap: Size {
+            width: LengthPercentage::Length(mm_to_pt(el.gap)),
+            height: LengthPercentage::Length(mm_to_pt(el.gap)),
+        },
+        padding: Rect {
+            top: LengthPercentage::Length(mm_to_pt(el.padding.top)),
+            right: LengthPercentage::Length(mm_to_pt(el.padding.right)),
+            bottom: LengthPercentage::Length(mm_to_pt(el.padding.bottom)),
+            left: LengthPercentage::Length(mm_to_pt(el.padding.left)),
+        },
+        align_items: Some(match el.align.as_str() {
+            "center" => AlignItems::Center,
+            "end" => AlignItems::FlexEnd,
+            "stretch" => AlignItems::Stretch,
+            _ => AlignItems::FlexStart,
+        }),
+        justify_content: Some(match el.justify.as_str() {
+            "center" => JustifyContent::Center,
+            "end" => JustifyContent::FlexEnd,
+            "space-between" => JustifyContent::SpaceBetween,
+            _ => JustifyContent::FlexStart,
+        }),
+        ..Default::default()
+    };
+
+    // Pozisyon moduna göre
+    match &el.position {
+        PositionMode::Absolute { x, y } => {
+            style.position = Position::Absolute;
+            style.inset = Rect {
+                top: LengthPercentageAuto::Length(mm_to_pt(*y)),
+                left: LengthPercentageAuto::Length(mm_to_pt(*x)),
+                right: auto(),
+                bottom: auto(),
+            };
+        }
+        PositionMode::Flow => {}
+    }
+
+    // Boyut
+    apply_size_to_style(&mut style, &el.size, parent_direction);
+
+    // Container border
+    if let Some(bw) = el.style.border_width {
+        let bpt = mm_to_pt(bw);
+        style.border = Rect {
+            top: LengthPercentage::Length(bpt),
+            right: LengthPercentage::Length(bpt),
+            bottom: LengthPercentage::Length(bpt),
+            left: LengthPercentage::Length(bpt),
+        };
+    }
+
+    style
+}
+
+/// Leaf element (text, line, image vs.) için taffy Style
+pub fn leaf_style(
+    size: &SizeConstraint,
+    position: &PositionMode,
+    parent_direction: Option<&str>,
+) -> Style {
+    let mut style = Style::default();
+
+    match position {
+        PositionMode::Absolute { x, y } => {
+            style.position = Position::Absolute;
+            style.inset = Rect {
+                top: LengthPercentageAuto::Length(mm_to_pt(*y)),
+                left: LengthPercentageAuto::Length(mm_to_pt(*x)),
+                right: auto(),
+                bottom: auto(),
+            };
+        }
+        PositionMode::Flow => {}
+    }
+
+    apply_size_to_style(&mut style, size, parent_direction);
+
+    style
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mm_to_pt_conversion() {
+        let pt = mm_to_pt(210.0);
+        // A4 width = 210mm ≈ 595.28pt
+        assert!((pt - 595.28).abs() < 0.1);
+    }
+
+    #[test]
+    fn test_fixed_size() {
+        let sv = SizeValue::Fixed { value: 50.0 };
+        match size_value_to_dimension(&sv) {
+            Dimension::Length(pt) => assert!((pt - mm_to_pt(50.0)).abs() < 0.01),
+            _ => panic!("Expected Length"),
+        }
+    }
+
+    #[test]
+    fn test_fr_maps_to_auto_dimension() {
+        let sv = SizeValue::Fr { value: 2.0 };
+        assert!(matches!(size_value_to_dimension(&sv), Dimension::Auto));
+    }
+}