971 lines
29 KiB
Rust
971 lines
29 KiB
Rust
//! Text widgets display information through writing.
|
|
//!
|
|
//! # Example
|
|
//! ```no_run
|
|
//! # mod iced { pub mod widget { pub fn text<T>(t: T) -> iced_core::widget::Text<'static, iced_core::Theme, ()> { unimplemented!() } }
|
|
//! # pub use iced_core::color; }
|
|
//! # pub type State = ();
|
|
//! # pub type Element<'a, Message> = iced_core::Element<'a, Message, iced_core::Theme, ()>;
|
|
//! use iced::widget::text;
|
|
//! use iced::color;
|
|
//!
|
|
//! enum Message {
|
|
//! // ...
|
|
//! }
|
|
//!
|
|
//! fn view(state: &State) -> Element<'_, Message> {
|
|
//! text("Hello, this is iced!")
|
|
//! .size(20)
|
|
//! .color(color!(0x0000ff))
|
|
//! .into()
|
|
//! }
|
|
//! ```
|
|
use crate::alignment;
|
|
use crate::layout;
|
|
use crate::mouse::{self, click};
|
|
use crate::renderer;
|
|
use crate::text;
|
|
use crate::text::paragraph::{self, Paragraph};
|
|
use crate::widget::tree::{self, Tree};
|
|
use crate::{
|
|
Clipboard, Color, Element, Event, Layout, Length, Pixels, Point, Rectangle,
|
|
Shell, Size, Theme, Widget, keyboard, touch,
|
|
};
|
|
|
|
use unicode_segmentation::UnicodeSegmentation;
|
|
|
|
pub use text::{Alignment, Ellipsize, LineHeight, Shaping, Wrapping};
|
|
|
|
/// A bunch of text.
|
|
///
|
|
/// # Example
|
|
/// ```no_run
|
|
/// # mod iced { pub mod widget { pub fn text<T>(t: T) -> iced_core::widget::Text<'static, iced_core::Theme, ()> { unimplemented!() } }
|
|
/// # pub use iced_core::color; }
|
|
/// # pub type State = ();
|
|
/// # pub type Element<'a, Message> = iced_core::Element<'a, Message, iced_core::Theme, ()>;
|
|
/// use iced::widget::text;
|
|
/// use iced::color;
|
|
///
|
|
/// enum Message {
|
|
/// // ...
|
|
/// }
|
|
///
|
|
/// fn view(state: &State) -> Element<'_, Message> {
|
|
/// text("Hello, this is iced!")
|
|
/// .size(20)
|
|
/// .color(color!(0x0000ff))
|
|
/// .into()
|
|
/// }
|
|
/// ```
|
|
pub struct Text<'a, Theme, Renderer>
|
|
where
|
|
Theme: Catalog,
|
|
Renderer: text::Renderer,
|
|
{
|
|
id: crate::widget::Id,
|
|
fragment: text::Fragment<'a>,
|
|
format: Format<Renderer::Font>,
|
|
class: Theme::Class<'a>,
|
|
selectable: bool,
|
|
}
|
|
|
|
impl<'a, Theme, Renderer> Text<'a, Theme, Renderer>
|
|
where
|
|
Theme: Catalog,
|
|
Renderer: text::Renderer,
|
|
{
|
|
/// Create a new fragment of [`Text`] with the given contents.
|
|
pub fn new(fragment: impl text::IntoFragment<'a>) -> Self {
|
|
Text {
|
|
id: crate::widget::Id::unique(),
|
|
fragment: fragment.into_fragment(),
|
|
format: Format::default(),
|
|
class: Theme::default(),
|
|
selectable: false,
|
|
}
|
|
}
|
|
|
|
/// Sets the size of the [`Text`].
|
|
pub fn size(mut self, size: impl Into<Pixels>) -> Self {
|
|
self.format.size = Some(size.into());
|
|
self
|
|
}
|
|
|
|
/// Sets the [`LineHeight`] of the [`Text`].
|
|
pub fn line_height(mut self, line_height: impl Into<LineHeight>) -> Self {
|
|
self.format.line_height = line_height.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the [`Font`] of the [`Text`].
|
|
///
|
|
/// [`Font`]: crate::text::Renderer::Font
|
|
pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
|
|
self.format.font = Some(font.into());
|
|
self
|
|
}
|
|
|
|
/// Sets the [`Font`] of the [`Text`], if `Some`.
|
|
///
|
|
/// [`Font`]: crate::text::Renderer::Font
|
|
pub fn font_maybe(
|
|
mut self,
|
|
font: Option<impl Into<Renderer::Font>>,
|
|
) -> Self {
|
|
self.format.font = font.map(Into::into);
|
|
self
|
|
}
|
|
|
|
/// Sets the width of the [`Text`] boundaries.
|
|
pub fn width(mut self, width: impl Into<Length>) -> Self {
|
|
self.format.width = width.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the height of the [`Text`] boundaries.
|
|
pub fn height(mut self, height: impl Into<Length>) -> Self {
|
|
self.format.height = height.into();
|
|
self
|
|
}
|
|
|
|
/// Centers the [`Text`], both horizontally and vertically.
|
|
pub fn center(self) -> Self {
|
|
self.align_x(alignment::Horizontal::Center)
|
|
.align_y(alignment::Vertical::Center)
|
|
}
|
|
|
|
/// Sets the [`alignment::Horizontal`] of the [`Text`].
|
|
pub fn align_x(mut self, alignment: impl Into<text::Alignment>) -> Self {
|
|
self.format.align_x = alignment.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the [`alignment::Vertical`] of the [`Text`].
|
|
pub fn align_y(
|
|
mut self,
|
|
alignment: impl Into<alignment::Vertical>,
|
|
) -> Self {
|
|
self.format.align_y = alignment.into();
|
|
self
|
|
}
|
|
|
|
/// Sets the [`Shaping`] strategy of the [`Text`].
|
|
pub fn shaping(mut self, shaping: Shaping) -> Self {
|
|
self.format.shaping = shaping;
|
|
self
|
|
}
|
|
|
|
/// Sets the [`Wrapping`] strategy of the [`Text`].
|
|
pub fn wrapping(mut self, wrapping: Wrapping) -> Self {
|
|
self.format.wrapping = wrapping;
|
|
self
|
|
}
|
|
|
|
// Sets the [`Ellipsize`] strategy of the [`Text`].
|
|
pub fn ellipsize(mut self, ellipsize: Ellipsize) -> Self {
|
|
self.format.ellipsize = ellipsize;
|
|
self
|
|
}
|
|
|
|
/// Sets the style of the [`Text`].
|
|
#[must_use]
|
|
pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
|
|
where
|
|
Theme::Class<'a>: From<StyleFn<'a, Theme>>,
|
|
{
|
|
self.class = (Box::new(style) as StyleFn<'a, Theme>).into();
|
|
self
|
|
}
|
|
|
|
/// Sets the [`Color`] of the [`Text`].
|
|
pub fn color(self, color: impl Into<Color>) -> Self
|
|
where
|
|
Theme::Class<'a>: From<StyleFn<'a, Theme>>,
|
|
{
|
|
self.color_maybe(Some(color))
|
|
}
|
|
|
|
/// Sets the [`Color`] of the [`Text`], if `Some`.
|
|
pub fn color_maybe(self, color: Option<impl Into<Color>>) -> Self
|
|
where
|
|
Theme::Class<'a>: From<StyleFn<'a, Theme>>,
|
|
{
|
|
let color = color.map(Into::into);
|
|
|
|
self.style(move |_theme| Style {
|
|
color,
|
|
..Style::default()
|
|
})
|
|
}
|
|
|
|
/// Makes the [`Text`] selectable. When enabled, the user can click and
|
|
/// drag to select text, and copy it with Ctrl+C / Cmd+C.
|
|
pub fn selectable(mut self) -> Self {
|
|
self.selectable = true;
|
|
self
|
|
}
|
|
|
|
/// Sets the style class of the [`Text`].
|
|
#[cfg(feature = "advanced")]
|
|
#[must_use]
|
|
pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
|
|
self.class = class.into();
|
|
self
|
|
}
|
|
}
|
|
|
|
/// The internal state of a [`Text`] widget.
|
|
pub struct State<P: Paragraph> {
|
|
/// The cached paragraph layout.
|
|
pub paragraph: paragraph::Plain<P>,
|
|
/// Lazily allocated when text is selectable and first interacted with.
|
|
selection: Option<Box<SelectionState>>,
|
|
}
|
|
|
|
impl<P: Paragraph> Default for State<P> {
|
|
fn default() -> Self {
|
|
Self {
|
|
paragraph: paragraph::Plain::default(),
|
|
selection: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<P: Paragraph> std::fmt::Debug for State<P> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("State")
|
|
.field("selection", &self.selection)
|
|
.finish_non_exhaustive()
|
|
}
|
|
}
|
|
|
|
impl<P: Paragraph> std::ops::Deref for State<P> {
|
|
type Target = paragraph::Plain<P>;
|
|
|
|
fn deref(&self) -> ¶graph::Plain<P> {
|
|
&self.paragraph
|
|
}
|
|
}
|
|
|
|
impl<P: Paragraph> std::ops::DerefMut for State<P> {
|
|
fn deref_mut(&mut self) -> &mut paragraph::Plain<P> {
|
|
&mut self.paragraph
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Default)]
|
|
struct SelectionState {
|
|
anchor: usize,
|
|
end: usize,
|
|
dragging: bool,
|
|
focused: bool,
|
|
modifiers: keyboard::Modifiers,
|
|
last_click: Option<click::Click>,
|
|
}
|
|
|
|
impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer>
|
|
for Text<'_, Theme, Renderer>
|
|
where
|
|
Theme: Catalog,
|
|
Renderer: text::Renderer,
|
|
{
|
|
fn tag(&self) -> tree::Tag {
|
|
tree::Tag::of::<State<Renderer::Paragraph>>()
|
|
}
|
|
|
|
fn state(&self) -> tree::State {
|
|
tree::State::new(State::<Renderer::Paragraph>::default())
|
|
}
|
|
|
|
fn size(&self) -> Size<Length> {
|
|
Size {
|
|
width: self.format.width,
|
|
height: self.format.height,
|
|
}
|
|
}
|
|
|
|
fn layout(
|
|
&mut self,
|
|
tree: &mut Tree,
|
|
renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
let state = tree.state.downcast_mut::<State<Renderer::Paragraph>>();
|
|
|
|
layout(
|
|
&mut state.paragraph,
|
|
renderer,
|
|
limits,
|
|
&self.fragment,
|
|
self.format,
|
|
)
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
tree: &Tree,
|
|
renderer: &mut Renderer,
|
|
theme: &Theme,
|
|
defaults: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
_cursor_position: mouse::Cursor,
|
|
viewport: &Rectangle,
|
|
) {
|
|
let state = tree.state.downcast_ref::<State<Renderer::Paragraph>>();
|
|
let style = theme.style(&self.class);
|
|
let bounds = layout.bounds();
|
|
let paragraph = state.paragraph.raw();
|
|
if let Some(sel) = &state.selection {
|
|
let left = sel.anchor.min(sel.end);
|
|
let right = sel.anchor.max(sel.end);
|
|
let content: &str = self.fragment.as_ref();
|
|
|
|
if left != right {
|
|
let lo_byte = grapheme_to_byte(content, left);
|
|
let hi_byte = grapheme_to_byte(content, right);
|
|
|
|
let anchor = bounds.anchor(
|
|
paragraph.min_bounds(),
|
|
paragraph.align_x(),
|
|
paragraph.align_y(),
|
|
);
|
|
|
|
let rects = paragraph.highlight(
|
|
0,
|
|
(lo_byte, text::Affinity::After),
|
|
(hi_byte, text::Affinity::Before),
|
|
);
|
|
|
|
for r in rects {
|
|
renderer.fill_quad(
|
|
renderer::Quad {
|
|
bounds: Rectangle {
|
|
x: anchor.x + r.x,
|
|
y: anchor.y + r.y,
|
|
width: r.width,
|
|
height: r.height,
|
|
},
|
|
..renderer::Quad::default()
|
|
},
|
|
style.selected_fill,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
draw(renderer, defaults, bounds, paragraph, style, viewport);
|
|
}
|
|
|
|
fn update(
|
|
&mut self,
|
|
tree: &mut Tree,
|
|
event: &Event,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
_renderer: &Renderer,
|
|
clipboard: &mut dyn Clipboard,
|
|
shell: &mut Shell<'_, Message>,
|
|
_viewport: &Rectangle,
|
|
) {
|
|
if !self.selectable {
|
|
return;
|
|
}
|
|
|
|
let state = tree.state.downcast_mut::<State<Renderer::Paragraph>>();
|
|
let bounds = layout.bounds();
|
|
let content: &str = self.fragment.as_ref();
|
|
let grapheme_count = content.graphemes(true).count();
|
|
let paragraph = state.paragraph.raw();
|
|
|
|
match event {
|
|
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
|
|
| Event::Touch(touch::Event::FingerPressed { .. }) => {
|
|
if let Some(pos) = cursor.position_over(bounds) {
|
|
let sel = state.selection.get_or_insert_with(|| {
|
|
Box::new(SelectionState::default())
|
|
});
|
|
|
|
let anchor = bounds.anchor(
|
|
paragraph.min_bounds(),
|
|
paragraph.align_x(),
|
|
paragraph.align_y(),
|
|
);
|
|
let relative =
|
|
Point::new(pos.x - anchor.x, pos.y - anchor.y);
|
|
|
|
let grapheme_pos =
|
|
hit_to_grapheme(paragraph, relative, content);
|
|
|
|
let new_click = click::Click::new(
|
|
pos,
|
|
mouse::Button::Left,
|
|
sel.last_click.take(),
|
|
);
|
|
|
|
match new_click.kind() {
|
|
click::Kind::Single => {
|
|
if sel.modifiers.shift() {
|
|
sel.end = grapheme_pos;
|
|
} else {
|
|
sel.anchor = grapheme_pos;
|
|
sel.end = grapheme_pos;
|
|
}
|
|
sel.dragging = true;
|
|
}
|
|
click::Kind::Double => {
|
|
sel.anchor =
|
|
previous_start_of_word(content, grapheme_pos);
|
|
sel.end = next_end_of_word(content, grapheme_pos);
|
|
sel.dragging = true;
|
|
}
|
|
click::Kind::Triple => {
|
|
sel.anchor = 0;
|
|
sel.end = grapheme_count;
|
|
sel.dragging = true;
|
|
}
|
|
}
|
|
|
|
sel.last_click = Some(new_click);
|
|
sel.focused = true;
|
|
shell.capture_event();
|
|
} else if let Some(sel) = &mut state.selection {
|
|
sel.focused = false;
|
|
sel.anchor = 0;
|
|
sel.end = 0;
|
|
sel.dragging = false;
|
|
}
|
|
}
|
|
|
|
Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
|
|
| Event::Touch(touch::Event::FingerLifted { .. }) => {
|
|
if let Some(sel) = &mut state.selection {
|
|
sel.dragging = false;
|
|
}
|
|
}
|
|
|
|
Event::Mouse(mouse::Event::CursorMoved { position })
|
|
| Event::Touch(touch::Event::FingerMoved { position, .. }) => {
|
|
if let Some(sel) = &mut state.selection {
|
|
if sel.dragging {
|
|
let anchor = bounds.anchor(
|
|
paragraph.min_bounds(),
|
|
paragraph.align_x(),
|
|
paragraph.align_y(),
|
|
);
|
|
let relative = Point::new(
|
|
position.x - anchor.x,
|
|
position.y - anchor.y,
|
|
);
|
|
|
|
sel.end = hit_to_grapheme(paragraph, relative, content);
|
|
shell.capture_event();
|
|
}
|
|
}
|
|
}
|
|
|
|
Event::Keyboard(keyboard::Event::KeyPressed {
|
|
key,
|
|
modifiers,
|
|
physical_key,
|
|
text: _,
|
|
..
|
|
}) => {
|
|
let focused =
|
|
state.selection.as_ref().is_some_and(|s| s.focused);
|
|
if !focused {
|
|
return;
|
|
}
|
|
let sel = state.selection.as_mut().unwrap();
|
|
|
|
if modifiers.command() {
|
|
match key.to_latin(*physical_key) {
|
|
Some('c') => {
|
|
let left = sel.anchor.min(sel.end);
|
|
let right = sel.anchor.max(sel.end);
|
|
if left != right {
|
|
let selected: String = content
|
|
.graphemes(true)
|
|
.skip(left)
|
|
.take(right - left)
|
|
.collect();
|
|
clipboard.write(
|
|
crate::clipboard::Kind::Standard,
|
|
selected,
|
|
);
|
|
}
|
|
shell.capture_event();
|
|
return;
|
|
}
|
|
Some('a') => {
|
|
sel.anchor = 0;
|
|
sel.end = grapheme_count;
|
|
shell.capture_event();
|
|
return;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
match key {
|
|
keyboard::Key::Named(keyboard::key::Named::ArrowLeft) => {
|
|
let by_word = is_jump_modifier(*modifiers);
|
|
if modifiers.shift() {
|
|
sel.end = if by_word {
|
|
previous_start_of_word(content, sel.end)
|
|
} else {
|
|
sel.end.saturating_sub(1)
|
|
};
|
|
} else {
|
|
let left = sel.anchor.min(sel.end);
|
|
let pos = if by_word {
|
|
previous_start_of_word(content, left)
|
|
} else {
|
|
left.saturating_sub(1)
|
|
};
|
|
sel.anchor = pos;
|
|
sel.end = pos;
|
|
}
|
|
shell.capture_event();
|
|
}
|
|
keyboard::Key::Named(keyboard::key::Named::ArrowRight) => {
|
|
let by_word = is_jump_modifier(*modifiers);
|
|
if modifiers.shift() {
|
|
sel.end = if by_word {
|
|
next_end_of_word(content, sel.end)
|
|
} else {
|
|
(sel.end + 1).min(grapheme_count)
|
|
};
|
|
} else {
|
|
let right = sel.anchor.max(sel.end);
|
|
let pos = if by_word {
|
|
next_end_of_word(content, right)
|
|
} else {
|
|
(right + 1).min(grapheme_count)
|
|
};
|
|
sel.anchor = pos;
|
|
sel.end = pos;
|
|
}
|
|
shell.capture_event();
|
|
}
|
|
keyboard::Key::Named(keyboard::key::Named::Home) => {
|
|
if modifiers.shift() {
|
|
sel.end = 0;
|
|
} else {
|
|
sel.anchor = 0;
|
|
sel.end = 0;
|
|
}
|
|
shell.capture_event();
|
|
}
|
|
keyboard::Key::Named(keyboard::key::Named::End) => {
|
|
if modifiers.shift() {
|
|
sel.end = grapheme_count;
|
|
} else {
|
|
sel.anchor = grapheme_count;
|
|
sel.end = grapheme_count;
|
|
}
|
|
shell.capture_event();
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
Event::Keyboard(keyboard::Event::ModifiersChanged(modifiers)) => {
|
|
if let Some(sel) = &mut state.selection {
|
|
sel.modifiers = *modifiers;
|
|
}
|
|
}
|
|
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
fn mouse_interaction(
|
|
&self,
|
|
_tree: &Tree,
|
|
layout: Layout<'_>,
|
|
cursor: mouse::Cursor,
|
|
_viewport: &Rectangle,
|
|
_renderer: &Renderer,
|
|
) -> mouse::Interaction {
|
|
if self.selectable && cursor.is_over(layout.bounds()) {
|
|
mouse::Interaction::Text
|
|
} else {
|
|
mouse::Interaction::None
|
|
}
|
|
}
|
|
|
|
fn operate(
|
|
&mut self,
|
|
_tree: &mut Tree,
|
|
layout: Layout<'_>,
|
|
_renderer: &Renderer,
|
|
operation: &mut dyn super::Operation,
|
|
) {
|
|
operation.text(None, layout.bounds(), &self.fragment);
|
|
}
|
|
|
|
#[cfg(feature = "a11y")]
|
|
fn a11y_nodes(
|
|
&self,
|
|
layout: Layout<'_>,
|
|
_state: &Tree,
|
|
_: mouse::Cursor,
|
|
) -> iced_accessibility::A11yTree {
|
|
use iced_accessibility::{
|
|
A11yTree,
|
|
accesskit::{Live, Node, Rect, Role},
|
|
};
|
|
|
|
let Rectangle {
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
} = layout.bounds();
|
|
let bounds = Rect::new(
|
|
x as f64,
|
|
y as f64,
|
|
(x + width) as f64,
|
|
(y + height) as f64,
|
|
);
|
|
|
|
let mut node = Node::new(Role::Paragraph);
|
|
|
|
// TODO is the name likely different from the content?
|
|
node.set_label(self.fragment.to_string().into_boxed_str());
|
|
node.set_bounds(bounds);
|
|
|
|
// TODO make this configurable
|
|
node.set_live(Live::Polite);
|
|
A11yTree::leaf(node, self.id.clone())
|
|
}
|
|
|
|
fn id(&self) -> Option<crate::widget::Id> {
|
|
Some(self.id.clone())
|
|
}
|
|
|
|
fn set_id(&mut self, id: crate::widget::Id) {
|
|
self.id = id;
|
|
}
|
|
}
|
|
|
|
/// The format of some [`Text`].
|
|
///
|
|
/// Check out the methods of the [`Text`] widget
|
|
/// to learn more about each field.
|
|
#[derive(Debug, Clone, Copy)]
|
|
#[allow(missing_docs)]
|
|
pub struct Format<Font> {
|
|
pub width: Length,
|
|
pub height: Length,
|
|
pub size: Option<Pixels>,
|
|
pub font: Option<Font>,
|
|
pub line_height: LineHeight,
|
|
pub align_x: text::Alignment,
|
|
pub align_y: alignment::Vertical,
|
|
pub shaping: Shaping,
|
|
pub wrapping: Wrapping,
|
|
pub ellipsize: Ellipsize,
|
|
}
|
|
|
|
impl<Font> Default for Format<Font> {
|
|
fn default() -> Self {
|
|
Self {
|
|
size: None,
|
|
line_height: LineHeight::default(),
|
|
font: None,
|
|
width: Length::Shrink,
|
|
height: Length::Shrink,
|
|
align_x: text::Alignment::Default,
|
|
align_y: alignment::Vertical::Top,
|
|
shaping: Shaping::default(),
|
|
wrapping: Wrapping::default(),
|
|
ellipsize: Ellipsize::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Produces the [`layout::Node`] of a [`Text`] widget.
|
|
pub fn layout<Renderer>(
|
|
paragraph: &mut paragraph::Plain<Renderer::Paragraph>,
|
|
renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
content: &str,
|
|
format: Format<Renderer::Font>,
|
|
) -> layout::Node
|
|
where
|
|
Renderer: text::Renderer,
|
|
{
|
|
layout::sized(limits, format.width, format.height, |limits| {
|
|
let bounds = limits.max();
|
|
|
|
let size = format.size.unwrap_or_else(|| renderer.default_size());
|
|
let font = format.font.unwrap_or_else(|| renderer.default_font());
|
|
|
|
let _ = paragraph.update(text::Text {
|
|
content,
|
|
bounds,
|
|
size,
|
|
line_height: format.line_height,
|
|
font,
|
|
align_x: format.align_x,
|
|
align_y: format.align_y,
|
|
shaping: format.shaping,
|
|
wrapping: format.wrapping,
|
|
ellipsize: format.ellipsize,
|
|
});
|
|
|
|
paragraph.min_bounds()
|
|
})
|
|
}
|
|
|
|
/// Draws text using the same logic as the [`Text`] widget.
|
|
pub fn draw<Renderer>(
|
|
renderer: &mut Renderer,
|
|
style: &renderer::Style,
|
|
bounds: Rectangle,
|
|
paragraph: &Renderer::Paragraph,
|
|
appearance: Style,
|
|
viewport: &Rectangle,
|
|
) where
|
|
Renderer: text::Renderer,
|
|
{
|
|
let anchor = bounds.anchor(
|
|
paragraph.min_bounds(),
|
|
paragraph.align_x(),
|
|
paragraph.align_y(),
|
|
);
|
|
|
|
renderer.fill_paragraph(
|
|
paragraph,
|
|
anchor,
|
|
appearance.color.unwrap_or(style.text_color),
|
|
*viewport,
|
|
);
|
|
}
|
|
|
|
impl<'a, Message, Theme, Renderer> From<Text<'a, Theme, Renderer>>
|
|
for Element<'a, Message, Theme, Renderer>
|
|
where
|
|
Theme: Catalog + 'a,
|
|
Renderer: text::Renderer + 'a,
|
|
{
|
|
fn from(
|
|
text: Text<'a, Theme, Renderer>,
|
|
) -> Element<'a, Message, Theme, Renderer> {
|
|
Element::new(text)
|
|
}
|
|
}
|
|
|
|
// impl<'a, Theme, Renderer> Clone for Text<'a, Theme, Renderer>
|
|
// where
|
|
// Renderer: text::Renderer,
|
|
// {
|
|
// fn clone(&self) -> Self {
|
|
// Self {
|
|
// id: self.id.clone(),
|
|
// content: self.content.clone(),
|
|
// size: self.size,
|
|
// line_height: self.line_height,
|
|
// width: self.width,
|
|
// height: self.height,
|
|
// horizontal_alignment: self.horizontal_alignment,
|
|
// vertical_alignment: self.vertical_alignment,
|
|
// font: self.font,
|
|
// style: self.style,
|
|
// shaping: self.shaping,
|
|
// wrap: self.wrap,
|
|
// }
|
|
// }
|
|
// }
|
|
// TODO(POP): Clone no longer can be implemented because of style being a Box(style)
|
|
|
|
impl<'a, Theme, Renderer> From<&'a str> for Text<'a, Theme, Renderer>
|
|
where
|
|
Theme: Catalog + 'a,
|
|
Renderer: text::Renderer,
|
|
{
|
|
fn from(content: &'a str) -> Self {
|
|
Self::new(content)
|
|
}
|
|
}
|
|
|
|
impl<'a, Message, Theme, Renderer> From<&'a str>
|
|
for Element<'a, Message, Theme, Renderer>
|
|
where
|
|
Theme: Catalog + 'a,
|
|
Renderer: text::Renderer + 'a,
|
|
{
|
|
fn from(content: &'a str) -> Self {
|
|
Text::from(content).into()
|
|
}
|
|
}
|
|
|
|
/// The appearance of some text.
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub struct Style {
|
|
/// The [`Color`] of the text.
|
|
///
|
|
/// The default, `None`, means using the inherited color.
|
|
pub color: Option<Color>,
|
|
/// The fill [`Color`] of the selection highlight.
|
|
pub selected_fill: Color,
|
|
}
|
|
|
|
impl Default for Style {
|
|
fn default() -> Self {
|
|
Self {
|
|
color: None,
|
|
selected_fill: DEFAULT_SELECTION_COLOR,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The theme catalog of a [`Text`].
|
|
pub trait Catalog: Sized {
|
|
/// The item class of this [`Catalog`].
|
|
type Class<'a>;
|
|
|
|
/// The default class produced by this [`Catalog`].
|
|
fn default<'a>() -> Self::Class<'a>;
|
|
|
|
/// The [`Style`] of a class with the given status.
|
|
fn style(&self, item: &Self::Class<'_>) -> Style;
|
|
}
|
|
|
|
/// A styling function for a [`Text`].
|
|
///
|
|
/// This is just a boxed closure: `Fn(&Theme, Status) -> Style`.
|
|
pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
|
|
|
|
impl Catalog for Theme {
|
|
type Class<'a> = StyleFn<'a, Self>;
|
|
|
|
fn default<'a>() -> Self::Class<'a> {
|
|
Box::new(|_theme| Style::default())
|
|
}
|
|
|
|
fn style(&self, class: &Self::Class<'_>) -> Style {
|
|
class(self)
|
|
}
|
|
}
|
|
|
|
/// The default text styling; color is inherited.
|
|
pub fn default(_theme: &Theme) -> Style {
|
|
Style::default()
|
|
}
|
|
|
|
/// Text with the default base color.
|
|
pub fn base(theme: &Theme) -> Style {
|
|
Style {
|
|
color: Some(theme.palette().text),
|
|
..Style::default()
|
|
}
|
|
}
|
|
|
|
/// Text conveying some important information, like an action.
|
|
pub fn primary(theme: &Theme) -> Style {
|
|
Style {
|
|
color: Some(theme.palette().primary),
|
|
..Style::default()
|
|
}
|
|
}
|
|
|
|
/// Text conveying some secondary information, like a footnote.
|
|
pub fn secondary(theme: &Theme) -> Style {
|
|
Style {
|
|
color: Some(theme.extended_palette().secondary.base.color),
|
|
..Style::default()
|
|
}
|
|
}
|
|
|
|
/// Text conveying some positive information, like a successful event.
|
|
pub fn success(theme: &Theme) -> Style {
|
|
Style {
|
|
color: Some(theme.palette().success),
|
|
..Style::default()
|
|
}
|
|
}
|
|
|
|
/// Text conveying some mildly negative information, like a warning.
|
|
pub fn warning(theme: &Theme) -> Style {
|
|
Style {
|
|
color: Some(theme.palette().warning),
|
|
..Style::default()
|
|
}
|
|
}
|
|
|
|
/// Text conveying some negative information, like an error.
|
|
pub fn danger(theme: &Theme) -> Style {
|
|
Style {
|
|
color: Some(theme.palette().danger),
|
|
..Style::default()
|
|
}
|
|
}
|
|
|
|
const DEFAULT_SELECTION_COLOR: Color = Color {
|
|
r: 0.0,
|
|
g: 0.47,
|
|
b: 0.84,
|
|
a: 0.3,
|
|
};
|
|
|
|
fn grapheme_to_byte(content: &str, grapheme_index: usize) -> usize {
|
|
content
|
|
.graphemes(true)
|
|
.take(grapheme_index)
|
|
.map(|g| g.len())
|
|
.sum()
|
|
}
|
|
|
|
fn hit_to_grapheme<P: Paragraph>(
|
|
paragraph: &P,
|
|
point: Point,
|
|
content: &str,
|
|
) -> usize {
|
|
match paragraph.hit_test(point) {
|
|
Some(hit) => {
|
|
let byte_offset = hit.cursor().min(content.len());
|
|
content[..byte_offset].graphemes(true).count()
|
|
}
|
|
None => content.graphemes(true).count(),
|
|
}
|
|
}
|
|
|
|
fn previous_start_of_word(content: &str, grapheme_index: usize) -> usize {
|
|
let graphemes: Vec<&str> = content.graphemes(true).collect();
|
|
let clamped = grapheme_index.min(graphemes.len());
|
|
let before: String = graphemes[..clamped].concat();
|
|
|
|
UnicodeSegmentation::split_word_bound_indices(&*before)
|
|
.filter(|(_, word)| !word.trim_start().is_empty())
|
|
.next_back()
|
|
.map_or(0, |(i, prev_word)| {
|
|
clamped
|
|
- prev_word.graphemes(true).count()
|
|
- before[i + prev_word.len()..].graphemes(true).count()
|
|
})
|
|
}
|
|
|
|
fn next_end_of_word(content: &str, grapheme_index: usize) -> usize {
|
|
let graphemes: Vec<&str> = content.graphemes(true).collect();
|
|
let clamped = grapheme_index.min(graphemes.len());
|
|
let after: String = graphemes[clamped..].concat();
|
|
|
|
UnicodeSegmentation::split_word_bound_indices(&*after)
|
|
.find(|(_, word)| !word.trim_start().is_empty())
|
|
.map_or(graphemes.len(), |(i, next_word)| {
|
|
clamped
|
|
+ next_word.graphemes(true).count()
|
|
+ after[..i].graphemes(true).count()
|
|
})
|
|
}
|
|
|
|
fn is_jump_modifier(modifiers: keyboard::Modifiers) -> bool {
|
|
if cfg!(target_os = "macos") {
|
|
modifiers.alt()
|
|
} else {
|
|
modifiers.control()
|
|
}
|
|
}
|