chore: refactor the input component (#165)
* refactor the input component * fix clippy * clean up
This commit is contained in:
reya
@@ -1,29 +1,34 @@
|
||||
use std::{ops::Range, rc::Rc};
|
||||
use std::ops::Range;
|
||||
use std::rc::Rc;
|
||||
|
||||
use gpui::{
|
||||
fill, point, px, relative, size, App, Bounds, Corners, Element, ElementId, ElementInputHandler,
|
||||
Entity, GlobalElementId, IntoElement, LayoutId, MouseButton, MouseMoveEvent, Path, Pixels,
|
||||
Point, SharedString, Size, Style, TextAlign, TextRun, UnderlineStyle, Window, WrappedLine,
|
||||
Entity, GlobalElementId, Half, Hitbox, IntoElement, LayoutId, MouseButton, MouseMoveEvent,
|
||||
Path, Pixels, Point, ShapedLine, SharedString, Size, Style, TextAlign, TextRun, UnderlineStyle,
|
||||
Window,
|
||||
};
|
||||
use rope::Rope;
|
||||
use smallvec::SmallVec;
|
||||
use theme::ActiveTheme;
|
||||
|
||||
use super::{InputState, LastLayout};
|
||||
use super::blink_cursor::CURSOR_WIDTH;
|
||||
use super::rope_ext::RopeExt;
|
||||
use super::state::{InputState, LastLayout};
|
||||
use crate::Root;
|
||||
|
||||
const CURSOR_THICKNESS: Pixels = px(2.);
|
||||
const RIGHT_MARGIN: Pixels = px(5.);
|
||||
const BOTTOM_MARGIN_ROWS: usize = 1;
|
||||
const BOTTOM_MARGIN_ROWS: usize = 3;
|
||||
pub(super) const RIGHT_MARGIN: Pixels = px(10.);
|
||||
pub(super) const LINE_NUMBER_RIGHT_MARGIN: Pixels = px(10.);
|
||||
|
||||
pub(super) struct TextElement {
|
||||
input: Entity<InputState>,
|
||||
pub(crate) state: Entity<InputState>,
|
||||
placeholder: SharedString,
|
||||
}
|
||||
|
||||
impl TextElement {
|
||||
pub(super) fn new(input: Entity<InputState>) -> Self {
|
||||
pub(super) fn new(state: Entity<InputState>) -> Self {
|
||||
Self {
|
||||
input,
|
||||
state,
|
||||
placeholder: SharedString::default(),
|
||||
}
|
||||
}
|
||||
@@ -36,12 +41,12 @@ impl TextElement {
|
||||
|
||||
fn paint_mouse_listeners(&mut self, window: &mut Window, _: &mut App) {
|
||||
window.on_mouse_event({
|
||||
let input = self.input.clone();
|
||||
let state = self.state.clone();
|
||||
|
||||
move |event: &MouseMoveEvent, _, window, cx| {
|
||||
if event.pressed_button == Some(MouseButton::Left) {
|
||||
input.update(cx, |input, cx| {
|
||||
input.on_drag_move(event, window, cx);
|
||||
state.update(cx, |state, cx| {
|
||||
state.on_drag_move(event, window, cx);
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -52,33 +57,44 @@ impl TextElement {
|
||||
///
|
||||
/// - cursor bounds
|
||||
/// - scroll offset
|
||||
/// - current line index
|
||||
/// - current row index (No only the visible lines, but all lines)
|
||||
///
|
||||
/// This method also will update for track scroll to cursor.
|
||||
fn layout_cursor(
|
||||
&self,
|
||||
lines: &[WrappedLine],
|
||||
line_height: Pixels,
|
||||
last_layout: &LastLayout,
|
||||
bounds: &mut Bounds<Pixels>,
|
||||
line_number_width: Pixels,
|
||||
window: &mut Window,
|
||||
_: &mut Window,
|
||||
cx: &mut App,
|
||||
) -> (Option<Bounds<Pixels>>, Point<Pixels>, Option<usize>) {
|
||||
let input = self.input.read(cx);
|
||||
let mut selected_range = input.selected_range.clone();
|
||||
if let Some(marked_range) = &input.marked_range {
|
||||
selected_range = marked_range.end..marked_range.end;
|
||||
let state = self.state.read(cx);
|
||||
|
||||
let line_height = last_layout.line_height;
|
||||
let visible_range = &last_layout.visible_range;
|
||||
let lines = &last_layout.lines;
|
||||
let text_wrapper = &state.text_wrapper;
|
||||
let line_number_width = last_layout.line_number_width;
|
||||
|
||||
let mut selected_range = state.selected_range;
|
||||
if let Some(ime_marked_range) = &state.ime_marked_range {
|
||||
selected_range = (ime_marked_range.end..ime_marked_range.end).into();
|
||||
}
|
||||
|
||||
let cursor_offset = input.cursor_offset();
|
||||
let mut current_line_index = None;
|
||||
let mut scroll_offset = input.scroll_handle.offset();
|
||||
let cursor = state.cursor();
|
||||
let mut current_row = None;
|
||||
let mut scroll_offset = state.scroll_handle.offset();
|
||||
let mut cursor_bounds = None;
|
||||
|
||||
// If the input has a fixed height (Otherwise is auto-grow), we need to add a bottom margin to the input.
|
||||
let bottom_margin = if input.is_auto_grow() {
|
||||
px(0.) + line_height
|
||||
let top_bottom_margin = if state.mode.is_auto_grow() {
|
||||
#[allow(clippy::if_same_then_else)]
|
||||
line_height
|
||||
} else if visible_range.len() < BOTTOM_MARGIN_ROWS * 8 {
|
||||
line_height
|
||||
} else {
|
||||
BOTTOM_MARGIN_ROWS * line_height + line_height
|
||||
BOTTOM_MARGIN_ROWS * line_height
|
||||
};
|
||||
|
||||
// The cursor corresponds to the current cursor position in the text no only the line.
|
||||
let mut cursor_pos = None;
|
||||
let mut cursor_start = None;
|
||||
@@ -86,68 +102,98 @@ impl TextElement {
|
||||
|
||||
let mut prev_lines_offset = 0;
|
||||
let mut offset_y = px(0.);
|
||||
for (line_ix, line) in lines.iter().enumerate() {
|
||||
|
||||
for (ix, wrap_line) in text_wrapper.lines.iter().enumerate() {
|
||||
let row = ix;
|
||||
let line_origin = point(px(0.), offset_y);
|
||||
|
||||
// break loop if all cursor positions are found
|
||||
if cursor_pos.is_some() && cursor_start.is_some() && cursor_end.is_some() {
|
||||
break;
|
||||
}
|
||||
|
||||
let line_origin = point(px(0.), offset_y);
|
||||
if cursor_pos.is_none() {
|
||||
let offset = cursor_offset.saturating_sub(prev_lines_offset);
|
||||
if let Some(pos) = line.position_for_index(offset, line_height) {
|
||||
current_line_index = Some(line_ix);
|
||||
cursor_pos = Some(line_origin + pos);
|
||||
let in_visible_range = ix >= visible_range.start;
|
||||
if let Some(line) = in_visible_range
|
||||
.then(|| lines.get(ix.saturating_sub(visible_range.start)))
|
||||
.flatten()
|
||||
{
|
||||
// If in visible range lines
|
||||
if cursor_pos.is_none() {
|
||||
let offset = cursor.saturating_sub(prev_lines_offset);
|
||||
if let Some(pos) = line.position_for_index(offset, line_height) {
|
||||
current_row = Some(row);
|
||||
cursor_pos = Some(line_origin + pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
if cursor_start.is_none() {
|
||||
let offset = selected_range.start.saturating_sub(prev_lines_offset);
|
||||
if let Some(pos) = line.position_for_index(offset, line_height) {
|
||||
cursor_start = Some(line_origin + pos);
|
||||
if cursor_start.is_none() {
|
||||
let offset = selected_range.start.saturating_sub(prev_lines_offset);
|
||||
if let Some(pos) = line.position_for_index(offset, line_height) {
|
||||
cursor_start = Some(line_origin + pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
if cursor_end.is_none() {
|
||||
let offset = selected_range.end.saturating_sub(prev_lines_offset);
|
||||
if let Some(pos) = line.position_for_index(offset, line_height) {
|
||||
cursor_end = Some(line_origin + pos);
|
||||
if cursor_end.is_none() {
|
||||
let offset = selected_range.end.saturating_sub(prev_lines_offset);
|
||||
if let Some(pos) = line.position_for_index(offset, line_height) {
|
||||
cursor_end = Some(line_origin + pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
offset_y += line.size(line_height).height;
|
||||
// +1 for skip the last `\n`
|
||||
prev_lines_offset += line.len() + 1;
|
||||
offset_y += line.size(line_height).height;
|
||||
// +1 for the last `\n`
|
||||
prev_lines_offset += line.len() + 1;
|
||||
} else {
|
||||
// If not in the visible range.
|
||||
|
||||
// Just increase the offset_y and prev_lines_offset.
|
||||
// This will let the scroll_offset to track the cursor position correctly.
|
||||
if prev_lines_offset >= cursor && cursor_pos.is_none() {
|
||||
current_row = Some(row);
|
||||
cursor_pos = Some(line_origin);
|
||||
}
|
||||
if prev_lines_offset >= selected_range.start && cursor_start.is_none() {
|
||||
cursor_start = Some(line_origin);
|
||||
}
|
||||
if prev_lines_offset >= selected_range.end && cursor_end.is_none() {
|
||||
cursor_end = Some(line_origin);
|
||||
}
|
||||
|
||||
offset_y += wrap_line.height(line_height);
|
||||
// +1 for the last `\n`
|
||||
prev_lines_offset += wrap_line.len() + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if let (Some(cursor_pos), Some(cursor_start), Some(cursor_end)) =
|
||||
(cursor_pos, cursor_start, cursor_end)
|
||||
{
|
||||
let cursor_moved = input.last_cursor_offset != Some(cursor_offset);
|
||||
let selection_changed = input.last_selected_range != Some(selected_range.clone());
|
||||
|
||||
if cursor_moved || selection_changed {
|
||||
scroll_offset.x =
|
||||
if scroll_offset.x + cursor_pos.x > (bounds.size.width - RIGHT_MARGIN) {
|
||||
// cursor is out of right
|
||||
bounds.size.width - RIGHT_MARGIN - cursor_pos.x
|
||||
} else if scroll_offset.x + cursor_pos.x < px(0.) {
|
||||
// cursor is out of left
|
||||
scroll_offset.x - cursor_pos.x
|
||||
} else {
|
||||
scroll_offset.x
|
||||
};
|
||||
scroll_offset.y = if scroll_offset.y + cursor_pos.y + line_height
|
||||
> bounds.size.height - bottom_margin
|
||||
let selection_changed = state.last_selected_range != Some(selected_range);
|
||||
if selection_changed {
|
||||
scroll_offset.x = if scroll_offset.x + cursor_pos.x
|
||||
> (bounds.size.width - line_number_width - RIGHT_MARGIN)
|
||||
{
|
||||
// cursor is out of bottom
|
||||
bounds.size.height - bottom_margin - cursor_pos.y
|
||||
} else if scroll_offset.y + cursor_pos.y < px(0.) {
|
||||
// cursor is out of top
|
||||
scroll_offset.y - cursor_pos.y
|
||||
// cursor is out of right
|
||||
bounds.size.width - line_number_width - RIGHT_MARGIN - cursor_pos.x
|
||||
} else if scroll_offset.x + cursor_pos.x < px(0.) {
|
||||
// cursor is out of left
|
||||
scroll_offset.x - cursor_pos.x
|
||||
} else {
|
||||
scroll_offset.y
|
||||
scroll_offset.x
|
||||
};
|
||||
|
||||
if input.selection_reversed {
|
||||
// If we change the scroll_offset.y, GPUI will render and trigger the next run loop.
|
||||
// So, here we just adjust offset by `line_height` for move smooth.
|
||||
scroll_offset.y =
|
||||
if scroll_offset.y + cursor_pos.y > bounds.size.height - top_bottom_margin {
|
||||
// cursor is out of bottom
|
||||
scroll_offset.y - line_height
|
||||
} else if scroll_offset.y + cursor_pos.y < top_bottom_margin {
|
||||
// cursor is out of top
|
||||
(scroll_offset.y + line_height).min(px(0.))
|
||||
} else {
|
||||
scroll_offset.y
|
||||
};
|
||||
|
||||
if state.selection_reversed {
|
||||
if scroll_offset.x + cursor_start.x < px(0.) {
|
||||
// selection start is out of left
|
||||
scroll_offset.x = -cursor_start.x;
|
||||
@@ -168,54 +214,55 @@ impl TextElement {
|
||||
}
|
||||
}
|
||||
|
||||
if input.show_cursor(window, cx) {
|
||||
// cursor blink
|
||||
let cursor_height = line_height;
|
||||
cursor_bounds = Some(Bounds::new(
|
||||
point(
|
||||
bounds.left() + cursor_pos.x + line_number_width + scroll_offset.x,
|
||||
bounds.top() + cursor_pos.y + ((line_height - cursor_height) / 2.),
|
||||
),
|
||||
size(CURSOR_THICKNESS, cursor_height),
|
||||
));
|
||||
};
|
||||
// cursor bounds
|
||||
let cursor_height = line_height;
|
||||
cursor_bounds = Some(Bounds::new(
|
||||
point(
|
||||
bounds.left() + cursor_pos.x + line_number_width + scroll_offset.x,
|
||||
bounds.top() + cursor_pos.y + ((line_height - cursor_height) / 2.),
|
||||
),
|
||||
size(CURSOR_WIDTH, cursor_height),
|
||||
));
|
||||
}
|
||||
|
||||
if let Some(deferred_scroll_offset) = state.deferred_scroll_offset {
|
||||
scroll_offset = deferred_scroll_offset;
|
||||
}
|
||||
|
||||
bounds.origin += scroll_offset;
|
||||
|
||||
(cursor_bounds, scroll_offset, current_line_index)
|
||||
(cursor_bounds, scroll_offset, current_row)
|
||||
}
|
||||
|
||||
fn layout_selections(
|
||||
&self,
|
||||
lines: &[WrappedLine],
|
||||
line_height: Pixels,
|
||||
/// Layout the match range to a Path.
|
||||
pub(crate) fn layout_match_range(
|
||||
range: Range<usize>,
|
||||
last_layout: &LastLayout,
|
||||
bounds: &mut Bounds<Pixels>,
|
||||
line_number_width: Pixels,
|
||||
_: &mut Window,
|
||||
cx: &mut App,
|
||||
) -> Option<Path<Pixels>> {
|
||||
let input = self.input.read(cx);
|
||||
let mut selected_range = input.selected_range.clone();
|
||||
if let Some(marked_range) = &input.marked_range {
|
||||
if !marked_range.is_empty() {
|
||||
selected_range = marked_range.end..marked_range.end;
|
||||
}
|
||||
}
|
||||
if selected_range.is_empty() {
|
||||
if range.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let (start_ix, end_ix) = if selected_range.start < selected_range.end {
|
||||
(selected_range.start, selected_range.end)
|
||||
} else {
|
||||
(selected_range.end, selected_range.start)
|
||||
};
|
||||
if range.start < last_layout.visible_range_offset.start
|
||||
|| range.end > last_layout.visible_range_offset.end
|
||||
{
|
||||
return None;
|
||||
}
|
||||
|
||||
let mut prev_lines_offset = 0;
|
||||
let line_height = last_layout.line_height;
|
||||
let visible_top = last_layout.visible_top;
|
||||
let visible_start_offset = last_layout.visible_range_offset.start;
|
||||
let lines = &last_layout.lines;
|
||||
let line_number_width = last_layout.line_number_width;
|
||||
|
||||
let start_ix = range.start;
|
||||
let end_ix = range.end;
|
||||
|
||||
let mut prev_lines_offset = visible_start_offset;
|
||||
let mut offset_y = visible_top;
|
||||
let mut line_corners = vec![];
|
||||
|
||||
let mut offset_y = px(0.);
|
||||
for line in lines.iter() {
|
||||
let line_size = line.size(line_height);
|
||||
let line_wrap_width = line_size.width;
|
||||
@@ -239,7 +286,6 @@ impl TextElement {
|
||||
(end.y / line_height).ceil() as usize - (start.y / line_height).ceil() as usize;
|
||||
|
||||
let mut end_x = end.x;
|
||||
|
||||
if wrapped_lines > 0 {
|
||||
end_x = line_wrap_width;
|
||||
}
|
||||
@@ -322,39 +368,79 @@ impl TextElement {
|
||||
builder.build().ok()
|
||||
}
|
||||
|
||||
fn layout_selections(
|
||||
&self,
|
||||
last_layout: &LastLayout,
|
||||
bounds: &mut Bounds<Pixels>,
|
||||
cx: &mut App,
|
||||
) -> Option<Path<Pixels>> {
|
||||
let state = self.state.read(cx);
|
||||
let mut selected_range = state.selected_range;
|
||||
if let Some(ime_marked_range) = &state.ime_marked_range {
|
||||
if !ime_marked_range.is_empty() {
|
||||
selected_range = (ime_marked_range.end..ime_marked_range.end).into();
|
||||
}
|
||||
}
|
||||
if selected_range.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let (start_ix, end_ix) = if selected_range.start < selected_range.end {
|
||||
(selected_range.start, selected_range.end)
|
||||
} else {
|
||||
(selected_range.end, selected_range.start)
|
||||
};
|
||||
|
||||
let range = start_ix.max(last_layout.visible_range_offset.start)
|
||||
..end_ix.min(last_layout.visible_range_offset.end);
|
||||
|
||||
Self::layout_match_range(range, last_layout, bounds)
|
||||
}
|
||||
|
||||
/// Calculate the visible range of lines in the viewport.
|
||||
///
|
||||
/// The visible range is based on unwrapped lines (Zero based).
|
||||
/// Returns
|
||||
///
|
||||
/// - visible_range: The visible range is based on unwrapped lines (Zero based).
|
||||
/// - visible_top: The top position of the first visible line in the scroll viewport.
|
||||
fn calculate_visible_range(
|
||||
&self,
|
||||
state: &InputState,
|
||||
line_height: Pixels,
|
||||
input_height: Pixels,
|
||||
) -> Range<usize> {
|
||||
if state.is_single_line() {
|
||||
return 0..1;
|
||||
) -> (Range<usize>, Pixels) {
|
||||
// Add extra rows to avoid showing empty space when scroll to bottom.
|
||||
let extra_rows = 1;
|
||||
let mut visible_top = px(0.);
|
||||
if state.mode.is_single_line() {
|
||||
return (0..1, visible_top);
|
||||
}
|
||||
|
||||
let scroll_top = -state.scroll_handle.offset().y;
|
||||
let total_lines = state.text_wrapper.lines.len();
|
||||
let total_lines = state.text_wrapper.len();
|
||||
let scroll_top = if let Some(deferred_scroll_offset) = state.deferred_scroll_offset {
|
||||
deferred_scroll_offset.y
|
||||
} else {
|
||||
state.scroll_handle.offset().y
|
||||
};
|
||||
|
||||
let mut visible_range = 0..total_lines;
|
||||
let mut line_top = px(0.);
|
||||
|
||||
let mut line_bottom = px(0.);
|
||||
for (ix, line) in state.text_wrapper.lines.iter().enumerate() {
|
||||
line_top += line.height(line_height);
|
||||
let wrapped_height = line.height(line_height);
|
||||
line_bottom += wrapped_height;
|
||||
|
||||
if line_top < scroll_top {
|
||||
if line_bottom < -scroll_top {
|
||||
visible_top = line_bottom - wrapped_height;
|
||||
visible_range.start = ix;
|
||||
}
|
||||
|
||||
if line_top > scroll_top + input_height {
|
||||
visible_range.end = (ix + 1).min(total_lines);
|
||||
if line_bottom + scroll_top >= input_height {
|
||||
visible_range.end = (ix + extra_rows).min(total_lines);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
visible_range
|
||||
(visible_range, visible_top)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -362,13 +448,17 @@ pub(super) struct PrepaintState {
|
||||
/// The lines of entire lines.
|
||||
last_layout: LastLayout,
|
||||
/// The lines only contains the visible lines in the viewport, based on `visible_range`.
|
||||
line_numbers: Option<Vec<SmallVec<[WrappedLine; 1]>>>,
|
||||
line_number_width: Pixels,
|
||||
///
|
||||
/// The child is the soft lines.
|
||||
line_numbers: Option<Vec<SmallVec<[ShapedLine; 1]>>>,
|
||||
/// Size of the scrollable area by entire lines.
|
||||
scroll_size: Size<Pixels>,
|
||||
cursor_bounds: Option<Bounds<Pixels>>,
|
||||
cursor_scroll_offset: Point<Pixels>,
|
||||
selection_path: Option<Path<Pixels>>,
|
||||
hover_highlight_path: Option<Path<Pixels>>,
|
||||
search_match_paths: Vec<(Path<Pixels>, bool)>,
|
||||
hover_definition_hitbox: Option<Hitbox>,
|
||||
bounds: Bounds<Pixels>,
|
||||
}
|
||||
|
||||
@@ -380,34 +470,9 @@ impl IntoElement for TextElement {
|
||||
}
|
||||
}
|
||||
|
||||
/// A debug function to print points as SVG path.
|
||||
#[allow(unused)]
|
||||
fn print_points_as_svg_path(line_corners: &Vec<Corners<Point<Pixels>>>, points: &[Point<Pixels>]) {
|
||||
for corners in line_corners {
|
||||
println!(
|
||||
"tl: ({}, {}), tr: ({}, {}), bl: ({}, {}), br: ({}, {})",
|
||||
corners.top_left.x.0 as i32,
|
||||
corners.top_left.y.0 as i32,
|
||||
corners.top_right.x.0 as i32,
|
||||
corners.top_right.y.0 as i32,
|
||||
corners.bottom_left.x.0 as i32,
|
||||
corners.bottom_left.y.0 as i32,
|
||||
corners.bottom_right.x.0 as i32,
|
||||
corners.bottom_right.y.0 as i32,
|
||||
);
|
||||
}
|
||||
|
||||
if !points.is_empty() {
|
||||
println!("M{},{}", points[0].x.0 as i32, points[0].y.0 as i32);
|
||||
for p in points.iter().skip(1) {
|
||||
println!("L{},{}", p.x.0 as i32, p.y.0 as i32);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Element for TextElement {
|
||||
type RequestLayoutState = ();
|
||||
type PrepaintState = PrepaintState;
|
||||
type RequestLayoutState = ();
|
||||
|
||||
fn id(&self) -> Option<ElementId> {
|
||||
None
|
||||
@@ -424,19 +489,20 @@ impl Element for TextElement {
|
||||
window: &mut Window,
|
||||
cx: &mut App,
|
||||
) -> (LayoutId, Self::RequestLayoutState) {
|
||||
let input = self.input.read(cx);
|
||||
let state = self.state.read(cx);
|
||||
let line_height = window.line_height();
|
||||
|
||||
let mut style = Style::default();
|
||||
style.size.width = relative(1.).into();
|
||||
if self.input.read(cx).is_multi_line() {
|
||||
if state.mode.is_multi_line() {
|
||||
style.flex_grow = 1.0;
|
||||
if let Some(h) = input.mode.height() {
|
||||
style.size.height = h.into();
|
||||
style.min_size.height = line_height.into();
|
||||
style.size.height = relative(1.).into();
|
||||
if state.mode.is_auto_grow() {
|
||||
// Auto grow to let height match to rows, but not exceed max rows.
|
||||
let rows = state.mode.max_rows().min(state.mode.rows());
|
||||
style.min_size.height = (rows * line_height).into();
|
||||
} else {
|
||||
style.size.height = relative(1.).into();
|
||||
style.min_size.height = (input.mode.rows() * line_height).into();
|
||||
style.min_size.height = line_height.into();
|
||||
}
|
||||
} else {
|
||||
// For single-line inputs, the minimum height should be the line height
|
||||
@@ -455,11 +521,19 @@ impl Element for TextElement {
|
||||
window: &mut Window,
|
||||
cx: &mut App,
|
||||
) -> Self::PrepaintState {
|
||||
let state = self.state.read(cx);
|
||||
let line_height = window.line_height();
|
||||
let input = self.input.read(cx);
|
||||
let multi_line = input.is_multi_line();
|
||||
let visible_range = self.calculate_visible_range(input, line_height, bounds.size.height);
|
||||
let text = input.text.clone();
|
||||
|
||||
let (visible_range, visible_top) =
|
||||
self.calculate_visible_range(state, line_height, bounds.size.height);
|
||||
let visible_start_offset = state.text.line_start_offset(visible_range.start);
|
||||
let visible_end_offset = state
|
||||
.text
|
||||
.line_end_offset(visible_range.end.saturating_sub(1));
|
||||
|
||||
let state = self.state.read(cx);
|
||||
let multi_line = state.mode.is_multi_line();
|
||||
let text = state.text.clone();
|
||||
let is_empty = text.is_empty();
|
||||
let placeholder = self.placeholder.clone();
|
||||
let style = window.text_style();
|
||||
@@ -467,9 +541,9 @@ impl Element for TextElement {
|
||||
let mut bounds = bounds;
|
||||
|
||||
let (display_text, text_color) = if is_empty {
|
||||
(placeholder, cx.theme().text_muted)
|
||||
} else if input.masked {
|
||||
("*".repeat(text.chars().count()).into(), cx.theme().text)
|
||||
(Rope::from(placeholder.as_str()), cx.theme().text_muted)
|
||||
} else if state.masked {
|
||||
(Rope::from("*".repeat(text.chars_count())), cx.theme().text)
|
||||
} else {
|
||||
(text.clone(), cx.theme().text)
|
||||
};
|
||||
@@ -500,20 +574,20 @@ impl Element for TextElement {
|
||||
|
||||
let runs = if !is_empty {
|
||||
vec![run]
|
||||
} else if let Some(marked_range) = &input.marked_range {
|
||||
} else if let Some(ime_marked_range) = &state.ime_marked_range {
|
||||
// IME marked text
|
||||
vec![
|
||||
TextRun {
|
||||
len: marked_range.start,
|
||||
len: ime_marked_range.start,
|
||||
..run.clone()
|
||||
},
|
||||
TextRun {
|
||||
len: marked_range.end - marked_range.start,
|
||||
len: ime_marked_range.end - ime_marked_range.start,
|
||||
underline: marked_run.underline,
|
||||
..run.clone()
|
||||
},
|
||||
TextRun {
|
||||
len: display_text.len() - marked_range.end,
|
||||
len: display_text.len() - ime_marked_range.end,
|
||||
..run.clone()
|
||||
},
|
||||
]
|
||||
@@ -524,35 +598,76 @@ impl Element for TextElement {
|
||||
vec![run]
|
||||
};
|
||||
|
||||
let wrap_width = if multi_line {
|
||||
let wrap_width = if multi_line && state.soft_wrap {
|
||||
Some(bounds.size.width - line_number_width - RIGHT_MARGIN)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
// NOTE: Here 50 lines about 150µs
|
||||
// let measure = crate::Measure::new("shape_text");
|
||||
let visible_text = display_text
|
||||
.slice_rows(visible_range.start as u32..visible_range.end as u32)
|
||||
.to_string();
|
||||
|
||||
let lines = window
|
||||
.text_system()
|
||||
.shape_text(display_text, font_size, &runs, wrap_width, None)
|
||||
.shape_text(visible_text.into(), font_size, &runs, wrap_width, None)
|
||||
.expect("failed to shape text");
|
||||
// measure.end();
|
||||
|
||||
let total_wrapped_lines = lines
|
||||
.iter()
|
||||
.map(|line| {
|
||||
// +1 is the first line, `wrap_boundaries` is the wrapped lines after the `\n`.
|
||||
1 + line.wrap_boundaries.len()
|
||||
})
|
||||
.sum::<usize>();
|
||||
let mut longest_line_width = wrap_width.unwrap_or(px(0.));
|
||||
if state.mode.is_multi_line() && !state.soft_wrap && lines.len() > 1 {
|
||||
let longtest_line: SharedString = state
|
||||
.text
|
||||
.line(state.text.summary().longest_row as usize)
|
||||
.to_string()
|
||||
.into();
|
||||
longest_line_width = window
|
||||
.text_system()
|
||||
.shape_line(
|
||||
longtest_line.clone(),
|
||||
font_size,
|
||||
&[TextRun {
|
||||
len: longtest_line.len(),
|
||||
font: style.font(),
|
||||
color: gpui::black(),
|
||||
background_color: None,
|
||||
underline: None,
|
||||
strikethrough: None,
|
||||
}],
|
||||
wrap_width,
|
||||
)
|
||||
.width;
|
||||
}
|
||||
|
||||
let max_line_width = lines
|
||||
.iter()
|
||||
.map(|line| line.width())
|
||||
.max()
|
||||
.unwrap_or(bounds.size.width);
|
||||
let total_wrapped_lines = state.text_wrapper.len();
|
||||
let empty_bottom_height = bounds
|
||||
.size
|
||||
.height
|
||||
.half()
|
||||
.max(BOTTOM_MARGIN_ROWS * line_height);
|
||||
let scroll_size = size(
|
||||
max_line_width + line_number_width + RIGHT_MARGIN,
|
||||
(total_wrapped_lines as f32 * line_height).max(bounds.size.height),
|
||||
if longest_line_width + line_number_width + RIGHT_MARGIN > bounds.size.width {
|
||||
longest_line_width + line_number_width + RIGHT_MARGIN
|
||||
} else {
|
||||
longest_line_width
|
||||
},
|
||||
(total_wrapped_lines as f32 * line_height + empty_bottom_height)
|
||||
.max(bounds.size.height),
|
||||
);
|
||||
|
||||
let mut last_layout = LastLayout {
|
||||
visible_range,
|
||||
visible_top,
|
||||
visible_range_offset: visible_start_offset..visible_end_offset,
|
||||
line_height,
|
||||
wrap_width,
|
||||
line_number_width,
|
||||
lines: Rc::new(lines),
|
||||
cursor_bounds: None,
|
||||
};
|
||||
|
||||
// `position_for_index` for example
|
||||
//
|
||||
// #### text
|
||||
@@ -584,37 +699,27 @@ impl Element for TextElement {
|
||||
|
||||
// Calculate the scroll offset to keep the cursor in view
|
||||
|
||||
let (cursor_bounds, cursor_scroll_offset, _) = self.layout_cursor(
|
||||
&lines,
|
||||
line_height,
|
||||
&mut bounds,
|
||||
line_number_width,
|
||||
window,
|
||||
cx,
|
||||
);
|
||||
let (cursor_bounds, cursor_scroll_offset, _) =
|
||||
self.layout_cursor(&last_layout, &mut bounds, window, cx);
|
||||
last_layout.cursor_bounds = cursor_bounds;
|
||||
|
||||
let selection_path = self.layout_selections(
|
||||
&lines,
|
||||
line_height,
|
||||
&mut bounds,
|
||||
line_number_width,
|
||||
window,
|
||||
cx,
|
||||
);
|
||||
let selection_path = self.layout_selections(&last_layout, &mut bounds, cx);
|
||||
let search_match_paths = vec![];
|
||||
let hover_highlight_path = None;
|
||||
let line_numbers = None;
|
||||
let hover_definition_hitbox = None;
|
||||
|
||||
PrepaintState {
|
||||
bounds,
|
||||
last_layout: LastLayout {
|
||||
lines: Rc::new(lines),
|
||||
line_height,
|
||||
visible_range,
|
||||
},
|
||||
last_layout,
|
||||
scroll_size,
|
||||
line_numbers: None,
|
||||
line_number_width,
|
||||
line_numbers,
|
||||
cursor_bounds,
|
||||
cursor_scroll_offset,
|
||||
selection_path,
|
||||
search_match_paths,
|
||||
hover_highlight_path,
|
||||
hover_definition_hitbox,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -628,21 +733,21 @@ impl Element for TextElement {
|
||||
window: &mut Window,
|
||||
cx: &mut App,
|
||||
) {
|
||||
let focus_handle = self.input.read(cx).focus_handle.clone();
|
||||
let focus_handle = self.state.read(cx).focus_handle.clone();
|
||||
let show_cursor = self.state.read(cx).show_cursor(window, cx);
|
||||
let focused = focus_handle.is_focused(window);
|
||||
let bounds = prepaint.bounds;
|
||||
let selected_range = self.input.read(cx).selected_range.clone();
|
||||
let visible_range = &prepaint.last_layout.visible_range;
|
||||
let selected_range = self.state.read(cx).selected_range;
|
||||
|
||||
window.handle_input(
|
||||
&focus_handle,
|
||||
ElementInputHandler::new(bounds, self.input.clone()),
|
||||
ElementInputHandler::new(bounds, self.state.clone()),
|
||||
cx,
|
||||
);
|
||||
|
||||
// Set Root focused_input when self is focused
|
||||
if focused {
|
||||
let state = self.input.clone();
|
||||
let state = self.state.clone();
|
||||
if Root::read(window, cx).focused_input.as_ref() != Some(&state) {
|
||||
Root::update(window, cx, |root, _, cx| {
|
||||
root.focused_input = Some(state);
|
||||
@@ -653,7 +758,7 @@ impl Element for TextElement {
|
||||
|
||||
// And reset focused_input when next_frame start
|
||||
window.on_next_frame({
|
||||
let state = self.input.clone();
|
||||
let state = self.state.clone();
|
||||
move |window, cx| {
|
||||
if !focused && Root::read(window, cx).focused_input.as_ref() == Some(&state) {
|
||||
Root::update(window, cx, |root, _, cx| {
|
||||
@@ -668,13 +773,10 @@ impl Element for TextElement {
|
||||
let line_height = window.line_height();
|
||||
let origin = bounds.origin;
|
||||
|
||||
let mut invisible_top_padding = px(0.);
|
||||
for line in prepaint.last_layout.lines.iter().take(visible_range.start) {
|
||||
invisible_top_padding += line.size(line_height).height;
|
||||
}
|
||||
let invisible_top_padding = prepaint.last_layout.visible_top;
|
||||
|
||||
let mut mask_offset_y = px(0.);
|
||||
if self.input.read(cx).masked {
|
||||
if self.state.read(cx).masked {
|
||||
// Move down offset for vertical centering the *****
|
||||
if cfg!(target_os = "macos") {
|
||||
mask_offset_y = px(3.);
|
||||
@@ -683,60 +785,105 @@ impl Element for TextElement {
|
||||
}
|
||||
}
|
||||
|
||||
// Paint active line
|
||||
let mut offset_y = px(0.);
|
||||
if let Some(line_numbers) = prepaint.line_numbers.as_ref() {
|
||||
offset_y += invisible_top_padding;
|
||||
|
||||
// Each item is the normal lines.
|
||||
for lines in line_numbers.iter() {
|
||||
for line in lines {
|
||||
let p = point(origin.x, origin.y + offset_y);
|
||||
let line_size = line.size(line_height);
|
||||
_ = line.paint(p, line_height, TextAlign::Left, None, window, cx);
|
||||
offset_y += line_size.height;
|
||||
}
|
||||
let height = line_height * lines.len() as f32;
|
||||
offset_y += height;
|
||||
}
|
||||
}
|
||||
|
||||
// Paint selections
|
||||
if let Some(path) = prepaint.selection_path.take() {
|
||||
window.paint_path(path, cx.theme().selection);
|
||||
if window.is_window_active() {
|
||||
let secondary_selection = cx.theme().selection;
|
||||
for (path, is_active) in prepaint.search_match_paths.iter() {
|
||||
window.paint_path(path.clone(), secondary_selection);
|
||||
|
||||
if *is_active {
|
||||
window.paint_path(path.clone(), cx.theme().selection);
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(path) = prepaint.selection_path.take() {
|
||||
window.paint_path(path, cx.theme().selection);
|
||||
}
|
||||
|
||||
// Paint hover highlight
|
||||
if let Some(path) = prepaint.hover_highlight_path.take() {
|
||||
window.paint_path(path, secondary_selection);
|
||||
}
|
||||
}
|
||||
|
||||
// Paint text
|
||||
let mut offset_y = mask_offset_y + invisible_top_padding;
|
||||
for line in prepaint
|
||||
.last_layout
|
||||
.iter()
|
||||
.skip(visible_range.start)
|
||||
.take(visible_range.len())
|
||||
{
|
||||
let p = point(origin.x + prepaint.line_number_width, origin.y + offset_y);
|
||||
for line in prepaint.last_layout.lines.iter() {
|
||||
let p = point(
|
||||
origin.x + prepaint.last_layout.line_number_width,
|
||||
origin.y + offset_y,
|
||||
);
|
||||
_ = line.paint(p, line_height, TextAlign::Left, None, window, cx);
|
||||
offset_y += line.size(line_height).height;
|
||||
}
|
||||
|
||||
if focused {
|
||||
// Paint blinking cursor
|
||||
if focused && show_cursor {
|
||||
if let Some(mut cursor_bounds) = prepaint.cursor_bounds.take() {
|
||||
cursor_bounds.origin.y += prepaint.cursor_scroll_offset.y;
|
||||
window.paint_quad(fill(cursor_bounds, cx.theme().cursor));
|
||||
}
|
||||
}
|
||||
|
||||
self.input.update(cx, |input, cx| {
|
||||
input.last_layout = Some(prepaint.last_layout.clone());
|
||||
input.last_bounds = Some(bounds);
|
||||
input.last_cursor_offset = Some(input.cursor_offset());
|
||||
input.set_input_bounds(input_bounds, cx);
|
||||
input.last_selected_range = Some(selected_range);
|
||||
input.scroll_size = prepaint.scroll_size;
|
||||
input.line_number_width = prepaint.line_number_width;
|
||||
input
|
||||
// Paint line numbers
|
||||
let mut offset_y = px(0.);
|
||||
if let Some(line_numbers) = prepaint.line_numbers.as_ref() {
|
||||
offset_y += invisible_top_padding;
|
||||
|
||||
// Paint line number background
|
||||
window.paint_quad(fill(
|
||||
Bounds {
|
||||
origin: input_bounds.origin,
|
||||
size: size(
|
||||
prepaint.last_layout.line_number_width - LINE_NUMBER_RIGHT_MARGIN,
|
||||
input_bounds.size.height,
|
||||
),
|
||||
},
|
||||
cx.theme().background,
|
||||
));
|
||||
|
||||
// Each item is the normal lines.
|
||||
for lines in line_numbers.iter() {
|
||||
let p = point(input_bounds.origin.x, origin.y + offset_y);
|
||||
|
||||
for line in lines {
|
||||
_ = line.paint(p, line_height, window, cx);
|
||||
offset_y += line_height;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self.state.update(cx, |state, cx| {
|
||||
state.last_layout = Some(prepaint.last_layout.clone());
|
||||
state.last_bounds = Some(bounds);
|
||||
state.last_cursor = Some(state.cursor());
|
||||
state.set_input_bounds(input_bounds, cx);
|
||||
state.last_selected_range = Some(selected_range);
|
||||
state.scroll_size = prepaint.scroll_size;
|
||||
state
|
||||
.scroll_handle
|
||||
.set_offset(prepaint.cursor_scroll_offset);
|
||||
state.deferred_scroll_offset = None;
|
||||
|
||||
cx.notify();
|
||||
});
|
||||
|
||||
if let Some(hitbox) = prepaint.hover_definition_hitbox.as_ref() {
|
||||
window.set_cursor_style(gpui::CursorStyle::PointingHand, hitbox);
|
||||
}
|
||||
|
||||
self.paint_mouse_listeners(window, cx);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user