260 lines
8.5 KiB
Rust
260 lines
8.5 KiB
Rust
use crate::app::TextEditor;
|
|
use eframe::egui;
|
|
use egui_extras::syntax_highlighting::{self};
|
|
|
|
use super::find_highlight;
|
|
|
|
pub(super) fn editor_view_ui(ui: &mut egui::Ui, app: &mut TextEditor) -> egui::Response {
|
|
let _current_match_position = app.get_current_match_position();
|
|
let show_find = app.show_find;
|
|
let _prev_show_find = app.prev_show_find;
|
|
let show_preferences = app.show_preferences;
|
|
let show_about = app.show_about;
|
|
let show_shortcuts = app.show_shortcuts;
|
|
let word_wrap = app.word_wrap;
|
|
let font_size = app.font_size;
|
|
let font_id = app.get_font_id();
|
|
let syntax_highlighting_enabled = app.syntax_highlighting;
|
|
|
|
let reset_zoom_key = egui::Id::new("editor_reset_zoom");
|
|
let should_reset_zoom = ui
|
|
.ctx()
|
|
.memory_mut(|mem| mem.data.get_temp::<bool>(reset_zoom_key).unwrap_or(false));
|
|
|
|
if should_reset_zoom {
|
|
app.zoom_factor = 1.0;
|
|
ui.ctx().set_zoom_factor(1.0);
|
|
ui.ctx().memory_mut(|mem| {
|
|
mem.data.insert_temp(reset_zoom_key, false);
|
|
});
|
|
}
|
|
|
|
let estimated_width = if !word_wrap {
|
|
app.calculate_content_based_width(ui)
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
let find_data = if show_find && !app.find_matches.is_empty() {
|
|
app.get_active_tab().map(|tab| {
|
|
(
|
|
tab.content.to_owned(),
|
|
app.find_matches.to_owned(),
|
|
app.current_match_index,
|
|
)
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let Some(active_tab) = app.get_active_tab_mut() else {
|
|
return ui.label("No file open, how did you get here?");
|
|
};
|
|
|
|
let bg_color = ui.visuals().extreme_bg_color;
|
|
let editor_rect = ui.available_rect_before_wrap();
|
|
ui.painter().rect_filled(editor_rect, 0.0, bg_color);
|
|
|
|
if let Some((content, matches, current_match_index)) = &find_data {
|
|
let font_id = ui
|
|
.style()
|
|
.text_styles
|
|
.get(&egui::TextStyle::Monospace)
|
|
.unwrap_or(&egui::FontId::monospace(font_size))
|
|
.to_owned();
|
|
|
|
let desired_width = if word_wrap {
|
|
ui.available_width()
|
|
} else {
|
|
f32::INFINITY
|
|
};
|
|
|
|
let temp_galley = ui.fonts(|fonts| {
|
|
fonts.layout(
|
|
content.to_owned(),
|
|
font_id.to_owned(),
|
|
ui.visuals().text_color(),
|
|
desired_width,
|
|
)
|
|
});
|
|
|
|
let text_area_left = editor_rect.left() + 4.0;
|
|
let text_area_top = editor_rect.top() + 2.0;
|
|
|
|
find_highlight::draw_find_highlights(
|
|
ui,
|
|
content,
|
|
matches,
|
|
*current_match_index,
|
|
&temp_galley,
|
|
text_area_left,
|
|
text_area_top,
|
|
font_size,
|
|
);
|
|
}
|
|
|
|
let desired_width = if word_wrap {
|
|
ui.available_width()
|
|
} else {
|
|
f32::INFINITY
|
|
};
|
|
|
|
let language = super::languages::get_language_from_extension(active_tab.file_path.as_deref());
|
|
let mut layouter = |ui: &egui::Ui, string: &dyn egui::TextBuffer, wrap_width: f32| {
|
|
// let syntect_theme =
|
|
// crate::app::theme::create_code_theme_from_visuals(ui.visuals(), font_size);
|
|
let text = string.as_str();
|
|
let theme = egui_extras::syntax_highlighting::CodeTheme::dark(font_size);
|
|
let mut layout_job = if syntax_highlighting_enabled && language != "txt" {
|
|
// let mut settings = egui_extras::syntax_highlighting::SyntectSettings::default();
|
|
// settings.ts = syntect_theme;
|
|
// syntax_highlighting::highlight_with(ui.ctx(), &ui.style().clone(), &theme, text, &language, &settings)
|
|
syntax_highlighting::highlight(ui.ctx(), &ui.style().clone(), &theme, text, &language)
|
|
} else {
|
|
syntax_highlighting::highlight(ui.ctx(), &ui.style().clone(), &theme, text, "")
|
|
};
|
|
|
|
if syntax_highlighting_enabled && language != "txt" {
|
|
for section in &mut layout_job.sections {
|
|
section.format.font_id = font_id.clone();
|
|
}
|
|
}
|
|
|
|
layout_job.wrap.max_width = wrap_width;
|
|
ui.fonts(|f| f.layout_job(layout_job))
|
|
};
|
|
|
|
let text_edit = egui::TextEdit::multiline(&mut active_tab.content)
|
|
.frame(false)
|
|
.code_editor()
|
|
.desired_width(desired_width)
|
|
.desired_rows(0)
|
|
.lock_focus(!show_find)
|
|
.cursor_at_end(false)
|
|
.layouter(&mut layouter)
|
|
.id(egui::Id::new("main_text_editor"));
|
|
|
|
let output = if word_wrap {
|
|
text_edit.show(ui)
|
|
} else {
|
|
egui::ScrollArea::horizontal()
|
|
.auto_shrink([false; 2])
|
|
.show(ui, |ui| {
|
|
ui.allocate_ui_with_layout(
|
|
egui::Vec2::new(estimated_width, ui.available_height()),
|
|
egui::Layout::left_to_right(egui::Align::TOP),
|
|
|ui| text_edit.show(ui),
|
|
)
|
|
})
|
|
.inner
|
|
.inner
|
|
};
|
|
|
|
let content_changed = output.response.changed();
|
|
let content_for_processing = if content_changed {
|
|
active_tab.update_modified_state();
|
|
Some(active_tab.content.to_owned())
|
|
} else {
|
|
None
|
|
};
|
|
|
|
// Save state cache when content changes (after releasing the borrow)
|
|
if content_changed {
|
|
if let Err(e) = app.save_state_cache() {
|
|
eprintln!("Failed to save state cache: {e}");
|
|
}
|
|
}
|
|
|
|
if content_changed && app.show_find && !app.find_query.is_empty() {
|
|
app.update_find_matches();
|
|
}
|
|
|
|
let current_cursor_pos = output
|
|
.state
|
|
.cursor
|
|
.char_range()
|
|
.map(|range| range.primary.index);
|
|
|
|
if let Some(content) = content_for_processing {
|
|
let previous_content = app.previous_content.to_owned();
|
|
let previous_cursor_pos = app.previous_cursor_char_index;
|
|
|
|
if !previous_content.is_empty() {
|
|
if let (Some(prev_cursor_pos), Some(curr_cursor_pos)) =
|
|
(previous_cursor_pos, current_cursor_pos)
|
|
{
|
|
app.process_incremental_change(
|
|
&previous_content,
|
|
&content,
|
|
prev_cursor_pos,
|
|
curr_cursor_pos,
|
|
ui,
|
|
);
|
|
}
|
|
} else {
|
|
app.process_text_for_rendering(&content, ui);
|
|
}
|
|
|
|
app.previous_content = content.to_owned();
|
|
app.previous_cursor_char_index = current_cursor_pos;
|
|
}
|
|
|
|
if app.font_settings_changed || app.text_needs_processing {
|
|
if let Some(active_tab) = app.get_active_tab() {
|
|
let content = active_tab.content.to_owned();
|
|
app.process_text_for_rendering(&content, ui);
|
|
}
|
|
app.font_settings_changed = false;
|
|
app.text_needs_processing = false;
|
|
}
|
|
|
|
if !word_wrap {
|
|
if let Some(cursor_pos) = current_cursor_pos {
|
|
let cursor_moved = Some(cursor_pos) != app.previous_cursor_position;
|
|
let text_changed = output.response.changed();
|
|
|
|
if cursor_moved || text_changed {
|
|
if let Some(active_tab) = app.get_active_tab() {
|
|
let content = &active_tab.content;
|
|
let cursor_line = content
|
|
.char_indices()
|
|
.take_while(|(byte_pos, _)| *byte_pos < cursor_pos)
|
|
.filter(|(_, ch)| *ch == '\n')
|
|
.count();
|
|
|
|
let font_id = ui
|
|
.style()
|
|
.text_styles
|
|
.get(&egui::TextStyle::Monospace)
|
|
.unwrap_or(&egui::FontId::monospace(font_size))
|
|
.to_owned();
|
|
let line_height = ui.fonts(|fonts| fonts.row_height(&font_id));
|
|
|
|
let y_pos = output.response.rect.top() + (cursor_line as f32 * line_height);
|
|
let cursor_rect = egui::Rect::from_min_size(
|
|
egui::pos2(output.response.rect.left(), y_pos),
|
|
egui::vec2(2.0, line_height),
|
|
);
|
|
|
|
let visible_area = ui.clip_rect();
|
|
if !visible_area.intersects(cursor_rect) {
|
|
ui.scroll_to_rect(cursor_rect, Some(egui::Align::Center));
|
|
}
|
|
}
|
|
}
|
|
app.previous_cursor_position = Some(cursor_pos);
|
|
}
|
|
}
|
|
|
|
if !output.response.has_focus()
|
|
&& !show_preferences
|
|
&& !show_about
|
|
&& !show_shortcuts
|
|
&& !show_find
|
|
{
|
|
output.response.request_focus();
|
|
}
|
|
|
|
output.response
|
|
}
|