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

resolve all lints, update MSRV

Browse source
This commit is contained in:
dsgallups 2025-01-22 16:29:02 -05:00 • committed by Jeremy Soller
parent 166b59f560
commit f05a69a9d9
18 changed files with 251 additions and 283 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.toml
View file

@ -7,7 +7,7 @@ edition = "2021"
license = "MIT OR Apache-2.0" license = "MIT OR Apache-2.0"
documentation = "https://docs.rs/cosmic-text/latest/cosmic_text/" documentation = "https://docs.rs/cosmic-text/latest/cosmic_text/"
repository = "https://github.com/pop-os/cosmic-text" repository = "https://github.com/pop-os/cosmic-text"
rust-version = "1.65" rust-version = "1.66"
[dependencies] [dependencies]
bitflags = "2.4.1" bitflags = "2.4.1"

356
examples/rich-text/src/main.rs
View file

@ -19,7 +19,7 @@ use winit::{
window::WindowBuilder, window::WindowBuilder,
}; };
fn set_buffer_text<'a>(buffer: &mut BorrowedWithFontSystem<'a, Buffer>) { fn set_buffer_text(buffer: &mut BorrowedWithFontSystem<'_, Buffer>) {
let attrs = Attrs::new(); let attrs = Attrs::new();
let serif_attrs = attrs.family(Family::Serif); let serif_attrs = attrs.family(Family::Serif);
let mono_attrs = attrs.family(Family::Monospace); let mono_attrs = attrs.family(Family::Monospace);
@ -126,7 +126,7 @@ fn main() {
Some(window.inner_size().height as f32), Some(window.inner_size().height as f32),
) )
}); });
editor.with_buffer_mut(|buffer| set_buffer_text(buffer)); editor.with_buffer_mut(set_buffer_text);
let mut ctrl_pressed = false; let mut ctrl_pressed = false;
let mut mouse_x = 0.0; let mut mouse_x = 0.0;
@ -144,207 +144,195 @@ fn main() {
.run(|event, elwt| { .run(|event, elwt| {
elwt.set_control_flow(ControlFlow::Wait); elwt.set_control_flow(ControlFlow::Wait);
let Event::WindowEvent { window_id, event } = event else {
return;
};
match event { match event {
Event::WindowEvent { window_id, event } => { WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
match event { log::info!("Updated scale factor for {window_id:?}");
WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
log::info!("Updated scale factor for {window_id:?}");
display_scale = scale_factor as f32; display_scale = scale_factor as f32;
editor.with_buffer_mut(|buffer| { editor
buffer.set_metrics(metrics.scale(display_scale)) .with_buffer_mut(|buffer| buffer.set_metrics(metrics.scale(display_scale)));
});
window.request_redraw(); window.request_redraw();
} }
WindowEvent::RedrawRequested => { WindowEvent::RedrawRequested => {
let (width, height) = { let (width, height) = {
let size = window.inner_size(); let size = window.inner_size();
(size.width, size.height) (size.width, size.height)
}; };
surface surface
.resize( .resize(
NonZeroU32::new(width).unwrap(), NonZeroU32::new(width).unwrap(),
NonZeroU32::new(height).unwrap(), NonZeroU32::new(height).unwrap(),
) )
.unwrap(); .unwrap();
let mut surface_buffer = surface.buffer_mut().unwrap(); let mut surface_buffer = surface.buffer_mut().unwrap();
let surface_buffer_u8 = unsafe { let surface_buffer_u8 = unsafe {
slice::from_raw_parts_mut( slice::from_raw_parts_mut(
surface_buffer.as_mut_ptr() as *mut u8, surface_buffer.as_mut_ptr() as *mut u8,
surface_buffer.len() * 4, surface_buffer.len() * 4,
) )
}; };
let mut pixmap = let mut pixmap =
PixmapMut::from_bytes(surface_buffer_u8, width, height).unwrap(); PixmapMut::from_bytes(surface_buffer_u8, width, height).unwrap();
pixmap.fill(bg_color); pixmap.fill(bg_color);
editor.with_buffer_mut(|buffer| { editor.with_buffer_mut(|buffer| {
buffer.set_size(Some(width as f32), Some(height as f32)) buffer.set_size(Some(width as f32), Some(height as f32))
}); });
let mut paint = Paint::default(); let mut paint = Paint {
paint.anti_alias = false; anti_alias: false,
editor.shape_as_needed(true); ..Default::default()
};
editor.shape_as_needed(true);
editor.draw( editor.draw(
&mut swash_cache, &mut swash_cache,
font_color, font_color,
cursor_color, cursor_color,
selection_color, selection_color,
selected_text_color, selected_text_color,
|x, y, w, h, color| { |x, y, w, h, color| {
// Note: due to softbuffer and tiny_skia having incompatible internal color representations we swap // Note: due to softbuffer and tiny_skia having incompatible internal color representations we swap
// the red and blue channels here // the red and blue channels here
paint.set_color_rgba8( paint.set_color_rgba8(color.b(), color.g(), color.r(), color.a());
color.b(), pixmap.fill_rect(
color.g(), Rect::from_xywh(x as f32, y as f32, w as f32, h as f32).unwrap(),
color.r(), &paint,
color.a(), Transform::identity(),
); None,
pixmap.fill_rect(
Rect::from_xywh(x as f32, y as f32, w as f32, h as f32)
.unwrap(),
&paint,
Transform::identity(),
None,
);
},
); );
},
);
surface_buffer.present().unwrap(); surface_buffer.present().unwrap();
} }
WindowEvent::ModifiersChanged(modifiers) => { WindowEvent::ModifiersChanged(modifiers) => {
ctrl_pressed = modifiers.state().control_key() ctrl_pressed = modifiers.state().control_key()
} }
WindowEvent::KeyboardInput { event, .. } => { WindowEvent::KeyboardInput { event, .. } => {
let KeyEvent { let KeyEvent {
logical_key, state, .. logical_key, state, ..
} = event; } = event;
if state.is_pressed() { if state.is_pressed() {
match logical_key { match logical_key {
Key::Named(NamedKey::ArrowLeft) => { Key::Named(NamedKey::ArrowLeft) => {
editor.action(Action::Motion(Motion::Left)) editor.action(Action::Motion(Motion::Left))
}
Key::Named(NamedKey::ArrowRight) => {
editor.action(Action::Motion(Motion::Right))
}
Key::Named(NamedKey::ArrowUp) => {
editor.action(Action::Motion(Motion::Up))
}
Key::Named(NamedKey::ArrowDown) => {
editor.action(Action::Motion(Motion::Down))
}
Key::Named(NamedKey::Home) => {
editor.action(Action::Motion(Motion::Home))
}
Key::Named(NamedKey::End) => {
editor.action(Action::Motion(Motion::End))
}
Key::Named(NamedKey::PageUp) => {
editor.action(Action::Motion(Motion::PageUp))
}
Key::Named(NamedKey::PageDown) => {
editor.action(Action::Motion(Motion::PageDown))
}
Key::Named(NamedKey::Escape) => editor.action(Action::Escape),
Key::Named(NamedKey::Enter) => editor.action(Action::Enter),
Key::Named(NamedKey::Backspace) => {
editor.action(Action::Backspace)
}
Key::Named(NamedKey::Delete) => editor.action(Action::Delete),
Key::Named(key) => {
if let Some(text) = key.to_text() {
for c in text.chars() {
editor.action(Action::Insert(c));
}
}
}
Key::Character(text) => {
if !ctrl_pressed {
for c in text.chars() {
editor.action(Action::Insert(c));
}
}
}
_ => {}
}
window.request_redraw();
} }
} Key::Named(NamedKey::ArrowRight) => {
WindowEvent::CursorMoved { editor.action(Action::Motion(Motion::Right))
device_id: _,
position,
} => {
// Update saved mouse position for use when handling click events
mouse_x = position.x;
mouse_y = position.y;
// Implement dragging
if mouse_left.is_pressed() {
// Execute Drag editor action (update selection)
editor.action(Action::Drag {
x: position.x as i32,
y: position.y as i32,
});
// Scroll if cursor is near edge of window while dragging
if mouse_y <= 5.0 {
editor.action(Action::Scroll { lines: -1 });
} else if mouse_y - 5.0 >= window.inner_size().height as f64 {
editor.action(Action::Scroll { lines: 1 });
}
window.request_redraw();
} }
} Key::Named(NamedKey::ArrowUp) => {
WindowEvent::MouseInput { editor.action(Action::Motion(Motion::Up))
device_id: _,
state,
button,
} => {
if button == MouseButton::Left {
if state == ElementState::Pressed
&& mouse_left == ElementState::Released
{
editor.action(Action::Click {
x: mouse_x /*- line_x*/ as i32,
y: mouse_y as i32,
});
window.request_redraw();
}
mouse_left = state;
} }
} Key::Named(NamedKey::ArrowDown) => {
WindowEvent::MouseWheel { editor.action(Action::Motion(Motion::Down))
device_id: _,
delta,
phase: _,
} => {
let line_delta = match delta {
MouseScrollDelta::LineDelta(_x, y) => y as i32,
MouseScrollDelta::PixelDelta(PhysicalPosition { x: _, y }) => {
unapplied_scroll_delta += y;
let line_delta = (unapplied_scroll_delta / 20.0).floor();
unapplied_scroll_delta -= line_delta * 20.0;
line_delta as i32
}
};
if line_delta != 0 {
editor.action(Action::Scroll { lines: -line_delta });
} }
Key::Named(NamedKey::Home) => {
editor.action(Action::Motion(Motion::Home))
}
Key::Named(NamedKey::End) => editor.action(Action::Motion(Motion::End)),
Key::Named(NamedKey::PageUp) => {
editor.action(Action::Motion(Motion::PageUp))
}
Key::Named(NamedKey::PageDown) => {
editor.action(Action::Motion(Motion::PageDown))
}
Key::Named(NamedKey::Escape) => editor.action(Action::Escape),
Key::Named(NamedKey::Enter) => editor.action(Action::Enter),
Key::Named(NamedKey::Backspace) => editor.action(Action::Backspace),
Key::Named(NamedKey::Delete) => editor.action(Action::Delete),
Key::Named(key) => {
if let Some(text) = key.to_text() {
for c in text.chars() {
editor.action(Action::Insert(c));
}
}
}
Key::Character(text) => {
if !ctrl_pressed {
for c in text.chars() {
editor.action(Action::Insert(c));
}
}
}
_ => {}
}
window.request_redraw();
}
}
WindowEvent::CursorMoved {
device_id: _,
position,
} => {
// Update saved mouse position for use when handling click events
mouse_x = position.x;
mouse_y = position.y;
// Implement dragging
if mouse_left.is_pressed() {
// Execute Drag editor action (update selection)
editor.action(Action::Drag {
x: position.x as i32,
y: position.y as i32,
});
// Scroll if cursor is near edge of window while dragging
if mouse_y <= 5.0 {
editor.action(Action::Scroll { lines: -1 });
} else if mouse_y - 5.0 >= window.inner_size().height as f64 {
editor.action(Action::Scroll { lines: 1 });
}
window.request_redraw();
}
}
WindowEvent::MouseInput {
device_id: _,
state,
button,
} => {
if button == MouseButton::Left {
if state == ElementState::Pressed && mouse_left == ElementState::Released {
editor.action(Action::Click {
x: mouse_x /*- line_x*/ as i32,
y: mouse_y as i32,
});
window.request_redraw(); window.request_redraw();
} }
WindowEvent::CloseRequested => { mouse_left = state;
//TODO: just close one window
elwt.exit();
}
_ => {}
} }
} }
WindowEvent::MouseWheel {
device_id: _,
delta,
phase: _,
} => {
let line_delta = match delta {
MouseScrollDelta::LineDelta(_x, y) => y as i32,
MouseScrollDelta::PixelDelta(PhysicalPosition { x: _, y }) => {
unapplied_scroll_delta += y;
let line_delta = (unapplied_scroll_delta / 20.0).floor();
unapplied_scroll_delta -= line_delta * 20.0;
line_delta as i32
}
};
if line_delta != 0 {
editor.action(Action::Scroll { lines: -line_delta });
}
window.request_redraw();
}
WindowEvent::CloseRequested => {
//TODO: just close one window
elwt.exit();
}
_ => {} _ => {}
} }
}) })

