1b-agent/OneCAD-Draft
1
0 Fork 0
forked from 1b-agent/opencadstudio-upstream
Code Pull Requests Activity
Files
593f7ca3e9502f2bf6c63d71085f56eabd810ef7
OneCAD-Draft/src/entities/table.rs
T
ramox81andClaude Opus 5.5 7f8f8457c7 Frames: state-following ribbon list, DWF/DGN frames, image frame encoding and profile, frame-only picking 
- The Frames list shows the drawing's frame state (hide / display and plot /
  display but not plot / frames vary), follows commands, undo and document
  switches, and lists the mixed state as a disabled item.
- DWFFRAME and DGNFRAME are frame variables of their own, kept in the header,
  and FRAME sets them with the others.
- Out-of-range frame values say "Requires an integer between 0 and 2." and
  ask again; a set value reports "Regenerating model.".
- IMAGEFRAME is stored in the image variables as bits (2 is written as 3) and
  a drawing without them uses the profile value, which setting IMAGEFRAME
  updates and the settings file keeps.
- Raster images, PDF underlays and wipeouts are picked on their frame only;
  underlay snap geometry is never picked.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-09-28 10:53:53 +03:00

3370 lines
135 KiB
Rust
Raw Blame History

use codec::entities::Table;
use glam::Vec3;
use crate::command::EntityTransform;
use crate::entities::common::{ro_prop as ro, square_grip};
use crate::entities::text_support::{
layout_mtext, MTextRenderOpts, MTextVAnchor, ResolvedTextStyle,
};
use crate::entities::traits::{Grippable, PropertyEditable, Transformable, RenderConvertible};
use crate::scene::convert::acad_to_render::{RenderEntity, RenderObject};
use crate::scene::model::object::{GripApply, GripDef, PropSection, Property, PropValue};
use crate::scene::view::transform;
use crate::scene::model::wire_model::SnapHint;
use crate::t;
thread_local! {
static PROPERTY_CELL: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
static PROPERTY_CELL_ACTIVE: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
pub fn set_prop_current_cell(index: usize) {
PROPERTY_CELL.with(|cell| cell.set(index));
}
pub fn set_prop_current_cell_active(active: bool) {
PROPERTY_CELL_ACTIVE.with(|cell| cell.set(active));
}
fn prop_current_cell() -> usize {
PROPERTY_CELL.with(std::cell::Cell::get)
}
fn prop_current_cell_active() -> bool {
PROPERTY_CELL_ACTIVE.with(std::cell::Cell::get)
}
fn v3(v: &codec::types::Vector3) -> Vec3 {
Vec3::new(v.x as f32, v.y as f32, v.z as f32)
}
fn table_axes(table: &Table) -> (Vec3, Vec3) {
let h = v3(&table.horizontal_direction).normalize_or(Vec3::X);
let normal = v3(&table.normal).normalize_or(Vec3::Z);
let down = h.cross(normal).normalize_or(Vec3::NEG_Y);
(h, down)
}
fn merged_owner_and_span(
table: &Table,
row: usize,
column: usize,
) -> Option<(usize, usize, usize, usize)> {
for range in &table.merged_ranges {
if range.contains(row, column) {
return (row == range.top_row && column == range.left_col).then_some((
range.top_row,
range.left_col,
range.bottom_row.min(table.rows.len().saturating_sub(1)),
range.right_col.min(table.columns.len().saturating_sub(1)),
));
}
}
for (owner_row, table_row) in table.rows.iter().enumerate() {
for (owner_column, cell) in table_row.cells.iter().enumerate() {
let row_end = owner_row
.saturating_add(cell.merge_height.max(1) as usize - 1)
.min(table.rows.len().saturating_sub(1));
let column_end = owner_column
.saturating_add(cell.merge_width.max(1) as usize - 1)
.min(table.columns.len().saturating_sub(1));
if row >= owner_row
&& row <= row_end
&& column >= owner_column
&& column <= column_end
{
return (row == owner_row && column == owner_column).then_some((
owner_row,
owner_column,
row_end,
column_end,
));
}
}
}
Some((row, column, row, column))
}
pub(crate) fn style_for_property<'a>(
table: &'a Table,
row: &'a codec::entities::table::TableRow,
column: usize,
cell: &'a codec::entities::table::TableCell,
property: codec::entities::table::CellStylePropertyFlags,
) -> Option<&'a codec::entities::table::CellStyle> {
let column_style = table
.columns
.get(column)
.and_then(|column| column.style.as_ref());
for style in [
cell.style.as_ref(),
row.style.as_ref(),
column_style,
table.base_style.as_ref(),
]
.into_iter()
.flatten()
{
if style.property_flags.contains(property) {
return Some(style);
}
}
None
}
fn style_for_border<'a>(
table: &'a Table,
row: &'a codec::entities::table::TableRow,
column: usize,
cell: &'a codec::entities::table::TableCell,
edge: codec::entities::table::CellEdgeFlags,
) -> Option<&'a codec::entities::table::CellStyle> {
let column_style = table
.columns
.get(column)
.and_then(|column| column.style.as_ref());
[
cell.style.as_ref(),
row.style.as_ref(),
column_style,
table.base_style.as_ref(),
]
.into_iter()
.flatten()
.find(|style| style.applied_border_edges.contains(edge))
}
pub(crate) fn resolved_title_suppressed(
table: &Table,
table_style: Option<&codec::objects::TableStyle>,
) -> bool {
table
.legacy_style_override
.as_ref()
.and_then(|style| style.title_suppressed)
.or_else(|| table_style.map(|style| style.title_suppressed))
.unwrap_or(false)
}
pub(crate) fn resolved_header_suppressed(
table: &Table,
table_style: Option<&codec::objects::TableStyle>,
) -> bool {
table
.legacy_style_override
.as_ref()
.and_then(|style| style.header_suppressed)
.or_else(|| table_style.map(|style| style.header_suppressed))
.unwrap_or(false)
}
pub(crate) fn resolved_flow_up(
table: &Table,
table_style: Option<&codec::objects::TableStyle>,
) -> bool {
use codec::entities::table::CellStylePropertyFlags;
table
.legacy_style_override
.as_ref()
.and_then(|style| style.flow_direction)
.map(|flow| flow != 0)
.or_else(|| {
table.base_style.as_ref().and_then(|style| {
style
.property_flags
.contains(CellStylePropertyFlags::FLOW_DIRECTION_BOTTOM_TO_TOP)
.then_some(true)
})
})
.unwrap_or_else(|| {
matches!(
table_style.map(|style| style.flow_direction),
Some(codec::objects::TableFlowDirection::Up)
)
})
}
pub(crate) fn resolved_table_margins(
table: &Table,
table_style: Option<&codec::objects::TableStyle>,
) -> (f64, f64) {
let horizontal = table
.legacy_style_override
.as_ref()
.and_then(|style| style.horizontal_cell_margin)
.or_else(|| table_style.map(|style| style.horizontal_margin))
.unwrap_or(0.0);
let vertical = table
.legacy_style_override
.as_ref()
.and_then(|style| style.vertical_cell_margin)
.or_else(|| table_style.map(|style| style.vertical_margin))
.unwrap_or(0.0);
(horizontal, vertical)
}
fn table_offsets(table: &Table, scale: f32) -> (Vec<f32>, Vec<f32>) {
let mut columns = Vec::with_capacity(table.columns.len() + 1);
columns.push(0.0);
for column in &table.columns {
columns.push(columns.last().copied().unwrap_or(0.0) + column.width as f32 * scale);
}
let mut rows = Vec::with_capacity(table.rows.len() + 1);
rows.push(0.0);
for row in &table.rows {
rows.push(rows.last().copied().unwrap_or(0.0) + row.height as f32 * scale);
}
(columns, rows)
}
#[derive(Clone, Copy)]
struct TableBreakSegment {
start_row: usize,
end_row: usize,
origin: Vec3,
}
fn table_break_segments(
table: &Table,
h: Vec3,
down: Vec3,
row_offsets: &[f32],
scale: f32,
) -> Vec<TableBreakSegment> {
use codec::entities::table::BreakOptionFlags;
let insertion = v3(&table.insertion_point);
if table.rows.is_empty() {
return Vec::new();
}
if !table.break_options.contains(BreakOptionFlags::ENABLE_BREAKS) {
return vec![TableBreakSegment {
start_row: 0,
end_row: table.rows.len() - 1,
origin: insertion,
}];
}
let offset_to_world = |offset: &codec::types::Vector3| insertion + v3(offset);
let mut cached: Vec<_> = table
.break_ranges
.iter()
.filter_map(|range| {
let start = range.start_row.max(0) as usize;
let end = range.end_row.max(0) as usize;
(start <= end && end < table.rows.len()).then(|| TableBreakSegment {
start_row: start,
end_row: end,
origin: {
let position = offset_to_world(&range.position);
if position.is_finite() {
position
} else {
insertion
}
},
})
})
.collect();
cached.sort_by_key(|segment| segment.start_row);
let cached_complete = cached.first().is_some_and(|segment| segment.start_row == 0)
&& cached
.last()
.is_some_and(|segment| segment.end_row + 1 == table.rows.len())
&& cached
.windows(2)
.all(|pair| pair[0].end_row + 1 == pair[1].start_row);
if cached_complete {
return cached;
}
let mut segments = Vec::new();
let mut start_row = 0usize;
let mut segment = 0usize;
while start_row < table.rows.len() {
let manual_heights = table
.break_options
.contains(BreakOptionFlags::ALLOW_MANUAL_HEIGHTS);
let max_height = table
.break_data
.get(if manual_heights { segment } else { 0 })
.map(|data| data.height as f32 * scale)
.filter(|height| *height > 1e-6)
.unwrap_or(f32::INFINITY);
let start_offset = row_offsets.get(start_row).copied().unwrap_or(0.0);
let mut end_row = start_row;
while end_row + 1 < table.rows.len()
&& row_offsets[end_row + 2] - start_offset <= max_height
{
end_row += 1;
}
let manual_positions = table
.break_options
.contains(BreakOptionFlags::ALLOW_MANUAL_POSITIONS);
let manual_origin = manual_positions
.then(|| table.break_data.get(segment))
.flatten()
.map(|data| offset_to_world(&data.position))
.filter(|position| position.is_finite());
let origin = manual_origin.unwrap_or_else(|| {
let spacing = table.break_spacing as f32 * scale;
let horizontal_step = table.total_width() as f32 * scale + spacing;
let vertical_step = if max_height.is_finite() {
max_height + spacing
} else {
table.total_height() as f32 * scale + spacing
};
match table.break_flow_direction {
codec::entities::table::BreakFlowDirection::Left => {
insertion - h * segment as f32 * horizontal_step
}
codec::entities::table::BreakFlowDirection::Vertical => {
insertion + down * segment as f32 * vertical_step
}
codec::entities::table::BreakFlowDirection::Right => {
insertion + h * segment as f32 * horizontal_step
}
}
});
segments.push(TableBreakSegment {
start_row,
end_row,
origin,
});
start_row = end_row.saturating_add(1);
segment = segment.saturating_add(1);
}
segments
}
fn break_frame_for_row(
table: &Table,
row: usize,
h: Vec3,
down: Vec3,
row_offsets: &[f32],
scale: f32,
) -> (Vec3, f32) {
let insertion = v3(&table.insertion_point);
if let Some(segment) = table_break_segments(table, h, down, row_offsets, scale)
.into_iter()
.find(|segment| row >= segment.start_row && row <= segment.end_row)
{
return (
segment.origin,
row_offsets.get(row).copied().unwrap_or(0.0)
- row_offsets
.get(segment.start_row)
.copied()
.unwrap_or(0.0),
);
}
(insertion, row_offsets.get(row).copied().unwrap_or(0.0))
}
fn break_frames_for_row(
table: &Table,
row: usize,
h: Vec3,
down: Vec3,
row_offsets: &[f32],
scale: f32,
top_label_rows: usize,
bottom_label_rows: usize,
) -> Vec<(Vec3, f32)> {
use codec::entities::table::BreakOptionFlags;
let segments = table_break_segments(table, h, down, row_offsets, scale);
let Some((segment_index, segment)) = segments
.iter()
.enumerate()
.find(|(_, segment)| row >= segment.start_row && row <= segment.end_row)
else {
return vec![break_frame_for_row(table, row, h, down, row_offsets, scale)];
};
let repeat_top = table
.break_options
.contains(BreakOptionFlags::REPEAT_TOP_LABELS)
&& top_label_rows > 0;
let repeat_bottom = table
.break_options
.contains(BreakOptionFlags::REPEAT_BOTTOM_LABELS)
&& bottom_label_rows > 0;
let top_label_rows = top_label_rows.min(table.rows.len());
let bottom_label_rows = bottom_label_rows.min(table.rows.len());
let bottom_start = table.rows.len().saturating_sub(bottom_label_rows);
let top_height = row_offsets
.get(top_label_rows)
.copied()
.unwrap_or(0.0);
let mut primary_top = row_offsets.get(row).copied().unwrap_or(0.0)
- row_offsets
.get(segment.start_row)
.copied()
.unwrap_or(0.0);
if repeat_top && segment_index > 0 {
primary_top += top_height;
}
let mut frames = vec![(segment.origin, primary_top)];
if repeat_top && row < top_label_rows {
for repeated_segment in segments.iter().skip(1) {
frames.push((
repeated_segment.origin,
row_offsets.get(row).copied().unwrap_or(0.0),
));
}
}
if repeat_bottom && row >= bottom_start {
let label_offset = row_offsets.get(row).copied().unwrap_or(0.0)
- row_offsets.get(bottom_start).copied().unwrap_or(0.0);
for (index, repeated_segment) in segments
.iter()
.enumerate()
.take(segments.len().saturating_sub(1))
{
let content_height = row_offsets
.get(repeated_segment.end_row + 1)
.copied()
.unwrap_or(0.0)
- row_offsets
.get(repeated_segment.start_row)
.copied()
.unwrap_or(0.0);
let repeated_top = content_height
+ if repeat_top && index > 0 {
top_height
} else {
0.0
}
+ label_offset;
frames.push((repeated_segment.origin, repeated_top));
}
}
frames
}
fn format_cell_value(value: &codec::entities::table::CellValue) -> String {
let display = value.display();
if !display.is_empty() {
return display.to_string();
}
use codec::entities::table::CellValueType;
match value.value_type {
CellValueType::Long => format!("{}", value.numeric_value as i64),
CellValueType::Double | CellValueType::Date => format!("{}", value.numeric_value),
CellValueType::Point2D => {
format!("{}, {}", value.point_value.x, value.point_value.y)
}
CellValueType::Point3D => format!(
"{}, {}, {}",
value.point_value.x, value.point_value.y, value.point_value.z
),
CellValueType::Handle => value
.handle_value
.map(|handle| format!("{:X}", handle.value()))
.unwrap_or_default(),
_ => String::new(),
}
}
fn table_cell_reference(reference: &str) -> Option<(usize, usize)> {
let reference = reference.trim();
let split = reference
.char_indices()
.find(|(_, ch)| ch.is_ascii_digit())?
.0;
let (letters, digits) = reference.split_at(split);
if letters.is_empty() || digits.is_empty() {
return None;
}
let mut column = 0usize;
for ch in letters.chars() {
if !ch.is_ascii_alphabetic() {
return None;
}
column = column
.checked_mul(26)?
.checked_add(ch.to_ascii_uppercase() as usize - 'A' as usize + 1)?;
}
let row = digits.parse::<usize>().ok()?.checked_sub(1)?;
Some((row, column.checked_sub(1)?))
}
fn evaluate_table_formula(table: &Table, expression: &str) -> Option<String> {
let body = expression.trim().strip_prefix('=')?.trim();
if let Some((row, column)) = table_cell_reference(body) {
return table.cell(row, column).map(|cell| cell.text_value().to_string());
}
let open = body.find('(')?;
let close = body.rfind(')')?;
let function = body[..open].trim().to_ascii_uppercase();
let range = &body[open + 1..close];
let (first, last) = range.split_once(':').unwrap_or((range, range));
let (r1, c1) = table_cell_reference(first)?;
let (r2, c2) = table_cell_reference(last)?;
let mut values = Vec::new();
for row in r1.min(r2)..=r1.max(r2) {
for column in c1.min(c2)..=c1.max(c2) {
if let Some(value) = table
.cell(row, column)
.and_then(|cell| cell.text_value().trim().parse::<f64>().ok())
{
values.push(value);
}
}
}
match function.as_str() {
"SUM" => Some(values.iter().sum::<f64>().to_string()),
"AVERAGE" | "AVG" if !values.is_empty() => {
Some((values.iter().sum::<f64>() / values.len() as f64).to_string())
}
"COUNT" => Some(values.len().to_string()),
"MIN" if !values.is_empty() => {
Some(values.into_iter().fold(f64::INFINITY, f64::min).to_string())
}
"MAX" if !values.is_empty() => Some(
values
.into_iter()
.fold(f64::NEG_INFINITY, f64::max)
.to_string(),
),
_ => None,
}
}
fn fallback_content_centers(
bounds: [f32; 4],
sizes: &[(f32, f32)],
layout: codec::entities::table::ContentLayoutFlags,
alignment: i32,
horizontal_spacing: f32,
vertical_spacing: f32,
) -> Vec<(f32, f32)> {
if sizes.is_empty() {
return Vec::new();
}
let [left, top, right, bottom] = bounds;
let inner_width = (right - left).max(0.0);
let horiz = ((alignment - 1).rem_euclid(3)) + 1;
let vert = ((alignment - 1) / 3) + 1;
let mut rows: Vec<Vec<usize>> = Vec::new();
if layout.contains(
codec::entities::table::ContentLayoutFlags::STACKED_VERTICAL,
) {
for index in 0..sizes.len() {
rows.push(vec![index]);
}
} else if layout.contains(
codec::entities::table::ContentLayoutFlags::STACKED_HORIZONTAL,
) {
rows.push((0..sizes.len()).collect());
} else {
let mut row = Vec::new();
let mut width = 0.0f32;
for (index, (item_width, _)) in sizes.iter().copied().enumerate() {
let next = if row.is_empty() {
item_width
} else {
width + horizontal_spacing + item_width
};
if !row.is_empty() && next > inner_width {
rows.push(std::mem::take(&mut row));
width = item_width;
} else {
width = next;
}
row.push(index);
}
if !row.is_empty() {
rows.push(row);
}
}
let row_heights: Vec<f32> = rows
.iter()
.map(|row| {
row.iter()
.map(|&index| sizes[index].1)
.fold(0.0f32, f32::max)
})
.collect();
let total_height = row_heights.iter().sum::<f32>()
+ vertical_spacing * rows.len().saturating_sub(1) as f32;
let mut y = match vert {
1 => top,
3 => bottom - total_height,
_ => (top + bottom - total_height) * 0.5,
};
let mut result = vec![(0.0f32, 0.0f32); sizes.len()];
for (row_index, row) in rows.iter().enumerate() {
let row_width = row.iter().map(|&index| sizes[index].0).sum::<f32>()
+ horizontal_spacing * row.len().saturating_sub(1) as f32;
let mut x = match horiz {
1 => left,
3 => right - row_width,
_ => (left + right - row_width) * 0.5,
};
for &index in row {
let (width, height) = sizes[index];
result[index] =
(x + width * 0.5, y + (row_heights[row_index] - height) * 0.5 + height * 0.5);
x += width + horizontal_spacing;
}
y += row_heights[row_index] + vertical_spacing;
}
result
}
fn content_display_value(
document: &codec::CadDocument,
table: &Table,
content: &codec::entities::table::CellContent,
) -> String {
if let Some(handle) = content.field_handle {
if let Some(value) =
crate::entities::field::resolve_handle(document, handle, table.common.handle)
{
return value;
}
if let Some(codec::objects::ObjectType::Field(field)) = document.objects.get(&handle) {
if !field.value_string.is_empty() {
return field.value_string.clone();
}
let value = format_cell_value(&field.value);
if !value.is_empty() {
return value;
}
}
}
let value = format_cell_value(&content.value);
evaluate_table_formula(table, &value).unwrap_or(value)
}
fn resolved_content_geometry(
document: &codec::CadDocument,
table: &Table,
row: usize,
column: usize,
cell: &codec::entities::table::TableCell,
content_index: usize,
) -> Option<codec::entities::table::CellContentGeometry> {
if let Some(geometry) = cell
.contents
.get(content_index)
.and_then(|content| content.geometry.clone())
.or_else(|| cell.geometries.get(content_index).cloned())
.or_else(|| (content_index == 0).then(|| cell.geometry.clone()).flatten())
{
return Some(geometry);
}
let handle = cell.geometry_handle?;
let flat_index = row
.saturating_mul(table.columns.len())
.saturating_add(column);
if let Some(codec::objects::ObjectType::DataObject(object)) =
document.objects.get(&handle)
{
if let codec::objects::DataObjectData::TableGeometry(geometry) =
&object.data
{
return geometry
.cells
.get(flat_index)
.and_then(|cell| cell.geometry.get(content_index))
.cloned();
}
}
document.objects.values().find_map(|object| {
let codec::objects::ObjectType::DataObject(object) = object else {
return None;
};
let codec::objects::DataObjectData::TableGeometry(geometry) =
&object.data
else {
return None;
};
geometry
.cells
.iter()
.find(|geometry_cell| geometry_cell.table_geometry == handle)
.and_then(|geometry_cell| geometry_cell.geometry.get(content_index))
.cloned()
})
}
pub(crate) fn block_cell_inserts(
table: &Table,
document: &codec::CadDocument,
anno_scale: f32,
) -> Vec<codec::entities::Insert> {
use codec::entities::table::ContentLayoutFlags;
use codec::entities::{AttributeEntity, EntityType, Insert};
use codec::types::Vector3;
if table.rows.is_empty() || table.columns.is_empty() {
return Vec::new();
}
let (h, down) = table_axes(table);
let table_style = table.table_style_handle.and_then(|handle| {
document.objects.get(&handle).and_then(|object| match object {
codec::objects::ObjectType::TableStyle(style) => Some(style),
_ => None,
})
});
let flow = if resolved_flow_up(table, table_style) {
-down
} else {
down
};
let (column_offsets, row_offsets) = table_offsets(table, anno_scale);
let table_rotation = table
.horizontal_direction
.y
.atan2(table.horizontal_direction.x);
let mut inserts = Vec::new();
for (row_index, row) in table.rows.iter().enumerate() {
for (column_index, cell) in row.cells.iter().enumerate() {
let Some((_, _, row_end, column_end)) =
merged_owner_and_span(table, row_index, column_index)
else {
continue;
};
let block_contents: Vec<_> = cell
.contents
.iter()
.enumerate()
.filter(|(_, content)| content.block_handle.is_some())
.collect();
if block_contents.is_empty() {
continue;
}
let (origin, row_top) = break_frame_for_row(
table,
row_index,
h,
flow,
&row_offsets,
anno_scale,
);
let row_bottom = row_top
+ row_offsets
.get(row_end + 1)
.copied()
.unwrap_or(row_offsets[row_index])
- row_offsets[row_index];
let column_left = column_offsets[column_index];
let column_right = column_offsets
.get(column_end + 1)
.copied()
.unwrap_or(column_left);
let layout_style = style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::CONTENT_LAYOUT,
);
let layout = layout_style
.map(|style| style.layout_flags)
.unwrap_or(ContentLayoutFlags::FLOW);
let count = block_contents.len() as f32;
for (slot_index, (content_index, content)) in
block_contents.into_iter().enumerate()
{
let Some(block_handle) = content.block_handle else {
continue;
};
let Some(record) = document
.block_records
.iter()
.find(|record| record.handle == block_handle)
else {
continue;
};
let mut x = (column_left + column_right) * 0.5;
let mut y = (row_top + row_bottom) * 0.5;
let mut z = 0.0f32;
if let Some(geometry) = resolved_content_geometry(
document,
table,
row_index,
column_index,
cell,
content_index,
) {
x = column_left
+ geometry.distance_to_center.x as f32 * anno_scale;
y = row_top
- geometry.distance_to_center.y as f32 * anno_scale;
z = geometry.distance_to_center.z as f32 * anno_scale;
} else if count > 1.0 {
let index = slot_index as f32;
if layout.contains(ContentLayoutFlags::STACKED_VERTICAL) {
y = row_top + (index + 0.5) * (row_bottom - row_top) / count;
} else {
x = column_left + (index + 0.5) * (column_right - column_left) / count;
}
}
let position =
origin + h * x + flow * y + v3(&table.normal).normalize_or(Vec3::Z) * z;
let scale_style = style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::BLOCK_SCALE,
);
let style_scale = scale_style
.map(|style| style.scale)
.filter(|scale| scale.abs() > 1e-9)
.unwrap_or(1.0);
let content_scale = if content.format_property_flags
& codec::entities::table::CellStylePropertyFlags::BLOCK_SCALE.bits() as i32
!= 0
&& content.scale.abs() > 1e-9
{
content.scale
} else if cell.block_scale.abs() > 1e-9 {
cell.block_scale
} else {
1.0
};
let mut scale = if content.format_property_flags
& codec::entities::table::CellStylePropertyFlags::BLOCK_SCALE.bits() as i32
!= 0
{
content_scale
} else {
style_scale.max(content_scale)
} * anno_scale as f64;
let auto_scale = cell.auto_fit
|| style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::AUTO_SCALE,
)
.is_some_and(|style| {
style
.property_flags
.contains(codec::entities::table::CellStylePropertyFlags::AUTO_SCALE)
});
let mut block_min =
Vector3::new(f64::MAX, f64::MAX, f64::MAX);
let mut block_max =
Vector3::new(f64::MIN, f64::MIN, f64::MIN);
let mut has_block_bounds = false;
for &handle in &record.entity_handles {
let Some(entity) = document.get_entity(handle) else {
continue;
};
let bounds = entity.as_entity().bounding_box();
if bounds.min.x.is_finite()
&& bounds.min.y.is_finite()
&& bounds.max.x.is_finite()
&& bounds.max.y.is_finite()
{
block_min.x = block_min.x.min(bounds.min.x);
block_min.y = block_min.y.min(bounds.min.y);
block_min.z = block_min.z.min(bounds.min.z);
block_max.x = block_max.x.max(bounds.max.x);
block_max.y = block_max.y.max(bounds.max.y);
block_max.z = block_max.z.max(bounds.max.z);
has_block_bounds = true;
}
}
if auto_scale && has_block_bounds {
let min = block_min;
let max = block_max;
let width = (max.x - min.x).abs();
let height = (max.y - min.y).abs();
let margin_left = style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_LEFT,
)
.map(|style| style.margin_left)
.unwrap_or(0.0);
let margin_right = style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_RIGHT,
)
.map(|style| style.margin_right)
.unwrap_or(0.0);
let margin_top = style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_TOP,
)
.map(|style| style.margin_top)
.unwrap_or(0.0);
let margin_bottom = style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_BOTTOM,
)
.map(|style| style.margin_bottom)
.unwrap_or(0.0);
let fit_x = ((column_right - column_left) as f64
- (margin_left + margin_right) * anno_scale as f64)
.max(0.0)
/ width.max(1e-9);
let fit_y = ((row_bottom - row_top) as f64
- (margin_top + margin_bottom) * anno_scale as f64)
.max(0.0)
/ height.max(1e-9);
scale *= fit_x.min(fit_y);
}
let rotation_style = style_for_property(
table,
row,
column_index,
cell,
codec::entities::table::CellStylePropertyFlags::ROTATION,
);
let content_rotation_explicit = content.format_property_flags
& codec::entities::table::CellStylePropertyFlags::ROTATION.bits() as i32
!= 0;
let content_rotation = if content_rotation_explicit {
content.rotation
} else {
rotation_style
.map(|style| style.rotation)
.unwrap_or(cell.rotation)
};
let rotation = table_rotation + content_rotation;
let mut insert = Insert::new(
record.name.clone(),
Vector3::new(position.x as f64, position.y as f64, position.z as f64),
);
insert.common = table.common.clone();
insert.normal = table.normal;
insert.rotation = rotation;
insert.set_x_scale(scale);
insert.set_y_scale(scale);
insert.set_z_scale(scale);
let local_anchor = if has_block_bounds {
(block_min + block_max) * 0.5
} else {
crate::scene::render_graph::block_base_point(document, &record.name)
};
let transformed_anchor = crate::scene::render_graph::insert_transform(
document,
&insert,
)
.apply(local_anchor);
insert.insert_point = insert.insert_point
+ Vector3::new(
position.x as f64 - transformed_anchor.x,
position.y as f64 - transformed_anchor.y,
position.z as f64 - transformed_anchor.z,
);
let attribute_definitions: Vec<_> = record
.entity_handles
.iter()
.filter_map(|handle| match document.get_entity(*handle) {
Some(EntityType::AttributeDefinition(definition)) => {
Some(definition)
}
_ => None,
})
.collect();
for attribute in &content.attributes {
let definition = match document
.get_entity(attribute.definition_handle)
{
Some(EntityType::AttributeDefinition(definition)) => {
Some(definition)
}
_ => attribute_definitions
.get(attribute.index.max(0) as usize)
.copied(),
};
let Some(definition) = definition else {
continue;
};
let mut entity =
AttributeEntity::from_definition(definition, Some(attribute.value.clone()));
codec::Entity::apply_transform(
&mut entity,
&crate::scene::render_graph::insert_transform(document, &insert),
);
entity.common.handle = table.common.handle;
insert.attributes.push(entity);
}
inserts.push(insert);
}
}
}
inserts
}
impl RenderConvertible for Table {
fn to_render(&self, document: &codec::CadDocument) -> Option<RenderEntity> {
if self.rows.is_empty() || self.columns.is_empty() {
return None;
}
// Lay the table out in a local frame with the origin at zero. The world
// insertion point is added back as f64 at the widening step below, so
// large coordinates (UTM etc.) keep full precision instead of snapping
// onto the coarse f32 grid — which would collide cell-text baselines and
// overflow the integer border-dedup keys.
let base = [
self.insertion_point.x,
self.insertion_point.y,
self.insertion_point.z,
];
let origin = Vec3::ZERO;
let (h, v_down) = table_axes(self);
let col_offsets: Vec<f32> = {
let mut off = 0.0f32;
let mut v = vec![0.0f32];
for col in &self.columns {
off += col.width as f32;
v.push(off);
}
v
};
let total_w = *col_offsets.last().unwrap_or(&0.0);
let row_offsets: Vec<f32> = {
let mut off = 0.0f32;
let mut v = vec![0.0f32];
for row in &self.rows {
off += row.height as f32;
v.push(off);
}
v
};
let total_h = *row_offsets.last().unwrap_or(&0.0);
let mut pts: Vec<[f32; 3]> = Vec::new();
let mut tris_pts: Vec<[f32; 3]> = Vec::new();
// Per-cell borders. When a cell carries a CellStyle, honour the
// visibility / `invisible` flag of each of its four borders so
// hidden borders disappear from the grid. Cells with no style still
// emit the standard four borders. To avoid drawing each shared edge
// twice we coalesce the segments by their (start, end) coordinates.
use rustc_hash::FxHashSet as HashSet;
let mut emitted: HashSet<(i32, i32, i32, i32)> = HashSet::default();
let try_add = |a: Vec3,
b: Vec3,
vis: bool,
emitted: &mut HashSet<(i32, i32, i32, i32)>,
pts: &mut Vec<[f32; 3]>| {
if !vis {
return;
}
let key = (
(a.x * 1_000.0) as i32,
(a.y * 1_000.0) as i32,
(b.x * 1_000.0) as i32,
(b.y * 1_000.0) as i32,
);
let key_rev = (key.2, key.3, key.0, key.1);
if emitted.contains(&key) || emitted.contains(&key_rev) {
return;
}
emitted.insert(key);
if !pts.is_empty() {
pts.push([f32::NAN; 3]);
}
pts.push([a.x, a.y, a.z]);
pts.push([b.x, b.y, b.z]);
};
for (ri, row) in self.rows.iter().enumerate() {
let row_top = row_offsets[ri];
let row_bot = row_offsets
.get(ri + 1)
.copied()
.unwrap_or(row_top + row.height as f32);
for (ci, cell) in row.cells.iter().enumerate() {
let col_left = col_offsets[ci];
let col_right = col_offsets.get(ci + 1).copied().unwrap_or(
col_left + self.columns.get(ci).map(|c| c.width as f32).unwrap_or(1.0),
);
// Default to visible when no style override is present.
let (top_vis, right_vis, bottom_vis, left_vis) = cell
.style
.as_ref()
.map(|s| {
(
!s.top_border.invisible,
!s.right_border.invisible,
!s.bottom_border.invisible,
!s.left_border.invisible,
)
})
.unwrap_or((true, true, true, true));
let tl = origin + h * col_left + v_down * row_top;
let tr = origin + h * col_right + v_down * row_top;
let br_ = origin + h * col_right + v_down * row_bot;
let bl = origin + h * col_left + v_down * row_bot;
try_add(tl, tr, top_vis, &mut emitted, &mut pts);
try_add(tr, br_, right_vis, &mut emitted, &mut pts);
try_add(bl, br_, bottom_vis, &mut emitted, &mut pts);
try_add(tl, bl, left_vis, &mut emitted, &mut pts);
}
}
// Suppress unused-variable warnings now that the simple grid-pass
// is gone — col/row offsets still feed cell drawing below.
let _ = (total_w, total_h);
// Cell text — resolve defaults via TableStyle, then layer per-cell
// overrides on top. Resolution order (text height, text style, alignment):
// 1. CellContent.* (per-content explicit override)
// 2. CellStyle.* (per-cell explicit override)
// 3. TableStyle.<row_kind>_row_style.* (table-wide default for this row class)
// 4. compiled-in fallback (0.18 / "txt" / MiddleCenter)
//
// Row classification: row 0 is Title (when not suppressed), row 1 is
// Header (when not suppressed), everything else is Data. The two
// suppressed flags shift the leading rows down to Data.
let lookup_style = |h: codec::Handle| -> Option<&codec::tables::TextStyle> {
document.text_styles.iter().find(|s| s.handle == h)
};
let table_style: Option<&codec::objects::TableStyle> =
self.table_style_handle.and_then(|h| {
document.objects.get(&h).and_then(|obj| match obj {
codec::objects::ObjectType::TableStyle(ts) => Some(ts),
_ => None,
})
});
let title_suppressed = resolved_title_suppressed(self, table_style);
let header_suppressed = resolved_header_suppressed(self, table_style);
let font_for_handle = |handle: Option<codec::Handle>| -> Option<String> {
handle.and_then(|h| lookup_style(h)).and_then(|s| {
let mut font_name = if !s.true_type_font.trim().is_empty() {
s.true_type_font.trim().to_string()
} else {
let file = s.font_file.trim();
if !file.is_empty() {
let basename = file.rsplit(['/', '\\']).next().unwrap_or(file);
let stem = basename.split('.').next().unwrap_or(basename).trim();
if !stem.is_empty() {
stem.to_string()
} else {
return None;
}
} else {
return None;
}
};
if !crate::scene::text::lff::is_builtin(&font_name) {
if let Some(canonical) = crate::scene::text::sysfont::canonical_family_name(&font_name) {
font_name = canonical;
}
}
Some(font_name)
})
};
// Build a ResolvedTextStyle for the cell — needed by the shared MText
// pipeline so inline `\W`, `\Q`, etc. compose with the style baseline.
let resolved_style_for_handle =
|handle: Option<codec::Handle>, font_name: String| -> ResolvedTextStyle {
let style = handle.and_then(|h| lookup_style(h));
ResolvedTextStyle {
font_name,
width_factor: style.map(|s| s.width_factor as f32).unwrap_or(1.0),
oblique_angle: style.map(|s| s.oblique_angle as f32).unwrap_or(0.0),
is_backward: style.map(|s| s.is_backward()).unwrap_or(false),
is_upside_down: style.map(|s| s.is_upside_down()).unwrap_or(false),
is_vertical: style.map(|s| s.is_vertical).unwrap_or(false),
}
};
for (ri, row) in self.rows.iter().enumerate() {
let row_top = row_offsets[ri];
let row_bot = row_offsets
.get(ri + 1)
.copied()
.unwrap_or(row_top + row.height as f32);
let row_mid = (row_top + row_bot) * 0.5;
// Pick the appropriate row_style from TableStyle for this row's role.
let row_style: Option<&codec::objects::RowCellStyle> = table_style.map(|ts| {
let kind = match (title_suppressed, header_suppressed, ri) {
(false, _, 0) => 0, // title
(false, false, 1) => 1, // header
(true, false, 0) => 1, // header pulled up
_ => 2, // data
};
match kind {
0 => &ts.title_row_style,
1 => &ts.header_row_style,
_ => &ts.data_row_style,
}
});
for (ci, cell) in row.cells.iter().enumerate() {
let text = cell.text_value();
if text.is_empty() {
continue;
}
let col_left = col_offsets[ci];
let col_width = self.columns.get(ci).map(|c| c.width as f32).unwrap_or(1.0);
let col_right = col_left + col_width;
// Resolve text height: content → cell-style → row-style → 0.18.
let content = cell.contents.first();
let cell_h = content
.map(|c| c.text_height)
.filter(|h| *h > 1e-6)
.or_else(|| {
cell.style
.as_ref()
.map(|s| s.text_height)
.filter(|h| *h > 1e-6)
})
.or_else(|| row_style.map(|s| s.text_height).filter(|h| *h > 1e-6))
.map(|h| h as f32)
.unwrap_or(0.18);
let margin = cell_h * 0.5_f32;
// Resolve text-style handle: content → cell-style → row-style.
let style_handle = content
.and_then(|c| c.text_style_handle)
.or_else(|| cell.style.as_ref().and_then(|s| s.text_style_handle))
.or_else(|| row_style.and_then(|s| s.text_style_handle));
let font_owned = font_for_handle(style_handle).unwrap_or_else(|| "txt".to_string());
let resolved = resolved_style_for_handle(style_handle, font_owned);
// Alignment resolution: cell.style.alignment (1-9) overrides;
// otherwise fall back to row_style.alignment, then MiddleCenter.
let align = cell
.style
.as_ref()
.map(|s| s.alignment)
.filter(|a| *a != 0)
.or_else(|| row_style.map(|s| s.alignment as i32))
.unwrap_or(5);
let horiz = ((align - 1).rem_euclid(3)) + 1; // 1=left, 2=center, 3=right
let vert = ((align - 1) / 3) + 1; // 1=top, 2=middle, 3=bottom
// Position the cell's MText block anchor at the requested
// alignment corner / midpoint of the cell's content area.
let (x_offset, attach_h_anchor) = match horiz {
1 => (col_left + margin, 0.0_f32),
3 => (col_right - margin, 1.0_f32),
_ => (col_left + col_width * 0.5, 0.5_f32),
};
let (y_offset, v_anchor) = match vert {
1 => (row_top + margin, MTextVAnchor::Top),
3 => (row_bot - margin, MTextVAnchor::Bottom),
_ => (row_mid, MTextVAnchor::Middle),
};
let text_origin = origin + h * x_offset + v_down * y_offset;
// Content rotation (radians) on top of table cell rotation.
let rot = content.map(|c| c.rotation as f32).unwrap_or(0.0) + cell.rotation as f32;
let layout = layout_mtext(&MTextRenderOpts {
// Not an MTEXT: text in a fixed box, never columnar.
columns: Default::default(),
value: text,
insertion: [text_origin.x as f64, text_origin.y as f64, origin.z as f64],
height: cell_h,
rect_w: 0.0,
rotation: rot,
style: &resolved,
attach_h_anchor,
v_anchor,
line_spacing_factor: 1.0,
exact_line_spacing: false,
rectangle_height: 0.0,
vertical_text: false,
want_glyph_boxes: false,
});
// Flatten TextStroke groups into the table's Lines buffer.
// Per-run inline `\C` / `\c` colour is dropped here because the
// table emits a single RenderObject::Lines for borders + text;
// tracking it would require splitting the table into multiple
// WireModels per cell colour. Borders + uniform-coloured runs
// honour the entity's outer colour.
for ts in &layout.strokes {
let ox = ts.origin[0] as f32;
let oy = ts.origin[1] as f32;
for stroke in &ts.strokes {
if stroke.len() < 2 {
continue;
}
if !pts.is_empty() {
pts.push([f32::NAN; 3]);
}
for &[x, y] in stroke {
pts.push([x + ox, y + oy, origin.z]);
}
}
for &[x, y] in &ts.fill_tris {
tris_pts.push([x + ox, y + oy, origin.z]);
}
}
}
}
// The layout above is in a local f32 frame (small magnitudes). Widen to
// f64 and add the world insertion so the absolute position carries full
// precision; tessellate.rs then applies world_offset.
let pts_f64: Vec<[f64; 3]> = pts
.into_iter()
.map(|[x, y, z]| {
if x.is_nan() {
[f64::NAN, f64::NAN, f64::NAN]
} else {
[x as f64 + base[0], y as f64 + base[1], z as f64 + base[2]]
}
})
.collect();
let fill_tris_f64: Vec<[f64; 3]> = tris_pts
.into_iter()
.map(|[x, y, z]| {
[x as f64 + base[0], y as f64 + base[1], z as f64 + base[2]]
})
.collect();
Some(RenderEntity {
pick_tris: Vec::new(),
object: RenderObject::Lines(pts_f64),
snap_pts: vec![(glam::DVec3::new(self.insertion_point.x, self.insertion_point.y, self.insertion_point.z), SnapHint::Insertion)],
tangent_geoms: vec![],
key_vertices: vec![],
fill_tris: fill_tris_f64,
})
}
}
/// Builds colored geometry for tables without a stored display block.
pub fn tessellate_table(
tab: &Table,
document: &codec::CadDocument,
selected: bool,
entity_color: [f32; 4],
line_weight_px: f32,
// Annotation scale: multiplies the table's paper-size geometry so an
// annotative table renders at the current annotation scale. 1.0 for a
// non-annotative table (its geometry is already at model size).
anno_scale: f32,
) -> Vec<crate::scene::model::wire_model::WireModel> {
use crate::scene::convert::tess_util::aci_to_rgba;
use crate::scene::model::wire_model::WireModel;
use codec::types::Color;
use rustc_hash::FxHashMap as HashMap;
if tab.rows.is_empty() || tab.columns.is_empty() {
return Vec::new();
}
let rel = |p: Vec3| -> [f32; 3] {
[
(p.x as f64) as f32,
(p.y as f64) as f32,
(p.z as f64) as f32,
]
};
let resolve_col = |c: &Color, fallback: [f32; 4]| -> [f32; 4] {
match c {
Color::ByLayer | Color::ByBlock => fallback,
_ => aci_to_rgba(c),
}
};
let key4 = |c: [f32; 4]| -> [u8; 4] {
[
(c[0] * 255.0) as u8,
(c[1] * 255.0) as u8,
(c[2] * 255.0) as u8,
(c[3] * 255.0) as u8,
]
};
let lw_px = |w: &codec::types::LineWeight| -> f32 {
match w {
codec::types::LineWeight::Value(v) if *v >= 0 => (*v as f32 / 100.0) * (96.0 / 25.4),
_ => line_weight_px,
}
};
let (h, v_down) = table_axes(tab);
// Flow direction: `Up` stacks rows upward instead of downward.
let table_style: Option<&codec::objects::TableStyle> =
tab.table_style_handle.and_then(|h| {
document.objects.get(&h).and_then(|obj| match obj {
codec::objects::ObjectType::TableStyle(ts) => Some(ts),
_ => None,
})
});
let flow_up = resolved_flow_up(tab, table_style);
let v_flow = if flow_up { -v_down } else { v_down };
let (col_offsets, row_offsets) = table_offsets(tab, anno_scale);
let title_suppressed = resolved_title_suppressed(tab, table_style);
let header_suppressed = resolved_header_suppressed(tab, table_style);
let top_label_rows = (usize::from(!title_suppressed) + usize::from(!header_suppressed))
.min(tab.rows.len());
let bottom_label_rows = usize::from(!tab.rows.is_empty());
let (horizontal_margin, vertical_margin) = resolved_table_margins(tab, table_style);
let h_margin = horizontal_margin as f32 * anno_scale;
let v_margin = vertical_margin as f32 * anno_scale;
let lookup_style = |hh: codec::Handle| -> Option<&codec::tables::TextStyle> {
document.text_styles.iter().find(|s| s.handle == hh)
};
let font_for_handle = |handle: Option<codec::Handle>| -> Option<String> {
handle.and_then(lookup_style).and_then(|s| {
let mut font_name = if !s.true_type_font.trim().is_empty() {
s.true_type_font.trim().to_string()
} else {
let file = s.font_file.trim();
let basename = file.rsplit(['/', '\\']).next().unwrap_or(file);
let stem = basename.split('.').next().unwrap_or(basename).trim();
if !stem.is_empty() {
stem.to_string()
} else {
return None;
}
};
if !crate::scene::text::lff::is_builtin(&font_name) {
if let Some(canonical) = crate::scene::text::sysfont::canonical_family_name(&font_name) {
font_name = canonical;
}
}
Some(font_name)
})
};
let resolved_style_for_handle =
|handle: Option<codec::Handle>, font_name: String| -> ResolvedTextStyle {
let style = handle.and_then(lookup_style);
ResolvedTextStyle {
font_name,
width_factor: style.map(|s| s.width_factor as f32).unwrap_or(1.0),
oblique_angle: style.map(|s| s.oblique_angle as f32).unwrap_or(0.0),
is_backward: style.map(|s| s.is_backward()).unwrap_or(false),
is_upside_down: style.map(|s| s.is_upside_down()).unwrap_or(false),
is_vertical: style.map(|s| s.is_vertical).unwrap_or(false),
}
};
// Accumulators keyed by quantised colour (+ weight for borders).
let mut fills: HashMap<[u8; 4], ([f32; 4], Vec<[f32; 3]>)> = HashMap::default();
// SDF cell text: glyph quads (per-vertex coloured) collected across all
// cells; emitted as one text-carrying wire at the end.
let mut text_verts: Vec<crate::scene::pipeline::text_gpu::TextVertex> = Vec::new();
let mut borders: HashMap<([u8; 4], u32), ([f32; 4], f32, Vec<[f32; 3]>)> = HashMap::default();
let mut emitted: rustc_hash::FxHashSet<(i32, i32, i32, i32, i32, i32)> =
rustc_hash::FxHashSet::default();
let sel_col = WireModel::SELECTED;
let mut add_edge = |a: Vec3,
b: Vec3,
col: [f32; 4],
lw: f32,
borders: &mut HashMap<([u8; 4], u32), ([f32; 4], f32, Vec<[f32; 3]>)>| {
let k = (
(a.x * 1000.0) as i32,
(a.y * 1000.0) as i32,
(a.z * 1000.0) as i32,
(b.x * 1000.0) as i32,
(b.y * 1000.0) as i32,
(b.z * 1000.0) as i32,
);
let kr = (k.3, k.4, k.5, k.0, k.1, k.2);
if emitted.contains(&k) || emitted.contains(&kr) {
return;
}
emitted.insert(k);
let entry = borders
.entry((key4(col), (lw * 100.0) as u32))
.or_insert_with(|| (col, lw, Vec::new()));
if !entry.2.is_empty() {
entry.2.push([f32::NAN; 3]);
}
entry.2.push(rel(a));
entry.2.push(rel(b));
};
let normal = v3(&tab.normal).normalize_or(Vec3::Z);
for (ri, row) in tab.rows.iter().enumerate() {
let row_style: Option<&codec::objects::RowCellStyle> = table_style.map(|ts| {
let kind = match (title_suppressed, header_suppressed, ri) {
(false, _, 0) => 0,
(false, false, 1) => 1,
(true, false, 0) => 1,
_ => 2,
};
match kind {
0 => &ts.title_row_style,
1 => &ts.header_row_style,
_ => &ts.data_row_style,
}
});
for (ci, cell) in row.cells.iter().enumerate() {
let Some((_, _, row_end, column_end)) =
merged_owner_and_span(tab, ri, ci)
else {
continue;
};
let frames = break_frames_for_row(
tab,
ri,
h,
v_flow,
&row_offsets,
anno_scale,
top_label_rows,
bottom_label_rows,
);
for (origin, row_top) in frames {
let merged_height = row_offsets
.get(row_end + 1)
.copied()
.unwrap_or(row_offsets[ri])
- row_offsets[ri];
let row_bot = row_top + merged_height;
let row_mid = (row_top + row_bot) * 0.5;
let col_left = col_offsets[ci];
let col_right = col_offsets
.get(column_end + 1)
.copied()
.unwrap_or(col_left);
let col_width = col_right - col_left;
let tl = origin + h * col_left + v_flow * row_top;
let tr = origin + h * col_right + v_flow * row_top;
let br_ = origin + h * col_right + v_flow * row_bot;
let bl = origin + h * col_left + v_flow * row_bot;
// ── Fill ──────────────────────────────────────────────────────
let fill_style = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::BACKGROUND_COLOR,
);
let (fill_on, fill_color) = if let Some(cs) = fill_style {
(cs.fill_enabled, cs.background_color)
} else if let Some(rs) = row_style {
(rs.fill_enabled, rs.fill_color)
} else {
(false, Color::ByLayer)
};
if fill_on {
let col = resolve_col(&fill_color, entity_color);
let buf = &mut fills
.entry(key4(col))
.or_insert_with(|| (col, Vec::new()))
.1;
for v in [bl, br_, tr, bl, tr, tl] {
buf.push(rel(v));
}
}
// ── Borders (per edge: cell override → row style → default) ───
// (top, right, bottom, left)
let edge = |which: u8| -> (bool, [f32; 4], f32) {
let edge_flag = match which {
0 => codec::entities::table::CellEdgeFlags::TOP,
1 => codec::entities::table::CellEdgeFlags::RIGHT,
2 => codec::entities::table::CellEdgeFlags::BOTTOM,
_ => codec::entities::table::CellEdgeFlags::LEFT,
};
if let Some(cs) = style_for_border(tab, row, ci, cell, edge_flag) {
let b = match which {
0 => &cs.top_border,
1 => &cs.right_border,
2 => &cs.bottom_border,
_ => &cs.left_border,
};
(
!b.invisible,
if selected {
sel_col
} else {
resolve_col(&b.color, entity_color)
},
lw_px(&b.line_weight),
)
} else if let Some(rs) = row_style {
let b = match which {
0 => &rs.top_border,
1 => &rs.right_border,
2 => &rs.bottom_border,
_ => &rs.left_border,
};
(
!b.is_invisible,
if selected {
sel_col
} else {
resolve_col(&b.color, entity_color)
},
lw_px(&b.line_weight),
)
} else {
(
true,
if selected { sel_col } else { entity_color },
line_weight_px,
)
}
};
let (tv, tc, tw) = edge(0);
if tv {
add_edge(tl, tr, tc, tw, &mut borders);
}
let (rv, rc, rw) = edge(1);
if rv {
add_edge(tr, br_, rc, rw, &mut borders);
}
let (bv, bc, bw) = edge(2);
if bv {
add_edge(bl, br_, bc, bw, &mut borders);
}
let (lv, lc, lw) = edge(3);
if lv {
add_edge(tl, bl, lc, lw, &mut borders);
}
let value_contents: Vec<_> = cell
.contents
.iter()
.enumerate()
.filter_map(|(index, content)| {
let text = content_display_value(document, tab, content);
(!text.is_empty()).then_some((index, content, text))
})
.collect();
let fallback_text_height = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::TEXT_HEIGHT,
)
.map(|style| style.text_height as f32)
.or_else(|| row_style.map(|style| style.text_height as f32))
.filter(|height| *height > 1e-6)
.unwrap_or(0.18)
* anno_scale;
let fallback_margin_left = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_LEFT,
)
.map(|style| style.margin_left as f32 * anno_scale)
.unwrap_or(h_margin.max(fallback_text_height * 0.5));
let fallback_margin_right = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_RIGHT,
)
.map(|style| style.margin_right as f32 * anno_scale)
.unwrap_or(h_margin.max(fallback_text_height * 0.5));
let fallback_margin_top = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_TOP,
)
.map(|style| style.margin_top as f32 * anno_scale)
.unwrap_or(v_margin.max(fallback_text_height * 0.5));
let fallback_margin_bottom = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_BOTTOM,
)
.map(|style| style.margin_bottom as f32 * anno_scale)
.unwrap_or(v_margin.max(fallback_text_height * 0.5));
let fallback_layout = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::CONTENT_LAYOUT,
)
.map(|style| style.layout_flags)
.unwrap_or(codec::entities::table::ContentLayoutFlags::FLOW);
let fallback_alignment = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::ALIGNMENT,
)
.map(|style| style.alignment)
.or_else(|| row_style.map(|style| style.alignment as i32))
.unwrap_or(5);
let fallback_h_spacing = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_HORIZONTAL_SPACING,
)
.map(|style| style.horizontal_spacing as f32 * anno_scale)
.unwrap_or(0.0);
let fallback_v_spacing = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_VERTICAL_SPACING,
)
.map(|style| style.vertical_spacing as f32 * anno_scale)
.unwrap_or(0.0);
let fallback_sizes: Vec<_> = value_contents
.iter()
.map(|(_, content, text)| {
let height = if content.text_height > 1e-6 {
content.text_height as f32 * anno_scale
} else {
fallback_text_height
};
let mut max_chars = 0usize;
let mut line_count = 0usize;
for line in text.split("\\P") {
max_chars = max_chars.max(line.chars().count());
line_count += 1;
}
(
(max_chars as f32 * height * 0.6).max(height * 0.5),
line_count.max(1) as f32 * height * 1.2,
)
})
.collect();
let fallback_centers = fallback_content_centers(
[
col_left + fallback_margin_left,
row_top + fallback_margin_top,
col_right - fallback_margin_right,
row_bot - fallback_margin_bottom,
],
&fallback_sizes,
fallback_layout,
fallback_alignment,
fallback_h_spacing,
fallback_v_spacing,
);
for (slot_index, (content_index, content, text)) in
value_contents.iter().enumerate()
{
let text_height_style = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::TEXT_HEIGHT,
);
let cell_h = (content.text_height > 1e-6)
.then_some(content.text_height)
.or_else(|| {
text_height_style
.map(|style| style.text_height)
.filter(|height| *height > 1e-6)
})
.or_else(|| {
row_style
.map(|style| style.text_height)
.filter(|height| *height > 1e-6)
})
.map(|height| height as f32)
.unwrap_or(0.18)
* anno_scale;
let margin_left = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_LEFT,
)
.map(|style| style.margin_left as f32 * anno_scale)
.filter(|margin| *margin > 1e-6)
.unwrap_or_else(|| h_margin.max(cell_h * 0.5));
let margin_right = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_RIGHT,
)
.map(|style| style.margin_right as f32 * anno_scale)
.filter(|margin| *margin > 1e-6)
.unwrap_or_else(|| h_margin.max(cell_h * 0.5));
let margin_top = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_TOP,
)
.map(|style| style.margin_top as f32 * anno_scale)
.filter(|margin| *margin > 1e-6)
.unwrap_or_else(|| v_margin.max(cell_h * 0.5));
let margin_bottom = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::MARGIN_BOTTOM,
)
.map(|style| style.margin_bottom as f32 * anno_scale)
.filter(|margin| *margin > 1e-6)
.unwrap_or_else(|| v_margin.max(cell_h * 0.5));
let style_handle = content.text_style_handle.or_else(|| {
style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::TEXT_STYLE,
)
.and_then(|style| style.text_style_handle)
})
.or_else(|| row_style.and_then(|style| style.text_style_handle));
let font_owned =
font_for_handle(style_handle).unwrap_or_else(|| "txt".to_string());
let resolved = resolved_style_for_handle(style_handle, font_owned);
let align = (content.alignment != 0)
.then_some(content.alignment)
.or_else(|| {
style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::ALIGNMENT,
)
.map(|style| style.alignment)
.filter(|alignment| *alignment != 0)
})
.or_else(|| row_style.map(|style| style.alignment as i32))
.unwrap_or(5);
let horiz = ((align - 1).rem_euclid(3)) + 1;
let vert = ((align - 1) / 3) + 1;
let (mut x_offset, mut attach_h_anchor) = match horiz {
1 => (col_left + margin_left, 0.0_f32),
3 => (col_right - margin_right, 1.0_f32),
_ => (col_left + col_width * 0.5, 0.5_f32),
};
let (mut y_offset, mut v_anchor) = match vert {
1 => (row_top + margin_top, MTextVAnchor::Top),
3 => (row_bot - margin_bottom, MTextVAnchor::Bottom),
_ => (row_mid, MTextVAnchor::Middle),
};
let mut z_offset = 0.0;
if let Some(geometry) = resolved_content_geometry(
document,
tab,
ri,
ci,
cell,
*content_index,
) {
x_offset =
col_left + geometry.distance_to_center.x as f32 * anno_scale;
y_offset =
row_top - geometry.distance_to_center.y as f32 * anno_scale;
z_offset = geometry.distance_to_center.z as f32 * anno_scale;
attach_h_anchor = 0.5;
v_anchor = MTextVAnchor::Middle;
} else if value_contents.len() > 1 {
if let Some((x, y)) = fallback_centers.get(slot_index) {
x_offset = *x;
y_offset = *y;
attach_h_anchor = 0.5;
v_anchor = MTextVAnchor::Middle;
}
}
let to = origin
+ h * x_offset
+ v_flow * y_offset
+ normal * z_offset;
let content_rotation_explicit = content.format_property_flags
& codec::entities::table::CellStylePropertyFlags::ROTATION.bits() as i32
!= 0;
let rot = if content_rotation_explicit {
content.rotation as f32
} else {
style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::ROTATION,
)
.map(|style| style.rotation as f32)
.unwrap_or(cell.rotation as f32)
};
let layout = layout_mtext(&MTextRenderOpts {
columns: Default::default(),
value: text,
insertion: [to.x as f64, to.y as f64, to.z as f64],
height: cell_h,
rect_w: (col_width - margin_left - margin_right).max(0.0),
rotation: rot,
style: &resolved,
attach_h_anchor,
v_anchor,
line_spacing_factor: 1.0,
exact_line_spacing: false,
rectangle_height: 0.0,
vertical_text: false,
want_glyph_boxes: false,
});
let tcol = if selected {
sel_col
} else if !matches!(
content.color,
Color::ByLayer | Color::ByBlock
) {
resolve_col(&content.color, entity_color)
} else if let Some(style) = style_for_property(
tab,
row,
ci,
cell,
codec::entities::table::CellStylePropertyFlags::CONTENT_COLOR,
) {
resolve_col(&style.content_color, entity_color)
} else if let Some(style) = row_style {
resolve_col(&style.text_color, entity_color)
} else {
entity_color
};
if let Ok(mut atlas) = crate::scene::text::sdf_atlas::text_atlas().lock() {
for stroke in &layout.strokes {
let Some(run) = &stroke.run else {
continue;
};
if crate::scene::text::web_font::requires_shaping(&run.text) {
if !stroke.fill_tris.is_empty() {
let entry = fills
.entry(key4(tcol))
.or_insert_with(|| (tcol, Vec::new()));
for &[x, y] in &stroke.fill_tris {
entry.1.push([
stroke.origin[0] as f32 + x,
stroke.origin[1] as f32 + y,
to.z as f32,
]);
}
}
if !stroke.strokes.is_empty() {
let entry = borders
.entry((key4(tcol), (line_weight_px * 100.0) as u32))
.or_insert_with(|| (tcol, line_weight_px, Vec::new()));
for s in &stroke.strokes {
if s.len() < 2 {
continue;
}
if !entry.2.is_empty() {
entry.2.push([f32::NAN; 3]);
}
for &[x, y] in s {
entry.2.push([
stroke.origin[0] as f32 + x,
stroke.origin[1] as f32 + y,
to.z as f32,
]);
}
}
}
continue;
}
let quads = crate::scene::text::glyph_quads::layout_glyph_quads(
&mut atlas,
run.height,
run.rotation,
run.width_factor,
run.oblique,
run.tracking,
&run.font,
run.bold,
&run.text,
);
crate::scene::pipeline::text_gpu::push_glyph_vertices(
&mut text_verts,
&quads,
[stroke.origin[0], stroke.origin[1], to.z as f64],
1.0,
tcol,
0.0,
);
}
}
}
}
}
}
let name = tab.common.handle.value().to_string();
let mk =
|color: [f32; 4], points: Vec<[f32; 3]>, fill_tris: Vec<[f32; 3]>, lw: f32| -> WireModel {
WireModel {
bg_adapt: None,
point_marker: None,
taper_widths: Vec::new(),
pattern_stations: Vec::new(),
world_width: 0.0,
depth_override: None,
display_visible: true,
snap_only: false,
plot_visible: true,
fill_is_3d: false,
fill_is_2d_solid: false,
render_instance: None,
pick_tris: Vec::new(),
pick_tris_low: Vec::new(),
dash_from_start: false,
dash_align_end: None,
text_verts: Vec::new(),
name: name.clone(),
points,
points_low: Vec::new(),
color,
selected,
pattern_length: 0.0,
pattern: [0.0; 8],
line_weight_px: lw,
aci: 0,
snap_pts: vec![],
tangent_geoms: vec![],
key_vertices: vec![],
aabb: WireModel::UNBOUNDED_AABB,
plinegen: true,
fill_tris,
// fill_tris_low intentionally empty: this fill renders on the
// top-level path, where consumers (face3d_gpu, xclip) treat a
// short low half as all-zero, so it draws at f32 precision
// (sub-metre error at UTM scale) — not a crash. Follow-up:
// double-single-split via points_to_ds to match emit_wire.
fill_tris_low: Vec::new(),
}
};
let mut out: Vec<WireModel> = Vec::new();
// Fills first (drawn under borders/text).
for (_, (color, tris)) in fills {
if !tris.is_empty() {
out.push(mk(color, vec![], tris, 1.0));
}
}
for (_, (color, lw, pts)) in borders {
if !pts.is_empty() {
out.push(mk(color, pts, vec![], lw));
}
}
// SDF cell text: one wire carrying the glyph quads (per-vertex coloured) +
// a glyph-bounds AABB (f64 accumulate → f32) so the text draws + picks;
// empty points so it adds no stroke geometry.
if !text_verts.is_empty() {
let (mut nx, mut ny, mut xx, mut xy) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
for v in &text_verts {
let x = v.pos[0] as f64 + v.pos_low[0] as f64;
let y = v.pos[1] as f64 + v.pos_low[1] as f64;
nx = nx.min(x);
xx = xx.max(x);
ny = ny.min(y);
xy = xy.max(y);
}
let mut w = mk(entity_color, vec![], vec![], line_weight_px);
w.aabb = [nx as f32, ny as f32, xx as f32, xy as f32];
w.text_verts = text_verts;
out.push(w);
}
out
}
impl Grippable for Table {
fn grips(&self) -> Vec<GripDef> {
let origin = glam::DVec3::new(
self.insertion_point.x,
self.insertion_point.y,
self.insertion_point.z,
);
let horizontal = glam::DVec3::new(
self.horizontal_direction.x,
self.horizontal_direction.y,
self.horizontal_direction.z,
)
.normalize_or(glam::DVec3::X);
let normal = glam::DVec3::new(self.normal.x, self.normal.y, self.normal.z)
.normalize_or(glam::DVec3::Z);
let down = horizontal.cross(normal).normalize_or(glam::DVec3::NEG_Y);
let width = self.total_width();
let height = self.total_height();
let mut grips = vec![square_grip(
0,
origin,
)];
grips.push(square_grip(1, origin + horizontal * width));
grips.push(square_grip(2, origin + down * height));
let mut offset = 0.0;
for (column, definition) in self.columns.iter().enumerate() {
offset += definition.width;
if column + 1 < self.columns.len() {
grips.push(square_grip(
100 + column,
origin + horizontal * offset + down * (height * 0.5),
));
}
}
offset = 0.0;
for (row, definition) in self.rows.iter().enumerate() {
offset += definition.height;
if row + 1 < self.rows.len() {
grips.push(square_grip(
1000 + row,
origin + horizontal * (width * 0.5) + down * offset,
));
}
}
for (index, data) in self.break_data.iter().enumerate() {
grips.push(square_grip(
2000 + index,
origin + glam::DVec3::new(data.position.x, data.position.y, data.position.z),
));
}
grips
}
fn apply_grip(&mut self, grip_id: usize, apply: GripApply) {
if let GripApply::Translate(delta) = apply {
if let Some(grip) = self.grips().into_iter().find(|grip| grip.id == grip_id) {
self.apply_grip(grip_id, GripApply::Absolute(grip.world + delta));
}
return;
}
let GripApply::Absolute(point) = apply else {
return;
};
if grip_id == 0 {
self.insertion_point.x = point.x;
self.insertion_point.y = point.y;
self.insertion_point.z = point.z;
return;
}
let origin = glam::DVec3::new(
self.insertion_point.x,
self.insertion_point.y,
self.insertion_point.z,
);
let horizontal = glam::DVec3::new(
self.horizontal_direction.x,
self.horizontal_direction.y,
self.horizontal_direction.z,
)
.normalize_or(glam::DVec3::X);
let normal = glam::DVec3::new(self.normal.x, self.normal.y, self.normal.z)
.normalize_or(glam::DVec3::Z);
let down = horizontal.cross(normal).normalize_or(glam::DVec3::NEG_Y);
if grip_id == 1 {
let width = (point - origin).dot(horizontal).max(1.0e-6);
let current = self.total_width();
if current > 1.0e-12 {
for column in &mut self.columns {
column.width *= width / current;
}
}
} else if grip_id == 2 {
let height = (point - origin).dot(down).max(1.0e-6);
let current = self.total_height();
if current > 1.0e-12 {
for row in &mut self.rows {
row.height *= height / current;
}
}
} else if (100..1000).contains(&grip_id) {
let column = grip_id - 100;
let before: f64 = self.columns.iter().take(column).map(|item| item.width).sum();
if let Some(definition) = self.columns.get_mut(column) {
definition.width = ((point - origin).dot(horizontal) - before).max(1.0e-6);
}
} else if (1000..2000).contains(&grip_id) {
let row = grip_id - 1000;
let before: f64 = self.rows.iter().take(row).map(|item| item.height).sum();
if let Some(definition) = self.rows.get_mut(row) {
definition.height = ((point - origin).dot(down) - before).max(1.0e-6);
}
} else if grip_id >= 2000 {
if let Some(data) = self.break_data.get_mut(grip_id - 2000) {
let offset = point - origin;
data.position = codec::types::Vector3::new(offset.x, offset.y, offset.z);
}
}
}
}
impl PropertyEditable for Table {
fn geometry_properties(&self, text_style_names: &[String]) -> Vec<PropSection> {
use crate::entities::common::edit_prop as edit;
use codec::entities::table::{BreakOptionFlags, CellStateFlags, CellStylePropertyFlags};
let bool_text = |value: bool| if value { t!("Yes") } else { t!("No") }.into_owned();
let toggle = |label: &str, field: &'static str, value: bool, enabled: bool| -> Property {
Property {
label: label.into(),
field,
value: if enabled {
PropValue::BoolToggle { field, value }
} else {
PropValue::ReadOnly(bool_text(value))
},
}
};
let choice = |label: &str,
field: &'static str,
selected: String,
options: Vec<String>,
enabled: bool|
-> Property {
Property {
label: label.into(),
field,
value: if enabled {
PropValue::Choice { selected, options }
} else {
PropValue::ReadOnly(selected)
},
}
};
let number = |label: &str, field: &'static str, value: f64, enabled: bool| -> Property {
if enabled {
edit(label, field, value)
} else {
ro(label, field, crate::entities::common::format_length(value))
}
};
let text = |label: &str, field: &'static str, value: String, enabled: bool| -> Property {
Property {
label: label.into(),
field,
value: if enabled {
PropValue::PlainText(value)
} else {
PropValue::ReadOnly(value)
},
}
};
let color_text = |color: codec::types::Color| match color {
codec::types::Color::None => "None".to_string(),
codec::types::Color::ByLayer => "ByLayer".to_string(),
codec::types::Color::ByBlock => "ByBlock".to_string(),
codec::types::Color::Index(index) => index.to_string(),
codec::types::Color::Rgb { r, g, b } => format!("{r},{g},{b}"),
};
let color = |label: &str,
field: &'static str,
value: codec::types::Color,
enabled: bool|
-> Property {
Property {
label: label.into(),
field,
value: if enabled {
PropValue::ColorChoice(value)
} else {
PropValue::ReadOnly(color_text(value))
},
}
};
// Direction = angle of the horizontal direction vector in the XY plane.
let direction_deg =
(self.horizontal_direction.y.atan2(self.horizontal_direction.x)).to_degrees();
let break_height = self.break_data.first().map(|data| data.height).unwrap_or(0.0);
let breaks_enabled = self.break_options.contains(BreakOptionFlags::ENABLE_BREAKS);
let manual_positions = self
.break_options
.contains(BreakOptionFlags::ALLOW_MANUAL_POSITIONS);
let manual_heights = self
.break_options
.contains(BreakOptionFlags::ALLOW_MANUAL_HEIGHTS);
let cell_count = self.rows.len().saturating_mul(self.columns.len());
let cell_index = prop_current_cell().min(cell_count.saturating_sub(1));
let cell_row = if self.columns.is_empty() {
0
} else {
cell_index / self.columns.len()
};
let cell_column = if self.columns.is_empty() {
0
} else {
cell_index % self.columns.len()
};
let table_row = self.rows.get(cell_row);
let cell = self.cell(cell_row, cell_column);
let row_style = table_row.and_then(|row| row.style.as_ref());
let column_style = self
.columns
.get(cell_column)
.and_then(|column| column.style.as_ref());
let style_for = |property| {
table_row.and_then(|row| {
cell.and_then(|cell| {
style_for_property(self, row, cell_column, cell, property)
})
})
};
let alignment_style = style_for(CellStylePropertyFlags::ALIGNMENT);
let alignment = match alignment_style.map(|style| style.alignment).unwrap_or(5) {
1 => "Top Left",
2 => "Top Center",
3 => "Top Right",
4 => "Middle Left",
6 => "Middle Right",
7 => "Bottom Left",
8 => "Bottom Center",
9 => "Bottom Right",
_ => "Middle Center",
};
let state = cell.map(|cell| cell.state).unwrap_or_default();
let content_editable = !state.intersects(
CellStateFlags::CONTENT_LOCKED | CellStateFlags::CONTENT_READ_ONLY,
);
let format_editable = !state.intersects(
CellStateFlags::FORMAT_LOCKED | CellStateFlags::FORMAT_READ_ONLY,
);
let immutable_lock = state.intersects(
CellStateFlags::CONTENT_READ_ONLY | CellStateFlags::FORMAT_READ_ONLY,
);
let cell_locked = state.intersects(
CellStateFlags::CONTENT_LOCKED
| CellStateFlags::CONTENT_READ_ONLY
| CellStateFlags::FORMAT_LOCKED
| CellStateFlags::FORMAT_READ_ONLY,
);
let table_flow_up = self
.legacy_style_override
.as_ref()
.and_then(|style| style.flow_direction)
.map(|flow| flow != 0)
.unwrap_or_else(|| {
self.base_style.as_ref().is_some_and(|style| {
style
.property_flags
.contains(CellStylePropertyFlags::FLOW_DIRECTION_BOTTOM_TO_TOP)
})
});
let legacy = self.legacy_style_override.as_ref();
let title_suppressed = legacy
.and_then(|style| style.title_suppressed)
.unwrap_or(false);
let header_suppressed = legacy
.and_then(|style| style.header_suppressed)
.unwrap_or(false);
let horizontal_margin = legacy
.and_then(|style| style.horizontal_cell_margin)
.or_else(|| self.base_style.as_ref().map(|style| style.margin_left))
.unwrap_or(0.06);
let vertical_margin = legacy
.and_then(|style| style.vertical_cell_margin)
.or_else(|| self.base_style.as_ref().map(|style| style.margin_top))
.unwrap_or(0.06);
let uniform_column_width = self.columns.first().map(|column| column.width).unwrap_or(0.0);
let columns_uniform = self
.columns
.iter()
.all(|column| (column.width - uniform_column_width).abs() <= 1.0e-9);
let uniform_row_height = self.rows.first().map(|row| row.height).unwrap_or(0.0);
let rows_uniform = self
.rows
.iter()
.all(|row| (row.height - uniform_row_height).abs() <= 1.0e-9);
let uniform_number = |label: &str,
field: &'static str,
value: f64,
uniform: bool|
-> Property {
if uniform {
edit(label, field, value)
} else {
Property {
label: label.into(),
field,
value: PropValue::PlainText(t!("Varies").into_owned()),
}
}
};
let override_count = self
.rows
.iter()
.filter(|row| row.style.is_some())
.count()
+ self
.columns
.iter()
.filter(|column| column.style.is_some())
.count()
+ self
.rows
.iter()
.flat_map(|row| row.cells.iter())
.filter(|cell| cell.style.is_some())
.count()
+ usize::from(self.base_style.is_some() || self.legacy_style_override.is_some());
let mut sections = vec![
PropSection {
title: t!("Table").into_owned(),
props: vec![
ro(t!("Table style").as_ref(), "tbl_style_handle", "Standard"),
toggle(
t!("Title suppressed").as_ref(),
"tbl_title_suppressed",
title_suppressed,
true,
),
toggle(
t!("Header suppressed").as_ref(),
"tbl_header_suppressed",
header_suppressed,
true,
),
choice(
t!("Flow direction").as_ref(),
"tbl_flow_direction",
if table_flow_up { "Up" } else { "Down" }.to_string(),
vec!["Down".into(), "Up".into()],
true,
),
edit(t!("Direction").as_ref(), "tbl_direction", direction_deg),
edit(t!("Rows").as_ref(), "tbl_rows", self.rows.len() as f64),
edit(t!("Columns").as_ref(), "tbl_cols", self.columns.len() as f64),
uniform_number(
t!("Column width").as_ref(),
"tbl_column_width",
uniform_column_width,
columns_uniform,
),
uniform_number(
t!("Row height").as_ref(),
"tbl_row_height",
uniform_row_height,
rows_uniform,
),
edit(t!("Table width").as_ref(), "tbl_width", self.total_width()),
edit(t!("Table height").as_ref(), "tbl_height", self.total_height()),
edit(
t!("Horizontal cell margin").as_ref(),
"tbl_horizontal_margin",
horizontal_margin,
),
edit(
t!("Vertical cell margin").as_ref(),
"tbl_vertical_margin",
vertical_margin,
),
ro(
t!("Table overrides").as_ref(),
"tbl_overrides",
if override_count == 0 {
t!("None").into_owned()
} else {
override_count.to_string()
},
),
],
},
PropSection {
title: t!("Geometry").into_owned(),
props: vec![
edit(t!("Insertion X").as_ref(), "tbl_insert_x", self.insertion_point.x),
edit(t!("Insertion Y").as_ref(), "tbl_insert_y", self.insertion_point.y),
edit(t!("Insertion Z").as_ref(), "tbl_insert_z", self.insertion_point.z),
ro(t!("Normal X").as_ref(), "tbl_normal_x", format!("{:.4}", self.normal.x)),
ro(t!("Normal Y").as_ref(), "tbl_normal_y", format!("{:.4}", self.normal.y)),
ro(t!("Normal Z").as_ref(), "tbl_normal_z", format!("{:.4}", self.normal.z)),
],
},
];
if prop_current_cell_active() {
let cell_type = match cell.map(|cell| cell.cell_type) {
Some(codec::entities::table::CellType::Block) => "Block",
_ => "Text",
};
let data_type = cell
.and_then(|cell| cell.contents.first())
.map(|content| match content.value.value_type {
codec::entities::table::CellValueType::Long => "Integer",
codec::entities::table::CellValueType::Double => "Decimal",
codec::entities::table::CellValueType::Date => "Date",
codec::entities::table::CellValueType::Point2D => "Point 2D",
codec::entities::table::CellValueType::Point3D => "Point 3D",
codec::entities::table::CellValueType::Handle => "Handle",
_ => "Text",
})
.unwrap_or("Text");
let style_source = if cell.and_then(|cell| cell.style.as_ref()).is_some() {
"Cell override"
} else if row_style.is_some() {
"Row override"
} else if column_style.is_some() {
"Column override"
} else {
"Table style"
};
let text_style = style_for(CellStylePropertyFlags::TEXT_STYLE)
.map(|style| style.text_style_name.clone())
.filter(|name| !name.is_empty())
.unwrap_or_else(|| "Standard".to_string());
let mut available_text_styles = text_style_names.to_vec();
if !available_text_styles
.iter()
.any(|name| name.eq_ignore_ascii_case(&text_style))
{
available_text_styles.insert(0, text_style.clone());
}
let rotation = style_for(CellStylePropertyFlags::ROTATION)
.map(|style| style.rotation)
.or_else(|| cell.map(|cell| cell.rotation))
.unwrap_or(0.0)
.to_degrees();
sections.push(PropSection {
title: t!("Cell").into_owned(),
props: vec![
Property {
label: t!("Current cell").into_owned(),
field: "tbl_current_cell",
value: PropValue::Stepper {
field: "tbl_current_cell",
display: format!(
"{},{} ({} / {})",
cell_row,
cell_column,
cell_index.saturating_add(1),
cell_count
),
},
},
ro(t!("Row").as_ref(), "tbl_cell_row", cell_row.to_string()),
ro(
t!("Column").as_ref(),
"tbl_cell_column",
cell_column.to_string(),
),
ro(t!("Cell style").as_ref(), "tbl_cell_style", style_source),
choice(
t!("Cell type").as_ref(),
"tbl_cell_type",
cell_type.to_string(),
vec!["Text".into(), "Block".into()],
content_editable,
),
text(
t!("Contents").as_ref(),
"tbl_cell_text",
cell.map(|cell| cell.text_value().to_string()).unwrap_or_default(),
content_editable,
),
choice(
t!("Alignment").as_ref(),
"tbl_cell_alignment",
alignment.to_string(),
vec![
"Top Left".into(),
"Top Center".into(),
"Top Right".into(),
"Middle Left".into(),
"Middle Center".into(),
"Middle Right".into(),
"Bottom Left".into(),
"Bottom Center".into(),
"Bottom Right".into(),
],
format_editable,
),
choice(
t!("Text style").as_ref(),
"tbl_cell_text_style",
text_style,
available_text_styles,
format_editable,
),
choice(
t!("Text rotation").as_ref(),
"tbl_cell_rotation",
format!("{rotation:.0}"),
vec!["0".into(), "90".into(), "180".into(), "270".into()],
format_editable,
),
number(
t!("Text height").as_ref(),
"tbl_cell_text_height",
style_for(CellStylePropertyFlags::TEXT_HEIGHT)
.map(|style| style.text_height)
.unwrap_or(0.18),
format_editable,
),
color(
t!("Content color").as_ref(),
"tbl_cell_content_color",
style_for(CellStylePropertyFlags::CONTENT_COLOR)
.map(|style| style.content_color)
.unwrap_or(codec::types::Color::ByBlock),
format_editable,
),
color(
t!("Background color").as_ref(),
"tbl_cell_background_color",
style_for(CellStylePropertyFlags::BACKGROUND_COLOR)
.map(|style| style.background_color)
.unwrap_or(codec::types::Color::ByBlock),
format_editable,
),
choice(
t!("Data type").as_ref(),
"tbl_cell_data_type",
data_type.to_string(),
vec![
"Text".into(),
"Integer".into(),
"Decimal".into(),
"Date".into(),
"Point 2D".into(),
"Point 3D".into(),
"Handle".into(),
],
format_editable,
),
text(
t!("Data format").as_ref(),
"tbl_cell_format",
style_for(CellStylePropertyFlags::DATA_FORMAT)
.map(|style| style.value_format.clone())
.unwrap_or_default(),
format_editable,
),
toggle(
t!("Background fill").as_ref(),
"tbl_cell_fill",
style_for(CellStylePropertyFlags::BACKGROUND_COLOR)
.is_some_and(|style| style.fill_enabled),
format_editable,
),
number(
t!("Left margin").as_ref(),
"tbl_cell_margin_left",
style_for(CellStylePropertyFlags::MARGIN_LEFT)
.map(|style| style.margin_left)
.unwrap_or(horizontal_margin),
format_editable,
),
number(
t!("Top margin").as_ref(),
"tbl_cell_margin_top",
style_for(CellStylePropertyFlags::MARGIN_TOP)
.map(|style| style.margin_top)
.unwrap_or(vertical_margin),
format_editable,
),
number(
t!("Right margin").as_ref(),
"tbl_cell_margin_right",
style_for(CellStylePropertyFlags::MARGIN_RIGHT)
.map(|style| style.margin_right)
.unwrap_or(horizontal_margin),
format_editable,
),
number(
t!("Bottom margin").as_ref(),
"tbl_cell_margin_bottom",
style_for(CellStylePropertyFlags::MARGIN_BOTTOM)
.map(|style| style.margin_bottom)
.unwrap_or(vertical_margin),
format_editable,
),
toggle(
t!("Top border").as_ref(),
"tbl_cell_border_top",
table_row
.and_then(|row| {
cell.and_then(|cell| {
style_for_border(
self,
row,
cell_column,
cell,
codec::entities::table::CellEdgeFlags::TOP,
)
})
})
.is_none_or(|style| !style.top_border.invisible),
format_editable,
),
toggle(
t!("Right border").as_ref(),
"tbl_cell_border_right",
table_row
.and_then(|row| {
cell.and_then(|cell| {
style_for_border(
self,
row,
cell_column,
cell,
codec::entities::table::CellEdgeFlags::RIGHT,
)
})
})
.is_none_or(|style| !style.right_border.invisible),
format_editable,
),
toggle(
t!("Bottom border").as_ref(),
"tbl_cell_border_bottom",
table_row
.and_then(|row| {
cell.and_then(|cell| {
style_for_border(
self,
row,
cell_column,
cell,
codec::entities::table::CellEdgeFlags::BOTTOM,
)
})
})
.is_none_or(|style| !style.bottom_border.invisible),
format_editable,
),
toggle(
t!("Left border").as_ref(),
"tbl_cell_border_left",
table_row
.and_then(|row| {
cell.and_then(|cell| {
style_for_border(
self,
row,
cell_column,
cell,
codec::entities::table::CellEdgeFlags::LEFT,
)
})
})
.is_none_or(|style| !style.left_border.invisible),
format_editable,
),
toggle(
t!("Locked").as_ref(),
"tbl_cell_locked",
cell_locked,
!immutable_lock,
),
],
});
}
sections.push(
PropSection {
title: t!("Table Breaks").into_owned(),
props: vec![
toggle(
t!("Enabled").as_ref(),
"tbl_break_enabled",
breaks_enabled,
true,
),
choice(
t!("Direction").as_ref(),
"tbl_break_direction",
match self.break_flow_direction {
codec::entities::table::BreakFlowDirection::Right => "Right",
codec::entities::table::BreakFlowDirection::Left => "Left",
codec::entities::table::BreakFlowDirection::Vertical => "Down",
}
.to_string(),
vec!["Right".into(), "Left".into(), "Down".into()],
breaks_enabled && !manual_positions,
),
toggle(
t!("Repeat top labels").as_ref(),
"tbl_break_repeat_top",
self.break_options
.contains(BreakOptionFlags::REPEAT_TOP_LABELS),
breaks_enabled,
),
toggle(
t!("Repeat bottom labels").as_ref(),
"tbl_break_repeat_bottom",
self.break_options
.contains(BreakOptionFlags::REPEAT_BOTTOM_LABELS),
breaks_enabled,
),
toggle(
t!("Manual positions").as_ref(),
"tbl_break_manual_positions",
manual_positions,
breaks_enabled,
),
toggle(
t!("Manual heights").as_ref(),
"tbl_break_manual_heights",
manual_heights,
breaks_enabled,
),
number(
t!("Maximum height").as_ref(),
"tbl_break_height",
break_height,
breaks_enabled && !manual_heights,
),
number(
t!("Spacing").as_ref(),
"tbl_break_spacing",
self.break_spacing,
breaks_enabled && !manual_positions,
),
],
},
);
sections
}
fn apply_geom_prop(&mut self, field: &str, value: &str) {
use crate::entities::common::parse_f64;
use codec::entities::table::{
BreakOptionFlags, CellStateFlags, CellStyle, CellStylePropertyFlags,
};
let flag = match field {
"tbl_break_enabled" => Some(BreakOptionFlags::ENABLE_BREAKS),
"tbl_break_repeat_top" => Some(BreakOptionFlags::REPEAT_TOP_LABELS),
"tbl_break_repeat_bottom" => Some(BreakOptionFlags::REPEAT_BOTTOM_LABELS),
"tbl_break_manual_positions" => Some(BreakOptionFlags::ALLOW_MANUAL_POSITIONS),
"tbl_break_manual_heights" => Some(BreakOptionFlags::ALLOW_MANUAL_HEIGHTS),
_ => None,
};
if let Some(flag) = flag {
if flag != BreakOptionFlags::ENABLE_BREAKS
&& !self.break_options.contains(BreakOptionFlags::ENABLE_BREAKS)
{
return;
}
let on = if value == "toggle" {
!self.break_options.contains(flag)
} else {
value == "true"
};
self.break_options.set(flag, on);
self.break_ranges.clear();
return;
}
match field {
"tbl_title_suppressed" | "tbl_header_suppressed" => {
let enabled = if value == "toggle" {
let current = if field == "tbl_title_suppressed" {
self.legacy_style_override
.as_ref()
.and_then(|style| style.title_suppressed)
.unwrap_or(false)
} else {
self.legacy_style_override
.as_ref()
.and_then(|style| style.header_suppressed)
.unwrap_or(false)
};
!current
} else {
value == "true"
};
let style = self.legacy_style_override.get_or_insert_with(Default::default);
if field == "tbl_title_suppressed" {
style.flags |= 0x0001;
style.title_suppressed = Some(enabled);
} else {
style.flags |= 0x0002;
style.header_suppressed = Some(enabled);
}
self.override_flag = true;
return;
}
"tbl_flow_direction" => {
let up = value.trim().eq_ignore_ascii_case("up");
let style = self.base_style.get_or_insert_with(Default::default);
style
.property_flags
.set(CellStylePropertyFlags::FLOW_DIRECTION_BOTTOM_TO_TOP, up);
let legacy = self.legacy_style_override.get_or_insert_with(Default::default);
legacy.flags |= 0x0004;
legacy.flow_direction = Some(if up { 1 } else { 0 });
self.override_flag = true;
return;
}
_ => {}
}
let cell_index = prop_current_cell();
let columns = self.columns.len();
let cell_position = (columns > 0).then_some((cell_index / columns, cell_index % columns));
if let Some((row, column)) = cell_position {
let state = self
.cell(row, column)
.map(|cell| cell.state)
.unwrap_or_default();
let content_editable = !state.intersects(
CellStateFlags::CONTENT_LOCKED | CellStateFlags::CONTENT_READ_ONLY,
);
let format_editable = !state.intersects(
CellStateFlags::FORMAT_LOCKED | CellStateFlags::FORMAT_READ_ONLY,
);
match field {
"tbl_cell_text" => {
if !content_editable {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
cell.set_text(value);
}
return;
}
"tbl_cell_type" => {
if !content_editable {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
cell.cell_type = if value.trim().eq_ignore_ascii_case("block") {
codec::entities::table::CellType::Block
} else {
codec::entities::table::CellType::Text
};
}
return;
}
"tbl_cell_alignment" => {
if !format_editable {
return;
}
let alignment = match value.trim().to_ascii_uppercase().as_str() {
"TOP LEFT" => 1,
"TOP CENTER" => 2,
"TOP RIGHT" => 3,
"MIDDLE LEFT" => 4,
"MIDDLE RIGHT" => 6,
"BOTTOM LEFT" => 7,
"BOTTOM CENTER" => 8,
"BOTTOM RIGHT" => 9,
_ => 5,
};
if let Some(cell) = self.cell_mut(row, column) {
let style = cell.style.get_or_insert_with(CellStyle::new);
style.alignment = alignment;
style.property_flags.insert(
codec::entities::table::CellStylePropertyFlags::ALIGNMENT,
);
}
return;
}
"tbl_cell_text_style" => {
if !format_editable {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
let style = cell.style.get_or_insert_with(CellStyle::new);
style.text_style_name = value.trim().to_string();
style
.property_flags
.insert(CellStylePropertyFlags::TEXT_STYLE);
}
return;
}
"tbl_cell_rotation" => {
if !format_editable {
return;
}
if let Some(rotation) = parse_f64(value) {
if let Some(cell) = self.cell_mut(row, column) {
let style = cell.style.get_or_insert_with(CellStyle::new);
style.rotation = rotation.to_radians();
style
.property_flags
.insert(CellStylePropertyFlags::ROTATION);
}
}
return;
}
"tbl_cell_data_type" => {
if !format_editable {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
if cell.contents.is_empty() {
cell.set_text("");
}
if let Some(content) = cell.contents.first_mut() {
content.value.value_type = match value.trim().to_ascii_uppercase().as_str() {
"INTEGER" => codec::entities::table::CellValueType::Long,
"DECIMAL" => codec::entities::table::CellValueType::Double,
"DATE" => codec::entities::table::CellValueType::Date,
"POINT 2D" => codec::entities::table::CellValueType::Point2D,
"POINT 3D" => codec::entities::table::CellValueType::Point3D,
"HANDLE" => codec::entities::table::CellValueType::Handle,
_ => codec::entities::table::CellValueType::String,
};
content.value.raw_type_code = content.value.value_type as i32;
}
let style = cell.style.get_or_insert_with(CellStyle::new);
style
.property_flags
.insert(CellStylePropertyFlags::DATA_TYPE);
}
return;
}
"tbl_cell_format" => {
if !format_editable {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
let style = cell.style.get_or_insert_with(CellStyle::new);
style.value_format = value.to_string();
style.property_flags.insert(
codec::entities::table::CellStylePropertyFlags::DATA_FORMAT,
);
}
return;
}
"tbl_cell_fill" => {
if !format_editable {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
let style = cell.style.get_or_insert_with(CellStyle::new);
style.fill_enabled = if value == "toggle" {
!style.fill_enabled
} else {
value == "true"
};
style.property_flags.insert(
codec::entities::table::CellStylePropertyFlags::BACKGROUND_COLOR,
);
}
return;
}
"tbl_cell_border_top"
| "tbl_cell_border_right"
| "tbl_cell_border_bottom"
| "tbl_cell_border_left" => {
if !format_editable {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
use codec::entities::table::{
BorderPropertyFlags, CellEdgeFlags,
};
let style = cell.style.get_or_insert_with(CellStyle::new);
let (border, edge) = match field {
"tbl_cell_border_top" => (&mut style.top_border, CellEdgeFlags::TOP),
"tbl_cell_border_right" => {
(&mut style.right_border, CellEdgeFlags::RIGHT)
}
"tbl_cell_border_bottom" => {
(&mut style.bottom_border, CellEdgeFlags::BOTTOM)
}
_ => (&mut style.left_border, CellEdgeFlags::LEFT),
};
let visible = if value == "toggle" {
border.invisible
} else {
value == "true"
};
border.invisible = !visible;
border.override_flags.insert(BorderPropertyFlags::INVISIBILITY);
style.applied_border_edges.insert(edge);
}
return;
}
"tbl_cell_locked" => {
if state.intersects(
CellStateFlags::CONTENT_READ_ONLY | CellStateFlags::FORMAT_READ_ONLY,
) {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
let locked = if value == "toggle" {
!cell.state.intersects(
CellStateFlags::CONTENT_LOCKED | CellStateFlags::FORMAT_LOCKED,
)
} else {
value == "true"
};
cell.state.set(CellStateFlags::CONTENT_LOCKED, locked);
cell.state.set(CellStateFlags::FORMAT_LOCKED, locked);
}
return;
}
_ => {}
}
}
let Some(number) = parse_f64(value) else {
if field == "tbl_break_direction" {
if !self.break_options.contains(BreakOptionFlags::ENABLE_BREAKS)
|| self
.break_options
.contains(BreakOptionFlags::ALLOW_MANUAL_POSITIONS)
{
return;
}
self.break_flow_direction = match value.trim().to_ascii_uppercase().as_str() {
"LEFT" => codec::entities::table::BreakFlowDirection::Left,
"DOWN" | "VERTICAL" => {
codec::entities::table::BreakFlowDirection::Vertical
}
_ => codec::entities::table::BreakFlowDirection::Right,
};
self.break_ranges.clear();
}
return;
};
match field {
"tbl_insert_x" => self.insertion_point.x = number,
"tbl_insert_y" => self.insertion_point.y = number,
"tbl_insert_z" => self.insertion_point.z = number,
"tbl_direction" => {
let radians = number.to_radians();
self.horizontal_direction.x = radians.cos();
self.horizontal_direction.y = radians.sin();
self.horizontal_direction.z = 0.0;
}
"tbl_rows" => {
let requested = number.round().max(1.0) as usize;
while self.rows.len() < requested {
self.add_row();
}
while self.rows.len() > requested {
self.remove_row(self.rows.len() - 1);
}
self.break_ranges.clear();
}
"tbl_cols" => {
let requested = number.round().max(1.0) as usize;
let width = self.columns.last().map(|column| column.width).unwrap_or(2.0);
while self.columns.len() < requested {
self.add_column(width);
}
while self.columns.len() > requested {
self.remove_column(self.columns.len() - 1);
}
self.break_ranges.clear();
}
"tbl_column_width" if number > 0.0 => {
for column in &mut self.columns {
column.width = number;
}
self.break_ranges.clear();
}
"tbl_row_height" if number > 0.0 => {
for row in &mut self.rows {
row.height = number;
}
self.break_ranges.clear();
}
"tbl_width" if number > 0.0 => {
let current = self.total_width();
if current > 1.0e-12 {
for column in &mut self.columns {
column.width *= number / current;
}
}
self.break_ranges.clear();
}
"tbl_height" if number > 0.0 => {
let current = self.total_height();
if current > 1.0e-12 {
for row in &mut self.rows {
row.height *= number / current;
}
}
self.break_ranges.clear();
}
"tbl_horizontal_margin" if number >= 0.0 => {
let style = self.base_style.get_or_insert_with(Default::default);
style.margin_left = number;
style.margin_right = number;
style.property_flags.insert(
CellStylePropertyFlags::MARGIN_LEFT | CellStylePropertyFlags::MARGIN_RIGHT,
);
let legacy = self.legacy_style_override.get_or_insert_with(Default::default);
legacy.flags |= 0x0008;
legacy.horizontal_cell_margin = Some(number);
self.override_flag = true;
}
"tbl_vertical_margin" if number >= 0.0 => {
let style = self.base_style.get_or_insert_with(Default::default);
style.margin_top = number;
style.margin_bottom = number;
style.property_flags.insert(
CellStylePropertyFlags::MARGIN_TOP | CellStylePropertyFlags::MARGIN_BOTTOM,
);
let legacy = self.legacy_style_override.get_or_insert_with(Default::default);
legacy.flags |= 0x0010;
legacy.vertical_cell_margin = Some(number);
self.override_flag = true;
}
"tbl_cell_text_height" if number > 0.0 => {
if let Some((row, column)) = cell_position {
let state = self
.cell(row, column)
.map(|cell| cell.state)
.unwrap_or_default();
if state.intersects(
CellStateFlags::FORMAT_LOCKED | CellStateFlags::FORMAT_READ_ONLY,
) {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
let style = cell.style.get_or_insert_with(CellStyle::new);
style.text_height = number;
style.property_flags.insert(
codec::entities::table::CellStylePropertyFlags::TEXT_HEIGHT,
);
}
}
}
"tbl_cell_margin_left"
| "tbl_cell_margin_top"
| "tbl_cell_margin_right"
| "tbl_cell_margin_bottom"
if number >= 0.0 =>
{
if let Some((row, column)) = cell_position {
let state = self
.cell(row, column)
.map(|cell| cell.state)
.unwrap_or_default();
if state.intersects(
CellStateFlags::FORMAT_LOCKED | CellStateFlags::FORMAT_READ_ONLY,
) {
return;
}
if let Some(cell) = self.cell_mut(row, column) {
let style = cell.style.get_or_insert_with(CellStyle::new);
let flag = match field {
"tbl_cell_margin_left" => {
style.margin_left = number;
CellStylePropertyFlags::MARGIN_LEFT
}
"tbl_cell_margin_top" => {
style.margin_top = number;
CellStylePropertyFlags::MARGIN_TOP
}
"tbl_cell_margin_right" => {
style.margin_right = number;
CellStylePropertyFlags::MARGIN_RIGHT
}
_ => {
style.margin_bottom = number;
CellStylePropertyFlags::MARGIN_BOTTOM
}
};
style.property_flags.insert(flag);
}
}
}
"tbl_break_height"
if number >= 0.0
&& self.break_options.contains(BreakOptionFlags::ENABLE_BREAKS)
&& !self
.break_options
.contains(BreakOptionFlags::ALLOW_MANUAL_HEIGHTS) =>
{
if self.break_data.is_empty() {
self.break_data.push(codec::entities::table::TableBreakData {
position: codec::types::Vector3::ZERO,
height: number,
flags: 0,
});
} else {
for data in &mut self.break_data {
data.height = number;
}
}
self.break_ranges.clear();
}
"tbl_break_spacing"
if number >= 0.0
&& self.break_options.contains(BreakOptionFlags::ENABLE_BREAKS)
&& !self
.break_options
.contains(BreakOptionFlags::ALLOW_MANUAL_POSITIONS) =>
{
self.break_spacing = number;
self.break_ranges.clear();
}
_ => {}
}
}
}
impl Transformable for Table {
fn apply_transform(&mut self, t: &EntityTransform) {
transform::apply_standard_entity_transform(self, t, |entity, p1, p2| {
transform::reflect_xy_point(
&mut entity.insertion_point.x,
&mut entity.insertion_point.y,
p1,
p2,
);
// Reflect the horizontal direction by reflecting a tip point
let mut tip_x = entity.insertion_point.x + entity.horizontal_direction.x;
let mut tip_y = entity.insertion_point.y + entity.horizontal_direction.y;
transform::reflect_xy_point(&mut tip_x, &mut tip_y, p1, p2);
entity.horizontal_direction.x = tip_x - entity.insertion_point.x;
entity.horizontal_direction.y = tip_y - entity.insertion_point.y;
});
}
}
/// Keep the per-cell merge dimensions (what DXF stores) in step with
/// `merged_ranges` (what DWG stores) after a scripted create or edit. Cells a
/// script did not touch keep their merge state when the ranges are unchanged.
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub(crate) fn normalize_scripted_table(old: Option<&Table>, new: &mut Table) {
if old.is_some_and(|old| old.merged_ranges == new.merged_ranges) {
return;
}
for row in &mut new.rows {
for cell in &mut row.cells {
cell.merge_width = 1;
cell.merge_height = 1;
}
}
let ranges = new.merged_ranges.clone();
for range in &ranges {
if let Some(cell) = new
.rows
.get_mut(range.top_row)
.and_then(|row| row.cells.get_mut(range.left_col))
{
cell.merge_width = range.col_count() as i32;
cell.merge_height = range.row_count() as i32;
}
}
}
View Git Blame Copy Permalink