use slotmap::new_key_type;
use crate::compositor::layout::Rect;
use crate::compositor::layout::cell::CellBuffer;
use crate::compositor::layout::engine::Placement;
use crate::parser::ast::{Alignment, Dimension, LiveScroll, TransitionKind};
new_key_type! {
pub struct NodeId;
}
#[derive(Debug, Clone, Copy)]
pub(super) struct MeasureMemo {
pub(super) pass: u64,
pub(super) width: u16,
pub(super) height: u16,
}
#[derive(Debug)]
pub struct Node {
pub(super) id: NodeId,
pub(super) kind: NodeKind,
pub(super) parent: Option<NodeId>,
pub(super) children: Vec<NodeId>,
pub(super) placement: Placement,
pub(super) focusable_screen_rect: Option<Rect>,
pub(super) buffer: Option<CellBuffer>,
pub(super) z_index: i16,
pub(super) transform: Transform,
pub(super) visible: bool,
pub(super) focusable: bool,
pub(super) hit_target: Option<Action>,
pub(super) aml_id: Option<String>,
pub(super) measured: Option<MeasureMemo>,
}
impl Node {
pub fn id(&self) -> NodeId {
self.id
}
pub fn kind(&self) -> &NodeKind {
&self.kind
}
pub fn parent(&self) -> Option<NodeId> {
self.parent
}
pub fn children(&self) -> &[NodeId] {
&self.children
}
pub fn placement(&self) -> &Placement {
&self.placement
}
pub fn focusable_screen_rect(&self) -> Option<Rect> {
self.focusable_screen_rect
}
pub fn buffer(&self) -> Option<&CellBuffer> {
self.buffer.as_ref()
}
pub fn z_index(&self) -> i16 {
self.z_index
}
pub fn transform(&self) -> Transform {
self.transform
}
pub fn visible(&self) -> bool {
self.visible
}
pub fn focusable(&self) -> bool {
self.focusable
}
pub fn hit_target(&self) -> Option<&Action> {
self.hit_target.as_ref()
}
pub fn aml_id(&self) -> Option<&str> {
self.aml_id.as_deref()
}
pub(crate) fn aml_id_capacity(&self) -> usize {
option_string_capacity(&self.aml_id)
}
pub fn kind_tag(&self) -> KindTag {
self.kind.tag()
}
pub(crate) fn retained_string_capacity(&self) -> usize {
option_string_capacity(&self.aml_id)
.saturating_add(self.kind.retained_string_capacity())
.saturating_add(
self.hit_target
.as_ref()
.map_or(0, Action::retained_string_capacity),
)
}
}
fn option_string_capacity(value: &Option<String>) -> usize {
value.as_ref().map_or(0, String::capacity)
}
fn string_vec_capacity(values: &[String]) -> usize {
values.iter().fold(0usize, |total, value| {
total.saturating_add(value.capacity())
})
}
#[derive(Debug, Clone)]
pub enum NodeKind {
Root,
Flow(FlowData),
Row(RowData),
Absolute(AbsoluteData),
Text(TextContent),
Input(InputData),
Select(SelectData),
OptionLeaf(OptionData),
Button(ButtonData),
Hr(HrData),
Spacer { lines: u16 },
Panel {
states: Vec<NodeId>,
active: NodeId,
initial_state: String,
},
Animation(AnimationData),
LiveRegion(LiveData),
Table,
Tr,
Th(CellData),
Td(CellData),
Link(LinkData),
Overlay(OverlayData),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct OverlayData {
pub source: OverlaySource,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OverlaySource {
PageTransition,
}
impl NodeKind {
pub fn tag(&self) -> KindTag {
match self {
NodeKind::Root => KindTag::Root,
NodeKind::Flow(_) => KindTag::Flow,
NodeKind::Row(_) => KindTag::Row,
NodeKind::Absolute(_) => KindTag::Absolute,
NodeKind::Text(_) => KindTag::Text,
NodeKind::Input(_) => KindTag::Input,
NodeKind::Select(_) => KindTag::Select,
NodeKind::OptionLeaf(_) => KindTag::OptionLeaf,
NodeKind::Button(_) => KindTag::Button,
NodeKind::Hr(_) => KindTag::Hr,
NodeKind::Spacer { .. } => KindTag::Spacer,
NodeKind::Panel { .. } => KindTag::Panel,
NodeKind::Animation(_) => KindTag::Animation,
NodeKind::LiveRegion(_) => KindTag::LiveRegion,
NodeKind::Table => KindTag::Table,
NodeKind::Tr => KindTag::Tr,
NodeKind::Th(_) => KindTag::Th,
NodeKind::Td(_) => KindTag::Td,
NodeKind::Link(_) => KindTag::Link,
NodeKind::Overlay(_) => KindTag::Overlay,
}
}
fn retained_string_capacity(&self) -> usize {
match self {
NodeKind::Flow(data) => option_string_capacity(&data.title)
.saturating_add(option_string_capacity(&data.form_action))
.saturating_add(option_string_capacity(&data.state_name))
.saturating_add(option_string_capacity(&data.details_summary)),
NodeKind::Absolute(data) => option_string_capacity(&data.title),
NodeKind::Text(data) => data
.runs
.capacity()
.saturating_mul(std::mem::size_of::<TextRun>())
.saturating_add(data.runs.iter().fold(0usize, |total, run| {
total.saturating_add(run.text.capacity())
})),
NodeKind::Input(data) => data
.name
.capacity()
.saturating_add(option_string_capacity(&data.placeholder))
.saturating_add(option_string_capacity(&data.value)),
NodeKind::Select(data) => data
.name
.capacity()
.saturating_add(option_string_capacity(&data.label)),
NodeKind::OptionLeaf(data) => {
data.value.capacity().saturating_add(data.label.capacity())
}
NodeKind::Button(data) => data
.label
.capacity()
.saturating_add(option_string_capacity(&data.target))
.saturating_add(data.states.as_deref().map_or(0, string_vec_capacity))
.saturating_add(option_string_capacity(&data.to))
.saturating_add(option_string_capacity(&data.href)),
NodeKind::Panel { initial_state, .. } => initial_state.capacity(),
NodeKind::Animation(data) => option_string_capacity(&data.src)
.saturating_add(option_string_capacity(&data.after)),
NodeKind::LiveRegion(data) => data.endpoint.capacity(),
NodeKind::Link(data) => data
.href
.capacity()
.saturating_add(option_string_capacity(&data.defer_animation)),
_ => 0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KindTag {
Root,
Flow,
Row,
Absolute,
Text,
Input,
Select,
OptionLeaf,
Button,
Hr,
Spacer,
Panel,
Animation,
LiveRegion,
Table,
Tr,
Th,
Td,
Link,
Overlay,
}
#[derive(Debug, Clone, Default)]
pub struct FlowData {
pub source: FlowSource,
pub border: BorderStyleTag,
pub title: Option<String>,
pub join_top: Option<u16>,
pub join_bottom: Option<u16>,
pub join_left: Option<u16>,
pub join_right: Option<u16>,
pub padding: u16,
pub width: Option<Dimension>,
pub height: Option<Dimension>,
pub fg: Option<crate::color::Color>,
pub bg: Option<crate::color::Color>,
pub align: Alignment,
pub sticky: Option<crate::parser::ast::StickyPosition>,
pub form_action: Option<String>,
pub list_style: Option<crate::parser::ast::ListStyle>,
pub list_bullet_char: Option<char>,
pub state_name: Option<String>,
pub state_transition: Option<crate::parser::ast::TransitionKind>,
pub state_transition_duration_ms: u32,
pub details_summary_count: u16,
pub details_summary: Option<String>,
pub details_open: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum FlowSource {
#[default]
Box,
Col,
Header,
Body,
Footer,
Nav,
Thead,
Tbody,
Pagination,
List,
Item,
Frame,
Details,
State,
Form,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum BorderStyleTag {
#[default]
None,
Single,
Double,
Rounded,
Heavy,
Ascii,
}
impl BorderStyleTag {
pub fn to_ast(self) -> crate::parser::ast::BorderStyle {
use crate::parser::ast::BorderStyle;
match self {
BorderStyleTag::None => BorderStyle::None,
BorderStyleTag::Single => BorderStyle::Single,
BorderStyleTag::Double => BorderStyle::Double,
BorderStyleTag::Rounded => BorderStyle::Rounded,
BorderStyleTag::Heavy => BorderStyle::Heavy,
BorderStyleTag::Ascii => BorderStyle::Ascii,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct RowData {
pub gap: u16,
pub align: crate::parser::ast::VerticalAlignment,
}
#[derive(Debug, Clone)]
pub struct AbsoluteData {
pub x: Option<u16>,
pub y: Option<u16>,
pub w: Dimension,
pub h: Dimension,
pub border: BorderStyleTag,
pub title: Option<String>,
pub join_top: Option<u16>,
pub join_bottom: Option<u16>,
pub join_left: Option<u16>,
pub join_right: Option<u16>,
pub padding: u16,
pub fg: Option<crate::color::Color>,
pub bg: Option<crate::color::Color>,
pub align: Alignment,
}
#[derive(Debug, Clone, Default)]
pub struct TextContent {
pub runs: Vec<TextRun>,
pub align: Alignment,
pub source: TextSource,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TextSource {
#[default]
Text,
Pre,
Heading(u8),
Art,
ElementDef,
TextAnimate,
}
#[derive(Debug, Clone, Default)]
pub struct TextRun {
pub text: String,
pub bold: bool,
pub italic: bool,
pub underline: bool,
pub strikethrough: bool,
pub dim: bool,
pub blink: bool,
pub fg: Option<crate::color::Color>,
pub bg: Option<crate::color::Color>,
}
#[derive(Debug, Clone)]
pub struct InputData {
pub name: String,
pub maxlen: u32,
pub placeholder: Option<String>,
pub multiline: bool,
pub rows: u16,
pub password: bool,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default)]
pub struct SelectData {
pub name: String,
pub label: Option<String>,
pub selected_index: usize,
}
#[derive(Debug, Clone)]
pub struct OptionData {
pub value: String,
pub selected: bool,
pub label: String,
}
#[derive(Debug, Clone)]
pub struct ButtonData {
pub label: String,
pub key: Option<char>,
pub action: crate::parser::ast::ButtonAction,
pub target: Option<String>,
pub states: Option<Vec<String>>,
pub to: Option<String>,
pub href: Option<String>,
pub transition: Option<crate::parser::ast::TransitionKind>,
pub transition_duration_ms: u32,
}
#[derive(Debug, Clone)]
pub struct HrData {
pub fg: Option<crate::color::Color>,
pub style: crate::parser::ast::HrStyle,
}
#[derive(Debug, Clone)]
pub struct AnimationData {
pub fps: u16,
pub autoplay: bool,
pub loop_behavior: crate::parser::ast::LoopBehavior,
pub loop_: bool,
pub background: bool,
pub src: Option<String>,
pub frames: Vec<NodeId>,
pub delay_ms: u32,
pub after: Option<String>,
pub x: Option<u16>,
pub y: Option<u16>,
pub w: Option<u16>,
pub h: Option<u16>,
}
#[derive(Debug, Clone)]
pub struct LiveData {
pub endpoint: String,
pub height: Dimension,
pub scroll: LiveScroll,
pub buffer: u32,
pub delta: bool,
}
#[derive(Debug, Clone)]
pub struct CellData {
pub fg: Option<crate::color::Color>,
}
#[derive(Debug, Clone)]
pub struct LinkData {
pub href: String,
pub key: Option<char>,
pub prefetch: bool,
pub transition: Option<TransitionKind>,
pub transition_duration_ms: u32,
pub defer_animation: Option<String>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Transform {
pub dx: i16,
pub dy: i16,
}
impl Transform {
pub const IDENTITY: Transform = Transform { dx: 0, dy: 0 };
pub fn is_identity(self) -> bool {
self.dx == 0 && self.dy == 0
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum Action {
Navigate {
href: String,
transition: Option<TransitionKind>,
transition_duration_ms: u32,
defer_animation: Option<String>,
},
SetPanelState { panel: String, state: String },
TogglePanel { panel: String, states: Vec<String> },
Submit { form: String },
FireTrigger {
event: String,
target: Option<String>,
},
ToggleDetails { id: String },
}
impl Action {
fn retained_string_capacity(&self) -> usize {
match self {
Action::Navigate {
href,
defer_animation,
..
} => href
.capacity()
.saturating_add(option_string_capacity(defer_animation)),
Action::SetPanelState { panel, state } => {
panel.capacity().saturating_add(state.capacity())
}
Action::TogglePanel { panel, states } => {
panel.capacity().saturating_add(string_vec_capacity(states))
}
Action::Submit { form } => form.capacity(),
Action::FireTrigger { event, target } => event
.capacity()
.saturating_add(option_string_capacity(target)),
Action::ToggleDetails { id } => id.capacity(),
}
}
}
pub(super) struct NodeBuilder {
pub(super) kind: NodeKind,
pub(super) aml_id: Option<String>,
pub(super) focusable: bool,
pub(super) hit_target: Option<Action>,
}
impl NodeBuilder {
pub(super) fn new(kind: NodeKind) -> Self {
Self {
kind,
aml_id: None,
focusable: false,
hit_target: None,
}
}
pub(super) fn aml_id(mut self, id: impl Into<Option<String>>) -> Self {
self.aml_id = id.into();
self
}
pub(super) fn focusable(mut self, focusable: bool) -> Self {
self.focusable = focusable;
self
}
pub(super) fn hit_target(mut self, action: Option<Action>) -> Self {
self.hit_target = action;
self
}
pub(super) fn finish(self, id: NodeId) -> Node {
Node {
id,
kind: self.kind,
parent: None,
children: Vec::new(),
placement: Placement::empty_at(0, 0),
focusable_screen_rect: None,
buffer: None,
z_index: 0,
transform: Transform::IDENTITY,
visible: true,
focusable: self.focusable,
hit_target: self.hit_target,
aml_id: self.aml_id,
measured: None,
}
}
}