1
src/attrs.rs
View file

@ -340,6 +340,7 @@ impl AttrsList {
} }
/// Split attributes list at an offset /// Split attributes list at an offset
#[allow(clippy::missing_panics_doc)]
pub fn split_off(&mut self, index: usize) -> Self { pub fn split_off(&mut self, index: usize) -> Self {
let mut new = Self::new(self.defaults.as_attrs()); let mut new = Self::new(self.defaults.as_attrs());
let mut removes = Vec::new(); let mut removes = Vec::new();

23
src/buffer.rs
View file

@ -32,11 +32,12 @@ pub struct LayoutRun<'a> {
pub line_w: f32, pub line_w: f32,
} }
impl<'a> LayoutRun<'a> { impl LayoutRun<'_> {
/// Return the pixel span `Some((x_left, x_width))` of the highlighted area between `cursor_start` /// Return the pixel span `Some((x_left, x_width))` of the highlighted area between `cursor_start`
/// and `cursor_end` within this run, or None if the cursor range does not intersect this run. /// and `cursor_end` within this run, or None if the cursor range does not intersect this run.
/// This may return widths of zero if `cursor_start == cursor_end`, if the run is empty, or if the /// This may return widths of zero if `cursor_start == cursor_end`, if the run is empty, or if the
/// region's left start boundary is the same as the cursor's end boundary or vice versa. /// region's left start boundary is the same as the cursor's end boundary or vice versa.
#[allow(clippy::missing_panics_doc)]
pub fn highlight(&self, cursor_start: Cursor, cursor_end: Cursor) -> Option<(f32, f32)> { pub fn highlight(&self, cursor_start: Cursor, cursor_end: Cursor) -> Option<(f32, f32)> {
let mut x_start = None; let mut x_start = None;
let mut x_end = None; let mut x_end = None;
@ -202,7 +203,7 @@ impl fmt::Display for Metrics {
/// A buffer of text that is shaped and laid out /// A buffer of text that is shaped and laid out
#[derive(Debug)] #[derive(Debug)]
pub struct Buffer { pub struct Buffer {
/// [BufferLine]s (or paragraphs) of text in the buffer /// [`BufferLine`]s (or paragraphs) of text in the buffer
pub lines: Vec<BufferLine>, pub lines: Vec<BufferLine>,
metrics: Metrics, metrics: Metrics,
width_opt: Option<f32>, width_opt: Option<f32>,
@ -305,6 +306,7 @@ impl Buffer {
} }
/// Shape lines until cursor, also scrolling to include cursor in view /// Shape lines until cursor, also scrolling to include cursor in view
#[allow(clippy::missing_panics_doc)]
pub fn shape_until_cursor( pub fn shape_until_cursor(
&mut self, &mut self,
font_system: &mut FontSystem, font_system: &mut FontSystem,
@ -323,11 +325,11 @@ impl Buffer {
let layout = self let layout = self
.line_layout(font_system, layout_cursor.line) .line_layout(font_system, layout_cursor.line)
.expect("shape_until_cursor failed to scroll forwards"); .expect("shape_until_cursor failed to scroll forwards");
for layout_i in 0..layout_cursor.layout { (0..layout_cursor.layout).for_each(|layout_i| {
layout_y += layout[layout_i] layout_y += layout[layout_i]
.line_height_opt .line_height_opt
.unwrap_or(metrics.line_height); .unwrap_or(metrics.line_height);
} });
layout_y layout_y
+ layout[layout_cursor.layout] + layout[layout_cursor.layout]
.line_height_opt .line_height_opt
@ -403,6 +405,7 @@ impl Buffer {
} }
/// Shape lines until scroll /// Shape lines until scroll
#[allow(clippy::missing_panics_doc)]
pub fn shape_until_scroll(&mut self, font_system: &mut FontSystem, prune: bool) { pub fn shape_until_scroll(&mut self, font_system: &mut FontSystem, prune: bool) {
let metrics = self.metrics; let metrics = self.metrics;
let old_scroll = self.scroll; let old_scroll = self.scroll;
@ -603,10 +606,8 @@ impl Buffer {
self.tab_width = tab_width; self.tab_width = tab_width;
// Shaping must be reset when tab width is changed // Shaping must be reset when tab width is changed
for line in self.lines.iter_mut() { for line in self.lines.iter_mut() {
if line.shape_opt().is_some() { if line.shape_opt().is_some() && line.text().contains('\t') {
if line.text().contains('\t') { line.reset_shaping();
line.reset_shaping();
}
} }
} }
self.redraw = true; self.redraw = true;
@ -1095,7 +1096,7 @@ impl Buffer {
layout_cursor.layout -= 1; layout_cursor.layout -= 1;
} else if layout_cursor.line > 0 { } else if layout_cursor.line > 0 {
layout_cursor.line -= 1; layout_cursor.line -= 1;
layout_cursor.layout = usize::max_value(); layout_cursor.layout = usize::MAX;
} }
if let Some(cursor_x) = cursor_x_opt { if let Some(cursor_x) = cursor_x_opt {
@ -1164,7 +1165,7 @@ impl Buffer {
} }
Motion::End => { Motion::End => {
let mut layout_cursor = self.layout_cursor(font_system, cursor)?; let mut layout_cursor = self.layout_cursor(font_system, cursor)?;
layout_cursor.glyph = usize::max_value(); layout_cursor.glyph = usize::MAX;
#[allow(unused_assignments)] #[allow(unused_assignments)]
{ {
(cursor, cursor_x_opt) = self.cursor_motion( (cursor, cursor_x_opt) = self.cursor_motion(
@ -1365,7 +1366,7 @@ impl Buffer {
} }
} }
impl<'a> BorrowedWithFontSystem<'a, Buffer> { impl BorrowedWithFontSystem<'_, Buffer> {
/// Shape lines until cursor, also scrolling to include cursor in view /// Shape lines until cursor, also scrolling to include cursor in view
pub fn shape_until_cursor(&mut self, cursor: Cursor, prune: bool) { pub fn shape_until_cursor(&mut self, cursor: Cursor, prune: bool) {
self.inner self.inner

2
src/buffer_line.rs
View file

@ -203,6 +203,7 @@ impl BufferLine {
} }
/// Shape line, will cache results /// Shape line, will cache results
#[allow(clippy::missing_panics_doc)]
pub fn shape(&mut self, font_system: &mut FontSystem, tab_width: u16) -> &ShapeLine { pub fn shape(&mut self, font_system: &mut FontSystem, tab_width: u16) -> &ShapeLine {
if self.shape_opt.is_unused() { if self.shape_opt.is_unused() {
let mut line = self let mut line = self
@ -228,6 +229,7 @@ impl BufferLine {
} }
/// Layout line, will cache results /// Layout line, will cache results
#[allow(clippy::missing_panics_doc)]
pub fn layout( pub fn layout(
&mut self, &mut self,
font_system: &mut FontSystem, font_system: &mut FontSystem,

1
src/cached.rs
View file

@ -67,6 +67,7 @@ impl<T: Clone + Debug> Cached<T> {
} }
/// Moves the value from `Self::Used` to `Self::Unused`. /// Moves the value from `Self::Used` to `Self::Unused`.
#[allow(clippy::missing_panics_doc)]
pub fn set_unused(&mut self) { pub fn set_unused(&mut self) {
if matches!(*self, Self::Used(_)) { if matches!(*self, Self::Used(_)) {
*self = Self::Unused(self.take_used().expect("cached value should be used")); *self = Self::Unused(self.take_used().expect("cached value should be used"));

4
src/cursor.rs
View file

@ -87,9 +87,9 @@ impl LayoutCursor {
pub enum Motion { pub enum Motion {
/// Apply specific [`LayoutCursor`] /// Apply specific [`LayoutCursor`]
LayoutCursor(LayoutCursor), LayoutCursor(LayoutCursor),
/// Move cursor to previous character ([Self::Left] in LTR, [Self::Right] in RTL) /// Move cursor to previous character ([`Self::Left`] in LTR, [`Self::Right`] in RTL)
Previous, Previous,
/// Move cursor to next character ([Self::Right] in LTR, [Self::Left] in RTL) /// Move cursor to next character ([`Self::Right`] in LTR, [`Self::Left`] in RTL)
Next, Next,
/// Move cursor left /// Move cursor left
Left, Left,

18
src/edit/editor.rs
View file

@ -109,6 +109,7 @@ impl<'buffer> Editor<'buffer> {
/// Draw the editor /// Draw the editor
#[cfg(feature = "swash")] #[cfg(feature = "swash")]
#[allow(clippy::too_many_arguments)]
pub fn draw<F>( pub fn draw<F>(
&self, &self,
font_system: &mut FontSystem, font_system: &mut FontSystem,
@ -527,16 +528,13 @@ impl<'buffer> Edit<'buffer> for Editor<'buffer> {
fn apply_change(&mut self, change: &Change) -> bool { fn apply_change(&mut self, change: &Change) -> bool {
// Cannot apply changes if there is a pending change // Cannot apply changes if there is a pending change
match self.change.take() { if let Some(pending) = self.change.take() {
Some(pending) => { if !pending.items.is_empty() {
if !pending.items.is_empty() { //TODO: is this a good idea?
//TODO: is this a good idea? log::warn!("pending change caused apply_change to be ignored!");
log::warn!("pending change caused apply_change to be ignored!"); self.change = Some(pending);
self.change = Some(pending); return false;
return false;
}
} }
None => {}
} }
for item in change.items.iter() { for item in change.items.iter() {
@ -898,7 +896,7 @@ impl<'buffer> Edit<'buffer> for Editor<'buffer> {
} }
} }
impl<'font_system, 'buffer> BorrowedWithFontSystem<'font_system, Editor<'buffer>> { impl BorrowedWithFontSystem<'_, Editor<'_>> {
#[cfg(feature = "swash")] #[cfg(feature = "swash")]
pub fn draw<F>( pub fn draw<F>(
&mut self, &mut self,

12
src/edit/mod.rs
View file

@ -71,7 +71,7 @@ pub enum BufferRef<'buffer> {
Arc(Arc<Buffer>), Arc(Arc<Buffer>),
} }
impl<'buffer> Clone for BufferRef<'buffer> { impl Clone for BufferRef<'_> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
match self { match self {
Self::Owned(buffer) => Self::Owned(buffer.clone()), Self::Owned(buffer) => Self::Owned(buffer.clone()),
@ -81,7 +81,7 @@ impl<'buffer> Clone for BufferRef<'buffer> {
} }
} }
impl<'buffer> From<Buffer> for BufferRef<'buffer> { impl From<Buffer> for BufferRef<'_> {
fn from(buffer: Buffer) -> Self { fn from(buffer: Buffer) -> Self {
Self::Owned(buffer) Self::Owned(buffer)
} }
@ -93,7 +93,7 @@ impl<'buffer> From<&'buffer mut Buffer> for BufferRef<'buffer> {
} }
} }
impl<'buffer> From<Arc<Buffer>> for BufferRef<'buffer> { impl From<Arc<Buffer>> for BufferRef<'_> {
fn from(arc: Arc<Buffer>) -> Self { fn from(arc: Arc<Buffer>) -> Self {
Self::Arc(arc) Self::Arc(arc)
} }
@ -197,7 +197,7 @@ pub trait Edit<'buffer> {
/// Set the [`Buffer`] redraw flag /// Set the [`Buffer`] redraw flag
fn set_redraw(&mut self, redraw: bool) { fn set_redraw(&mut self, redraw: bool) {
self.with_buffer_mut(|buffer| buffer.set_redraw(redraw)) self.with_buffer_mut(|buffer| buffer.set_redraw(redraw));
} }
/// Get the current cursor /// Get the current cursor
@ -300,7 +300,7 @@ pub trait Edit<'buffer> {
/// Delete text starting at start Cursor and ending at end Cursor /// Delete text starting at start Cursor and ending at end Cursor
fn delete_range(&mut self, start: Cursor, end: Cursor); fn delete_range(&mut self, start: Cursor, end: Cursor);
/// Insert text at specified cursor with specified attrs_list /// Insert text at specified cursor with specified `attrs_list`
fn insert_at(&mut self, cursor: Cursor, data: &str, attrs_list: Option<AttrsList>) -> Cursor; fn insert_at(&mut self, cursor: Cursor, data: &str, attrs_list: Option<AttrsList>) -> Cursor;
/// Copy selection /// Copy selection
@ -334,7 +334,7 @@ pub trait Edit<'buffer> {
fn cursor_position(&self) -> Option<(i32, i32)>; fn cursor_position(&self) -> Option<(i32, i32)>;
} }
impl<'font_system, 'buffer, E: Edit<'buffer>> BorrowedWithFontSystem<'font_system, E> { impl<'buffer, E: Edit<'buffer>> BorrowedWithFontSystem<'_, E> {
/// Get the internal [`Buffer`], mutably /// Get the internal [`Buffer`], mutably
pub fn with_buffer_mut<F: FnOnce(&mut BorrowedWithFontSystem<Buffer>) -> T, T>( pub fn with_buffer_mut<F: FnOnce(&mut BorrowedWithFontSystem<Buffer>) -> T, T>(
&mut self, &mut self,

8
src/edit/syntect.rs
View file

@ -125,7 +125,7 @@ impl<'syntax_system, 'buffer> SyntaxEditor<'syntax_system, 'buffer> {
let text = fs::read_to_string(path)?; let text = fs::read_to_string(path)?;
self.editor.with_buffer_mut(|buffer| { self.editor.with_buffer_mut(|buffer| {
buffer.set_text(font_system, &text, attrs, Shaping::Advanced) buffer.set_text(font_system, &text, attrs, Shaping::Advanced);
}); });
//TODO: re-use text //TODO: re-use text
@ -235,7 +235,7 @@ impl<'syntax_system, 'buffer> SyntaxEditor<'syntax_system, 'buffer> {
} }
} }
impl<'syntax_system, 'buffer> Edit<'buffer> for SyntaxEditor<'syntax_system, 'buffer> { impl<'buffer> Edit<'buffer> for SyntaxEditor<'_, 'buffer> {
fn buffer_ref(&self) -> &BufferRef<'buffer> { fn buffer_ref(&self) -> &BufferRef<'buffer> {
self.editor.buffer_ref() self.editor.buffer_ref()
} }
@ -440,9 +440,7 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for SyntaxEditor<'syntax_system, 'bu
} }
} }
impl<'font_system, 'syntax_system, 'buffer> impl BorrowedWithFontSystem<'_, SyntaxEditor<'_, '_>> {
BorrowedWithFontSystem<'font_system, SyntaxEditor<'syntax_system, 'buffer>>
{
/// Load text from a file, and also set syntax to the best option /// Load text from a file, and also set syntax to the best option
/// ///
/// ## Errors /// ## Errors

77
src/edit/vi.rs
View file

@ -209,6 +209,9 @@ impl<'syntax_system, 'buffer> ViEditor<'syntax_system, 'buffer> {
} }
/// Load text from a file, and also set syntax to the best option /// Load text from a file, and also set syntax to the best option
///
/// ## Errors
/// Returns an `io::Error` if reading the file fails
#[cfg(feature = "std")] #[cfg(feature = "std")]
pub fn load_text<P: AsRef<std::path::Path>>( pub fn load_text<P: AsRef<std::path::Path>>(
&mut self, &mut self,
@ -517,7 +520,7 @@ impl<'syntax_system, 'buffer> ViEditor<'syntax_system, 'buffer> {
} }
} }
impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer> { impl<'buffer> Edit<'buffer> for ViEditor<'_, 'buffer> {
fn buffer_ref(&self) -> &BufferRef<'buffer> { fn buffer_ref(&self) -> &BufferRef<'buffer> {
self.editor.buffer_ref() self.editor.buffer_ref()
} }
@ -646,10 +649,7 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
} }
}; };
let has_selection = match editor.selection() { let has_selection = !matches!(editor.selection(), Selection::None);
Selection::None => false,
_ => true,
};
self.parser.parse(key, has_selection, |event| { self.parser.parse(key, has_selection, |event| {
log::debug!(" Event {:?}", event); log::debug!(" Event {:?}", event);
@ -778,17 +778,14 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
TextObject::DoubleQuotes => select_in(editor, '"', '"', include), TextObject::DoubleQuotes => select_in(editor, '"', '"', include),
TextObject::Parentheses => select_in(editor, '(', ')', include), TextObject::Parentheses => select_in(editor, '(', ')', include),
TextObject::Search { forwards } => { TextObject::Search { forwards } => {
match &self.search_opt { if let Some((value, _)) = &self.search_opt {
Some((value, _)) => { if search(editor, value, forwards) {
if search(editor, value, forwards) { let mut cursor = editor.cursor();
let mut cursor = editor.cursor(); editor.set_selection(Selection::Normal(cursor));
editor.set_selection(Selection::Normal(cursor)); //TODO: traverse lines if necessary
//TODO: traverse lines if necessary cursor.index += value.len();
cursor.index += value.len(); editor.set_cursor(cursor);
editor.set_cursor(cursor);
}
} }
None => {}
} }
} }
TextObject::SingleQuotes => select_in(editor, '\'', '\'', include), TextObject::SingleQuotes => select_in(editor, '\'', '\'', include),
@ -880,15 +877,11 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
editor.with_buffer(|buffer| { editor.with_buffer(|buffer| {
let text = buffer.lines[cursor.line].text(); let text = buffer.lines[cursor.line].text();
if cursor.index < text.len() { if cursor.index < text.len() {
match text[cursor.index..] if let Some((i, _)) = text[cursor.index..]
.char_indices() .char_indices()
.filter(|&(i, c)| i > 0 && c == find_c) .find(|&(i, c)| i > 0 && c == find_c)
.next()
{ {
Some((i, _)) => { cursor.index += i;
cursor.index += i;
}
None => {}
} }
} }
}); });
@ -986,15 +979,11 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
editor.with_buffer(|buffer| { editor.with_buffer(|buffer| {
let text = buffer.lines[cursor.line].text(); let text = buffer.lines[cursor.line].text();
if cursor.index > 0 { if cursor.index > 0 {
match text[..cursor.index] if let Some((i, _)) = text[..cursor.index]
.char_indices() .char_indices()
.filter(|&(_, c)| c == find_c) .rfind(|&(_, c)| c == find_c)
.last()
{ {
Some((i, _)) => { cursor.index = i;
cursor.index = i;
}
None => {}
} }
} }
}); });
@ -1006,7 +995,7 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
editor.with_buffer(|buffer| { editor.with_buffer(|buffer| {
let text = buffer.lines[cursor.line].text(); let text = buffer.lines[cursor.line].text();
if cursor.index > 0 { if cursor.index > 0 {
match text[..cursor.index] if let Some(i) = text[..cursor.index]
.char_indices() .char_indices()
.filter_map(|(i, c)| { .filter_map(|(i, c)| {
if c == find_c { if c == find_c {
@ -1019,10 +1008,7 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
}) })
.last() .last()
{ {
Some(i) => { cursor.index = i;
cursor.index = i;
}
None => {}
} }
} }
}); });
@ -1132,16 +1118,12 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
//TODO: is this efficient? //TODO: is this efficient?
let action_opt = editor.with_buffer(|buffer| { let action_opt = editor.with_buffer(|buffer| {
let mut layout_runs = buffer.layout_runs(); let mut layout_runs = buffer.layout_runs();
if let Some(first) = layout_runs.next() {
if let Some(last) = layout_runs.last() { match (layout_runs.next(), layout_runs.last()) {
Some(Action::Motion(Motion::GotoLine( (Some(first), Some(last)) => Some(Action::Motion(
(last.line_i + first.line_i) / 2, Motion::GotoLine((last.line_i + first.line_i) / 2),
))) )),
} else { _ => None,
None
}
} else {
None
} }
}); });
match action_opt { match action_opt {
@ -1167,10 +1149,11 @@ impl<'syntax_system, 'buffer> Edit<'buffer> for ViEditor<'syntax_system, 'buffer
} }
} }
impl<'font_system, 'syntax_system, 'buffer> impl BorrowedWithFontSystem<'_, ViEditor<'_, '_>> {
BorrowedWithFontSystem<'font_system, ViEditor<'syntax_system, 'buffer>>
{
/// Load text from a file, and also set syntax to the best option /// Load text from a file, and also set syntax to the best option
///
/// ## Errors
/// Returns an `io::Error` if reading the file fails
#[cfg(feature = "std")] #[cfg(feature = "std")]
pub fn load_text<P: AsRef<std::path::Path>>( pub fn load_text<P: AsRef<std::path::Path>>(
&mut self, &mut self,

2
src/font/fallback/mod.rs
View file

@ -140,7 +140,7 @@ impl<'a> FontFallbackIter<'a> {
} }
} }
impl<'a> Iterator for FontFallbackIter<'a> { impl Iterator for FontFallbackIter<'_> {
type Item = Arc<Font>; type Item = Arc<Font>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
if let Some(fallback_info) = self.font_system.monospace_fallbacks_buffer.pop_first() { if let Some(fallback_info) = self.font_system.monospace_fallbacks_buffer.pop_first() {

4
src/font/mod.rs
View file

@ -185,11 +185,11 @@ mod test {
let now = std::time::Instant::now(); let now = std::time::Instant::now();
let mut db = fontdb::Database::new(); let mut db = fontdb::Database::new();
let locale = get_locale().unwrap(); let locale = get_locale().expect("Local available");
db.load_system_fonts(); db.load_system_fonts();
FontSystem::new_with_locale_and_db(locale, db); FontSystem::new_with_locale_and_db(locale, db);
#[cfg(not(target_arch = "wasm32"))] #[cfg(not(target_arch = "wasm32"))]
println!("Fonts load time {}ms.", now.elapsed().as_millis()) println!("Fonts load time {}ms.", now.elapsed().as_millis());
} }
} }

6
src/font/system.rs
View file

@ -106,7 +106,7 @@ pub struct FontSystem {
/// Scratch buffer for shaping and laying out. /// Scratch buffer for shaping and laying out.
pub(crate) shape_buffer: ShapeBuffer, pub(crate) shape_buffer: ShapeBuffer,
/// Buffer for use in FontFallbackIter. /// Buffer for use in `FontFallbackIter`.
pub(crate) monospace_fallbacks_buffer: BTreeSet<MonospaceFallbackInfo>, pub(crate) monospace_fallbacks_buffer: BTreeSet<MonospaceFallbackInfo>,
/// Cache for shaped runs /// Cache for shaped runs
@ -372,7 +372,7 @@ pub struct BorrowedWithFontSystem<'a, T> {
pub(crate) font_system: &'a mut FontSystem, pub(crate) font_system: &'a mut FontSystem,
} }
impl<'a, T> Deref for BorrowedWithFontSystem<'a, T> { impl<T> Deref for BorrowedWithFontSystem<'_, T> {
type Target = T; type Target = T;
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
@ -380,7 +380,7 @@ impl<'a, T> Deref for BorrowedWithFontSystem<'a, T> {
} }
} }
impl<'a, T> DerefMut for BorrowedWithFontSystem<'a, T> { impl<T> DerefMut for BorrowedWithFontSystem<'_, T> {
fn deref_mut(&mut self) -> &mut Self::Target { fn deref_mut(&mut self) -> &mut Self::Target {
self.inner self.inner
} }

4
src/layout.rs
View file

@ -28,7 +28,7 @@ pub struct LayoutGlyph {
pub y: f32, pub y: f32,
/// Width of hitbox /// Width of hitbox
pub w: f32, pub w: f32,
/// Unicode BiDi embedding level, character is left-to-right if `level` is divisible by 2 /// Unicode `BiDi` embedding level, character is left-to-right if `level` is divisible by 2
pub level: unicode_bidi::Level, pub level: unicode_bidi::Level,
/// X offset in line /// X offset in line
/// ///
@ -58,7 +58,7 @@ pub struct LayoutGlyph {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct PhysicalGlyph { pub struct PhysicalGlyph {
/// Cache key, see [CacheKey] /// Cache key, see [`CacheKey`]
pub cache_key: CacheKey, pub cache_key: CacheKey,
/// Integer component of X offset in line /// Integer component of X offset in line
pub x: i32, pub x: i32,

4
src/line_ending.rs
View file

@ -48,11 +48,11 @@ impl<'a> LineIter<'a> {
} }
} }
impl<'a> Iterator for LineIter<'a> { impl Iterator for LineIter<'_> {
type Item = (Range<usize>, LineEnding); type Item = (Range<usize>, LineEnding);
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
let start = self.start; let start = self.start;
match self.string[start..self.end].find(&['\r', '\n']) { match self.string[start..self.end].find(['\r', '\n']) {
Some(i) => { Some(i) => {
let end = start + i; let end = start + i;
self.start = end; self.start = end;

8
src/shape.rs
View file

@ -384,12 +384,8 @@ fn shape_run_cached(
// Skip if attrs matches default attrs // Skip if attrs matches default attrs
continue; continue;
} }
let start = max(attrs_range.start, start_run) let start = max(attrs_range.start, start_run).saturating_sub(start_run);
.checked_sub(start_run) let end = min(attrs_range.end, end_run).saturating_sub(start_run);
.unwrap_or(0);
let end = min(attrs_range.end, end_run)
.checked_sub(start_run)
.unwrap_or(0);
if end > start { if end > start {
let range = start..end; let range = start..end;
key.attrs_spans.push((range, attrs.clone())); key.attrs_spans.push((range, attrs.clone()));

2
src/shape_run_cache.rs
View file

@ -33,7 +33,7 @@ impl ShapeRunCache {
self.cache.insert(key, (self.age, glyphs)); self.cache.insert(key, (self.age, glyphs));
} }
/// Remove anything in the cache with an age older than keep_ages /// Remove anything in the cache with an age older than `keep_ages`
pub fn trim(&mut self, keep_ages: u64) { pub fn trim(&mut self, keep_ages: u64) {
self.cache self.cache
.retain(|_key, (age, _glyphs)| *age + keep_ages >= self.age); .retain(|_key, (age, _glyphs)| *age + keep_ages >= self.age);