takumi 0.73.0

Render your React components to images.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::iter::once;

use taffy::{AvailableSpace, Layout, Size};

use crate::{
  Result,
  layout::{
    inline::{
      InlineContentKind, InlineItem, InlineLayoutStage, create_inline_constraint,
      create_inline_layout, measure_inline_layout,
    },
    node::{Node, NodeStyleLayers, TextData},
  },
  rendering::{Canvas, MaxHeight, RenderContext, inline_drawing::draw_inline_layout},
};

pub(crate) fn take_text_style_layers(node: &mut Node) -> NodeStyleLayers {
  NodeStyleLayers {
    preset: node.metadata.preset.take(),
    author_tw: node.metadata.tw.take(),
    inline: node.metadata.style.take(),
  }
}

pub(crate) fn text_inline_content(text: &TextData) -> Option<InlineContentKind<'_>> {
  Some(InlineContentKind::Text(text.text.as_str().into()))
}

pub(crate) fn draw_text_node_content(
  text: &TextData,
  context: &RenderContext,
  canvas: &mut Canvas,
  layout: Layout,
) -> Result<()> {
  let font_style = context.style.to_sized_font_style(context);
  let size = layout.content_box_size();

  if font_style.sizing.font_size == 0.0 {
    return Ok(());
  }

  let max_height = match font_style.parent.line_clamp.as_ref() {
    Some(clamp) => Some(MaxHeight::HeightAndLines(size.height, clamp.count)),
    None => Some(MaxHeight::Absolute(size.height)),
  };

  let inline_text: InlineItem<'_, '_> = InlineItem::Text {
    text: text.text.as_str().into(),
    context,
  };

  let (inline_layout, _, spans) = create_inline_layout(
    once(inline_text),
    Size {
      width: AvailableSpace::Definite(size.width),
      height: AvailableSpace::Definite(size.height),
    },
    size.width,
    max_height,
    &font_style,
    context.global,
    InlineLayoutStage::Draw,
  );

  draw_inline_layout(context, canvas, layout, inline_layout, &font_style, &spans)?;

  Ok(())
}

pub(crate) fn measure_text_node(
  text: &TextData,
  context: &RenderContext,
  available_space: Size<AvailableSpace>,
  known_dimensions: Size<Option<f32>>,
) -> Size<f32> {
  let inline_content: InlineItem<'_, '_> = InlineItem::Text {
    text: text.text.as_str().into(),
    context,
  };

  let (max_width, max_height) =
    create_inline_constraint(context, available_space, known_dimensions);
  let font_style = context.style.to_sized_font_style(context);

  let (mut layout, _, _) = create_inline_layout(
    once(inline_content),
    available_space,
    max_width,
    max_height,
    &font_style,
    context.global,
    InlineLayoutStage::Measure,
  );

  measure_inline_layout(&mut layout, max_width)
}