use super::{keep_node, Layer};
use crate::effect::{
box_is_effect, consume_following_box, effect_box_crop, glass_crop, is_math_node, is_rule_id,
keep_for_effect, math_crop, rasterize_slice,
};
use crate::geo::find_geo;
use crate::ir::PageElement;
use crate::picture::picture_from_draw;
use crate::shape::shapes_from_box;
use crate::table::{paint_node_id, table_ref_placeholder, take_table, TakeTable};
use crate::text::{textbox_from_draw_ctx, TextFonts};
use crate::IdmlError;
use k2f_core::{LockFile, Page, PaintOp};
use k2f_paint::OpenedDocument;
use std::collections::{BTreeMap, HashSet};
pub(super) fn scan_ops(
ops: &[PaintOp],
page: &Page,
page_idx: usize,
lock: &LockFile,
layer: Layer,
doc: &OpenedDocument,
fonts: &TextFonts,
running_ids: &HashSet<String>,
list_starts: &BTreeMap<String, u32>,
tables: &crate::table::TableIndex,
media_n: &mut u32,
raster_n: &mut u32,
) -> Result<Vec<PageElement>, IdmlError> {
let root = doc.semantic_root();
let running = doc.running_blocks();
let assets = doc.assets();
let expand_pages = Some((lock.geometry.pages.len(), page_idx + 1));
let is_master = matches!(layer, Layer::Master { .. });
let mut elements = Vec::new();
let mut seen_master = HashSet::new();
let mut emitted_tables = HashSet::new();
let mut skip = HashSet::new();
for (i, op) in ops.iter().enumerate() {
if skip.contains(&i) {
continue;
}
if let Some(nid) = paint_node_id(op) {
if !keep_node(nid, running_ids, is_master, &mut seen_master) {
continue;
}
}
match take_table(
op,
tables,
&mut emitted_tables,
page,
ops,
root,
running,
fonts,
)? {
TakeTable::Skip => continue,
TakeTable::Built(tbl) => {
elements.push(PageElement::Table(tbl));
continue;
}
TakeTable::NotMember => {}
}
match op {
PaintOp::Unknown => return Err(IdmlError::UnknownOp),
PaintOp::BackdropBlur { node_id, rect, .. } => {
let follow = consume_following_box(ops, i, node_id);
if let Some(j) = follow {
skip.insert(j);
}
let crop = glass_crop(rect, ops, follow)?;
let pic = slice(
lock, page_idx, page, ops, node_id, crop, false, raster_n, doc,
)?;
elements.push(PageElement::Raster(pic));
}
PaintOp::DrawText {
node_id,
rect,
runs,
} => {
let Some(node) = k2f_core::find_in_trees(root, running, node_id) else {
continue;
};
if is_math_node(node) {
let crop = math_crop(ops, node_id, rect);
let pic = slice(
lock, page_idx, page, ops, node_id, crop, true, raster_n, doc,
)?;
elements.push(PageElement::Raster(pic));
continue;
}
let geo = find_geo(&page.root, node_id);
if let Some(tb) = textbox_from_draw_ctx(
node,
rect,
runs,
geo,
fonts,
list_starts.get(&node.id).copied().unwrap_or(1),
expand_pages,
) {
elements.push(PageElement::TextBox(tb));
}
}
PaintOp::DrawBox {
node_id,
rect,
decoration,
} => {
if is_rule_id(node_id) {
continue;
}
if box_is_effect(node_id, decoration)? {
let crop = effect_box_crop(rect, decoration)?;
let pic = slice(
lock, page_idx, page, ops, node_id, crop, false, raster_n, doc,
)?;
elements.push(PageElement::Raster(pic));
continue;
}
for shape in shapes_from_box(node_id, rect, decoration)? {
elements.push(PageElement::Shape(shape));
}
}
PaintOp::DrawImage {
node_id,
rect,
src,
fit,
corner_radius_pt,
} => {
let pic = picture_from_draw(
node_id,
rect,
src,
assets,
*media_n,
*fit,
*corner_radius_pt,
)?;
*media_n = media_n.saturating_add(1);
elements.push(PageElement::Picture(pic));
}
PaintOp::DrawTableReference { node_id, rect, .. } => {
elements.push(PageElement::Shape(table_ref_placeholder(node_id, rect)));
}
}
}
Ok(elements)
}
fn slice(
lock: &LockFile,
page_idx: usize,
page: &Page,
ops: &[PaintOp],
node_id: &str,
crop: k2f_core::Rect,
math: bool,
raster_n: &mut u32,
doc: &OpenedDocument,
) -> Result<crate::ir::PictureBox, IdmlError> {
let keep = keep_for_effect(node_id, page, math);
let pic = rasterize_slice(
lock,
page_idx,
page,
ops,
&keep,
crop,
node_id,
*raster_n,
doc.fonts(),
doc.assets(),
)?;
*raster_n = raster_n.saturating_add(1);
Ok(pic)
}