leyoda/cosmic-text
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use image renderer for iced text widget

Browse source
This commit is contained in:
Jeremy Soller 2022-10-31 12:04:33 -06:00
parent b0ec548a5e
commit d49e8881fd
No known key found for this signature in database
GPG key ID: 87F211AF2BE4C2FE
4 changed files with 74 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

253
examples/editor-libcosmic/src/text_new.rs
View file

@ -1,253 +0,0 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
use cosmic::iced_native::{
{Color, Element, Length, Point, Rectangle, Size, Theme},
layout::{self, Layout},
renderer,
widget::{self, tree, Widget},
};
use cosmic_text::{
Attrs,
AttrsList,
SwashCache,
BufferLine,
Metrics,
};
use std::{
cmp,
sync::Mutex,
time::Instant,
};
pub struct Appearance {
background_color: Option<Color>,
text_color: Color,
}
pub trait StyleSheet {
fn appearance(&self) -> Appearance;
}
impl StyleSheet for Theme {
fn appearance(&self) -> Appearance {
match self {
Theme::Dark => Appearance {
background_color: None,
text_color: Color::from_rgb8(0xFF, 0xFF, 0xFF),
},
Theme::Light => Appearance {
background_color: None,
text_color: Color::from_rgb8(0x00, 0x00, 0x00),
},
}
}
}
pub struct Text {
line: BufferLine<'static>,
metrics: Metrics,
}
impl Text {
pub fn new(string: &str) -> Self {
let instant = Instant::now();
//TODO: make it possible to set attrs
let mut line = BufferLine::new(
string,
AttrsList::new(Attrs::new())
);
//TODO: do we have to immediately shape?
line.shape(&crate::FONT_SYSTEM);
let text = Self {
line,
metrics: Metrics::new(14, 20),
};
log::debug!("Text::new in {:?}", instant.elapsed());
text
}
}
pub fn text(string: &str) -> Text {
Text::new(string)
}
impl<Message, Renderer> Widget<Message, Renderer> for Text
where
Renderer: renderer::Renderer,
Renderer::Theme: StyleSheet,
{
fn tag(&self) -> tree::Tag {
tree::Tag::of::<State>()
}
fn state(&self) -> tree::State {
tree::State::new(State::new())
}
fn width(&self) -> Length {
Length::Shrink
}
fn height(&self) -> Length {
Length::Shrink
}
fn layout(
&self,
_renderer: &Renderer,
limits: &layout::Limits,
) -> layout::Node {
let instant = Instant::now();
let shape = self.line.shape_opt().as_ref().unwrap();
//TODO: can we cache this?
let mut layout_lines = Vec::new();
shape.layout(
self.metrics.font_size,
limits.max().width as i32,
&mut layout_lines,
0,
self.line.wrap_simple()
);
let mut width = 0;
let mut height = 0;
for layout_line in layout_lines {
for glyph in layout_line.glyphs.iter() {
width = cmp::max(width, (glyph.x + glyph.w) as i32 + 1);
}
height += self.metrics.line_height;
}
let size = Size::new(width as f32, height as f32);
log::debug!("layout {:?} in {:?}", size, instant.elapsed());
layout::Node::new(size)
}
fn draw(
&self,
tree: &widget::Tree,
renderer: &mut Renderer,
theme: &Renderer::Theme,
_style: &renderer::Style,
layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) {
let instant = Instant::now();
let state = tree.state.downcast_ref::<State>();
let appearance = theme.appearance();
if let Some(background_color) = appearance.background_color {
renderer.fill_quad(
renderer::Quad {
bounds: layout.bounds(),
border_radius: 0.0,
border_width: 0.0,
border_color: Color::TRANSPARENT,
},
background_color
);
}
let text_color = cosmic_text::Color::rgba(
cmp::max(0, cmp::min(255, (appearance.text_color.r * 255.0) as i32)) as u8,
cmp::max(0, cmp::min(255, (appearance.text_color.g * 255.0) as i32)) as u8,
cmp::max(0, cmp::min(255, (appearance.text_color.b * 255.0) as i32)) as u8,
cmp::max(0, cmp::min(255, (appearance.text_color.a * 255.0) as i32)) as u8,
);
let shape = self.line.shape_opt().as_ref().unwrap();
//TODO: can we cache this?
let mut layout_lines = Vec::new();
shape.layout(
self.metrics.font_size,
layout.bounds().width as i32,
&mut layout_lines,
0,
self.line.wrap_simple()
);
let mut cache = state.cache.lock().unwrap();
let mut line_y = self.metrics.font_size;
for layout_line in layout_lines {
for glyph in layout_line.glyphs.iter() {
let (cache_key, x_int, y_int) = (glyph.cache_key, glyph.x_int, glyph.y_int);
let glyph_color = match glyph.color_opt {
Some(some) => some,
None => text_color,
};
cache.with_pixels(cache_key, glyph_color, |x, y, color| {
let a = color.a();
if a > 0 {
let r = color.r();
let g = color.g();
let b = color.b();
renderer.fill_quad(
renderer::Quad {
bounds: Rectangle::new(
Point::new(
layout.bounds().x + (x_int + x) as f32,
layout.bounds().y + (line_y + y_int + y) as f32
),
Size::new(1.0, 1.0)
),
border_radius: 0.0,
border_width: 0.0,
border_color: Color::TRANSPARENT,
},
Color::from_rgba8(r, g, b, a as f32 / 255.0),
);
}
});
}
line_y += self.metrics.line_height;
}
log::trace!("draw {:?} in {:?}", layout.bounds(), instant.elapsed());
}
}
impl<'a, Message, Renderer> From<Text> for Element<'a, Message, Renderer>
where
Renderer: renderer::Renderer,
Renderer::Theme: StyleSheet,
{
fn from(text: Text) -> Self {
Self::new(text)
}
}
pub struct State {
cache: Mutex<SwashCache<'static>>,
}
impl State {
/// Creates a new [`State`].
pub fn new() -> State {
let instant = Instant::now();
let state = State {
cache: Mutex::new(SwashCache::new(&crate::FONT_SYSTEM)),
};
log::debug!("created state in {:?}", instant.elapsed());
state
}
}