use std::cell::RefCell;
use std::rc::Rc;
use crate::text_builder::{
empty_render_info, layout_text, layout_text_vector, Anchor, LayoutParams, LineHeight,
TextAlign, TextRenderInfo,
};
use crate::vector_font::VectorFont;
pub fn layout_defaults() -> LayoutParams {
LayoutParams::default()
}
pub trait OpacitySink {
fn set_opacity_at(&mut self, member_id: usize, opacity: f64);
}
pub struct Text {
pub color: [f64; 3],
opacity: f64,
needs_sync: bool,
text_render_info: Option<TextRenderInfo>,
batched_text: Option<Rc<RefCell<dyn OpacitySink>>>,
member_id: Option<usize>,
vector_mode: bool,
vector_font: Option<Rc<VectorFont>>,
params: LayoutParams,
layouts_performed: u64,
}
impl Default for Text {
fn default() -> Self {
Text::new()
}
}
impl Text {
pub fn new() -> Self {
Text {
color: [1.0, 1.0, 1.0],
opacity: 1.0,
needs_sync: true,
text_render_info: None,
batched_text: None,
member_id: None,
vector_mode: false,
vector_font: None,
params: LayoutParams::default(),
layouts_performed: 0,
}
}
pub fn text(&self) -> &str {
&self.params.text
}
pub fn set_text(&mut self, value: impl Into<String>) {
let value = value.into();
if self.params.text != value {
self.params.text = value;
self.needs_sync = true;
}
}
pub fn font_size(&self) -> f64 {
self.params.font_size
}
pub fn set_font_size(&mut self, value: f64) {
if self.params.font_size != value {
self.params.font_size = value;
self.needs_sync = true;
}
}
pub fn font_family(&self) -> &str {
&self.params.font_family
}
pub fn set_font_family(&mut self, value: impl Into<String>) {
let value = value.into();
if self.params.font_family != value {
self.params.font_family = value;
self.needs_sync = true;
}
}
pub fn font_weight(&self) -> &str {
&self.params.font_weight
}
pub fn set_font_weight(&mut self, value: impl Into<String>) {
let value = value.into();
if self.params.font_weight != value {
self.params.font_weight = value;
self.needs_sync = true;
}
}
pub fn font_style(&self) -> &str {
&self.params.font_style
}
pub fn set_font_style(&mut self, value: impl Into<String>) {
let value = value.into();
if self.params.font_style != value {
self.params.font_style = value;
self.needs_sync = true;
}
}
pub fn letter_spacing(&self) -> f64 {
self.params.letter_spacing
}
pub fn set_letter_spacing(&mut self, value: f64) {
if self.params.letter_spacing != value {
self.params.letter_spacing = value;
self.needs_sync = true;
}
}
pub fn line_height(&self) -> LineHeight {
self.params.line_height
}
pub fn set_line_height(&mut self, value: LineHeight) {
if self.params.line_height != value {
self.params.line_height = value;
self.needs_sync = true;
}
}
pub fn anchor_x(&self) -> &Anchor {
&self.params.anchor_x
}
pub fn set_anchor_x(&mut self, value: Anchor) {
if self.params.anchor_x != value {
self.params.anchor_x = value;
self.needs_sync = true;
}
}
pub fn anchor_y(&self) -> &Anchor {
&self.params.anchor_y
}
pub fn set_anchor_y(&mut self, value: Anchor) {
if self.params.anchor_y != value {
self.params.anchor_y = value;
self.needs_sync = true;
}
}
pub fn text_align(&self) -> TextAlign {
self.params.text_align
}
pub fn set_text_align(&mut self, value: TextAlign) {
if self.params.text_align != value {
self.params.text_align = value;
self.needs_sync = true;
}
}
pub fn max_width(&self) -> f64 {
self.params.max_width
}
pub fn set_max_width(&mut self, value: f64) {
if self.params.max_width != value {
self.params.max_width = value;
self.needs_sync = true;
}
}
pub fn text_render_info(&self) -> Option<&TextRenderInfo> {
self.text_render_info.as_ref()
}
#[doc(hidden)]
pub fn needs_sync(&self) -> bool {
self.needs_sync
}
pub(crate) fn mark_needs_sync(&mut self) {
self.needs_sync = true;
}
#[doc(hidden)]
pub fn layouts_performed(&self) -> u64 {
self.layouts_performed
}
pub fn opacity(&self) -> f64 {
self.opacity
}
pub fn set_opacity(&mut self, value: f64) {
if self.opacity == value {
return;
}
self.opacity = value;
if let (Some(batch), Some(member_id)) = (self.batched_text.as_ref(), self.member_id) {
batch.borrow_mut().set_opacity_at(member_id, value);
}
}
#[doc(hidden)]
pub fn attach_to_batch(&mut self, batch: Rc<RefCell<dyn OpacitySink>>, member_id: usize) {
self.batched_text = Some(batch);
self.member_id = Some(member_id);
}
#[doc(hidden)]
pub fn detach_from_batch(&mut self) {
self.batched_text = None;
self.member_id = None;
}
pub fn member_id(&self) -> Option<usize> {
self.member_id
}
pub fn set_vector_mode(&mut self, on: bool) {
self.vector_mode = on;
}
pub fn vector_mode(&self) -> bool {
self.vector_mode
}
pub fn set_vector_font(&mut self, font: Option<Rc<VectorFont>>) {
self.vector_font = font;
}
pub fn sync(&mut self) -> &TextRenderInfo {
#[allow(clippy::unnecessary_unwrap)]
if !self.needs_sync && self.text_render_info.is_some() {
return self
.text_render_info
.as_ref()
.expect("sdf-text: text_render_info.is_some() was just checked");
}
let params = self.params.clone();
if self.vector_mode {
match self.vector_font.clone() {
None => {
self.text_render_info = Some(empty_render_info(params));
return self
.text_render_info
.as_ref()
.expect("sdf-text: text_render_info was set on the line above");
}
Some(font) => {
self.text_render_info = Some(layout_text_vector(params, Some(&font)));
}
}
} else {
self.text_render_info = Some(layout_text(params));
}
self.layouts_performed += 1;
self.needs_sync = false;
self.text_render_info
.as_ref()
.expect("sdf-text: text_render_info was set by the branch above")
}
}