//! A table's borders, as Writer and Impress report them (DOC-07). use std::io; use serde_json::Value; use crate::ipc::{Pack, Unpack}; /// One axis in twips: columns run across, rows down. #[derive(Clone, Debug, Default, PartialEq)] pub struct Lines { /// The first line, from `offset`. pub left: i32, /// The last line, from `offset`. pub right: i32, pub offset: i32, pub inner: Vec, /// Bounds of the first and last lines, when sent. pub ends: Option<[(i32, i32); 2]>, } /// An inner line and the kernel's bounds for it. #[derive(Clone, Copy, Debug, PartialEq)] pub struct Line { pub position: i32, pub min: i32, pub max: i32, pub hidden: bool, } /// The table holding the cursor. #[derive(Clone, Debug, Default, PartialEq)] pub struct Table { pub columns: Lines, pub rows: Lines, } /// Reads a `LOK_CALLBACK_TABLE_SELECTED` payload; `{}` is no table. pub fn read(text: &str) -> Result, String> { let fault = || format!("an unreadable table: {text}"); let json: Value = serde_json::from_str(text).map_err(|_| fault())?; let object = json.as_object().ok_or_else(fault)?; if object.is_empty() { return Ok(None); } // Impress writes every value as text (boost's property tree). let int = |value: Option<&Value>| match value? { Value::Number(number) => i32::try_from(number.as_i64()?).ok(), Value::String(text) => text.parse().ok(), _ => None, }; let flag = |value: Option<&Value>| match value? { Value::Bool(on) => Some(*on), Value::String(text) => text.parse().ok(), _ => None, }; let lines = |key: &str| -> Option { let axis = object.get(key)?; // Boost writes an empty list as an empty string. let entries = match axis.get("entries")? { Value::Array(entries) => entries.as_slice(), Value::String(text) if text.is_empty() => &[], _ => return None, }; let inner = entries.iter().map(|entry| { Some(Line { position: int(entry.get("position"))?, min: int(entry.get("min"))?, max: int(entry.get("max"))?, hidden: flag(entry.get("hidden"))?, }) }); let bound = |key: &str| int(axis.get(key)); let ends = match ["leftMin", "leftMax", "rightMin", "rightMax"].map(|key| axis.get(key).is_some()) { [false, false, false, false] => None, [true, true, true, true] => { Some([(bound("leftMin")?, bound("leftMax")?), (bound("rightMin")?, bound("rightMax")?)]) } _ => return None, }; Some(Lines { left: int(axis.get("left"))?, right: int(axis.get("right"))?, offset: int(axis.get("tableOffset"))?, inner: inner.collect::>()?, ends, }) }; let columns = lines("columns").ok_or_else(fault)?; let rows = lines("rows").ok_or_else(fault)?; Ok(Some(Table { columns, rows })) } impl Table { pub(crate) fn pack(table: Option<&Table>, pack: Pack) -> Pack { let Some(table) = table else { return pack.u64(0); }; [&table.columns, &table.rows].into_iter().fold(pack.u64(1), |pack, axis| { let pack = pack .i64(axis.left.into()) .i64(axis.right.into()) .i64(axis.offset.into()) .u64(axis.inner.len() as u64); let pack = match axis.ends { None => pack.u64(0), Some(ends) => ends.iter().fold(pack.u64(1), |pack, &(low, high)| pack.i64(low.into()).i64(high.into())), }; axis.inner.iter().fold(pack, |pack, line| { pack.i64(line.position.into()) .i64(line.min.into()) .i64(line.max.into()) .u64(line.hidden as u64) }) }) } pub(crate) fn unpack(unpack: &mut Unpack) -> io::Result> { if unpack.u64()? == 0 { return Ok(None); } let mut lines = || -> io::Result { let mut int = || i32::try_from(unpack.i64()?).map_err(io::Error::other); let (left, right, offset) = (int()?, int()?, int()?); let count = unpack.u64()?; let ends = match unpack.u64()? { 0 => None, _ => { let mut int = || i32::try_from(unpack.i64()?).map_err(io::Error::other); Some([(int()?, int()?), (int()?, int()?)]) } }; let inner = (0..count) .map(|_| { let mut int = || i32::try_from(unpack.i64()?).map_err(io::Error::other); let (position, min, max) = (int()?, int()?, int()?); Ok(Line { position, min, max, hidden: unpack.u64()? != 0 }) }) .collect::>()?; Ok(Lines { left, right, offset, inner, ends }) }; let columns = lines()?; let rows = lines()?; Ok(Some(Table { columns, rows })) } } #[cfg(test)] mod tests { use super::*; const SEEN: &str = r#"{ "columns": { "left": 0, "right": 9638, "tableOffset": 1135, "entries": [ { "position": 4819, "min": 300, "max": 9338, "hidden": false } ] }, "rows": { "left": 0, "right": 552, "tableOffset": 1418, "entries": [ { "position": 276, "min": 100, "max": 552, "hidden": false } ] } }"#; /// As Impress sent it for a new 2x2 table. const IMPRESS: &str = r#"{ "columns": { "tableOffset": "3929", "left": "0", "right": "7993", "entries": [ { "position": "3996", "min": "340", "max": "7653", "hidden": "false" } ] }, "rows": { "tableOffset": "4340", "left": "0", "right": "1091", "entries": [ { "position": "545", "min": "340", "max": "152183880", "hidden": "false" } ] }, "rectangle": { "x": "3940", "y": "4351", "width": "7993", "height": "1091" } }"#; #[test] fn impress_writes_numbers_as_text() { let table = read(IMPRESS).expect("readable").expect("a table"); assert_eq!(table.columns.offset, 3929); assert_eq!(table.columns.inner, [Line { position: 3996, min: 340, max: 7653, hidden: false }]); assert_eq!(table.rows.right, 1091); assert!(read(&IMPRESS.replace("\"false\"", "\"no\"")).is_err(), "a flag is true or false"); assert_eq!(table.rows.ends, None, "an unpatched kernel sends no ends"); } /// One row, as Impress sends it with patch 0047. const ONE_ROW: &str = r#"{ "columns": { "tableOffset": "3929", "left": "0", "right": "7993", "leftMin": "-152183880", "leftMax": "7823", "rightMin": "170", "rightMax": "152183880", "entries": "" }, "rows": { "tableOffset": "4340", "left": "0", "right": "545", "leftMin": "-152183880", "leftMax": "28", "rightMin": "517", "rightMax": "152183880", "entries": "" } }"#; #[test] fn one_line_has_no_inner_lines_and_its_ends_cross_the_wire() { let table = read(ONE_ROW).expect("readable").expect("a table"); assert!(table.columns.inner.is_empty() && table.rows.inner.is_empty()); assert_eq!(table.rows.ends, Some([(-152_183_880, 28), (517, 152_183_880)])); assert!(read(&ONE_ROW.replace("\"entries\": \"\"", "\"entries\": \"x\"")).is_err(), "text is no list"); assert!(read(&ONE_ROW.replace("\"leftMin\": \"-152183880\", ", "")).is_err(), "ends come in fours"); let bytes = Table::pack(Some(&table), Pack::new()).bytes(); assert_eq!(Table::unpack(&mut Unpack::new(&bytes)).expect("unpacks"), Some(table)); } #[test] fn a_table_reads_and_crosses_the_wire() { assert_eq!(read("{ }"), Ok(None), "no table"); let table = read(SEEN).expect("readable").expect("a table"); assert_eq!(table.columns.offset, 1135); assert_eq!(table.rows.inner[0].position, 276); let text = SEEN.replace("\"left\": 0,", "\"left\": \"zero\","); assert!(read(&text).is_err(), "a word is no number"); assert!(read("[]").is_err()); let bytes = Table::pack(Some(&table), Pack::new()).bytes(); let back = Table::unpack(&mut Unpack::new(&bytes)).expect("unpacks"); assert_eq!(back, Some(table)); let none = Table::pack(None, Pack::new()).bytes(); assert_eq!(Table::unpack(&mut Unpack::new(&none)).expect("unpacks"), None); } }