1use crate::{
2 draw_target::DrawTarget,
3 geometry::{Point, Size},
4 image::Image,
5 mono_font::{
6 draw_target::{Background, Both, Foreground, MonoFontDrawTarget},
7 MonoFont,
8 },
9 pixelcolor::{BinaryColor, PixelColor},
10 primitives::Rectangle,
11 text::{
12 renderer::{CharacterStyle, TextMetrics, TextRenderer},
13 Baseline, DecorationColor,
14 },
15 Drawable,
16};
17use az::SaturatingAs;
18
19/// Style properties for text using a monospaced font.
20///
21/// A `MonoTextStyle` can be applied to a [`Text`] object to define how the text is drawn.
22///
23/// Because `MonoTextStyle` has the [`non_exhaustive`] attribute, it cannot be created using a
24/// struct literal. To create a `MonoTextStyle` with a given text color and transparent
25/// background, use the [`new`] method. For more complex text styles, use the
26/// [`MonoTextStyleBuilder`].
27///
28/// [`Text`]: crate::text::Text
29/// [`non_exhaustive`]: https://blog.rust-lang.org/2019/12/19/Rust-1.40.0.html#[non_exhaustive]-structs,-enums,-and-variants
30/// [`new`]: MonoTextStyle::new()
31#[derive(Copy, Clone, Debug, PartialEq)]
32#[cfg_attr(feature = "defmt", derive(::defmt::Format))]
33#[non_exhaustive]
34pub struct MonoTextStyle<'a, C> {
35 /// Text color.
36 pub text_color: Option<C>,
37
38 /// Background color.
39 pub background_color: Option<C>,
40
41 /// Underline color.
42 pub underline_color: DecorationColor<C>,
43
44 /// Strikethrough color.
45 pub strikethrough_color: DecorationColor<C>,
46
47 /// Font.
48 pub font: &'a MonoFont<'a>,
49}
50
51impl<'a, C> MonoTextStyle<'a, C>
52where
53 C: PixelColor,
54{
55 /// Creates a text style with transparent background.
56 pub const fn new(font: &'a MonoFont<'a>, text_color: C) -> Self {
57 MonoTextStyleBuilder::new()
58 .font(font)
59 .text_color(text_color)
60 .build()
61 }
62
63 /// Returns `true` if the style is transparent.
64 ///
65 /// Drawing a `Text` with a transparent `MonoTextStyle` will not draw any pixels.
66 ///
67 /// [`Text`]: super::text::Text
68 pub fn is_transparent(&self) -> bool {
69 self.text_color.is_none()
70 && self.background_color.is_none()
71 && self.underline_color.is_none()
72 && self.strikethrough_color.is_none()
73 }
74
75 fn line_elements<'t>(
76 &self,
77 mut position: Point,
78 text: &'t str,
79 ) -> impl Iterator<Item = (Point, LineElement)> + 't {
80 let char_width = self.font.character_size.width as i32;
81 let spacing_width = self.font.character_spacing as i32;
82
83 let mut chars = text.chars();
84 let mut next_char = chars.next();
85 let mut add_spacing = false;
86
87 core::iter::from_fn(move || {
88 if add_spacing {
89 let p = position;
90 position.x += spacing_width;
91
92 add_spacing = false;
93
94 Some((p, LineElement::Spacing))
95 } else if let Some(c) = next_char {
96 let p = position;
97 position.x += char_width;
98
99 next_char = chars.next();
100 add_spacing = next_char.is_some();
101
102 Some((p, LineElement::Char(c)))
103 } else {
104 Some((position, LineElement::Done))
105 }
106 })
107 }
108
109 fn draw_decorations<D>(
110 &self,
111 width: u32,
112 position: Point,
113 target: &mut D,
114 ) -> Result<(), D::Error>
115 where
116 D: DrawTarget<Color = C>,
117 {
118 if let Some(color) = self.strikethrough_color.to_color(self.text_color) {
119 let rect = self.font.strikethrough.to_rectangle(position, width);
120 target.fill_solid(&rect, color)?;
121 }
122
123 if let Some(color) = self.underline_color.to_color(self.text_color) {
124 let rect = self.font.underline.to_rectangle(position, width);
125 target.fill_solid(&rect, color)?;
126 }
127
128 Ok(())
129 }
130
131 fn draw_string_binary<D>(
132 &self,
133 text: &str,
134 position: Point,
135 mut target: D,
136 ) -> Result<Point, D::Error>
137 where
138 D: DrawTarget<Color = BinaryColor>,
139 {
140 for (p, element) in self.line_elements(position, text) {
141 match element {
142 LineElement::Char(c) => {
143 let glyph = self.font.glyph(c);
144 Image::new(&glyph, p).draw(&mut target)?;
145 }
146 // Fill space between characters if background color is set.
147 LineElement::Spacing if self.font.character_spacing > 0 => {
148 if self.background_color.is_some() {
149 target.fill_solid(
150 &Rectangle::new(
151 p,
152 Size::new(
153 self.font.character_spacing,
154 self.font.character_size.height,
155 ),
156 ),
157 BinaryColor::Off,
158 )?;
159 }
160 }
161 LineElement::Spacing => {}
162 LineElement::Done => return Ok(p),
163 }
164 }
165
166 Ok(position)
167 }
168
169 /// Returns the vertical offset between the line position and the top edge of the bounding box.
170 fn baseline_offset(&self, baseline: Baseline) -> i32 {
171 match baseline {
172 Baseline::Top => 0,
173 Baseline::Bottom => self
174 .font
175 .character_size
176 .height
177 .saturating_sub(1)
178 .saturating_as(),
179 Baseline::Middle => {
180 (self.font.character_size.height.saturating_sub(1) / 2).saturating_as()
181 }
182 Baseline::Alphabetic => self.font.baseline.saturating_as(),
183 }
184 }
185}
186
187impl<C> TextRenderer for MonoTextStyle<'_, C>
188where
189 C: PixelColor,
190{
191 type Color = C;
192
193 fn draw_string<D>(
194 &self,
195 text: &str,
196 position: Point,
197 baseline: Baseline,
198 target: &mut D,
199 ) -> Result<Point, D::Error>
200 where
201 D: DrawTarget<Color = Self::Color>,
202 {
203 let position = position - Point::new(0, self.baseline_offset(baseline));
204
205 let next = match (self.text_color, self.background_color) {
206 (Some(text_color), Some(background_color)) => self.draw_string_binary(
207 text,
208 position,
209 MonoFontDrawTarget::new(target, Both(text_color, background_color)),
210 )?,
211 (Some(text_color), None) => self.draw_string_binary(
212 text,
213 position,
214 MonoFontDrawTarget::new(target, Foreground(text_color)),
215 )?,
216 (None, Some(background_color)) => self.draw_string_binary(
217 text,
218 position,
219 MonoFontDrawTarget::new(target, Background(background_color)),
220 )?,
221 (None, None) => {
222 let dx = (self.font.character_size.width + self.font.character_spacing)
223 * text.chars().count() as u32;
224
225 position + Size::new(dx, 0)
226 }
227 };
228
229 if next.x > position.x {
230 let width = (next.x - position.x) as u32;
231 self.draw_decorations(width, position, target)?;
232 }
233
234 Ok(next + Point::new(0, self.baseline_offset(baseline)))
235 }
236
237 fn draw_whitespace<D>(
238 &self,
239 width: u32,
240 position: Point,
241 baseline: Baseline,
242 target: &mut D,
243 ) -> Result<Point, D::Error>
244 where
245 D: DrawTarget<Color = Self::Color>,
246 {
247 let position = position - Point::new(0, self.baseline_offset(baseline));
248
249 if width != 0 {
250 if let Some(background_color) = self.background_color {
251 target.fill_solid(
252 &Rectangle::new(position, Size::new(width, self.font.character_size.height)),
253 background_color,
254 )?;
255 }
256
257 self.draw_decorations(width, position, target)?;
258 }
259
260 Ok(position + Point::new(width.saturating_as(), self.baseline_offset(baseline)))
261 }
262
263 fn measure_string(&self, text: &str, position: Point, baseline: Baseline) -> TextMetrics {
264 let bb_position = position - Point::new(0, self.baseline_offset(baseline));
265
266 let bb_width = (text.chars().count() as u32
267 * (self.font.character_size.width + self.font.character_spacing))
268 .saturating_sub(self.font.character_spacing);
269
270 let bb_height = if self.underline_color != DecorationColor::None {
271 self.font.underline.height + self.font.underline.offset
272 } else {
273 self.font.character_size.height
274 };
275
276 let bb_size = Size::new(bb_width, bb_height);
277
278 TextMetrics {
279 bounding_box: Rectangle::new(bb_position, bb_size),
280 next_position: position + bb_size.x_axis(),
281 }
282 }
283
284 fn line_height(&self) -> u32 {
285 self.font.character_size.height
286 }
287}
288
289impl<C> CharacterStyle for MonoTextStyle<'_, C>
290where
291 C: PixelColor,
292{
293 type Color = C;
294
295 fn set_text_color(&mut self, text_color: Option<Self::Color>) {
296 self.text_color = text_color;
297 }
298
299 fn set_background_color(&mut self, background_color: Option<Self::Color>) {
300 self.background_color = background_color;
301 }
302
303 fn set_underline_color(&mut self, underline_color: DecorationColor<Self::Color>) {
304 self.underline_color = underline_color;
305 }
306
307 fn set_strikethrough_color(&mut self, strikethrough_color: DecorationColor<Self::Color>) {
308 self.strikethrough_color = strikethrough_color;
309 }
310}
311
312#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
313#[cfg_attr(feature = "defmt", derive(::defmt::Format))]
314enum LineElement {
315 Char(char),
316 Spacing,
317 Done,
318}
319
320/// Text style builder for monospaced fonts.
321///
322/// Use this builder to create [`MonoTextStyle`]s for [`Text`].
323///
324/// # Examples
325///
326/// ## Render yellow text on a blue background
327///
328/// This uses the [`FONT_6X9`] font, but [other fonts] can also be used.
329///
330/// ```rust
331/// use embedded_graphics::{
332/// mono_font::{ascii::FONT_6X9, MonoTextStyle, MonoTextStyleBuilder},
333/// pixelcolor::Rgb565,
334/// prelude::*,
335/// text::Text,
336/// };
337///
338/// let style = MonoTextStyleBuilder::new()
339/// .font(&FONT_6X9)
340/// .text_color(Rgb565::YELLOW)
341/// .background_color(Rgb565::BLUE)
342/// .build();
343///
344/// let text = Text::new("Hello Rust!", Point::new(0, 0), style);
345/// ```
346///
347/// ## Transparent background
348///
349/// If a property is omitted, it will remain at its default value in the resulting
350/// `MonoTextStyle` returned by `.build()`. This example draws white text with no background at
351/// all.
352///
353/// ```rust
354/// use embedded_graphics::{
355/// mono_font::{ascii::FONT_6X9, MonoTextStyle, MonoTextStyleBuilder},
356/// pixelcolor::Rgb565,
357/// prelude::*,
358/// text::Text,
359/// };
360///
361/// let style = MonoTextStyleBuilder::new()
362/// .font(&FONT_6X9)
363/// .text_color(Rgb565::WHITE)
364/// .build();
365///
366/// let text = Text::new("Hello Rust!", Point::new(0, 0), style);
367/// ```
368///
369/// ## Modifying an existing style
370///
371/// The builder can also be used to modify an existing style.
372///
373/// ```
374/// use embedded_graphics::{
375/// mono_font::{ascii::{FONT_6X9, FONT_10X20}, MonoTextStyle, MonoTextStyleBuilder},
376/// pixelcolor::Rgb565,
377/// prelude::*,
378/// text::Text,
379/// };
380///
381/// let style = MonoTextStyle::new(&FONT_6X9, Rgb565::YELLOW);
382///
383/// let style_larger = MonoTextStyleBuilder::from(&style)
384/// .font(&FONT_10X20)
385/// .build();
386/// ```
387///
388/// [`FONT_6X9`]: crate::mono_font::ascii::FONT_6X9
389/// [other fonts]: super
390/// [`Text`]: crate::text::Text
391#[derive(Copy, Clone, Debug)]
392#[cfg_attr(feature = "defmt", derive(::defmt::Format))]
393pub struct MonoTextStyleBuilder<'a, C> {
394 style: MonoTextStyle<'a, C>,
395}
396
397impl<'a, C> MonoTextStyleBuilder<'a, C>
398where
399 C: PixelColor,
400{
401 /// Creates a new text style builder.
402 pub const fn new() -> Self {
403 Self {
404 style: MonoTextStyle {
405 font: &super::NULL_FONT,
406 background_color: None,
407 text_color: None,
408 underline_color: DecorationColor::None,
409 strikethrough_color: DecorationColor::None,
410 },
411 }
412 }
413
414 /// Sets the font.
415 pub const fn font<'b>(self, font: &'b MonoFont<'b>) -> MonoTextStyleBuilder<'b, C> {
416 let style = MonoTextStyle {
417 font,
418 background_color: self.style.background_color,
419 text_color: self.style.text_color,
420 underline_color: self.style.underline_color,
421 strikethrough_color: self.style.strikethrough_color,
422 };
423
424 MonoTextStyleBuilder { style }
425 }
426
427 /// Enables underline using the text color.
428 pub const fn underline(mut self) -> Self {
429 self.style.underline_color = DecorationColor::TextColor;
430
431 self
432 }
433
434 /// Enables strikethrough using the text color.
435 pub const fn strikethrough(mut self) -> Self {
436 self.style.strikethrough_color = DecorationColor::TextColor;
437
438 self
439 }
440
441 /// Resets the text color to transparent.
442 pub const fn reset_text_color(mut self) -> Self {
443 self.style.text_color = None;
444
445 self
446 }
447
448 /// Resets the background color to transparent.
449 pub const fn reset_background_color(mut self) -> Self {
450 self.style.background_color = None;
451
452 self
453 }
454
455 /// Removes the underline decoration.
456 pub const fn reset_underline(mut self) -> Self {
457 self.style.underline_color = DecorationColor::None;
458
459 self
460 }
461
462 /// Removes the strikethrough decoration.
463 pub const fn reset_strikethrough(mut self) -> Self {
464 self.style.strikethrough_color = DecorationColor::None;
465
466 self
467 }
468
469 /// Sets the text color.
470 pub const fn text_color(mut self, text_color: C) -> Self {
471 self.style.text_color = Some(text_color);
472
473 self
474 }
475
476 /// Sets the background color.
477 pub const fn background_color(mut self, background_color: C) -> Self {
478 self.style.background_color = Some(background_color);
479
480 self
481 }
482
483 /// Enables underline with a custom color.
484 pub const fn underline_with_color(mut self, underline_color: C) -> Self {
485 self.style.underline_color = DecorationColor::Custom(underline_color);
486
487 self
488 }
489
490 /// Enables strikethrough with a custom color.
491 pub const fn strikethrough_with_color(mut self, strikethrough_color: C) -> Self {
492 self.style.strikethrough_color = DecorationColor::Custom(strikethrough_color);
493
494 self
495 }
496
497 /// Builds the text style.
498 ///
499 /// This method can only be called after a font was set by using the [`font`] method. All other
500 /// settings are optional and they will be set to their default value if they are missing.
501 ///
502 /// [`font`]: MonoTextStyleBuilder::font()
503 pub const fn build(self) -> MonoTextStyle<'a, C> {
504 self.style
505 }
506}
507
508impl<'a, C> From<&MonoTextStyle<'a, C>> for MonoTextStyleBuilder<'a, C>
509where
510 C: PixelColor,
511{
512 fn from(style: &MonoTextStyle<'a, C>) -> Self {
513 Self { style: *style }
514 }
515}
516
517#[cfg(test)]
518mod tests {
519 use super::*;
520 use crate::{
521 geometry::Dimensions,
522 image::ImageRaw,
523 mock_display::MockDisplay,
524 mono_font::{
525 ascii::{FONT_10X20, FONT_6X9},
526 iso_8859_1::FONT_6X9 as FONT_6X9_LATIN1,
527 mapping,
528 tests::*,
529 DecorationDimensions,
530 },
531 pixelcolor::{BinaryColor, Rgb888, RgbColor},
532 text::Text,
533 Drawable,
534 };
535
536 const SPACED_FONT: MonoFont = MonoFont {
537 character_spacing: 5,
538 underline: DecorationDimensions::new(9, 1),
539 ..FONT_6X9
540 };
541
542 const UNDERLINED_WHITE_STYLE: MonoTextStyle<Rgb888> = MonoTextStyleBuilder::new()
543 .font(&FONT_6X9)
544 .text_color(Rgb888::WHITE)
545 .underline()
546 .build();
547
548 #[test]
549 fn builder_default() {
550 assert_eq!(
551 MonoTextStyleBuilder::<BinaryColor>::new()
552 .font(&FONT_10X20)
553 .build(),
554 MonoTextStyle {
555 font: &FONT_10X20,
556 text_color: None,
557 background_color: None,
558 underline_color: DecorationColor::None,
559 strikethrough_color: DecorationColor::None,
560 }
561 );
562 }
563
564 #[test]
565 fn builder_text_color() {
566 assert_eq!(
567 MonoTextStyleBuilder::new()
568 .font(&FONT_10X20)
569 .text_color(BinaryColor::On)
570 .build(),
571 MonoTextStyle::new(&FONT_10X20, BinaryColor::On)
572 );
573 }
574
575 #[test]
576 fn builder_background_color() {
577 assert_eq!(
578 MonoTextStyleBuilder::new()
579 .font(&FONT_10X20)
580 .background_color(BinaryColor::On)
581 .build(),
582 {
583 let mut style = MonoTextStyleBuilder::new().font(&FONT_10X20).build();
584
585 style.text_color = None;
586 style.background_color = Some(BinaryColor::On);
587
588 style
589 }
590 );
591 }
592
593 #[test]
594 fn builder_resets() {
595 let base = MonoTextStyleBuilder::new()
596 .font(&FONT_10X20)
597 .text_color(BinaryColor::On)
598 .background_color(BinaryColor::On)
599 .underline()
600 .strikethrough();
601
602 assert_eq!(
603 base.reset_text_color().build(),
604 MonoTextStyleBuilder::new()
605 .font(&FONT_10X20)
606 .background_color(BinaryColor::On)
607 .underline()
608 .strikethrough()
609 .build()
610 );
611
612 assert_eq!(
613 base.reset_background_color().build(),
614 MonoTextStyleBuilder::new()
615 .font(&FONT_10X20)
616 .text_color(BinaryColor::On)
617 .underline()
618 .strikethrough()
619 .build()
620 );
621
622 assert_eq!(
623 base.reset_underline().build(),
624 MonoTextStyleBuilder::new()
625 .font(&FONT_10X20)
626 .text_color(BinaryColor::On)
627 .background_color(BinaryColor::On)
628 .strikethrough()
629 .build()
630 );
631
632 assert_eq!(
633 base.reset_strikethrough().build(),
634 MonoTextStyleBuilder::new()
635 .font(&FONT_10X20)
636 .text_color(BinaryColor::On)
637 .background_color(BinaryColor::On)
638 .underline()
639 .build()
640 );
641 }
642
643 #[test]
644 fn underline_text_color() {
645 let mut display = MockDisplay::new();
646 Text::new("ABC", Point::new(0, 6), UNDERLINED_WHITE_STYLE)
647 .draw(&mut display)
648 .unwrap();
649
650 display.assert_pattern(&[
651 " ",
652 " W WWWW WW ",
653 " W W W W W W ",
654 "W W WWWW W ",
655 "WWWWW W W W ",
656 "W W W W W W ",
657 "W W WWWW WW ",
658 " ",
659 "WWWWWWWWWWWWWWWWWW",
660 ]);
661 }
662
663 #[test]
664 fn underline_text_color_with_alignment() {
665 let mut display = MockDisplay::new();
666 Text::with_baseline(
667 "ABC",
668 Point::new(0, 6),
669 UNDERLINED_WHITE_STYLE,
670 Baseline::Middle,
671 )
672 .draw(&mut display)
673 .unwrap();
674
675 display.assert_pattern(&[
676 " ",
677 " ",
678 " ",
679 " W WWWW WW ",
680 " W W W W W W ",
681 "W W WWWW W ",
682 "WWWWW W W W ",
683 "W W W W W W ",
684 "W W WWWW WW ",
685 " ",
686 "WWWWWWWWWWWWWWWWWW",
687 ]);
688 }
689
690 #[test]
691 fn underline_custom_color() {
692 let style = MonoTextStyleBuilder::new()
693 .font(&FONT_6X9)
694 .text_color(Rgb888::WHITE)
695 .underline_with_color(Rgb888::RED)
696 .build();
697
698 let mut display = MockDisplay::new();
699 Text::new("ABC", Point::new(0, 6), style)
700 .draw(&mut display)
701 .unwrap();
702
703 display.assert_pattern(&[
704 " ",
705 " W WWWW WW ",
706 " W W W W W W ",
707 "W W WWWW W ",
708 "WWWWW W W W ",
709 "W W W W W W ",
710 "W W WWWW WW ",
711 " ",
712 "RRRRRRRRRRRRRRRRRR",
713 ]);
714 }
715
716 #[test]
717 fn strikethrough_text_color() {
718 let style = MonoTextStyleBuilder::new()
719 .font(&FONT_6X9)
720 .text_color(Rgb888::WHITE)
721 .strikethrough()
722 .build();
723
724 let mut display = MockDisplay::new();
725 display.set_allow_overdraw(true);
726
727 Text::new("ABC", Point::new(0, 6), style)
728 .draw(&mut display)
729 .unwrap();
730
731 display.assert_pattern(&[
732 " ",
733 " W WWWW WW ",
734 " W W W W W W ",
735 "W W WWWW W ",
736 "WWWWWWWWWWWWWWWWWW",
737 "W W W W W W ",
738 "W W WWWW WW ",
739 ]);
740 }
741
742 #[test]
743 fn strikethrough_custom_color() {
744 let style = MonoTextStyleBuilder::new()
745 .font(&FONT_6X9)
746 .text_color(Rgb888::WHITE)
747 .strikethrough_with_color(Rgb888::RED)
748 .build();
749
750 let mut display = MockDisplay::new();
751 display.set_allow_overdraw(true);
752
753 Text::new("ABC", Point::new(0, 6), style)
754 .draw(&mut display)
755 .unwrap();
756
757 display.assert_pattern(&[
758 " ",
759 " W WWWW WW ",
760 " W W W W W W ",
761 "W W WWWW W ",
762 "RRRRRRRRRRRRRRRRRR",
763 "W W W W W W ",
764 "W W WWWW WW ",
765 ]);
766 }
767
768 #[test]
769 fn whitespace_background() {
770 let style = MonoTextStyleBuilder::new()
771 .font(&FONT_6X9)
772 .text_color(Rgb888::YELLOW)
773 .background_color(Rgb888::WHITE)
774 .build();
775
776 let mut display = MockDisplay::new();
777 style
778 .draw_whitespace(4, Point::zero(), Baseline::Top, &mut display)
779 .unwrap();
780
781 display.assert_pattern(&[
782 "WWWW", //
783 "WWWW", //
784 "WWWW", //
785 "WWWW", //
786 "WWWW", //
787 "WWWW", //
788 "WWWW", //
789 "WWWW", //
790 "WWWW", //
791 ]);
792 }
793
794 #[test]
795 fn whitespace_decorations() {
796 let style = MonoTextStyleBuilder::new()
797 .font(&FONT_6X9)
798 .text_color(Rgb888::YELLOW)
799 .underline_with_color(Rgb888::GREEN)
800 .strikethrough_with_color(Rgb888::RED)
801 .build();
802
803 let mut display = MockDisplay::new();
804 style
805 .draw_whitespace(3, Point::zero(), Baseline::Top, &mut display)
806 .unwrap();
807
808 display.assert_pattern(&[
809 " ", //
810 " ", //
811 " ", //
812 " ", //
813 "RRR", //
814 " ", //
815 " ", //
816 " ", //
817 "GGG", //
818 ]);
819 }
820
821 #[test]
822 fn whitespace_background_and_decorations() {
823 let style = MonoTextStyleBuilder::new()
824 .font(&FONT_6X9)
825 .text_color(Rgb888::YELLOW)
826 .background_color(Rgb888::WHITE)
827 .underline_with_color(Rgb888::GREEN)
828 .strikethrough_with_color(Rgb888::RED)
829 .build();
830
831 let mut display = MockDisplay::new();
832 display.set_allow_overdraw(true);
833
834 style
835 .draw_whitespace(8, Point::zero(), Baseline::Top, &mut display)
836 .unwrap();
837
838 display.assert_pattern(&[
839 "WWWWWWWW", //
840 "WWWWWWWW", //
841 "WWWWWWWW", //
842 "WWWWWWWW", //
843 "RRRRRRRR", //
844 "WWWWWWWW", //
845 "WWWWWWWW", //
846 "WWWWWWWW", //
847 "GGGGGGGG", //
848 ]);
849 }
850
851 #[test]
852 fn character_spacing() {
853 assert_text_from_pattern(
854 "##",
855 &SPACED_FONT,
856 &[
857 " ",
858 " # # # # ",
859 " # # # # ",
860 "##### ##### ",
861 " # # # # ",
862 "##### ##### ",
863 " # # # # ",
864 " # # # # ",
865 ],
866 );
867 }
868
869 #[test]
870 fn character_spacing_with_background() {
871 let character_style = MonoTextStyleBuilder::new()
872 .font(&SPACED_FONT)
873 .text_color(BinaryColor::On)
874 .background_color(BinaryColor::Off)
875 .build();
876
877 let mut display = MockDisplay::new();
878 Text::with_baseline("##", Point::zero(), character_style, Baseline::Top)
879 .draw(&mut display)
880 .unwrap();
881
882 display.assert_pattern(&[
883 ".................",
884 ".#.#........#.#..",
885 ".#.#........#.#..",
886 "#####......#####.",
887 ".#.#........#.#..",
888 "#####......#####.",
889 ".#.#........#.#..",
890 ".#.#........#.#..",
891 ".................",
892 ]);
893 }
894
895 #[test]
896 fn character_spacing_decorations() {
897 let character_style = MonoTextStyleBuilder::new()
898 .font(&SPACED_FONT)
899 .text_color(Rgb888::WHITE)
900 .underline_with_color(Rgb888::GREEN)
901 .strikethrough_with_color(Rgb888::RED)
902 .build();
903
904 let mut display = MockDisplay::new();
905 display.set_allow_overdraw(true);
906
907 Text::with_baseline("##", Point::zero(), character_style, Baseline::Top)
908 .draw(&mut display)
909 .unwrap();
910
911 display.assert_pattern(&[
912 " ",
913 " W W W W ",
914 " W W W W ",
915 "WWWWW WWWWW ",
916 "RRRRRRRRRRRRRRRRR",
917 "WWWWW WWWWW ",
918 " W W W W ",
919 " W W W W ",
920 " ",
921 "GGGGGGGGGGGGGGGGG",
922 ]);
923 }
924
925 #[test]
926 fn character_spacing_dimensions() {
927 let style = MonoTextStyleBuilder::new()
928 .font(&SPACED_FONT)
929 .text_color(BinaryColor::On)
930 .build();
931
932 assert_eq!(
933 Text::with_baseline("#", Point::zero(), style, Baseline::Top).bounding_box(),
934 Rectangle::new(Point::zero(), Size::new(6, 9)),
935 );
936
937 assert_eq!(
938 Text::with_baseline("##", Point::zero(), style, Baseline::Top).bounding_box(),
939 Rectangle::new(Point::zero(), Size::new(6 * 2 + 5, 9)),
940 );
941 assert_eq!(
942 Text::with_baseline("###", Point::zero(), style, Baseline::Top).bounding_box(),
943 Rectangle::new(Point::zero(), Size::new(6 * 3 + 5 * 2, 9)),
944 );
945 }
946
947 #[test]
948 fn underlined_character_dimensions() {
949 let style = MonoTextStyleBuilder::new()
950 .font(&SPACED_FONT)
951 .text_color(BinaryColor::On)
952 .underline()
953 .build();
954
955 assert_eq!(
956 Text::with_baseline("#", Point::zero(), style, Baseline::Top).bounding_box(),
957 Rectangle::new(Point::zero(), Size::new(6, 10)),
958 );
959 }
960
961 #[test]
962 fn control_characters() {
963 let style = MonoTextStyle::new(&FONT_6X9, BinaryColor::On);
964
965 let mut display = MockDisplay::new();
966 style
967 .draw_string("A\t\n\rB", Point::zero(), Baseline::Top, &mut display)
968 .unwrap();
969
970 let mut expected = MockDisplay::new();
971 style
972 .draw_string("A???B", Point::zero(), Baseline::Top, &mut expected)
973 .unwrap();
974
975 display.assert_eq(&expected);
976 }
977
978 #[test]
979 fn character_style() {
980 let mut style = MonoTextStyle::new(&FONT_6X9, BinaryColor::On);
981 CharacterStyle::set_text_color(&mut style, None);
982 CharacterStyle::set_background_color(&mut style, Some(BinaryColor::On));
983 CharacterStyle::set_underline_color(&mut style, DecorationColor::TextColor);
984 CharacterStyle::set_strikethrough_color(
985 &mut style,
986 DecorationColor::Custom(BinaryColor::On),
987 );
988
989 assert_eq!(
990 style,
991 MonoTextStyle {
992 text_color: None,
993 background_color: Some(BinaryColor::On),
994 underline_color: DecorationColor::TextColor,
995 strikethrough_color: DecorationColor::Custom(BinaryColor::On),
996 font: &FONT_6X9,
997 }
998 );
999 }
1000
1001 #[test]
1002 fn draw_string_return_value() {
1003 let style = MonoTextStyle::new(&FONT_6X9, BinaryColor::On);
1004 let start = Point::new(10, 20);
1005 let expected_next = start + Point::new(2 * 6, 0);
1006
1007 for baseline in [
1008 Baseline::Top,
1009 Baseline::Middle,
1010 Baseline::Alphabetic,
1011 Baseline::Bottom,
1012 ]
1013 .iter()
1014 {
1015 let mut display = MockDisplay::new();
1016 let next = style
1017 .draw_string("AB", start, *baseline, &mut display)
1018 .unwrap();
1019
1020 assert_eq!(
1021 next, expected_next,
1022 "Unexpected next point for {:?}: {:?} (expected {:?})",
1023 baseline, next, expected_next
1024 );
1025 }
1026 }
1027
1028 #[test]
1029 fn draw_whitespace_return_value() {
1030 let style = MonoTextStyle::new(&FONT_6X9, BinaryColor::On);
1031 let start = Point::new(10, 20);
1032 let expected_next = start + Point::new(15, 0);
1033
1034 for baseline in [
1035 Baseline::Top,
1036 Baseline::Middle,
1037 Baseline::Alphabetic,
1038 Baseline::Bottom,
1039 ]
1040 .iter()
1041 {
1042 let mut display = MockDisplay::new();
1043 let next = style
1044 .draw_whitespace(15, start, *baseline, &mut display)
1045 .unwrap();
1046
1047 assert_eq!(
1048 next, expected_next,
1049 "Unexpected next point for {:?}: {:?} (expected {:?})",
1050 baseline, next, expected_next
1051 );
1052 }
1053 }
1054
1055 #[test]
1056 fn latin1_text_dimensions_one_line() {
1057 let position = Point::new(5, 5);
1058
1059 let style = MonoTextStyleBuilder::<BinaryColor>::new()
1060 .font(&FONT_6X9_LATIN1)
1061 .build();
1062 let text = Text::with_baseline("123°§£", position, style, Baseline::Top);
1063
1064 assert_eq!(
1065 text.bounding_box(),
1066 Rectangle::new(
1067 position,
1068 FONT_6X9_LATIN1
1069 .character_size
1070 .component_mul(Size::new(6, 1))
1071 )
1072 );
1073
1074 let mut display = MockDisplay::new();
1075 let next = text.draw(&mut display).unwrap();
1076
1077 assert_eq!(next, position + FONT_6X9_LATIN1.character_size.x_axis() * 6);
1078 }
1079
1080 #[test]
1081 fn transparent_text_dimensions_one_line() {
1082 let position = Point::new(5, 5);
1083
1084 let style = MonoTextStyleBuilder::<BinaryColor>::new()
1085 .font(&FONT_6X9)
1086 .build();
1087 let text = Text::with_baseline("123", position, style, Baseline::Top);
1088
1089 assert_eq!(
1090 text.bounding_box(),
1091 Rectangle::new(
1092 position,
1093 FONT_6X9.character_size.component_mul(Size::new(3, 1))
1094 )
1095 );
1096
1097 let mut display = MockDisplay::new();
1098 let next = text.draw(&mut display).unwrap();
1099
1100 assert_eq!(next, position + FONT_6X9.character_size.x_axis() * 3);
1101 }
1102
1103 #[test]
1104 fn transparent_text_dimensions_one_line_spaced() {
1105 let position = Point::new(5, 5);
1106
1107 let style = MonoTextStyleBuilder::<BinaryColor>::new()
1108 .font(&SPACED_FONT)
1109 .build();
1110 let text = Text::with_baseline("123", position, style, Baseline::Top);
1111
1112 assert_eq!(
1113 text.bounding_box(),
1114 Rectangle::new(
1115 position,
1116 SPACED_FONT.character_size.component_mul(Size::new(3, 1))
1117 + Size::new(SPACED_FONT.character_spacing, 0) * 2
1118 )
1119 );
1120
1121 let mut display = MockDisplay::new();
1122 let next = text.draw(&mut display).unwrap();
1123
1124 assert_eq!(
1125 next,
1126 position
1127 + (SPACED_FONT.character_size.x_axis()
1128 + Size::new(SPACED_FONT.character_spacing, 0))
1129 * 3
1130 );
1131 }
1132
1133 #[test]
1134 fn transparent_text_dimensions_two_lines() {
1135 let position = Point::new(5, 5);
1136
1137 let style = MonoTextStyleBuilder::<BinaryColor>::new()
1138 .font(&FONT_6X9)
1139 .build();
1140 let text = Text::with_baseline("123\n1", position, style, Baseline::Top);
1141
1142 assert_eq!(
1143 text.bounding_box(),
1144 Rectangle::new(
1145 position,
1146 FONT_6X9.character_size.component_mul(Size::new(3, 2))
1147 )
1148 );
1149
1150 let mut display = MockDisplay::new();
1151 let next = text.draw(&mut display).unwrap();
1152
1153 assert_eq!(next, position + FONT_6X9.character_size);
1154 }
1155
1156 #[test]
1157 fn elements_iter() {
1158 let style = MonoTextStyle::new(&SPACED_FONT, BinaryColor::On);
1159
1160 let mut iter = style.line_elements(Point::new(10, 20), "");
1161 assert_eq!(iter.next(), Some((Point::new(10, 20), LineElement::Done)));
1162
1163 let mut iter = style.line_elements(Point::new(10, 20), "a");
1164 assert_eq!(
1165 iter.next(),
1166 Some((Point::new(10, 20), LineElement::Char('a')))
1167 );
1168 assert_eq!(iter.next(), Some((Point::new(16, 20), LineElement::Done)));
1169
1170 let mut iter = style.line_elements(Point::new(10, 20), "abc");
1171 assert_eq!(
1172 iter.next(),
1173 Some((Point::new(10, 20), LineElement::Char('a')))
1174 );
1175 assert_eq!(
1176 iter.next(),
1177 Some((Point::new(16, 20), LineElement::Spacing))
1178 );
1179 assert_eq!(
1180 iter.next(),
1181 Some((Point::new(21, 20), LineElement::Char('b')))
1182 );
1183 assert_eq!(
1184 iter.next(),
1185 Some((Point::new(27, 20), LineElement::Spacing))
1186 );
1187 assert_eq!(
1188 iter.next(),
1189 Some((Point::new(32, 20), LineElement::Char('c')))
1190 );
1191 assert_eq!(iter.next(), Some((Point::new(38, 20), LineElement::Done)));
1192 }
1193
1194 #[test]
1195 fn builder_change_font() {
1196 let _style = {
1197 let font = MonoFont {
1198 image: ImageRaw::new(&[1, 2, 3], 1),
1199 character_size: Size::new(1, 2),
1200 character_spacing: 0,
1201 baseline: 0,
1202 strikethrough: DecorationDimensions::default_strikethrough(2),
1203 underline: DecorationDimensions::default_underline(2),
1204 glyph_mapping: &mapping::ASCII,
1205 };
1206
1207 let style = MonoTextStyleBuilder::new()
1208 .font(&font)
1209 .text_color(BinaryColor::On)
1210 .build();
1211
1212 // `style` cannot be returned from this block, because if is limited by the lifetime of
1213 // `font`. But it should be possible to return `style2` because `FONT_6X9` is a const.
1214 let style2 = MonoTextStyleBuilder::from(&style).font(&FONT_6X9).build();
1215
1216 style2
1217 };
1218 }
1219}
1220