mirror of
https://github.com/duhanbalci/dreport.git
synced 2026-07-01 18:39:16 +00:00
1320 lines
49 KiB
Rust
1320 lines
49 KiB
Rust
use std::collections::HashMap;
|
||
|
||
use dreport_core::models::*;
|
||
use taffy::prelude::*;
|
||
|
||
use crate::data_resolve::ResolvedData;
|
||
use crate::sizing::{self, mm_to_pt, pt_to_mm};
|
||
use crate::table_layout::{self, TableExpandCache};
|
||
use crate::text_measure::TextMeasurer;
|
||
use crate::{ElementLayout, LayoutError, LayoutResult, ResolvedContent, ResolvedStyle};
|
||
|
||
/// Taffy node ile dreport element arasındaki mapping
|
||
struct NodeInfo {
|
||
element_id: String,
|
||
element_type: String,
|
||
content: Option<ResolvedContent>,
|
||
style: ResolvedStyle,
|
||
children_ids: Vec<String>,
|
||
}
|
||
|
||
/// Taffy leaf node'lar için ölçüm context'i
|
||
struct MeasureContext {
|
||
text: String,
|
||
font_family: Option<String>,
|
||
font_size_pt: f32,
|
||
font_weight: Option<String>,
|
||
/// Rich text span'ları (varsa text/font_family/font_size_pt/font_weight yok sayılır)
|
||
rich_spans: Option<Vec<crate::text_measure::RichSpanMeasure>>,
|
||
}
|
||
|
||
/// Ana layout hesaplama fonksiyonu.
|
||
pub fn compute(
|
||
template: &Template,
|
||
resolved: &ResolvedData,
|
||
measurer: &mut TextMeasurer,
|
||
) -> Result<LayoutResult, LayoutError> {
|
||
let page_w_pt = mm_to_pt(template.page.width);
|
||
let page_width_mm = template.page.width;
|
||
|
||
// --- 1. Header layout (varsa) ---
|
||
let (header_elements, header_height_mm) = if let Some(ref header) = template.header {
|
||
compute_section(header, page_w_pt, page_width_mm, resolved, measurer)?
|
||
} else {
|
||
(vec![], 0.0)
|
||
};
|
||
|
||
// --- 2. Footer layout (varsa) ---
|
||
let (footer_elements, footer_height_mm) = if let Some(ref footer) = template.footer {
|
||
compute_section(footer, page_w_pt, page_width_mm, resolved, measurer)?
|
||
} else {
|
||
(vec![], 0.0)
|
||
};
|
||
|
||
// --- 3. Body layout — SINIRSIZ YÜKSEKLİK ---
|
||
let mut taffy = TaffyTree::<MeasureContext>::new();
|
||
taffy.disable_rounding();
|
||
let mut node_map: HashMap<NodeId, NodeInfo> = HashMap::new();
|
||
let mut table_cache = TableExpandCache::new();
|
||
|
||
let page_width_mm = template.page.width;
|
||
let root_node = build_container(
|
||
&template.root,
|
||
&mut taffy,
|
||
&mut node_map,
|
||
resolved,
|
||
None,
|
||
measurer,
|
||
page_width_mm,
|
||
&mut table_cache,
|
||
)?;
|
||
|
||
// Sayfa wrapper: sayfa genişliğinde ama yükseklik sınırsız (auto)
|
||
let page_style = Style {
|
||
display: Display::Flex,
|
||
flex_direction: FlexDirection::Column,
|
||
size: Size {
|
||
width: Dimension::length(page_w_pt),
|
||
height: Dimension::auto(),
|
||
},
|
||
..Default::default()
|
||
};
|
||
let page_node = taffy.new_with_children(page_style, &[root_node])?;
|
||
|
||
taffy.compute_layout_with_measure(
|
||
page_node,
|
||
Size {
|
||
width: AvailableSpace::Definite(page_w_pt),
|
||
height: AvailableSpace::MaxContent,
|
||
},
|
||
|known_dimensions, available_space, _node_id, context, _style| {
|
||
measure_leaf(known_dimensions, available_space, context, measurer)
|
||
},
|
||
)?;
|
||
|
||
let body_elements = collect_layout(&taffy, root_node, &node_map, resolved, 0.0, 0.0)?;
|
||
|
||
// --- 4. Container break modlarını topla ---
|
||
let break_modes = collect_break_modes(&template.root);
|
||
|
||
// --- 4b. repeat_header == false olan tablo ID'lerini topla ---
|
||
let no_repeat_header_tables = collect_no_repeat_header_tables(&template.root);
|
||
|
||
// --- 5. Sayfalara böl ---
|
||
let input = crate::page_break::PageSplitInput {
|
||
body_elements,
|
||
page_height_mm: template.page.height,
|
||
header_height_mm,
|
||
footer_height_mm,
|
||
header_elements,
|
||
footer_elements,
|
||
page_width_mm: template.page.width,
|
||
break_modes,
|
||
page_number_formats: resolved.page_number_formats.clone(),
|
||
root_padding_top_mm: template.root.padding.top,
|
||
no_repeat_header_tables,
|
||
};
|
||
|
||
let pages = crate::page_break::split_into_pages(input);
|
||
|
||
Ok(LayoutResult { pages })
|
||
}
|
||
|
||
/// Header veya footer gibi bağımsız bir container section'ı hesapla.
|
||
/// Sayfa genişliğinde, auto yükseklikte layout yapar.
|
||
fn compute_section(
|
||
container: &ContainerElement,
|
||
page_w_pt: f32,
|
||
page_width_mm: f64,
|
||
resolved: &ResolvedData,
|
||
measurer: &mut TextMeasurer,
|
||
) -> Result<(Vec<ElementLayout>, f64), LayoutError> {
|
||
let mut taffy = TaffyTree::<MeasureContext>::new();
|
||
taffy.disable_rounding();
|
||
let mut node_map: HashMap<NodeId, NodeInfo> = HashMap::new();
|
||
let mut table_cache = TableExpandCache::new();
|
||
|
||
let section_node = build_container(
|
||
container,
|
||
&mut taffy,
|
||
&mut node_map,
|
||
resolved,
|
||
None,
|
||
measurer,
|
||
page_width_mm,
|
||
&mut table_cache,
|
||
)?;
|
||
|
||
let wrapper_style = Style {
|
||
display: Display::Flex,
|
||
flex_direction: FlexDirection::Column,
|
||
size: Size {
|
||
width: Dimension::length(page_w_pt),
|
||
height: Dimension::auto(),
|
||
},
|
||
..Default::default()
|
||
};
|
||
let wrapper_node = taffy.new_with_children(wrapper_style, &[section_node])?;
|
||
|
||
taffy.compute_layout_with_measure(
|
||
wrapper_node,
|
||
Size {
|
||
width: AvailableSpace::Definite(page_w_pt),
|
||
height: AvailableSpace::MaxContent,
|
||
},
|
||
|known_dimensions, available_space, _node_id, context, _style| {
|
||
measure_leaf(known_dimensions, available_space, context, measurer)
|
||
},
|
||
)?;
|
||
|
||
let elements = collect_layout(&taffy, section_node, &node_map, resolved, 0.0, 0.0)?;
|
||
|
||
// Section yüksekliği
|
||
let section_layout = taffy.layout(section_node)?;
|
||
let height_mm = pt_to_mm(section_layout.size.height);
|
||
|
||
Ok((elements, height_mm))
|
||
}
|
||
|
||
/// Template ağacındaki tüm container'ların break_inside modlarını topla.
|
||
fn collect_break_modes(root: &ContainerElement) -> HashMap<String, String> {
|
||
let mut modes = HashMap::new();
|
||
collect_break_modes_recursive(&TemplateElement::Container(root.clone()), &mut modes);
|
||
modes
|
||
}
|
||
|
||
fn collect_break_modes_recursive(el: &TemplateElement, modes: &mut HashMap<String, String>) {
|
||
if let TemplateElement::Container(c) = el {
|
||
modes.insert(c.base.id.clone(), c.break_inside.clone());
|
||
for child in &c.children {
|
||
collect_break_modes_recursive(child, modes);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// repeat_header == false olan tablo ID'lerini topla.
|
||
fn collect_no_repeat_header_tables(root: &ContainerElement) -> std::collections::HashSet<String> {
|
||
let mut set = std::collections::HashSet::new();
|
||
collect_no_repeat_recursive(&TemplateElement::Container(root.clone()), &mut set);
|
||
set
|
||
}
|
||
|
||
fn collect_no_repeat_recursive(el: &TemplateElement, set: &mut std::collections::HashSet<String>) {
|
||
match el {
|
||
TemplateElement::Container(c) => {
|
||
for child in &c.children {
|
||
collect_no_repeat_recursive(child, set);
|
||
}
|
||
}
|
||
TemplateElement::RepeatingTable(t) => {
|
||
if t.repeat_header == Some(false) {
|
||
set.insert(t.base.id.clone());
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
/// Container element'ini taffy node ağacına ekle (recursive)
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn build_container(
|
||
el: &ContainerElement,
|
||
taffy: &mut TaffyTree<MeasureContext>,
|
||
node_map: &mut HashMap<NodeId, NodeInfo>,
|
||
resolved: &ResolvedData,
|
||
parent_direction: Option<&str>,
|
||
measurer: &mut TextMeasurer,
|
||
page_width_mm: f64,
|
||
table_cache: &mut TableExpandCache,
|
||
) -> Result<NodeId, LayoutError> {
|
||
let style = sizing::container_to_style(el, parent_direction);
|
||
let direction = el.direction.as_str();
|
||
|
||
// Child'lar için kullanılabilir genişliği hesapla
|
||
// Container'ın kendi padding ve border'ını çıkar
|
||
let border_w = el.style.border_width.unwrap_or(0.0);
|
||
let container_own_width = match &el.base.size.width {
|
||
SizeValue::Fixed { value } => *value,
|
||
_ => page_width_mm, // Fr veya Auto ise parent'ın genişliğini kullan
|
||
};
|
||
let content_width_mm =
|
||
container_own_width - el.padding.left - el.padding.right - border_w * 2.0;
|
||
let content_width_mm = content_width_mm.max(0.0);
|
||
|
||
let mut child_nodes = Vec::new();
|
||
let mut children_ids = Vec::new();
|
||
|
||
for child in &el.children {
|
||
// Koşullu render: hidden_elements'te olan elemanları atla
|
||
if resolved.hidden_elements.contains(child.id()) {
|
||
continue;
|
||
}
|
||
let child_node = build_element(
|
||
child,
|
||
taffy,
|
||
node_map,
|
||
resolved,
|
||
Some(direction),
|
||
measurer,
|
||
content_width_mm,
|
||
table_cache,
|
||
)?;
|
||
child_nodes.push(child_node);
|
||
children_ids.push(child.id().to_string());
|
||
}
|
||
|
||
let node = taffy.new_with_children(style, &child_nodes)?;
|
||
|
||
node_map.insert(
|
||
node,
|
||
NodeInfo {
|
||
element_id: el.base.id.clone(),
|
||
element_type: el.type_str().to_string(),
|
||
content: None,
|
||
style: (&el.style).into(),
|
||
children_ids,
|
||
},
|
||
);
|
||
|
||
Ok(node)
|
||
}
|
||
|
||
/// Leaf node oluştur ve node_map'e kaydet (tekrarlayan boilerplate'i ortadan kaldırır).
|
||
fn register_leaf(
|
||
taffy: &mut TaffyTree<MeasureContext>,
|
||
node_map: &mut HashMap<NodeId, NodeInfo>,
|
||
style: Style,
|
||
id: &str,
|
||
element_type: &str,
|
||
content: Option<ResolvedContent>,
|
||
resolved_style: ResolvedStyle,
|
||
) -> Result<NodeId, LayoutError> {
|
||
let node = taffy.new_leaf(style)?;
|
||
node_map.insert(
|
||
node,
|
||
NodeInfo {
|
||
element_id: id.to_string(),
|
||
element_type: element_type.to_string(),
|
||
content,
|
||
style: resolved_style,
|
||
children_ids: vec![],
|
||
},
|
||
);
|
||
Ok(node)
|
||
}
|
||
|
||
/// Herhangi bir element tipini taffy node'a çevir
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn build_element(
|
||
el: &TemplateElement,
|
||
taffy: &mut TaffyTree<MeasureContext>,
|
||
node_map: &mut HashMap<NodeId, NodeInfo>,
|
||
resolved: &ResolvedData,
|
||
parent_direction: Option<&str>,
|
||
measurer: &mut TextMeasurer,
|
||
page_width_mm: f64,
|
||
table_cache: &mut TableExpandCache,
|
||
) -> Result<NodeId, LayoutError> {
|
||
match el {
|
||
TemplateElement::Container(e) => build_container(
|
||
e,
|
||
taffy,
|
||
node_map,
|
||
resolved,
|
||
parent_direction,
|
||
measurer,
|
||
page_width_mm,
|
||
table_cache,
|
||
),
|
||
TemplateElement::StaticText(e) => build_resolved_text_leaf(
|
||
&e.base,
|
||
e.type_str(),
|
||
&e.style,
|
||
taffy,
|
||
node_map,
|
||
resolved,
|
||
parent_direction,
|
||
&e.content,
|
||
),
|
||
TemplateElement::Text(e) => build_resolved_text_leaf(
|
||
&e.base,
|
||
e.type_str(),
|
||
&e.style,
|
||
taffy,
|
||
node_map,
|
||
resolved,
|
||
parent_direction,
|
||
"",
|
||
),
|
||
TemplateElement::PageNumber(e) => build_resolved_text_leaf(
|
||
&e.base,
|
||
e.type_str(),
|
||
&e.style,
|
||
taffy,
|
||
node_map,
|
||
resolved,
|
||
parent_direction,
|
||
"1 / 1",
|
||
),
|
||
TemplateElement::CurrentDate(e) => build_resolved_text_leaf(
|
||
&e.base,
|
||
e.type_str(),
|
||
&e.style,
|
||
taffy,
|
||
node_map,
|
||
resolved,
|
||
parent_direction,
|
||
"",
|
||
),
|
||
TemplateElement::CalculatedText(e) => build_resolved_text_leaf(
|
||
&e.base,
|
||
e.type_str(),
|
||
&e.style,
|
||
taffy,
|
||
node_map,
|
||
resolved,
|
||
parent_direction,
|
||
"",
|
||
),
|
||
TemplateElement::Line(e) => {
|
||
let stroke_w = e.style.stroke_width.unwrap_or(0.5);
|
||
let mut style = sizing::leaf_style(&e.base.size, &e.base.position, parent_direction);
|
||
if matches!(e.base.size.height, SizeValue::Auto) {
|
||
style.size.height = Dimension::length(mm_to_pt(stroke_w));
|
||
}
|
||
let mut rs: ResolvedStyle = (&e.style).into();
|
||
rs.stroke_width = Some(stroke_w);
|
||
register_leaf(
|
||
taffy, node_map, style,
|
||
&e.base.id, e.type_str(),
|
||
Some(ResolvedContent::Line),
|
||
rs,
|
||
)
|
||
}
|
||
TemplateElement::Image(e) => {
|
||
let style = sizing::leaf_style(&e.base.size, &e.base.position, parent_direction);
|
||
let src = resolved.images.get(&e.base.id).cloned().unwrap_or_default();
|
||
register_leaf(
|
||
taffy, node_map, style,
|
||
&e.base.id, e.type_str(),
|
||
Some(ResolvedContent::Image { src }),
|
||
(&e.style).into(),
|
||
)
|
||
}
|
||
TemplateElement::Barcode(e) => {
|
||
let mut style = sizing::leaf_style(&e.base.size, &e.base.position, parent_direction);
|
||
let value = resolved.barcodes.get(&e.base.id).cloned().unwrap_or_default();
|
||
let is_qr = e.format == "qr";
|
||
if matches!(e.base.size.height, SizeValue::Auto) {
|
||
style.min_size.height = Dimension::length(mm_to_pt(if is_qr { 20.0 } else { 15.0 }));
|
||
}
|
||
if matches!(e.base.size.width, SizeValue::Auto) {
|
||
style.min_size.width = Dimension::length(mm_to_pt(if is_qr { 20.0 } else { 40.0 }));
|
||
}
|
||
register_leaf(
|
||
taffy, node_map, style,
|
||
&e.base.id, e.type_str(),
|
||
Some(ResolvedContent::Barcode { format: e.format.clone(), value }),
|
||
(&e.style).into(),
|
||
)
|
||
}
|
||
TemplateElement::RepeatingTable(e) => {
|
||
// Tabloyu container ağacına expand et (cache ile)
|
||
let expanded = table_layout::expand_table_cached(
|
||
e,
|
||
resolved,
|
||
measurer,
|
||
page_width_mm,
|
||
table_cache,
|
||
);
|
||
|
||
// Expand edilmiş tablo cell'lerinin text'lerini resolved'a ekle
|
||
// (expand_table StaticText'ler üretir, bunların text'leri zaten content'te)
|
||
let mut table_resolved = resolved.clone();
|
||
register_expanded_texts(
|
||
&TemplateElement::Container(expanded.clone()),
|
||
&mut table_resolved,
|
||
);
|
||
|
||
// Container olarak build et
|
||
build_container(
|
||
&expanded,
|
||
taffy,
|
||
node_map,
|
||
&table_resolved,
|
||
parent_direction,
|
||
measurer,
|
||
page_width_mm,
|
||
table_cache,
|
||
)
|
||
}
|
||
TemplateElement::Shape(e) => {
|
||
let style = sizing::leaf_style(&e.base.size, &e.base.position, parent_direction);
|
||
register_leaf(
|
||
taffy, node_map, style,
|
||
&e.base.id, e.type_str(),
|
||
Some(ResolvedContent::Shape { shape_type: e.shape_type.clone() }),
|
||
(&e.style).into(),
|
||
)
|
||
}
|
||
TemplateElement::Checkbox(e) => {
|
||
let checked = resolved
|
||
.texts
|
||
.get(&e.base.id)
|
||
.map(|s| s == "true")
|
||
.unwrap_or(false);
|
||
let box_size_mm = e.style.size.unwrap_or(4.0);
|
||
let mut style = sizing::leaf_style(&e.base.size, &e.base.position, parent_direction);
|
||
if matches!(e.base.size.width, SizeValue::Auto) {
|
||
style.size.width = Dimension::length(mm_to_pt(box_size_mm));
|
||
}
|
||
if matches!(e.base.size.height, SizeValue::Auto) {
|
||
style.size.height = Dimension::length(mm_to_pt(box_size_mm));
|
||
}
|
||
register_leaf(
|
||
taffy, node_map, style,
|
||
&e.base.id, e.type_str(),
|
||
Some(ResolvedContent::Checkbox { checked }),
|
||
(&e.style).into(),
|
||
)
|
||
}
|
||
TemplateElement::RichText(e) => {
|
||
let spans = resolved.rich_texts.get(&e.base.id).cloned().unwrap_or_default();
|
||
let rich_span_measures: Vec<crate::text_measure::RichSpanMeasure> = spans
|
||
.iter()
|
||
.map(|s| crate::text_measure::RichSpanMeasure {
|
||
text: s.text.clone(),
|
||
font_family: s.font_family.clone(),
|
||
font_size_pt: s.font_size.unwrap_or(11.0) as f32,
|
||
font_weight: s.font_weight.clone(),
|
||
})
|
||
.collect();
|
||
|
||
let max_font_size_pt = rich_span_measures
|
||
.iter()
|
||
.map(|s| s.font_size_pt)
|
||
.fold(11.0f32, f32::max);
|
||
|
||
let style = sizing::leaf_style(&e.base.size, &e.base.position, parent_direction);
|
||
|
||
let context = MeasureContext {
|
||
text: String::new(),
|
||
font_family: None,
|
||
font_size_pt: max_font_size_pt,
|
||
font_weight: None,
|
||
rich_spans: Some(rich_span_measures),
|
||
};
|
||
|
||
let node = taffy.new_leaf_with_context(style, context)?;
|
||
|
||
// ResolvedContent::RichText span'ları oluştur
|
||
let resolved_spans: Vec<crate::ResolvedRichSpan> = spans
|
||
.iter()
|
||
.map(|s| crate::ResolvedRichSpan {
|
||
text: s.text.clone(),
|
||
font_size: s.font_size,
|
||
font_weight: s.font_weight.clone(),
|
||
font_family: s.font_family.clone(),
|
||
color: s.color.clone(),
|
||
})
|
||
.collect();
|
||
|
||
node_map.insert(
|
||
node,
|
||
NodeInfo {
|
||
element_id: e.base.id.clone(),
|
||
element_type: e.type_str().to_string(),
|
||
content: Some(ResolvedContent::RichText {
|
||
spans: resolved_spans,
|
||
}),
|
||
style: (&e.style).into(),
|
||
children_ids: vec![],
|
||
},
|
||
);
|
||
Ok(node)
|
||
}
|
||
TemplateElement::Chart(e) => {
|
||
let mut style = sizing::leaf_style(&e.base.size, &e.base.position, parent_direction);
|
||
if matches!(e.base.size.width, SizeValue::Auto) {
|
||
style.min_size.width = Dimension::length(mm_to_pt(80.0));
|
||
}
|
||
if matches!(e.base.size.height, SizeValue::Auto) {
|
||
style.min_size.height = Dimension::length(mm_to_pt(60.0));
|
||
}
|
||
register_leaf(
|
||
taffy, node_map, style,
|
||
&e.base.id, e.type_str(),
|
||
None, // SVG collect_layout'ta üretilecek
|
||
ResolvedStyle::default(),
|
||
)
|
||
}
|
||
TemplateElement::PageBreak(e) => {
|
||
let style = Style {
|
||
size: Size {
|
||
width: Dimension::auto(),
|
||
height: Dimension::length(mm_to_pt(0.5)),
|
||
},
|
||
..Default::default()
|
||
};
|
||
register_leaf(
|
||
taffy, node_map, style,
|
||
&e.base.id, e.type_str(),
|
||
None,
|
||
ResolvedStyle::default(),
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Expand edilmiş tablo cell'lerinin text'lerini ResolvedData'ya kaydet
|
||
fn register_expanded_texts(el: &TemplateElement, resolved: &mut ResolvedData) {
|
||
match el {
|
||
TemplateElement::StaticText(e) => {
|
||
resolved.texts.insert(e.base.id.clone(), e.content.clone());
|
||
}
|
||
TemplateElement::Container(e) => {
|
||
for child in &e.children {
|
||
register_expanded_texts(child, resolved);
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
/// Generic text leaf builder — HasTextStyle trait ile text-benzeri elementleri tek yerde build eder
|
||
fn build_resolved_text_leaf(
|
||
el_base: &ElementBase,
|
||
el_type_str: &str,
|
||
text_style: &TextStyle,
|
||
taffy: &mut TaffyTree<MeasureContext>,
|
||
node_map: &mut HashMap<NodeId, NodeInfo>,
|
||
resolved: &ResolvedData,
|
||
parent_direction: Option<&str>,
|
||
fallback_text: &str,
|
||
) -> Result<NodeId, LayoutError> {
|
||
let text = resolved
|
||
.texts
|
||
.get(&el_base.id)
|
||
.map(|s| s.as_str())
|
||
.unwrap_or(fallback_text);
|
||
build_text_leaf(
|
||
taffy,
|
||
node_map,
|
||
&el_base.id,
|
||
el_type_str,
|
||
text,
|
||
text_style,
|
||
&el_base.size,
|
||
&el_base.position,
|
||
parent_direction,
|
||
)
|
||
}
|
||
|
||
/// Text leaf node oluştur (static_text, text, page_number için ortak)
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn build_text_leaf(
|
||
taffy: &mut TaffyTree<MeasureContext>,
|
||
node_map: &mut HashMap<NodeId, NodeInfo>,
|
||
id: &str,
|
||
element_type: &str,
|
||
text: &str,
|
||
text_style: &TextStyle,
|
||
size: &SizeConstraint,
|
||
position: &PositionMode,
|
||
parent_direction: Option<&str>,
|
||
) -> Result<NodeId, LayoutError> {
|
||
let style = sizing::leaf_style(size, position, parent_direction);
|
||
let font_size_pt = text_style.font_size.unwrap_or(11.0) as f32;
|
||
|
||
let context = MeasureContext {
|
||
text: text.to_string(),
|
||
font_family: text_style.font_family.clone(),
|
||
font_size_pt,
|
||
font_weight: text_style.font_weight.clone(),
|
||
rich_spans: None,
|
||
};
|
||
|
||
let node = taffy.new_leaf_with_context(style, context)?;
|
||
|
||
node_map.insert(
|
||
node,
|
||
NodeInfo {
|
||
element_id: id.to_string(),
|
||
element_type: element_type.to_string(),
|
||
content: Some(ResolvedContent::Text {
|
||
value: text.to_string(),
|
||
}),
|
||
style: text_style.into(),
|
||
children_ids: vec![],
|
||
},
|
||
);
|
||
|
||
Ok(node)
|
||
}
|
||
|
||
/// Taffy MeasureFunc: text leaf node'ları ölç
|
||
fn measure_leaf(
|
||
known_dimensions: Size<Option<f32>>,
|
||
available_space: Size<AvailableSpace>,
|
||
context: Option<&mut MeasureContext>,
|
||
measurer: &mut TextMeasurer,
|
||
) -> Size<f32> {
|
||
let Some(ctx) = context else {
|
||
// Context yoksa (line, image vs.) → taffy style'daki boyutu kullan
|
||
return Size {
|
||
width: known_dimensions.width.unwrap_or(0.0),
|
||
height: known_dimensions.height.unwrap_or(0.0),
|
||
};
|
||
};
|
||
|
||
// Bilinen boyutlar varsa onları kullan
|
||
if let (Some(w), Some(h)) = (known_dimensions.width, known_dimensions.height) {
|
||
return Size {
|
||
width: w,
|
||
height: h,
|
||
};
|
||
}
|
||
|
||
let available_width = match available_space.width {
|
||
AvailableSpace::Definite(w) => Some(w),
|
||
AvailableSpace::MaxContent => None,
|
||
AvailableSpace::MinContent => Some(0.0),
|
||
};
|
||
|
||
let (measured_w, measured_h) = if let Some(ref rich_spans) = ctx.rich_spans {
|
||
measurer.measure_rich_text(rich_spans, available_width)
|
||
} else {
|
||
measurer.measure(
|
||
&ctx.text,
|
||
ctx.font_family.as_deref(),
|
||
ctx.font_size_pt,
|
||
ctx.font_weight.as_deref(),
|
||
available_width,
|
||
)
|
||
};
|
||
|
||
Size {
|
||
width: known_dimensions.width.unwrap_or(measured_w),
|
||
height: known_dimensions.height.unwrap_or(measured_h),
|
||
}
|
||
}
|
||
|
||
/// Taffy layout sonuçlarını ElementLayout listesine dönüştür (recursive).
|
||
/// Pozisyon biriktirmesi f64 (mm) cinsinde yapılır — f32'de toplama hassasiyet kaybına yol açar.
|
||
fn collect_layout(
|
||
taffy: &TaffyTree<MeasureContext>,
|
||
node: NodeId,
|
||
node_map: &HashMap<NodeId, NodeInfo>,
|
||
resolved: &ResolvedData,
|
||
parent_x_mm: f64,
|
||
parent_y_mm: f64,
|
||
) -> Result<Vec<ElementLayout>, LayoutError> {
|
||
let mut elements = Vec::new();
|
||
|
||
let Some(info) = node_map.get(&node) else {
|
||
return Ok(elements);
|
||
};
|
||
|
||
let layout = taffy.layout(node)?;
|
||
let x_mm = parent_x_mm + pt_to_mm(layout.location.x);
|
||
let y_mm = parent_y_mm + pt_to_mm(layout.location.y);
|
||
let w_mm = pt_to_mm(layout.size.width);
|
||
let h_mm = pt_to_mm(layout.size.height);
|
||
|
||
// Chart elementleri için SVG üret (boyutlar artık belli)
|
||
let content = if info.element_type == "chart" {
|
||
resolved.charts.get(&info.element_id).map(|cd| {
|
||
ResolvedContent::Chart {
|
||
svg: crate::chart_render::render_svg(cd, w_mm, h_mm),
|
||
chart_data: Box::new(crate::ChartRenderData::from(cd)),
|
||
}
|
||
})
|
||
} else {
|
||
info.content.clone()
|
||
};
|
||
|
||
elements.push(ElementLayout {
|
||
id: info.element_id.clone(),
|
||
x_mm,
|
||
y_mm,
|
||
width_mm: w_mm,
|
||
height_mm: h_mm,
|
||
element_type: info.element_type.clone(),
|
||
content,
|
||
style: info.style.clone(),
|
||
children: info.children_ids.clone(),
|
||
});
|
||
|
||
// Child node'ları da topla
|
||
let children = taffy.children(node)?;
|
||
for child_node in children {
|
||
let child_elements = collect_layout(taffy, child_node, node_map, resolved, x_mm, y_mm)?;
|
||
elements.extend(child_elements);
|
||
}
|
||
|
||
Ok(elements)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use serde_json::json;
|
||
|
||
fn simple_template() -> Template {
|
||
Template {
|
||
id: "test".to_string(),
|
||
name: "Test".to_string(),
|
||
page: PageSettings {
|
||
width: 210.0,
|
||
height: 297.0,
|
||
},
|
||
fonts: vec!["Noto Sans".to_string()],
|
||
header: None,
|
||
footer: None,
|
||
format_config: None,
|
||
locale: None,
|
||
root: ContainerElement {
|
||
base: ElementBase::flow("root".to_string(), SizeConstraint {
|
||
width: SizeValue::Auto,
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
direction: "column".to_string(),
|
||
gap: 5.0,
|
||
padding: Padding {
|
||
top: 15.0,
|
||
right: 15.0,
|
||
bottom: 15.0,
|
||
left: 15.0,
|
||
},
|
||
align: "stretch".to_string(),
|
||
justify: "start".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("title".to_string(), SizeConstraint {
|
||
width: SizeValue::Fr { value: 1.0 },
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
style: TextStyle {
|
||
font_size: Some(18.0),
|
||
font_weight: Some("bold".to_string()),
|
||
..Default::default()
|
||
},
|
||
content: "FATURA".to_string(),
|
||
}),
|
||
TemplateElement::Line(LineElement {
|
||
base: ElementBase::flow("line1".to_string(), SizeConstraint {
|
||
width: SizeValue::Fr { value: 1.0 },
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
style: LineStyle {
|
||
stroke_color: Some("#000000".to_string()),
|
||
stroke_width: Some(0.5),
|
||
},
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("body".to_string(), SizeConstraint {
|
||
width: SizeValue::Fr { value: 1.0 },
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
style: TextStyle {
|
||
font_size: Some(11.0),
|
||
..Default::default()
|
||
},
|
||
content: "Bu bir test belgesidir.".to_string(),
|
||
}),
|
||
],
|
||
},
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_basic_layout() {
|
||
let template = simple_template();
|
||
let data = json!({});
|
||
let resolved = crate::data_resolve::resolve_template(&template, &data);
|
||
let fonts = crate::text_measure::load_test_fonts();
|
||
let mut measurer = TextMeasurer::new(&fonts);
|
||
|
||
let result = compute(&template, &resolved, &mut measurer).unwrap();
|
||
|
||
assert_eq!(result.pages.len(), 1);
|
||
let page = &result.pages[0];
|
||
assert_eq!(page.width_mm, 210.0);
|
||
assert_eq!(page.height_mm, 297.0);
|
||
|
||
println!("Layout sonuçları:");
|
||
for el in &page.elements {
|
||
println!(
|
||
" {} ({}): x={:.1}mm y={:.1}mm w={:.1}mm h={:.1}mm",
|
||
el.id, el.element_type, el.x_mm, el.y_mm, el.width_mm, el.height_mm
|
||
);
|
||
}
|
||
|
||
// Root container + 3 children = en az 4 element
|
||
assert!(page.elements.len() >= 4);
|
||
|
||
// Root container pozisyonu: (0, 0)
|
||
let root = page.elements.iter().find(|e| e.id == "root").unwrap();
|
||
assert!(root.x_mm.abs() < 0.1);
|
||
assert!(root.y_mm.abs() < 0.1);
|
||
|
||
// Title: padding'in içinde olmalı (x ≈ 15mm, y ≈ 15mm)
|
||
let title = page.elements.iter().find(|e| e.id == "title").unwrap();
|
||
assert!((title.x_mm - 15.0).abs() < 1.0);
|
||
assert!((title.y_mm - 15.0).abs() < 1.0);
|
||
assert!(
|
||
title.width_mm > 100.0,
|
||
"title width={:.1}mm, expected > 100mm",
|
||
title.width_mm
|
||
);
|
||
|
||
// Line: title'dan sonra (y > title.y)
|
||
let line = page.elements.iter().find(|e| e.id == "line1").unwrap();
|
||
assert!(line.y_mm > title.y_mm);
|
||
assert!(line.height_mm < 2.0);
|
||
|
||
// Body: line'dan sonra
|
||
let body = page.elements.iter().find(|e| e.id == "body").unwrap();
|
||
assert!(body.y_mm > line.y_mm);
|
||
}
|
||
|
||
#[test]
|
||
fn test_row_container() {
|
||
let template = Template {
|
||
id: "test".to_string(),
|
||
name: "Test".to_string(),
|
||
page: PageSettings {
|
||
width: 210.0,
|
||
height: 297.0,
|
||
},
|
||
fonts: vec![],
|
||
header: None,
|
||
footer: None,
|
||
format_config: None,
|
||
locale: None,
|
||
root: ContainerElement {
|
||
base: ElementBase::flow("root".to_string(), SizeConstraint {
|
||
width: SizeValue::Auto,
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
direction: "column".to_string(),
|
||
gap: 0.0,
|
||
padding: Padding {
|
||
top: 10.0,
|
||
right: 10.0,
|
||
bottom: 10.0,
|
||
left: 10.0,
|
||
},
|
||
align: "stretch".to_string(),
|
||
justify: "start".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![TemplateElement::Container(ContainerElement {
|
||
base: ElementBase::flow("row".to_string(), SizeConstraint {
|
||
width: SizeValue::Fr { value: 1.0 },
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
direction: "row".to_string(),
|
||
gap: 5.0,
|
||
padding: Padding {
|
||
top: 0.0,
|
||
right: 0.0,
|
||
bottom: 0.0,
|
||
left: 0.0,
|
||
},
|
||
align: "start".to_string(),
|
||
justify: "start".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("left".to_string(), SizeConstraint {
|
||
width: SizeValue::Fr { value: 1.0 },
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
style: TextStyle {
|
||
font_size: Some(11.0),
|
||
..Default::default()
|
||
},
|
||
content: "Sol".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("right".to_string(), SizeConstraint {
|
||
width: SizeValue::Fr { value: 1.0 },
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
style: TextStyle {
|
||
font_size: Some(11.0),
|
||
..Default::default()
|
||
},
|
||
content: "Sağ".to_string(),
|
||
}),
|
||
],
|
||
})],
|
||
},
|
||
};
|
||
|
||
let data = json!({});
|
||
let resolved = crate::data_resolve::resolve_template(&template, &data);
|
||
let fonts = crate::text_measure::load_test_fonts();
|
||
let mut measurer = TextMeasurer::new(&fonts);
|
||
let result = compute(&template, &resolved, &mut measurer).unwrap();
|
||
|
||
let page = &result.pages[0];
|
||
let left = page.elements.iter().find(|e| e.id == "left").unwrap();
|
||
let right = page.elements.iter().find(|e| e.id == "right").unwrap();
|
||
|
||
// İki eleman eşit genişlikte olmalı (fr: 1 + fr: 1)
|
||
assert!((left.width_mm - right.width_mm).abs() < 1.0);
|
||
|
||
// Right, left'in sağında olmalı
|
||
assert!(right.x_mm > left.x_mm + left.width_mm - 1.0);
|
||
|
||
// İkisinin toplam genişliği ≈ 190mm (210 - 10 - 10 padding, - 5mm gap)
|
||
let total = left.width_mm + right.width_mm + 5.0; // gap
|
||
assert!((total - 190.0).abs() < 2.0);
|
||
|
||
println!("Row layout:");
|
||
for el in &page.elements {
|
||
println!(
|
||
" {} ({}): x={:.1}mm y={:.1}mm w={:.1}mm h={:.1}mm",
|
||
el.id, el.element_type, el.x_mm, el.y_mm, el.width_mm, el.height_mm
|
||
);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_absolute_positioning() {
|
||
let template = Template {
|
||
id: "test".to_string(),
|
||
name: "Test".to_string(),
|
||
page: PageSettings {
|
||
width: 210.0,
|
||
height: 297.0,
|
||
},
|
||
fonts: vec![],
|
||
header: None,
|
||
footer: None,
|
||
format_config: None,
|
||
locale: None,
|
||
root: ContainerElement {
|
||
base: ElementBase::flow("root".to_string(), SizeConstraint {
|
||
width: SizeValue::Auto,
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
}),
|
||
direction: "column".to_string(),
|
||
gap: 0.0,
|
||
padding: Padding {
|
||
top: 0.0,
|
||
right: 0.0,
|
||
bottom: 0.0,
|
||
left: 0.0,
|
||
},
|
||
align: "stretch".to_string(),
|
||
justify: "start".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase {
|
||
id: "abs_text".to_string(),
|
||
condition: None,
|
||
position: PositionMode::Absolute { x: 50.0, y: 80.0 },
|
||
size: SizeConstraint {
|
||
width: SizeValue::Fixed { value: 100.0 },
|
||
height: SizeValue::Auto,
|
||
min_width: None,
|
||
min_height: None,
|
||
max_width: None,
|
||
max_height: None,
|
||
},
|
||
},
|
||
style: TextStyle {
|
||
font_size: Some(14.0),
|
||
..Default::default()
|
||
},
|
||
content: "Absolute".to_string(),
|
||
})],
|
||
},
|
||
};
|
||
|
||
let data = json!({});
|
||
let resolved = crate::data_resolve::resolve_template(&template, &data);
|
||
let fonts = crate::text_measure::load_test_fonts();
|
||
let mut measurer = TextMeasurer::new(&fonts);
|
||
let result = compute(&template, &resolved, &mut measurer).unwrap();
|
||
|
||
let page = &result.pages[0];
|
||
let abs = page.elements.iter().find(|e| e.id == "abs_text").unwrap();
|
||
|
||
// Absolute pozisyon: x ≈ 50mm, y ≈ 80mm
|
||
assert!((abs.x_mm - 50.0).abs() < 1.0);
|
||
assert!((abs.y_mm - 80.0).abs() < 1.0);
|
||
assert!((abs.width_mm - 100.0).abs() < 1.0);
|
||
|
||
println!(
|
||
"Absolute: x={:.1}mm y={:.1}mm w={:.1}mm h={:.1}mm",
|
||
abs.x_mm, abs.y_mm, abs.width_mm, abs.height_mm
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_invoice_header_overflow() {
|
||
// App.vue'daki fatura şablonunun header kısmını birebir test et
|
||
let sz_auto = SizeConstraint {
|
||
width: SizeValue::Auto,
|
||
height: SizeValue::Auto,
|
||
..Default::default()
|
||
};
|
||
let sz_fr_auto = SizeConstraint {
|
||
width: SizeValue::Fr { value: 1.0 },
|
||
height: SizeValue::Auto,
|
||
..Default::default()
|
||
};
|
||
let p0 = Padding::default();
|
||
|
||
let template = Template {
|
||
id: "test".to_string(),
|
||
name: "Test".to_string(),
|
||
page: PageSettings {
|
||
width: 210.0,
|
||
height: 297.0,
|
||
},
|
||
fonts: vec!["Noto Sans".to_string()],
|
||
header: None,
|
||
footer: None,
|
||
format_config: None,
|
||
locale: None,
|
||
root: ContainerElement {
|
||
base: ElementBase::flow("root".to_string(), sz_auto.clone()),
|
||
direction: "column".to_string(),
|
||
gap: 5.0,
|
||
padding: Padding {
|
||
top: 15.0,
|
||
right: 15.0,
|
||
bottom: 15.0,
|
||
left: 15.0,
|
||
},
|
||
align: "stretch".to_string(),
|
||
justify: "start".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![
|
||
// Header row
|
||
TemplateElement::Container(ContainerElement {
|
||
base: ElementBase::flow("c_header".to_string(), sz_fr_auto.clone()),
|
||
direction: "row".to_string(),
|
||
gap: 5.0,
|
||
padding: p0.clone(),
|
||
align: "start".to_string(),
|
||
justify: "space-between".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![
|
||
// Sol: firma bilgileri
|
||
TemplateElement::Container(ContainerElement {
|
||
base: ElementBase::flow("c_firma".to_string(), sz_fr_auto.clone()),
|
||
direction: "column".to_string(),
|
||
gap: 1.0,
|
||
padding: p0.clone(),
|
||
align: "start".to_string(),
|
||
justify: "start".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_firma_unvan".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(14.0),
|
||
font_weight: Some("bold".to_string()),
|
||
..Default::default()
|
||
},
|
||
content: "Teknova Yazılım ve Danışmanlık A.Ş.".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_firma_adres".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(9.0),
|
||
..Default::default()
|
||
},
|
||
content: "Levent Mah. Inovasyon Sk. No:42 Kat:5"
|
||
.to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_firma_il".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(9.0),
|
||
..Default::default()
|
||
},
|
||
content: "Istanbul".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_firma_tel".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(9.0),
|
||
..Default::default()
|
||
},
|
||
content: "Tel: +90 212 555 0042".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_firma_vd".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(9.0),
|
||
..Default::default()
|
||
},
|
||
content: "VD: Levent VD".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_firma_vn".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(9.0),
|
||
..Default::default()
|
||
},
|
||
content: "VN: 1234567890".to_string(),
|
||
}),
|
||
],
|
||
}),
|
||
// Sağ: fatura başlığı
|
||
TemplateElement::Container(ContainerElement {
|
||
base: ElementBase::flow("c_fatura_baslik".to_string(), sz_auto.clone()),
|
||
direction: "column".to_string(),
|
||
gap: 2.0,
|
||
padding: p0.clone(),
|
||
align: "end".to_string(),
|
||
justify: "start".to_string(),
|
||
style: ContainerStyle::default(),
|
||
break_inside: "auto".to_string(),
|
||
children: vec![
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_fatura_baslik".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(18.0),
|
||
font_weight: Some("bold".to_string()),
|
||
..Default::default()
|
||
},
|
||
content: "FATURA".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_fatura_no".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(10.0),
|
||
..Default::default()
|
||
},
|
||
content: "No: FTR-2026-001547".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_fatura_tarih".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(10.0),
|
||
..Default::default()
|
||
},
|
||
content: "Tarih: 2026-03-29".to_string(),
|
||
}),
|
||
TemplateElement::StaticText(StaticTextElement {
|
||
base: ElementBase::flow("el_fatura_vade".to_string(), sz_auto.clone()),
|
||
style: TextStyle {
|
||
font_size: Some(10.0),
|
||
..Default::default()
|
||
},
|
||
content: "Vade: 2026-04-28".to_string(),
|
||
}),
|
||
],
|
||
}),
|
||
],
|
||
}),
|
||
],
|
||
},
|
||
};
|
||
|
||
let data = json!({});
|
||
let resolved = crate::data_resolve::resolve_template(&template, &data);
|
||
let fonts = crate::text_measure::load_test_fonts();
|
||
let mut measurer = TextMeasurer::new(&fonts);
|
||
let result = compute(&template, &resolved, &mut measurer).unwrap();
|
||
|
||
let page = &result.pages[0];
|
||
println!("\n=== FATURA HEADER LAYOUT ===");
|
||
for el in &page.elements {
|
||
println!(
|
||
" {:20} ({:12}): x={:9.4}mm y={:9.4}mm w={:9.4}mm h={:9.4}mm",
|
||
el.id, el.element_type, el.x_mm, el.y_mm, el.width_mm, el.height_mm
|
||
);
|
||
}
|
||
|
||
// c_header sınırlarını kontrol et
|
||
let header = page.elements.iter().find(|e| e.id == "c_header").unwrap();
|
||
let fatura_baslik = page
|
||
.elements
|
||
.iter()
|
||
.find(|e| e.id == "c_fatura_baslik")
|
||
.unwrap();
|
||
|
||
let header_right = header.x_mm + header.width_mm;
|
||
let header_bottom = header.y_mm + header.height_mm;
|
||
let fb_right = fatura_baslik.x_mm + fatura_baslik.width_mm;
|
||
let fb_bottom = fatura_baslik.y_mm + fatura_baslik.height_mm;
|
||
|
||
println!(
|
||
"\n c_header sağ kenar: {:.1}mm, alt kenar: {:.1}mm",
|
||
header_right, header_bottom
|
||
);
|
||
println!(
|
||
" c_fatura_baslik sağ kenar: {:.1}mm, alt kenar: {:.1}mm",
|
||
fb_right, fb_bottom
|
||
);
|
||
println!(" Yatay taşma: {:.1}mm", fb_right - header_right);
|
||
println!(" Dikey taşma: {:.1}mm", fb_bottom - header_bottom);
|
||
|
||
// c_fatura_baslik, c_header'ın dışına taşmamalı
|
||
assert!(
|
||
fb_right <= header_right + 0.5,
|
||
"c_fatura_baslik sağ kenarı ({:.1}mm) c_header sağ kenarını ({:.1}mm) aşıyor!",
|
||
fb_right,
|
||
header_right
|
||
);
|
||
assert!(
|
||
fb_bottom <= header_bottom + 0.5,
|
||
"c_fatura_baslik alt kenarı ({:.1}mm) c_header alt kenarını ({:.1}mm) aşıyor!",
|
||
fb_bottom,
|
||
header_bottom
|
||
);
|
||
}
|
||
}
|