omg-team/qode
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

use gpui

Browse Source
This commit is contained in:
dedal.qq
2026-10-30 00:31:49 +03:00
parent dce595fbc0
commit e00f63e5da
17 changed files with 6479 additions and 3200 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/api.rs
+87 -78
View File
@@ -1,22 +1,57 @@
//! Глобальный API приложения.
//!
//! Единственная точка входа для команд управления окном и редактором: UI-код
//! не работает с `ViewportCommand` и состоянием редактора напрямую, а вызывает
//! и Lua-сценарии не трогают `Window` и состояние вида напрямую, а вызывают
//! методы [`AppApi`].
//!
//! Команды окна не выполняются в момент вызова: Lua-обработчик выполняется вне
//! контекста `App`/`Window`, поэтому [`AppApi`] складывает их в очередь, а вид
//! вычитывает её в начале кадра.
use std::cell::RefCell;
use std::cell::{Cell, RefCell};
use std::collections::VecDeque;
use std::rc::Rc;
use eframe::egui;
use crate::editor::EditorState;
use crate::editor::{Language, Workspace};
use crate::keymap::{KeyBinding, KeyMap};
use crate::syntax::Language;
thread_local! {
/// Текущий экземпляр API. `thread_local`, потому что `egui::Context` привязан
/// к потоку с event loop; заодно это делает тесты независимыми друг от друга.
/// Текущий экземпляр API. `thread_local`, потому что UI GPUI привязан к
/// потоку с event loop; заодно это делает тесты независимыми друг от друга.
static INSTANCE: RefCell<Option<AppApi>> = const { RefCell::new(None) };
/// Команды окна, ожидающие ближайшего кадра.
static WINDOW_COMMANDS: RefCell<VecDeque<WindowCommand>> = const { RefCell::new(VecDeque::new()) };
/// Развёрнуто ли окно. Вид обновляет значение в каждом кадре, чтобы
/// `app:is_maximized()` из Lua видел актуальное состояние.
static WINDOW_MAXIMIZED: Cell<bool> = const { Cell::new(false) };
}
/// Действие над окном, отложенное до ближайшего кадра.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum WindowCommand {
Close,
Minimize,
ToggleMaximize,
SetMaximized(bool),
}
/// Запоминает, развёрнуто ли окно сейчас.
pub fn set_window_maximized(maximized: bool) {
WINDOW_MAXIMIZED.with(|state| state.set(maximized));
}
/// Забирает накопленные команды окна.
///
/// Очередь очищается: выполнять команды нужно ровно один раз.
pub fn drain_window_commands() -> Vec<WindowCommand> {
WINDOW_COMMANDS.with(|queue| queue.borrow_mut().drain(..).collect())
}
/// Кладёт команду в очередь.
fn push_window_command(command: WindowCommand) {
WINDOW_COMMANDS.with(|queue| queue.borrow_mut().push_back(command));
}
/// Краткая информация об открытой вкладке.
@@ -31,8 +66,8 @@ pub struct TabInfo {
/// Глобальный объект с функциями управления приложением.
///
/// Использование: `AppApi::global().close()`, `AppApi::global().tabs()`.
/// Экземпляр устанавливается в начале каждого кадра (см. [`AppApi::install`]),
/// поэтому всегда указывает на актуальные `egui::Context` и состояние редактора.
/// Экземпляр устанавливается один раз при создании приложения (см.
/// [`AppApi::install`]) и указывает на общие с видом документы и карту клавиш.
///
/// Методы этого `impl`-блока автоматически экспортируются в Lua через
/// `#[mlua::userdata_impl]`: в сценариях они доступны как `app:method(...)`.
@@ -40,28 +75,18 @@ pub struct TabInfo {
#[derive(Clone, mlua::UserData)]
pub struct AppApi {
#[lua(skip)]
ctx: egui::Context,
#[lua(skip)]
editor: Rc<RefCell<EditorState>>,
workspace: Rc<RefCell<Workspace>>,
#[lua(skip)]
keymap: Rc<RefCell<KeyMap>>,
}
#[mlua::userdata_impl]
impl AppApi {
/// Делает переданные контекст, состояние редактора и карту клавиш текущими
/// для [`AppApi::global`].
/// Делает переданные документы и карту клавиш текущими для
/// [`AppApi::global`].
#[lua(skip)]
pub fn install(
ctx: egui::Context,
editor: Rc<RefCell<EditorState>>,
keymap: Rc<RefCell<KeyMap>>,
) -> Self {
let api = Self {
ctx,
editor,
keymap,
};
pub fn install(workspace: Rc<RefCell<Workspace>>, keymap: Rc<RefCell<KeyMap>>) -> Self {
let api = Self { workspace, keymap };
INSTANCE.with(|slot| *slot.borrow_mut() = Some(api.clone()));
api
}
@@ -69,7 +94,7 @@ impl AppApi {
/// Глобальный экземпляр API.
///
/// # Panics
/// Если [`AppApi::install`] ещё не вызывался (ни одного кадра не отрисовано).
/// Если [`AppApi::install`] ещё не вызывался.
#[lua(skip)]
pub fn global() -> Self {
INSTANCE.with(|slot| {
@@ -79,18 +104,12 @@ impl AppApi {
})
}
/// Контекст egui, к которому привязан API.
#[lua(skip)]
pub fn context(&self) -> &egui::Context {
&self.ctx
}
/// Все открытые вкладки в порядке слева направо.
#[allow(dead_code)]
// Часть публичного API приложения: вызывается внешним кодом и тестами.
#[lua(infallible)]
pub fn tabs(&self) -> Vec<TabInfo> {
self.editor
self.workspace
.borrow()
.documents()
.iter()
@@ -107,7 +126,7 @@ impl AppApi {
// Часть публичного API приложения: вызывается внешним кодом и тестами.
#[lua(infallible, name = "active_tab")]
pub fn active_tab_index(&self) -> usize {
self.editor.borrow().active_index()
self.workspace.borrow().active_index()
}
/// Переключает на следующую вкладку (по кругу) и возвращает её индекс.
@@ -115,9 +134,9 @@ impl AppApi {
// Часть публичного API приложения: вызывается внешним кодом и тестами.
#[lua(infallible)]
pub fn next_tab(&self) -> usize {
let mut editor = self.editor.borrow_mut();
let next = (editor.active_index() + 1) % editor.documents().len();
editor.set_active(next);
let mut workspace = self.workspace.borrow_mut();
let next = (workspace.active_index() + 1) % workspace.documents().len();
workspace.set_active(next);
next
}
@@ -126,10 +145,10 @@ impl AppApi {
// Часть публичного API приложения: вызывается внешним кодом и тестами.
#[lua(infallible)]
pub fn previous_tab(&self) -> usize {
let mut editor = self.editor.borrow_mut();
let count = editor.documents().len();
let previous = (editor.active_index() + count - 1) % count;
editor.set_active(previous);
let mut workspace = self.workspace.borrow_mut();
let count = workspace.documents().len();
let previous = (workspace.active_index() + count - 1) % count;
workspace.set_active(previous);
previous
}
@@ -139,11 +158,11 @@ impl AppApi {
/// последняя вкладка, вместо неё открывается пустой документ.
#[lua(infallible)]
pub fn close_tab(&self, index: usize) -> bool {
let mut editor = self.editor.borrow_mut();
if index >= editor.documents().len() {
let mut workspace = self.workspace.borrow_mut();
if index >= workspace.documents().len() {
return false;
}
editor.close(index);
workspace.close(index);
true
}
@@ -153,10 +172,13 @@ impl AppApi {
/// При успешной записи с вкладки снимается маркер несохранённых изменений.
#[lua(skip)]
pub fn save(&self) -> std::io::Result<()> {
let mut editor = self.editor.borrow_mut();
let doc = editor.active_mut();
std::fs::write(&doc.name, &doc.content)?;
doc.mark_saved();
let (path, content) = {
let workspace = self.workspace.borrow();
let doc = workspace.active();
(doc.name.clone(), doc.content.clone())
};
std::fs::write(&path, content)?;
self.workspace.borrow_mut().mark_active_saved();
Ok(())
}
@@ -176,8 +198,7 @@ impl AppApi {
/// * `!a` — отпускание клавиши;
/// * `<A-!r>` — отпускание клавиши при зажатом Alt.
///
/// Клавиша определяется по физическому коду, поэтому Caps Lock и раскладка
/// не важны. Повторное назначение той же клавиши заменяет обработчик.
/// Повторное назначение той же клавиши заменяет обработчик.
///
/// # Errors
/// Возвращает ошибку Lua, если запись привязки некорректна.
@@ -190,13 +211,13 @@ impl AppApi {
/// Содержимое активной вкладки.
#[lua(infallible)]
pub fn active_text(&self) -> String {
self.editor.borrow().active().content.clone()
self.workspace.borrow().active().content.clone()
}
/// Заменяет содержимое активной вкладки.
#[lua(skip)]
pub fn set_active_text(&self, text: impl Into<String>) {
self.editor.borrow_mut().active_mut().content = text.into();
self.workspace.borrow_mut().set_active_text(text);
}
/// Lua-версия [`AppApi::set_active_text`] (generic-методы не экспортируются).
@@ -208,9 +229,9 @@ impl AppApi {
/// Открывает новую пустую вкладку, делает её активной и возвращает её индекс.
#[lua(infallible)]
pub fn open_tab(&self) -> usize {
let mut editor = self.editor.borrow_mut();
editor.open_new();
editor.active_index()
let mut workspace = self.workspace.borrow_mut();
workspace.open_new();
workspace.active_index()
}
/// Делает вкладку активной по её номеру в списке [`AppApi::tabs`].
@@ -218,11 +239,11 @@ impl AppApi {
/// Возвращает `false`, если вкладки с таким номером нет.
#[lua(infallible)]
pub fn set_active_tab(&self, index: usize) -> bool {
let mut editor = self.editor.borrow_mut();
if index >= editor.documents().len() {
let mut workspace = self.workspace.borrow_mut();
if index >= workspace.documents().len() {
return false;
}
editor.set_active(index);
workspace.set_active(index);
true
}
@@ -238,12 +259,7 @@ impl AppApi {
let Some(language) = Language::from_name(language) else {
return false;
};
let mut editor = self.editor.borrow_mut();
let Some(doc) = editor.document_mut(index) else {
return false;
};
doc.language = Some(language);
true
self.workspace.borrow_mut().set_language(index, language)
}
/// Lua-версия [`AppApi::set_language`].
@@ -256,7 +272,7 @@ impl AppApi {
/// или `nil`, если подсветка выключена / вкладки нет.
#[lua(infallible)]
pub fn language(&self, index: usize) -> Option<String> {
self.editor
self.workspace
.borrow()
.document(index)
.and_then(|doc| doc.language)
@@ -268,43 +284,36 @@ impl AppApi {
/// Возвращает `false`, если вкладки с таким номером нет.
#[lua(infallible)]
pub fn clear_language(&self, index: usize) -> bool {
let mut editor = self.editor.borrow_mut();
let Some(doc) = editor.document_mut(index) else {
return false;
};
doc.language = None;
true
self.workspace.borrow_mut().clear_language(index)
}
/// Закрывает окно приложения.
#[lua(infallible)]
pub fn close(&self) {
self.ctx.send_viewport_cmd(egui::ViewportCommand::Close);
push_window_command(WindowCommand::Close);
}
/// Разворачивает окно на весь экран или возвращает его прежний размер.
#[lua(infallible)]
pub fn toggle_maximize(&self) {
self.set_maximized(!self.is_maximized());
push_window_command(WindowCommand::ToggleMaximize);
}
/// Разворачивает (`true`) или восстанавливает (`false`) окно.
#[lua(infallible)]
pub fn set_maximized(&self, maximized: bool) {
self.ctx
.send_viewport_cmd(egui::ViewportCommand::Maximized(maximized));
push_window_command(WindowCommand::SetMaximized(maximized));
}
/// Сворачивает окно.
#[lua(infallible)]
pub fn minimize(&self) {
self.ctx
.send_viewport_cmd(egui::ViewportCommand::Minimized(true));
push_window_command(WindowCommand::Minimize);
}
/// Развёрнуто ли окно прямо сейчас.
#[lua(infallible)]
pub fn is_maximized(&self) -> bool {
self.ctx.input(|i| i.viewport().maximized.unwrap_or(false))
WINDOW_MAXIMIZED.with(Cell::get)
}
}
src/app.rs
+351 -128
View File
@@ -1,175 +1,398 @@
//! Приложение: окно без системных рамок и его содержимое.
//! Приложение: окно, вкладки и редактор кода.
//!
//! Вид [`MyApp`] — единственное место, где доменная модель [`Workspace`]
//! встречается с виджетами gpui-component. Текст вкладки живёт в модели,
//! а `Editor` показывает активный документ; синхронизация выполняется в
//! `render`, когда меняется [`Workspace::revision`].
use std::cell::RefCell;
use std::rc::Rc;
use eframe::egui;
use gpui_kit::component::button::{Button, ButtonVariants};
use gpui_kit::component::input::{Editor, EditorState, InputEvent, TabSize};
use gpui_kit::component::tab::{Tab, TabBar};
use gpui_kit::component::{ActiveTheme, IconName, Sizable, StyledExt, TitleBar, h_flex};
use gpui_kit::*;
use crate::api::AppApi;
use crate::constants::CORNER_RADIUS;
use crate::editor::EditorState;
use crate::api::{self, AppApi, WindowCommand};
use crate::constants::{TAB_SIZE, WINDOW_TITLE};
use crate::editor::Workspace;
use crate::keymap::KeyMap;
use crate::script::ScriptEngine;
use crate::ui::title_bar::TitleBarResponses;
use crate::ui::{code_editor, resize_handles, tabs, title_bar};
#[derive(Default)]
/// Приложение текстового редактора.
pub struct MyApp {
/// Открытые документы, вкладки над редактором и активная вкладка.
/// Открытые документы, вкладки и активная вкладка.
///
/// Состояние общее с [`AppApi`] (`Rc<RefCell<_>>`), чтобы им можно было
/// управлять через `AppApi::global()`.
editor: Rc<RefCell<EditorState>>,
/// управлять через `AppApi::global()` и Lua.
workspace: Rc<RefCell<Workspace>>,
/// Привязки клавиш и их Lua-обработчики.
///
/// Лежит перед `scripts`, чтобы обработчики (ссылки на Lua-значения)
/// уничтожились раньше самого Lua-движка.
keymap: Rc<RefCell<KeyMap>>,
/// Виджет редактора, показывающий активный документ.
editor: Entity<EditorState>,
/// Ревизия [`Workspace`], уже перенесённая в `editor`.
synced_revision: u64,
/// Идентификатор документа, который сейчас показан в редакторе.
///
/// Нужен, чтобы отличить переключение вкладки от изменения её текста и
/// сохранить/восстановить курсор при переходе.
displayed_id: u64,
/// Курсор редактора ещё ни разу не получал фокус.
focused_once: bool,
/// Подписка на изменения редактора; держим её, пока жив вид.
_editor_subscription: Subscription,
/// Движок Lua, созданный при старте.
///
/// Хранится, чтобы глобальное окружение и загруженные модули жили, пока
/// работает приложение.
#[allow(dead_code)]
scripts: Option<ScriptEngine>,
}
impl eframe::App for MyApp {
/// Фон вне скруглённого окна должен быть полностью прозрачным,
/// иначе eframe зальёт его цветом по умолчанию и скругления не будет видно.
fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
egui::Color32::TRANSPARENT.to_normalized_gamma_f32()
}
fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
self.show(ui);
}
}
impl MyApp {
/// Создаёт приложение и сразу выполняет стартовый Lua-сценарий.
/// Создаёт приложение, но не выполняет стартовый сценарий.
///
/// Ошибки чтения/выполнения сценария печатаются в stderr и не мешают
/// запуску приложения: без `init.lua` редактор просто работает как обычно.
pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
let mut app = Self::default();
/// Такой конструктор удобен тестам: они не зависят от `init.lua` в
/// рабочем каталоге. Боевой запуск использует [`Self::with_startup_script`].
pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
let workspace = Rc::new(RefCell::new(Workspace::default()));
let keymap = Rc::new(RefCell::new(KeyMap::default()));
// API доступен сценарию уже до первого кадра.
let api = AppApi::install(cc.egui_ctx.clone(), app.editor.clone(), app.keymap.clone());
match ScriptEngine::new(api) {
let initial_text = workspace.borrow().active().content.clone();
let editor = cx.new(|cx| {
EditorState::new(window, cx)
.line_number(true)
.folding(true)
.searchable(true)
.tab_size(TabSize {
tab_size: TAB_SIZE,
hard_tabs: false,
})
.default_value(initial_text)
});
// Любая правка в виджете сразу попадает в модель. Ревизию при этом не
// трогаем: редактор уже показывает этот текст, и обратная
// синхронизация сбросила бы курсор после каждого символа.
let _editor_subscription = cx.subscribe_in(
&editor,
window,
|this, _editor, event: &InputEvent, _window, cx| {
if matches!(event, InputEvent::Change) {
let text = this.editor.read(cx).value().to_string();
let mut workspace = this.workspace.borrow_mut();
let was_dirty = workspace.active().is_dirty();
workspace.replace_active_content(text);
// Индикатор на вкладке меняется только при переходе
// «чисто → грязно» (или обратно после отмены правки).
if was_dirty != workspace.active().is_dirty() {
drop(workspace);
cx.notify();
}
}
},
);
let displayed_id = workspace.borrow().active().id;
AppApi::install(workspace.clone(), keymap.clone());
Self {
workspace,
keymap,
editor,
synced_revision: 0,
displayed_id,
focused_once: false,
_editor_subscription,
scripts: None,
}
}
/// Выполняет `init.lua` из каталога сценариев.
///
/// Ошибки печатаются в stderr и не мешают запуску: без `init.lua`
/// редактор работает как обычно.
pub fn with_startup_script(mut self) -> Self {
match ScriptEngine::new(AppApi::global()) {
Ok(engine) => {
if let Err(err) = engine.run_startup() {
eprintln!("Lua: {err}");
}
app.scripts = Some(engine);
self.scripts = Some(engine);
}
Err(err) => eprintln!("Lua: не удалось создать движок: {err}"),
}
app
self
}
/// Состояние редактора (доступ для тестов).
/// Общие документы (доступ для тестов).
#[cfg(test)]
pub fn editor(&self) -> std::cell::Ref<'_, EditorState> {
self.editor.borrow()
pub fn workspace_handle(&self) -> Rc<RefCell<Workspace>> {
self.workspace.clone()
}
/// Всё содержимое окна. Вынесено из `eframe::App::ui`, чтобы можно было
/// вернуть наружу `Response`-ы заголовка (пригодится для проверок/тестов).
pub fn show(&mut self, ui: &mut egui::Ui) -> TitleBarResponses {
let ctx = ui.ctx().clone();
// Публикуем глобальный API на текущий кадр: дальше любой модуль может
// управлять приложением и редактором через `AppApi::global()`.
AppApi::install(ctx.clone(), self.editor.clone(), self.keymap.clone());
// Обработчики клавиш вызываем до отрисовки, чтобы изменения состояния
// успели попасть в текущий кадр.
self.dispatch_keys(&ctx);
// Базовый фрейм для всего окна приложения со скруглением
let style = ui.style().clone();
let panel_frame = egui::Frame::new()
.fill(style.visuals.window_fill()) // Фон из текущей темы
.corner_radius(egui::CornerRadius::same(CORNER_RADIUS)) // Скругление углов самого окна
.stroke(egui::Stroke::new(
1.0,
style.visuals.widgets.noninteractive.bg_stroke.color,
))
.inner_margin(0.0) // Чтобы заголовок плотно прижимался к краям
.outer_margin(0.0);
let mut bar = None;
egui::CentralPanel::default()
.frame(panel_frame)
.show(ui, |ui| {
// 1. Отрисовка интегрированного заголовка (Title Bar)
// с именем активного документа, как в обычном редакторе.
let title = self.editor.borrow().active().name.clone();
bar = Some(title_bar::render(ui, &title));
// 2. Вкладки и редактор занимают всю оставшуюся площадь
self.show_workspace(ui);
});
// Контент прилегает к краям панели, поэтому рамку окна рисуем поверх него.
ui.painter().rect_stroke(
ctx.content_rect(),
egui::CornerRadius::same(CORNER_RADIUS),
egui::Stroke::new(1.0, style.visuals.widgets.noninteractive.bg_stroke.color),
egui::StrokeKind::Inside,
);
// 3. Невидимые зоны изменения размера по краям (после контента — значит, поверх него).
resize_handles::render(ui);
bar.expect("CentralPanel всегда отрисовывает заголовок")
/// Редактор активной вкладки (доступ для тестов).
#[cfg(test)]
pub fn editor_handle(&self) -> Entity<EditorState> {
self.editor.clone()
}
/// Вызывает Lua-обработчики, совпавшие с событиями клавиатуры этого кадра.
fn dispatch_keys(&self, ctx: &egui::Context) {
// Заём карты заканчивается до вызова колбэков: обработчик может сам
// вызвать `app:map_key` и изменить привязки.
let callbacks = self.keymap.borrow().callbacks_for(ctx);
for callback in callbacks {
if let Err(err) = callback.call::<()>(()) {
eprintln!("Lua: ошибка в обработчике клавиши: {err}");
/// Переносит изменения модели в виджет редактора.
///
/// `set_value` сбрасывает выделение и прокрутку, поэтому вызывается только
/// когда текст действительно изменился извне (смена вкладки, Lua, `+`/`×`).
fn sync_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
let revision = self.workspace.borrow().revision();
if revision == self.synced_revision {
return;
}
self.synced_revision = revision;
let (active_id, content, language, cursor) = {
let workspace = self.workspace.borrow();
let doc = workspace.active();
(doc.id, doc.content.clone(), doc.language, doc.cursor)
};
let switching = active_id != self.displayed_id;
if switching {
// Запоминаем курсор покидаемой вкладки до того, как индекс
// документа перестанет быть актуальным.
let cursor = self.editor.read(cx).cursor();
if let Some(doc) = self
.workspace
.borrow_mut()
.document_mut_by_id(self.displayed_id)
{
doc.cursor = cursor;
}
}
self.displayed_id = active_id;
let highlight = language
.map(|language| language.highlight_name())
.unwrap_or("");
self.editor.update(cx, |state, cx| {
if state.value().as_ref() != content.as_str() {
state.set_value(content, window, cx);
}
if state.language_name().as_ref() != highlight {
state.set_highlighter(highlight, cx);
}
if switching {
let cursor = cursor.min(state.value().len());
state.set_selected_range(cursor..cursor, cx);
}
state.focus(window, cx);
});
}
/// Полоса вкладок: активная вкладка, маркер несохранённых изменений и «+».
fn render_tabs(&self, cx: &mut Context<Self>) -> impl IntoElement {
let (tabs, active) = {
let workspace = self.workspace.borrow();
(
workspace
.documents()
.iter()
.map(|doc| (doc.name.clone(), doc.is_dirty()))
.collect::<Vec<_>>(),
workspace.active_index(),
)
};
let entity = cx.entity();
let mut bar = TabBar::new("tabs").selected_index(active);
for (index, (name, dirty)) in tabs.into_iter().enumerate() {
// У несохранённого документа вместо крестика горит точка — как в
// исходном приложении.
let suffix: AnyElement = if dirty {
div()
.size(px(6.))
.rounded_full()
.bg(cx.theme().primary)
.into_any_element()
} else {
let entity = entity.clone();
Button::new(format!("close-tab-{index}"))
.xsmall()
.ghost()
.icon(IconName::Close)
.tooltip("Закрыть вкладку")
.on_click(move |_, _, cx| {
// Иначе клик закроет вкладку и тут же переключит на неё
// соседнюю по уже устаревшему индексу.
cx.stop_propagation();
entity.update(cx, |this, cx| {
this.workspace.borrow_mut().close(index);
cx.notify();
});
})
.into_any_element()
};
bar = bar.child(Tab::new().label(name).suffix(suffix));
}
bar.suffix(
Button::new("new-tab")
.xsmall()
.ghost()
.icon(IconName::Plus)
.tooltip("Новая вкладка")
.on_click({
let entity = entity.clone();
move |_, _, cx| {
entity.update(cx, |this, cx| {
this.workspace.borrow_mut().open_new();
cx.notify();
});
}
}),
)
.on_click({
let entity = entity.clone();
move |index, _, cx| {
entity.update(cx, |this, cx| {
this.workspace.borrow_mut().set_active(*index);
cx.notify();
});
}
})
}
}
impl Render for MyApp {
fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
// Состояние окна нужно `app:is_maximized()` из Lua.
api::set_window_maximized(window.is_maximized());
// Команды могли накопиться в Lua-обработчике или в стартовом сценарии.
apply_window_commands(window);
self.sync_editor(window, cx);
if !self.focused_once {
self.focused_once = true;
self.editor.update(cx, |state, cx| state.focus(window, cx));
}
let title = {
let workspace = self.workspace.borrow();
format!("{} — {WINDOW_TITLE}", workspace.active().name)
};
let keymap = self.keymap.clone();
let entity = cx.entity();
div()
.id("app-root")
.size_full()
.flex()
.flex_col()
.bg(cx.theme().background)
.text_color(cx.theme().foreground)
.on_key_down({
let keymap = keymap.clone();
let entity = entity.clone();
move |event, window, cx| {
let mut handled = false;
if is_save_shortcut(&event.keystroke) {
save_active_tab();
handled = true;
}
handled |= dispatch_keymap(&keymap, &event.keystroke, true);
// Обработчик мог поставить команду окна или изменить документы.
apply_window_commands(window);
if handled {
entity.update(cx, |_, cx| cx.notify());
}
}
})
.on_key_up({
let keymap = keymap.clone();
let entity = entity.clone();
move |event, window, cx| {
let handled = dispatch_keymap(&keymap, &event.keystroke, false);
apply_window_commands(window);
if handled {
entity.update(cx, |_, cx| cx.notify());
}
}
})
.child(
TitleBar::new().child(
h_flex()
.w_full()
.pr_2()
.justify_between()
.child(div().text_sm().font_medium().child(title))
.child(
div()
.text_xs()
.text_color(cx.theme().muted_foreground)
.child("gpui-kit · tree-sitter"),
),
),
)
.child(self.render_tabs(cx))
.child(
div()
.flex_1()
.w_full()
.min_h_0()
.child(Editor::new(&self.editor).bordered(false).size_full()),
)
}
}
/// Выполняет накопленные команды окна.
fn apply_window_commands(window: &mut Window) {
for command in api::drain_window_commands() {
match command {
WindowCommand::Close => {
window.remove_window();
return;
}
WindowCommand::Minimize => window.minimize_window(),
WindowCommand::ToggleMaximize => window.zoom_window(),
WindowCommand::SetMaximized(maximized) => {
if window.is_maximized() != maximized {
window.zoom_window();
}
}
}
}
}
/// Полоса вкладок и редактор активного документа.
fn show_workspace(&mut self, ui: &mut egui::Ui) {
let mut focus_editor = false;
/// Ctrl+S (Cmd+S на macOS) сохраняет активную вкладку.
fn is_save_shortcut(keystroke: &Keystroke) -> bool {
keystroke.key.eq_ignore_ascii_case("s")
&& (keystroke.modifiers.control || keystroke.modifiers.platform)
&& !keystroke.modifiers.alt
}
// Ctrl+S пишет активную вкладку в файл с её названием.
if ui.input_mut(|input| input.consume_key(egui::Modifiers::COMMAND, egui::Key::S))
&& let Err(err) = AppApi::global().save()
{
eprintln!("Не удалось сохранить вкладку: {err}");
}
// Заём держим только на время отрисовки, чтобы действия из API
// (они берут тот же `RefCell`) не конфликтовали с ним.
let actions = {
let editor = self.editor.borrow();
tabs::render(ui, editor.documents(), editor.active_index())
};
if let Some(index) = actions.clicked_tab {
self.editor.borrow_mut().set_active(index);
focus_editor = true;
}
if let Some(index) = actions.closed_tab {
AppApi::global().close_tab(index);
}
if actions.add_clicked {
self.editor.borrow_mut().open_new();
focus_editor = true;
}
let mut editor = self.editor.borrow_mut();
code_editor::render(ui, editor.active_mut(), focus_editor);
/// Сохраняет активную вкладку, печатая ошибку в stderr.
fn save_active_tab() {
if let Err(err) = AppApi::global().save() {
eprintln!("Не удалось сохранить вкладку: {err}");
}
}
/// Вызывает Lua-обработчики, совпавшие с событием клавиатуры.
///
/// Возвращает `true`, если хотя бы один обработчик вызван. Заём карты
/// заканчивается до вызова колбэков: обработчик может сам вызвать
/// `app:map_key` и изменить привязки.
fn dispatch_keymap(keymap: &Rc<RefCell<KeyMap>>, keystroke: &Keystroke, pressed: bool) -> bool {
let callbacks = keymap.borrow().callbacks_for(keystroke, pressed);
let handled = !callbacks.is_empty();
for callback in callbacks {
if let Err(err) = callback.call::<()>(()) {
eprintln!("Lua: ошибка в обработчике клавиши: {err}");
}
}
handled
}
src/constants.rs
+15 -9
View File
@@ -1,16 +1,22 @@
//! Константы оформления окна.
//! Константы оформления окна и сценариев.
/// Насколько сильно скругляются углы окна.
pub const CORNER_RADIUS: u8 = 12;
/// Ширина окна при запуске.
pub const WINDOW_WIDTH: f32 = 900.0;
/// Высота интегрированного заголовка.
pub const TITLE_BAR_HEIGHT: f32 = 32.0;
/// Высота окна при запуске.
pub const WINDOW_HEIGHT: f32 = 600.0;
/// Толщина невидимой зоны по краям окна, за которую можно менять размер.
pub const RESIZE_BORDER: f32 = 6.0;
/// Минимальная ширина окна.
pub const MIN_WINDOW_WIDTH: f32 = 420.0;
/// Высота полосы вкладок над редактором.
pub const TAB_BAR_HEIGHT: f32 = 34.0;
/// Минимальная высота окна.
pub const MIN_WINDOW_HEIGHT: f32 = 280.0;
/// Подпись окна в панели задач и в заголовке.
pub const WINDOW_TITLE: &str = "Custom Window App";
/// Ширина одного уровня отступа в редакторе.
pub const TAB_SIZE: usize = 4;
/// Каталог, в котором приложение ищет Lua-сценарии.
///
src/editor.rs
+150 -14
View File
@@ -1,18 +1,88 @@
//! Документы редактора и состояние вкладок.
//!
//! Это доменная модель приложения: текст, имена и языки вкладок живут здесь,
//! а виджет `Editor` из gpui-component показывает активный документ. Такое
//! разделение позволяет Lua-сценариям менять документы без доступа к `Window`
//! и `App`: вид обновляет редактор, когда меняется [`Workspace::revision`].
use std::sync::atomic::{AtomicU64, Ordering};
use crate::syntax::{Language, SyntaxState};
/// Счётчик идентификаторов документов.
static NEXT_ID: AtomicU64 = AtomicU64::new(1);
/// Языки, для которых в редакторе включена подсветка tree-sitter.
///
/// Названия намеренно короткие (`js`, а не `javascript`): именно их возвращает
/// [`Language::name`] и показывает Lua-API. gpui-component принимает такие
/// псевдонимы и сам приводит их к имени грамматики.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Language {
Rust,
Go,
JavaScript,
Json,
Python,
}
impl Language {
/// Все поддерживаемые языки.
#[allow(dead_code)]
// Часть публичного интерфейса модуля: удобно для перебора языков снаружи.
pub const ALL: [Self; 5] = [
Self::Rust,
Self::Go,
Self::JavaScript,
Self::Json,
Self::Python,
];
/// Разбирает название языка из API/сценария.
///
/// Основные имена — `rust`, `go`, `js`, `json`, `python`; короткие
/// (`rs`, `golang`, `javascript`, `py`) и регистр тоже принимаются.
pub fn from_name(name: &str) -> Option<Self> {
match name.trim().to_ascii_lowercase().as_str() {
"rust" | "rs" => Some(Self::Rust),
"go" | "golang" => Some(Self::Go),
"js" | "javascript" | "node" => Some(Self::JavaScript),
"json" => Some(Self::Json),
"python" | "py" => Some(Self::Python),
_ => None,
}
}
/// Каноническое имя языка (то, что возвращает `AppApi::language`).
pub fn name(self) -> &'static str {
match self {
Self::Rust => "rust",
Self::Go => "go",
Self::JavaScript => "js",
Self::Json => "json",
Self::Python => "python",
}
}
/// Имя языка для `EditorState::set_highlighter`.
///
/// Здесь `js` разворачивается в `javascript`: так грамматика находится
/// без дополнительных псевдонимов на нашей стороне.
pub fn highlight_name(self) -> &'static str {
match self {
Self::Rust => "rust",
Self::Go => "go",
Self::JavaScript => "javascript",
Self::Json => "json",
Self::Python => "python",
}
}
}
/// Открытый в редакторе документ.
pub struct Document {
/// Стабильный идентификатор, пока документ открыт.
///
/// По нему `TextEdit` и `ScrollArea` хранят курсор, выделение и прокрутку,
/// поэтому переключение вкладок не сбрасывает состояние редактора.
/// По нему вид отличает «ту же вкладку» от «другой вкладки с тем же
/// индексом» после закрытия соседей.
pub id: u64,
pub name: String,
pub content: String,
@@ -21,8 +91,8 @@ pub struct Document {
/// `None` — подсветка выключена (поведение по умолчанию). Включается
/// только явно через `AppApi::set_language`, например из Lua-сценария.
pub language: Option<Language>,
/// Разбор tree-sitter и кэш подсветки для этого документа.
pub syntax: SyntaxState,
/// Позиция курсора в байтах на момент ухода с вкладки.
pub cursor: usize,
/// Содержимое на момент последнего «сохранения».
saved_content: String,
}
@@ -36,7 +106,7 @@ impl Document {
saved_content: content.clone(),
content,
language: None,
syntax: SyntaxState::default(),
cursor: 0,
}
}
@@ -55,13 +125,19 @@ impl Document {
///
/// Инвариант: `documents` никогда не пуст — редактор всегда показывает хотя бы
/// один документ. Это позволяет `active`/`active_mut` не возвращать `Option`.
pub struct EditorState {
pub struct Workspace {
documents: Vec<Document>,
active: usize,
next_untitled: u32,
/// Номер «поколения» состояния.
///
/// Вид перечитывает активный документ в редактор только когда ревизия
/// изменилась. Набор текста сам обновляет документ и ревизию не трогает,
/// иначе редактор переставлял бы курсор после каждого символа.
revision: u64,
}
impl Default for EditorState {
impl Default for Workspace {
fn default() -> Self {
Self {
documents: vec![
@@ -70,11 +146,12 @@ impl Default for EditorState {
],
active: 0,
next_untitled: 0,
revision: 0,
}
}
}
impl EditorState {
impl Workspace {
pub fn documents(&self) -> &[Document] {
&self.documents
}
@@ -96,15 +173,26 @@ impl EditorState {
self.documents.get(index)
}
/// Изменяемый документ по номеру вкладки (для API).
pub fn document_mut(&mut self, index: usize) -> Option<&mut Document> {
self.documents.get_mut(index)
/// Изменяемый документ по стабильному идентификатору.
pub fn document_mut_by_id(&mut self, id: u64) -> Option<&mut Document> {
self.documents.iter_mut().find(|doc| doc.id == id)
}
/// Текущая ревизия состояния.
pub fn revision(&self) -> u64 {
self.revision
}
/// Сообщает виду, что документы нужно перечитать.
fn bump(&mut self) {
self.revision = self.revision.wrapping_add(1);
}
/// Делает вкладку активной, если индекс существует.
pub fn set_active(&mut self, index: usize) {
if index < self.documents.len() {
if index < self.documents.len() && index != self.active {
self.active = index;
self.bump();
}
}
@@ -116,6 +204,7 @@ impl EditorState {
"",
));
self.active = self.documents.len() - 1;
self.bump();
}
/// Закрывает вкладку и выбирает соседнюю.
@@ -135,6 +224,53 @@ impl EditorState {
} else if index == self.active {
self.active = self.active.min(self.documents.len() - 1);
}
self.bump();
}
/// Обновляет текст активного документа без изменения ревизии.
///
/// Используется видом после ввода в редакторе: сам виджет уже показывает
/// этот текст, поэтому повторная синхронизация только сбросила бы курсор.
pub fn replace_active_content(&mut self, content: String) {
self.active_mut().content = content;
}
/// Заменяет текст активной вкладки извне (Lua, меню, тесты).
pub fn set_active_text(&mut self, text: impl Into<String>) {
self.active_mut().content = text.into();
self.bump();
}
/// Включает подсветку для вкладки; возвращает `false`, если вкладки нет.
pub fn set_language(&mut self, index: usize, language: Language) -> bool {
let Some(doc) = self.documents.get_mut(index) else {
return false;
};
if doc.language != Some(language) {
doc.language = Some(language);
self.bump();
}
true
}
/// Выключает подсветку для вкладки; возвращает `false`, если вкладки нет.
pub fn clear_language(&mut self, index: usize) -> bool {
let Some(doc) = self.documents.get_mut(index) else {
return false;
};
if doc.language.take().is_some() {
self.bump();
}
true
}
/// Помечает активный документ сохранённым.
///
/// Ревизия меняется, чтобы индикатор несохранённых изменений на вкладке
/// перерисовался даже без отдельного уведомления вида.
pub fn mark_active_saved(&mut self) {
self.active_mut().mark_saved();
self.bump();
}
}
src/keymap.rs
+194 -104
View File
@@ -7,10 +7,21 @@
//! * `!a` — отпускание клавиши;
//! * `<A-!r>` — отпускание клавиши при зажатом Alt.
//!
//! Клавиша всегда определяется по физическому коду (`physical_key`), поэтому
//! Caps Lock и текущая раскладка клавиатуры на совпадение не влияют.
//! Клавиша сравнивается с `Keystroke.key` из GPUI. Это не результат ввода, а
//! имя клавиши, которое платформа уже нормализует:
//!
//! * Caps Lock не превращает `a` в `A`;
//! * на Linux и Windows буквы берутся по аппаратному keycode, поэтому на
//! русской раскладке физическая `q` всё равно приходит как `"q"`, а
//! напечатанная `й` — только в `key_char`;
//! * на macOS GPUI отдаёт символ раскладки, поэтому там привязки следуют
//! раскладке (ограничение самого GPUI, не этого модуля).
//!
//! Отдельного поля с физическим кодом в публичном `Keystroke`/`KeyDownEvent`
//! у gpui-kit 0.8.1 нет, но для Linux/Windows он и не нужен: ASCII-имя клавиши
//! уже восстановлено по keycode.
use eframe::egui;
use gpui_kit::Keystroke;
/// Модификаторы, которые учитываются при совпадении привязки.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
@@ -23,16 +34,23 @@ pub struct Modifiers {
impl Modifiers {
/// Все три модификатора должны совпасть точно: `<C-z>` не сработает,
/// если вместе с Ctrl зажат ещё и Shift.
fn matches(self, pressed: &egui::Modifiers) -> bool {
self.shift == pressed.shift && self.ctrl == pressed.ctrl && self.alt == pressed.alt
///
/// `platform` (Cmd/Super) и `function` в записи привязки не выражаются,
/// поэтому события с ними не совпадают ни с одной привязкой.
fn matches(self, pressed: &gpui_kit::Modifiers) -> bool {
self.shift == pressed.shift
&& self.ctrl == pressed.control
&& self.alt == pressed.alt
&& !pressed.platform
&& !pressed.function
}
}
/// Разобранная привязка клавиши.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct KeyBinding {
/// Физическая клавиша (не зависит от раскладки и Caps Lock).
pub key: egui::Key,
/// Каноническое имя клавиши в нижнем регистре (`a`, `1`, `pageup`, `f5`).
pub key: String,
pub modifiers: Modifiers,
/// `true` — обработчик вызывается при отпускании клавиши.
pub on_release: bool,
@@ -95,9 +113,25 @@ impl KeyBinding {
})
}
/// Совпадает ли привязка с конкретным событием клавиатуры.
fn matches(&self, key: egui::Key, pressed: bool, modifiers: &egui::Modifiers) -> bool {
self.key == key && self.on_release == !pressed && self.modifiers.matches(modifiers)
/// Совпадает ли привязка с событием клавиатуры.
///
/// `pressed` — `true` для нажатия и `false` для отпускания.
pub fn matches(&self, keystroke: &Keystroke, pressed: bool) -> bool {
self.on_release == !pressed
&& self.modifiers.matches(&keystroke.modifiers)
&& self.key_matches(keystroke)
}
/// Клавиша события совпадает с привязкой.
///
/// Помимо `key` проверяется `key_char`: на части раскладок GPUI кладёт
/// в `key` не-ASCII символ, а печатаемый символ — в `key_char`.
fn key_matches(&self, keystroke: &Keystroke) -> bool {
canonical_key(&keystroke.key) == self.key
|| keystroke
.key_char
.as_deref()
.is_some_and(|key_char| canonical_key(key_char) == self.key)
}
}
@@ -109,52 +143,67 @@ fn split_release(token: &str) -> (bool, &str) {
}
}
/// Превращает имя клавиши из привязки в [`egui::Key`].
fn parse_key(token: &str) -> Result<egui::Key, String> {
/// Приводит имя клавиши из привязки к каноническому виду.
fn parse_key(token: &str) -> Result<String, String> {
let token = token.trim();
if token.is_empty() {
return Err("не указана клавиша".to_owned());
}
// Односимвольные клавиши (`a`, `1`, `-`) и точные имена (`F1`, `Space`).
if let Some(key) = egui::Key::from_name(token) {
return Ok(key);
match canonical_key(token).as_str() {
// Одиночный символ уже канонизирован (`A` → `a`).
canonical if canonical.chars().count() == 1 => Ok(canonical.to_owned()),
canonical if canonical.starts_with('f') && canonical[1..].parse::<u8>().is_ok() => {
Ok(canonical.to_owned())
}
canonical
if matches!(
canonical,
"space"
| "tab"
| "enter"
| "escape"
| "backspace"
| "delete"
| "insert"
| "home"
| "end"
| "pageup"
| "pagedown"
| "up"
| "down"
| "left"
| "right"
) =>
{
Ok(canonical.to_owned())
}
_ => Err(format!("неизвестная клавиша: {token}")),
}
// Регистронезависимые имена: `space`, `enter`, `esc`, `pgup` и т. п.
if let Some(key) = alias_key(token) {
return Ok(key);
}
// `f1` → `F1`.
if let Some(key) = egui::Key::from_name(&token.to_ascii_uppercase()) {
return Ok(key);
}
Err(format!("неизвестная клавиша: {token}"))
}
/// Имена клавиш в нижнем регистре, которых нет в [`egui::Key::from_name`].
fn alias_key(token: &str) -> Option<egui::Key> {
let name = match token.to_ascii_lowercase().as_str() {
"space" => "Space",
"tab" => "Tab",
"enter" | "return" | "cr" => "Enter",
"esc" | "escape" => "Escape",
"backspace" | "bs" => "Backspace",
"delete" | "del" => "Delete",
"insert" => "Insert",
"home" => "Home",
"end" => "End",
"pageup" | "pgup" => "PageUp",
"pagedown" | "pgdn" => "PageDown",
"up" | "arrowup" => "ArrowUp",
"down" | "arrowdown" => "ArrowDown",
"left" | "arrowleft" => "ArrowLeft",
"right" | "arrowright" => "ArrowRight",
_ => return None,
};
egui::Key::from_name(name)
/// Каноническое имя клавиши: нижний регистр, псевдонимы приведены к одному виду.
///
/// Функция используется и при разборе записи привязки, и при сравнении с
/// событием GPUI, поэтому обе стороны всегда говорят на одном языке.
fn canonical_key(key: &str) -> String {
let lower = key.trim().to_lowercase();
match lower.as_str() {
" " => return "space".to_owned(),
"return" | "cr" => return "enter".to_owned(),
"esc" => return "escape".to_owned(),
"bs" => return "backspace".to_owned(),
"del" => return "delete".to_owned(),
"ins" => return "insert".to_owned(),
"pgup" | "page_up" => return "pageup".to_owned(),
"pgdn" | "page_down" => return "pagedown".to_owned(),
"arrowup" => return "up".to_owned(),
"arrowdown" => return "down".to_owned(),
"arrowleft" => return "left".to_owned(),
"arrowright" => return "right".to_owned(),
_ => {}
}
lower
}
/// Привязка вместе с Lua-функцией, которую нужно выполнить.
@@ -184,46 +233,17 @@ impl KeyMap {
}
}
/// Собирает обработчики, которые нужно вызвать для событий текущего кадра.
/// Собирает обработчики, которые нужно вызвать для одного события.
///
/// Заём `KeyMap` здесь заканчивается: вызывать колбэки нужно уже после
/// возврата из метода, потому что обработчик может сам менять привязки
/// через `app:map_key`.
pub fn callbacks_for(&self, ctx: &egui::Context) -> Vec<mlua::Function> {
let key_events: Vec<(egui::Key, bool, egui::Modifiers)> = ctx.input(|input| {
input
.events
.iter()
.filter_map(|event| {
let egui::Event::Key {
key,
physical_key,
pressed,
modifiers,
..
} = event
else {
return None;
};
// Физический код не зависит от раскладки и Caps Lock.
// Логическая клавиша — запасной вариант для платформ,
// где physical_key не заполняется.
Some((physical_key.unwrap_or(*key), *pressed, *modifiers))
})
.collect()
});
let mut callbacks = Vec::new();
for (key, pressed, modifiers) in key_events {
for binding in &self.bindings {
if binding.binding.matches(key, pressed, &modifiers) {
callbacks.push(binding.callback.clone());
}
}
}
callbacks
pub fn callbacks_for(&self, keystroke: &Keystroke, pressed: bool) -> Vec<mlua::Function> {
self.bindings
.iter()
.filter(|binding| binding.binding.matches(keystroke, pressed))
.map(|binding| binding.callback.clone())
.collect()
}
}
@@ -231,6 +251,15 @@ impl KeyMap {
mod tests {
use super::*;
/// Событие без символа ввода: для проверки совпадения этого достаточно.
fn stroke(key: &str, modifiers: gpui_kit::Modifiers) -> Keystroke {
Keystroke {
modifiers,
key: key.to_owned(),
key_char: None,
}
}
fn parse(spec: &str) -> KeyBinding {
KeyBinding::parse(spec).expect("привязка должна разбираться")
}
@@ -240,7 +269,7 @@ mod tests {
assert_eq!(
parse("a"),
KeyBinding {
key: egui::Key::A,
key: "a".to_owned(),
modifiers: Modifiers::default(),
on_release: false,
}
@@ -248,7 +277,7 @@ mod tests {
assert_eq!(
parse("1"),
KeyBinding {
key: egui::Key::Num1,
key: "1".to_owned(),
modifiers: Modifiers::default(),
on_release: false,
}
@@ -256,7 +285,7 @@ mod tests {
assert_eq!(
parse("!a"),
KeyBinding {
key: egui::Key::A,
key: "a".to_owned(),
modifiers: Modifiers::default(),
on_release: true,
}
@@ -268,7 +297,7 @@ mod tests {
assert_eq!(
parse("<S-c>"),
KeyBinding {
key: egui::Key::C,
key: "c".to_owned(),
modifiers: Modifiers {
shift: true,
..Default::default()
@@ -279,7 +308,7 @@ mod tests {
assert_eq!(
parse("<C-z>"),
KeyBinding {
key: egui::Key::Z,
key: "z".to_owned(),
modifiers: Modifiers {
ctrl: true,
..Default::default()
@@ -290,7 +319,7 @@ mod tests {
assert_eq!(
parse("<A-!r>"),
KeyBinding {
key: egui::Key::R,
key: "r".to_owned(),
modifiers: Modifiers {
alt: true,
..Default::default()
@@ -301,7 +330,7 @@ mod tests {
assert_eq!(
parse("<C-S-A-x>"),
KeyBinding {
key: egui::Key::X,
key: "x".to_owned(),
modifiers: Modifiers {
shift: true,
ctrl: true,
@@ -314,7 +343,7 @@ mod tests {
#[test]
fn invalid_bindings_are_rejected() {
for spec in ["", " ", "<", "<C-z", "<Q-z>", "!"] {
for spec in ["", " ", "<", "<C-z", "<Q-z>", "!", "<S-unknown>"] {
assert!(
KeyBinding::parse(spec).is_err(),
"строка {spec:?} должна быть отклонена"
@@ -324,29 +353,90 @@ mod tests {
#[test]
fn named_keys_are_case_insensitive() {
assert_eq!(parse("<C-space>").key, egui::Key::Space);
assert_eq!(parse("<S-enter>").key, egui::Key::Enter);
assert_eq!(parse("<A-esc>").key, egui::Key::Escape);
assert_eq!(parse("<C-f1>").key, egui::Key::F1);
assert_eq!(parse("<C-pgdn>").key, egui::Key::PageDown);
assert_eq!(parse("<C-space>").key, "space");
assert_eq!(parse("<S-enter>").key, "enter");
assert_eq!(parse("<A-esc>").key, "escape");
assert_eq!(parse("<C-f1>").key, "f1");
assert_eq!(parse("<C-pgdn>").key, "pagedown");
assert_eq!(parse("<C-F5>").key, "f5");
}
#[test]
fn matching_requires_exact_modifiers() {
let binding = parse("<S-c>");
let shift = egui::Modifiers {
let shift = gpui_kit::Modifiers {
shift: true,
..Default::default()
};
let shift_ctrl = egui::Modifiers {
let shift_ctrl = gpui_kit::Modifiers {
shift: true,
ctrl: true,
control: true,
..Default::default()
};
assert!(binding.matches(egui::Key::C, true, &shift));
assert!(!binding.matches(egui::Key::C, true, &shift_ctrl));
assert!(!binding.matches(egui::Key::C, false, &shift));
assert!(!binding.matches(egui::Key::V, true, &shift));
assert!(binding.matches(&stroke("c", shift), true));
assert!(!binding.matches(&stroke("c", shift_ctrl), true));
assert!(!binding.matches(&stroke("c", shift), false));
assert!(!binding.matches(&stroke("v", shift), true));
}
#[test]
fn caps_lock_and_key_char_do_not_break_plain_keys() {
let binding = parse("a");
// Caps Lock: GPUI сообщает напечатанный символ `A`, привязка — `a`.
assert!(binding.matches(&stroke("A", gpui_kit::Modifiers::default()), true));
// Символ, который напечатала бы клавиша, может отличаться от имени
// клавиши (композиция, Option на macOS): GPUI кладёт его в key_char.
let mut event = stroke("x", gpui_kit::Modifiers::default());
event.key_char = Some("a".to_owned());
assert!(binding.matches(&event, true));
// А вот Shift+A — уже другое событие.
let shift = gpui_kit::Modifiers {
shift: true,
..Default::default()
};
assert!(!binding.matches(&stroke("a", shift), true));
}
#[test]
fn cyrillic_layout_uses_the_key_name_gpui_reports() {
let binding = parse("<C-q>");
let ctrl = gpui_kit::Modifiers {
control: true,
..Default::default()
};
// Linux/Windows: GPUI восстанавливает ASCII-клавишу по аппаратному
// keycode, поэтому при русской раскладке key уже "q", а напечатанная
// "й" лежит только в key_char. Таблица соответствий не нужна.
let mut event = stroke("q", ctrl);
event.key_char = Some("й".to_owned());
assert!(binding.matches(&event, true));
// Соседняя физическая клавиша по-прежнему не подходит.
event.key = "w".to_owned();
event.key_char = Some("ц".to_owned());
assert!(!binding.matches(&event, true));
}
#[test]
fn release_bindings_match_only_key_up() {
let binding = parse("<!A>");
let plain = gpui_kit::Modifiers::default();
assert!(!binding.matches(&stroke("a", plain), true));
assert!(binding.matches(&stroke("a", plain), false));
// Alt зажат: обычная привязка отпускания больше не совпадает.
let alt = gpui_kit::Modifiers {
alt: true,
..Default::default()
};
assert!(!binding.matches(&stroke("a", alt), false));
// А привязка вида `<A-!a>` — совпадает.
assert!(parse("<A-!a>").matches(&stroke("a", alt), false));
}
}
src/main.rs
+41 -25
View File
@@ -1,39 +1,55 @@
//! Точка входа приложения.
//!
//! Окно создаётся средствами GPUI (gpui-kit). Заголовок рисует компонент
//! `TitleBar`: он же отвечает за перетаскивание окна, двойной клик и кнопки
//! свернуть/развернуть/закрыть, поэтому отдельные зоны изменения размера
//! больше не нужны.
mod api;
mod app;
mod constants;
mod editor;
mod keymap;
mod script;
mod syntax;
mod ui;
#[cfg(test)]
mod tests;
use gpui_kit::component::TitleBar;
use gpui_kit::*;
use app::MyApp;
use eframe::egui;
use constants::{MIN_WINDOW_HEIGHT, MIN_WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE, WINDOW_WIDTH};
fn main() -> eframe::Result<()> {
let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_inner_size([900.0, 600.0])
.with_min_inner_size([420.0, 280.0])
.with_decorations(false) // Отключаем стандартные рамки ОС
.with_transparent(true), // Прозрачность для скругления углов
// Аппаратный MSAA (сглаживание на уровне GPU): 0 — выключен,
// дальше степень двойки. Для плоского 2D-интерфейса egui разница
// почти незаметна, но если внутри появится 3D/сложные меши,
// это единственный «настоящий» переключатель сглаживания.
multisampling: 4,
// Дизеринг убирает полосы (banding) на градиентах и полупрозрачных
// заливках. Он включён по умолчанию, здесь оставлен явно.
dithering: true,
..Default::default()
};
fn main() {
application().with_assets(assets::Assets).run(|cx| {
// Инициализация темы, шрифтов и компонентов обязательна до создания окон.
init(cx);
eframe::run_native(
"Custom Window 0.37",
options,
Box::new(|cc| Ok(Box::new(MyApp::new(cc)))),
)
open_window(window_options(), cx, |window, cx| {
cx.new(|cx| MyApp::new(window, cx).with_startup_script())
})
.expect("не удалось открыть окно");
});
}
/// Параметры окна в стиле исходного приложения: размер 900×600, минимум
/// 420×280 и собственный заголовок вместо системного.
fn window_options() -> WindowOptions {
WindowOptions {
window_bounds: Some(WindowBounds::Windowed(Bounds::new(
point(px(100.), px(100.)),
size(px(WINDOW_WIDTH), px(WINDOW_HEIGHT)),
))),
window_min_size: Some(size(px(MIN_WINDOW_WIDTH), px(MIN_WINDOW_HEIGHT))),
// На Linux системный заголовок включается на уровне оконного менеджера.
// `Client` просит отдать оформление приложению — это аналог
// `with_decorations(false)` из прошлой версии.
window_decorations: Some(WindowDecorations::Client),
titlebar: Some(TitlebarOptions {
title: Some(WINDOW_TITLE.into()),
..TitleBar::title_bar_options()
}),
..TitleBar::window_options()
}
}
src/syntax.rs
-522
View File
@@ -1,522 +0,0 @@
//! Интеграция tree-sitter: разбор текста и подсветка синтаксиса.
//!
//! Модуль не зависит от UI-кода: [`SyntaxState::parse`] возвращает обычное
//! дерево tree-sitter, поэтому его можно использовать не только для цветов,
//! но и для навигации по структуре кода, поиска узлов и проверки ошибок.
//!
//! Подсветка — это список байтовых диапазонов с [`HighlightStyle`]. Как именно
//! их раскрашивать, решает редактор (см. `ui::code_editor`).
//!
//! Поддерживаемые языки: Rust, Go, JavaScript, JSON, Python. Подсветка
//! выключена, пока для документа явно не выбран язык (см. `AppApi::set_language`).
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::sync::OnceLock;
use tree_sitter::{Parser, Query, QueryCursor, StreamingIterator, Tree};
/// Язык, для которого подключена грамматика tree-sitter.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Language {
Rust,
Go,
JavaScript,
Json,
Python,
}
impl Language {
/// Все поддерживаемые языки.
#[allow(dead_code)]
// Часть публичного интерфейса модуля: удобно для перебора языков снаружи.
pub const ALL: [Self; 5] = [
Self::Rust,
Self::Go,
Self::JavaScript,
Self::Json,
Self::Python,
];
/// Разбирает название языка из API/сценария.
///
/// Основные имена — `rust`, `go`, `js`, `json`, `python`; короткие
/// (`rs`, `golang`, `javascript`, `py`) и регистр тоже принимаются.
pub fn from_name(name: &str) -> Option<Self> {
match name.trim().to_ascii_lowercase().as_str() {
"rust" | "rs" => Some(Self::Rust),
"go" | "golang" => Some(Self::Go),
"js" | "javascript" | "node" => Some(Self::JavaScript),
"json" => Some(Self::Json),
"python" | "py" => Some(Self::Python),
_ => None,
}
}
/// Каноническое имя языка (то, что возвращает `AppApi::language`).
pub fn name(self) -> &'static str {
match self {
Self::Rust => "rust",
Self::Go => "go",
Self::JavaScript => "js",
Self::Json => "json",
Self::Python => "python",
}
}
/// Грамматика tree-sitter для языка.
fn grammar(self) -> tree_sitter::Language {
match self {
Self::Rust => tree_sitter_rust::LANGUAGE.into(),
Self::Go => tree_sitter_go::LANGUAGE.into(),
Self::JavaScript => tree_sitter_javascript::LANGUAGE.into(),
Self::Json => tree_sitter_json::LANGUAGE.into(),
Self::Python => tree_sitter_python::LANGUAGE.into(),
}
}
/// Запрос подсветки для языка.
fn query_source(self) -> &'static str {
match self {
Self::Rust => RUST_QUERY,
Self::Go => GO_QUERY,
Self::JavaScript => JS_QUERY,
Self::Json => JSON_QUERY,
Self::Python => PYTHON_QUERY,
}
}
}
/// Семантическая категория участка кода.
///
/// Редактор сам выбирает цвет для каждой категории, поэтому тема оформления
/// не зависит от грамматик.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum HighlightStyle {
Keyword,
String,
Escape,
Number,
Comment,
Function,
Type,
Property,
Constant,
Operator,
Punctuation,
Variable,
}
impl HighlightStyle {
/// Числовая метка для компактного буфера при разборе пересечений.
fn tag(self) -> u8 {
match self {
Self::Keyword => 1,
Self::String => 2,
Self::Escape => 3,
Self::Number => 4,
Self::Comment => 5,
Self::Function => 6,
Self::Type => 7,
Self::Property => 8,
Self::Constant => 9,
Self::Operator => 10,
Self::Punctuation => 11,
Self::Variable => 12,
}
}
fn from_tag(tag: u8) -> Option<Self> {
Some(match tag {
1 => Self::Keyword,
2 => Self::String,
3 => Self::Escape,
4 => Self::Number,
5 => Self::Comment,
6 => Self::Function,
7 => Self::Type,
8 => Self::Property,
9 => Self::Constant,
10 => Self::Operator,
11 => Self::Punctuation,
12 => Self::Variable,
_ => return None,
})
}
/// Приоритет при совпадении диапазонов: более специфичная категория
/// должна перекрывать более общую (например, имя функции — свойство).
fn priority(self) -> u8 {
match self {
Self::Variable | Self::Punctuation | Self::Operator | Self::String => 1,
Self::Number | Self::Constant | Self::Property => 2,
Self::Escape | Self::Type => 3,
Self::Function => 4,
Self::Keyword | Self::Comment => 5,
}
}
}
/// Участок текста с назначенным стилем (байтовые смещения, `end` не включён).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct HighlightSpan {
pub start: usize,
pub end: usize,
pub style: HighlightStyle,
}
/// Состояние разбора одного документа: переиспользуемый парсер и кэш подсветки.
///
/// Кэш сравнивает язык и хеш текста, поэтому при наборе текста подсветка
/// пересчитывается, а в остальные кадры берётся готовый результат.
#[derive(Default)]
pub struct SyntaxState {
parser: Option<Parser>,
cache: Option<HighlightCache>,
}
impl SyntaxState {
/// Разбирает текст в дерево tree-sitter.
///
/// Это универсальная точка входа: дерево можно обходить для поиска
/// определений, проверки ошибок и любых других задач, не связанных с
/// подсветкой. Возвращает `None`, если грамматика не установилась.
pub fn parse(&mut self, language: Language, text: &str) -> Option<Tree> {
let parser = self.parser.get_or_insert_with(Parser::new);
if let Err(err) = parser.set_language(&language.grammar()) {
eprintln!("tree-sitter: не удалось установить язык {language:?}: {err}");
return None;
}
parser.parse(text, None)
}
/// Подсвеченные участки текста для языка.
///
/// Результат кэшируется по языку и содержимому, поэтому вызывать метод
/// каждый кадр дёшево, пока текст не изменился.
pub fn spans(&mut self, language: Language, text: &str) -> &[HighlightSpan] {
let signature = Signature {
language,
len: text.len(),
hash: hash_text(text),
};
let fresh = self
.cache
.as_ref()
.is_some_and(|cache| cache.signature == signature);
if !fresh {
// Подсветка строится поверх того же дерева, которое отдаёт `parse`,
// поэтому разбор всегда один.
let spans = self
.parse(language, text)
.map(|tree| highlight_tree(language, text, &tree))
.unwrap_or_default();
self.cache = Some(HighlightCache { signature, spans });
}
&self
.cache
.as_ref()
.expect("кэш заполняется выше при промахе")
.spans
}
}
/// Ключ кэша подсветки.
#[derive(Clone, Copy, PartialEq, Eq)]
struct Signature {
language: Language,
len: usize,
hash: u64,
}
struct HighlightCache {
signature: Signature,
spans: Vec<HighlightSpan>,
}
/// Сырой захват запроса до разрешения пересечений.
struct RawSpan {
start: usize,
end: usize,
style: HighlightStyle,
}
impl RawSpan {
fn priority(&self) -> u8 {
self.style.priority()
}
}
/// Считает участки подсветки по готовому дереву tree-sitter.
fn highlight_tree(language: Language, text: &str, tree: &Tree) -> Vec<HighlightSpan> {
let Some(query) = query(language) else {
return Vec::new();
};
let capture_names = query.capture_names();
let mut cursor = QueryCursor::new();
let mut matches = cursor.matches(query, tree.root_node(), text.as_bytes());
let mut raw = Vec::new();
while let Some(matched) = matches.next() {
for capture in matched.captures {
let Some(style) = style_for_capture(capture_names[capture.index as usize]) else {
continue;
};
let range = capture.node.byte_range();
if range.start < range.end && range.end <= text.len() {
raw.push(RawSpan {
start: range.start,
end: range.end,
style,
});
}
}
}
drop(matches);
resolve_overlaps(text, raw)
}
/// Раскрашивает байты «сверху вниз»: сначала крупные участки, затем более
/// мелкие и приоритетные. Так вложенные escape-последовательности попадают
/// внутрь строк, а имя функции перекрывает свойство с тем же диапазоном.
fn resolve_overlaps(text: &str, mut raw: Vec<RawSpan>) -> Vec<HighlightSpan> {
raw.sort_by(|a, b| {
(b.end - b.start)
.cmp(&(a.end - a.start))
.then(a.priority().cmp(&b.priority()))
});
let mut cells = vec![0u8; text.len()];
for span in raw {
cells[span.start..span.end].fill(span.style.tag());
}
let mut spans = Vec::new();
let mut index = 0;
while index < cells.len() {
let tag = cells[index];
let start = index;
while index < cells.len() && cells[index] == tag {
index += 1;
}
if let Some(style) = HighlightStyle::from_tag(tag) {
spans.push(HighlightSpan {
start,
end: index,
style,
});
}
}
spans
}
/// Сопоставляет имя захвата запроса (`@function.method`, `@string`, ...)
/// с категорией стиля.
fn style_for_capture(name: &str) -> Option<HighlightStyle> {
// Ключи JSON-объекта грамматика помечает как строки — рисуем их как свойства.
if name == "string.special.key" {
return Some(HighlightStyle::Property);
}
let head = name.split('.').next().unwrap_or(name);
Some(match head {
"keyword" => HighlightStyle::Keyword,
"string" | "text" => HighlightStyle::String,
"escape" => HighlightStyle::Escape,
"number" => HighlightStyle::Number,
"comment" => HighlightStyle::Comment,
"function" | "method" | "attribute" | "decorator" => HighlightStyle::Function,
"type" | "constructor" => HighlightStyle::Type,
"property" => HighlightStyle::Property,
"constant" | "boolean" => HighlightStyle::Constant,
"operator" => HighlightStyle::Operator,
"punctuation" => HighlightStyle::Punctuation,
"variable" | "parameter" => HighlightStyle::Variable,
_ => return None,
})
}
fn hash_text(text: &str) -> u64 {
let mut hasher = DefaultHasher::new();
text.hash(&mut hasher);
hasher.finish()
}
/// Скомпилированный запрос подсветки (один на язык, создаётся при первом обращении).
fn query(language: Language) -> Option<&'static Query> {
static RUST: OnceLock<Option<Query>> = OnceLock::new();
static GO: OnceLock<Option<Query>> = OnceLock::new();
static JS: OnceLock<Option<Query>> = OnceLock::new();
static JSON: OnceLock<Option<Query>> = OnceLock::new();
static PYTHON: OnceLock<Option<Query>> = OnceLock::new();
let slot = match language {
Language::Rust => &RUST,
Language::Go => &GO,
Language::JavaScript => &JS,
Language::Json => &JSON,
Language::Python => &PYTHON,
};
slot.get_or_init(
|| match Query::new(&language.grammar(), language.query_source()) {
Ok(query) => Some(query),
Err(err) => {
eprintln!("tree-sitter: запрос подсветки для {language:?}: {err}");
None
}
},
)
.as_ref()
}
// Запросы намеренно не используют предикаты `#match?`: они не нужны для
// базовой подсветки и не должны зависеть от конкретной реализации tree-sitter.
const RUST_QUERY: &str = r#"
(line_comment) @comment
(block_comment) @comment
(doc_comment) @comment
(string_literal) @string
(raw_string_literal) @string
(char_literal) @string
(escape_sequence) @escape
(integer_literal) @number
(float_literal) @number
(boolean_literal) @constant
(type_identifier) @type
(primitive_type) @type
(field_identifier) @property
(lifetime) @type
(function_item name: (identifier) @function)
(function_signature_item name: (identifier) @function)
(macro_invocation macro: (identifier) @function)
(call_expression function: (identifier) @function)
(call_expression function: (field_expression field: (field_identifier) @function))
(metavariable) @variable
[
"as" "async" "await" "break" "const" "continue" "default" "dyn" "else"
"enum" "extern" "fn" "for" "gen" "if" "impl" "in" "let" "loop" "match"
"mod" "move" "pub" "raw" "ref" "return" "static" "struct" "trait" "type"
"union" "unsafe" "use" "where" "while" "yield"
] @keyword
(crate) @keyword
(mutable_specifier) @keyword
(self) @keyword
(super) @keyword
"#;
const GO_QUERY: &str = r#"
(comment) @comment
(interpreted_string_literal) @string
(raw_string_literal) @string
(rune_literal) @string
(escape_sequence) @escape
(int_literal) @number
(float_literal) @number
(imaginary_literal) @number
(true) @constant
(false) @constant
(nil) @constant
(iota) @constant
(type_identifier) @type
(field_identifier) @property
(function_declaration name: (identifier) @function)
(method_declaration name: (field_identifier) @function)
(call_expression function: (identifier) @function)
(call_expression function: (selector_expression field: (field_identifier) @function))
[
"break" "case" "chan" "const" "continue" "default" "defer" "else"
"fallthrough" "for" "func" "go" "goto" "if" "import" "interface" "map"
"package" "range" "return" "select" "struct" "switch" "type" "var"
] @keyword
"#;
const JS_QUERY: &str = r#"
(comment) @comment
(string) @string
(template_string) @string
(regex) @string
(escape_sequence) @escape
(number) @number
(true) @constant
(false) @constant
(null) @constant
(undefined) @constant
(property_identifier) @property
(function_declaration name: (identifier) @function)
(generator_function_declaration name: (identifier) @function)
(method_definition name: (property_identifier) @function)
(class_declaration name: (identifier) @type)
(call_expression function: (identifier) @function)
(call_expression function: (member_expression property: (property_identifier) @function))
[
"as" "async" "await" "break" "case" "catch" "class" "const" "continue"
"debugger" "default" "delete" "do" "else" "export" "extends" "finally"
"for" "from" "function" "get" "if" "import" "in" "instanceof" "let"
"new" "of" "return" "set" "static" "switch" "target" "throw" "try"
"typeof" "var" "void" "while" "with" "yield"
] @keyword
(this) @keyword
(super) @keyword
"#;
const JSON_QUERY: &str = r#"
(comment) @comment
(escape_sequence) @escape
(pair key: (string) @string.special.key)
(string) @string
(number) @number
(true) @constant
(false) @constant
(null) @constant
"#;
const PYTHON_QUERY: &str = r#"
(comment) @comment
(string) @string
(concatenated_string) @string
(escape_sequence) @escape
(integer) @number
(float) @number
(none) @constant
(true) @constant
(false) @constant
(attribute attribute: (identifier) @property)
(type (identifier) @type)
(function_definition name: (identifier) @function)
(class_definition name: (identifier) @type)
(decorator) @function
(call function: (identifier) @function)
(call function: (attribute attribute: (identifier) @function))
[
"and" "as" "assert" "async" "await" "break" "class" "continue" "def"
"del" "elif" "else" "except" "finally" "for" "from" "global" "if"
"import" "in" "is" "lambda" "match" "nonlocal" "not" "or" "pass"
"raise" "return" "try" "while" "with" "yield"
] @keyword
"#;
src/tests.rs
+265 -417
View File
@@ -1,196 +1,29 @@
//! Проверки UI-логики на «сырых» событиях egui (без реального окна).
//! Тесты доменной модели, Lua-интеграции и клавиатурных привязок.
//!
//! UI-часть (заголовок, перетаскивание, изменение размера) теперь принадлежит
//! gpui-kit, поэтому её отдельно не проверяем. Остаются тесты, которые
//! фиксируют поведение самого приложения: документы, API, Lua и KeyMap.
use std::cell::RefCell;
use std::rc::Rc;
use eframe::egui;
use gpui_kit::{Keystroke, Modifiers, TestAppContext};
use crate::api::AppApi;
use crate::api::{AppApi, WindowCommand, drain_window_commands};
use crate::app::MyApp;
use crate::editor::EditorState;
use crate::keymap::KeyMap;
use crate::editor::{Language, Workspace};
use crate::keymap::{KeyBinding, KeyMap, Modifiers as KeyModifiers};
use crate::script::ScriptEngine;
use crate::syntax::{HighlightStyle, Language, SyntaxState};
use crate::ui::title_bar::TitleBarResponses;
const SCREEN: egui::Vec2 = egui::vec2(600.0, 400.0);
/// Один проход кадра для данного экземпляра приложения:
/// возвращает ответы заголовка и команды окна.
fn step_app(
ctx: &egui::Context,
app: &mut MyApp,
events: Vec<egui::Event>,
) -> (TitleBarResponses, Vec<egui::ViewportCommand>) {
let raw = egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, SCREEN)),
events,
..Default::default()
};
let mut bar = None;
let mut out = ctx.run_ui(raw, |ui| {
bar = Some(app.show(ui));
});
let commands = out
.viewport_output
.get(&egui::ViewportId::ROOT)
.map(|output| output.commands.clone())
.unwrap_or_default();
out.textures_delta.clear();
(bar.expect("заголовок отрисован"), commands)
}
/// Один проход кадра на свежем приложении.
fn step(
ctx: &egui::Context,
events: Vec<egui::Event>,
) -> (TitleBarResponses, Vec<egui::ViewportCommand>) {
let mut app = MyApp::default();
step_app(ctx, &mut app, events)
}
fn button_event(pos: egui::Pos2, pressed: bool) -> egui::Event {
egui::Event::PointerButton {
pos,
button: egui::PointerButton::Primary,
pressed,
modifiers: egui::Modifiers::default(),
}
}
fn click_at(ctx: &egui::Context, pos: egui::Pos2) -> Vec<egui::ViewportCommand> {
let mut commands = Vec::new();
commands.extend(step(ctx, vec![egui::Event::PointerMoved(pos)]).1);
commands.extend(step(ctx, vec![button_event(pos, true)]).1);
commands.extend(step(ctx, vec![]).1);
commands.extend(step(ctx, vec![button_event(pos, false)]).1);
commands.extend(step(ctx, vec![]).1);
commands
}
fn press_at(ctx: &egui::Context, pos: egui::Pos2) -> Vec<egui::ViewportCommand> {
let mut commands = step(ctx, vec![egui::Event::PointerMoved(pos)]).1;
commands.extend(step(ctx, vec![button_event(pos, true)]).1);
commands
}
/// Событие клавиатуры, у которого логическая клавиша может отличаться от
/// физической (как при смене раскладки).
fn key_event(
physical: egui::Key,
logical: egui::Key,
pressed: bool,
modifiers: egui::Modifiers,
) -> egui::Event {
egui::Event::Key {
key: logical,
physical_key: Some(physical),
pressed,
repeat: false,
modifiers,
}
fn install_api(workspace: Rc<RefCell<Workspace>>) -> (AppApi, Rc<RefCell<KeyMap>>) {
let keymap = Rc::new(RefCell::new(KeyMap::default()));
let api = AppApi::install(workspace, keymap.clone());
(api, keymap)
}
#[test]
fn title_bar_buttons_are_hoverable_and_clickable() {
let ctx = egui::Context::default();
// прогреваем: egui считает раскладку по предыдущему кадру
step(&ctx, vec![]);
let (bar, _) = step(&ctx, vec![]);
let close_pos = bar.close.rect.center();
let maximize_pos = bar.maximize.rect.center();
let minimize_pos = bar.minimize.rect.center();
// Кнопки должны находиться в заголовке, а не где-то ещё
assert!(bar.drag.rect.contains(close_pos));
// Наведение даёт подсветку
step(&ctx, vec![egui::Event::PointerMoved(close_pos)]);
let (hovered, _) = step(&ctx, vec![]);
assert!(
hovered.close.hovered(),
"кнопка «закрыть» не подсвечивается"
);
let close_cmds = click_at(&ctx, close_pos);
assert!(
close_cmds.contains(&egui::ViewportCommand::Close),
"клик по «закрыть» не отправил Close: {close_cmds:?}"
);
let max_cmds = click_at(&ctx, maximize_pos);
assert!(
max_cmds.contains(&egui::ViewportCommand::Maximized(true)),
"клик по «развернуть» не отправил Maximized: {max_cmds:?}"
);
let min_cmds = click_at(&ctx, minimize_pos);
assert!(
min_cmds.contains(&egui::ViewportCommand::Minimized(true)),
"клик по «свернуть» не отправил Minimized: {min_cmds:?}"
);
}
#[test]
fn dragging_title_bar_starts_window_drag_even_over_the_text() {
for (name, x_offset) in [("по тексту", 40.0), ("по пустому месту", 300.0)]
{
let ctx = egui::Context::default();
step(&ctx, vec![]);
let (bar, _) = step(&ctx, vec![]);
let start = egui::pos2(bar.drag.rect.left() + x_offset, bar.drag.rect.center().y);
let moved = start + egui::vec2(24.0, 12.0);
step(&ctx, vec![egui::Event::PointerMoved(start)]);
let mut commands = step(&ctx, vec![button_event(start, true)]).1;
commands.extend(step(&ctx, vec![egui::Event::PointerMoved(moved)]).1);
assert!(
commands.contains(&egui::ViewportCommand::StartDrag),
"драг заголовка {name} не инициировал перемещение окна: {commands:?}"
);
}
}
#[test]
fn edges_and_corners_start_resize() {
use egui::viewport::ResizeDirection as Dir;
let cases = [
(egui::pos2(300.0, 2.0), Dir::North),
(egui::pos2(300.0, SCREEN.y - 2.0), Dir::South),
(egui::pos2(2.0, 200.0), Dir::West),
(egui::pos2(SCREEN.x - 2.0, 200.0), Dir::East),
(egui::pos2(2.0, 2.0), Dir::NorthWest),
(egui::pos2(SCREEN.x - 2.0, 2.0), Dir::NorthEast),
(egui::pos2(SCREEN.x - 2.0, SCREEN.y - 2.0), Dir::SouthEast),
(egui::pos2(2.0, SCREEN.y - 2.0), Dir::SouthWest),
];
for (pos, expected) in cases {
let ctx = egui::Context::default();
step(&ctx, vec![]);
step(&ctx, vec![]);
let commands = press_at(&ctx, pos);
assert!(
commands.contains(&egui::ViewportCommand::BeginResize(expected)),
"в точке {pos:?} ожидался BeginResize({expected:?}), получено: {commands:?}"
);
assert!(
!commands.contains(&egui::ViewportCommand::StartDrag),
"в точке {pos:?} вместо ресайза началось перемещение окна"
);
}
}
#[test]
fn editor_state_keeps_at_least_one_tab() {
let mut state = EditorState::default();
fn workspace_keeps_at_least_one_tab() {
let mut state = Workspace::default();
assert_eq!(state.documents().len(), 2);
assert_eq!(state.active().name, "main.rs");
@@ -213,58 +46,51 @@ fn editor_state_keeps_at_least_one_tab() {
#[test]
fn closing_tab_before_active_keeps_the_same_document_active() {
let mut state = EditorState::default();
let mut state = Workspace::default();
state.open_new();
let name = state.active().name.clone();
let id = state.active().id;
state.close(0);
assert_eq!(state.active().name, name);
assert_eq!(state.active().id, id);
assert_eq!(state.active_index(), 1);
}
#[test]
fn editing_marks_document_dirty_and_saving_clears_it() {
let mut state = EditorState::default();
let mut state = Workspace::default();
assert!(!state.active().is_dirty());
state.active_mut().content.push_str("\n// правка\n");
state.set_active_text("// правка\n");
assert!(state.active().is_dirty());
state.active_mut().mark_saved();
state.mark_active_saved();
assert!(!state.active().is_dirty());
}
#[test]
fn typing_into_editor_updates_active_document() {
let ctx = egui::Context::default();
let mut app = MyApp::default();
fn revision_changes_only_for_external_edits() {
let mut state = Workspace::default();
let revision = state.revision();
// Прогреваем раскладку и кликаем в область редактора ниже панели вкладок.
step_app(&ctx, &mut app, vec![]);
let editor_pos = egui::pos2(SCREEN.x / 2.0, SCREEN.y - 80.0);
step_app(&ctx, &mut app, vec![egui::Event::PointerMoved(editor_pos)]);
step_app(&ctx, &mut app, vec![button_event(editor_pos, true)]);
step_app(&ctx, &mut app, vec![button_event(editor_pos, false)]);
// Набор текста в виджете ревизию не двигает: редактор уже показывает текст.
state.replace_active_content("typed".to_owned());
assert_eq!(state.revision(), revision);
step_app(&ctx, &mut app, vec![egui::Event::Text("ZZZ".to_owned())]);
// Внешняя замена (Lua) — двигает.
state.set_active_text("from lua");
assert_ne!(state.revision(), revision);
let editor = app.editor();
let doc = editor.active();
assert!(
doc.content.contains("ZZZ"),
"введённый текст не попал в документ: {:?}",
doc.content
);
assert!(doc.is_dirty(), "правка должна помечать документ изменённым");
// Переключение вкладки — тоже.
let before_switch = state.revision();
state.set_active(1);
assert_ne!(state.revision(), before_switch);
}
#[test]
fn api_lists_tabs_and_closes_them_by_number() {
let ctx = egui::Context::default();
let mut app = MyApp::default();
step_app(&ctx, &mut app, vec![]);
let workspace = Rc::new(RefCell::new(Workspace::default()));
let (api, _keymap) = install_api(workspace.clone());
let api = AppApi::global();
let tabs = api.tabs();
assert_eq!(
tabs.iter()
@@ -279,52 +105,44 @@ fn api_lists_tabs_and_closes_them_by_number() {
assert!(api.close_tab(1));
assert_eq!(api.tabs().len(), 1);
assert_eq!(app.editor().documents().len(), 1);
assert_eq!(workspace.borrow().documents().len(), 1);
}
#[test]
fn api_save_writes_active_tab_to_file_named_after_it() {
// Тест пишет во временный файл, а не в каталог проекта.
let mut state = EditorState::default();
let workspace = Rc::new(RefCell::new(Workspace::default()));
let path = std::env::temp_dir().join(format!(
"egui-rust-test-save-{}-{}.rs",
"gpui-editor-test-save-{}-{}.rs",
std::process::id(),
state.active().id
workspace.borrow().active().id
));
let _ = std::fs::remove_file(&path);
{
let mut state = workspace.borrow_mut();
let doc = state.active_mut();
doc.name = path.to_string_lossy().into_owned();
doc.content = "fn main() {}\n".to_owned();
}
assert!(state.active().is_dirty());
assert!(workspace.borrow().active().is_dirty());
let editor = Rc::new(RefCell::new(state));
let api = AppApi::install(
egui::Context::default(),
editor.clone(),
Rc::new(RefCell::new(KeyMap::default())),
);
let (api, _keymap) = install_api(workspace.clone());
api.save().expect("сохранение должно удаться");
assert_eq!(
std::fs::read_to_string(&path).expect("файл должен существовать"),
"fn main() {}\n"
);
assert!(!editor.borrow().active().is_dirty());
assert!(!workspace.borrow().active().is_dirty());
let _ = std::fs::remove_file(&path);
}
#[test]
fn api_switches_tabs_forward_and_back_in_a_cycle() {
let editor = Rc::new(RefCell::new(EditorState::default()));
let api = AppApi::install(
egui::Context::default(),
editor.clone(),
Rc::new(RefCell::new(KeyMap::default())),
);
let workspace = Rc::new(RefCell::new(Workspace::default()));
let (api, _keymap) = install_api(workspace.clone());
assert_eq!(api.active_tab_index(), 0);
@@ -337,18 +155,39 @@ fn api_switches_tabs_forward_and_back_in_a_cycle() {
// С первой вкладки предыдущая — последняя.
assert_eq!(api.previous_tab(), 1);
assert_eq!(api.previous_tab(), 0);
assert_eq!(editor.borrow().active_index(), 0);
assert_eq!(workspace.borrow().active_index(), 0);
}
#[test]
fn lua_script_can_include_files_and_control_the_app() {
let ctx = egui::Context::default();
let mut app = MyApp::default();
// Первый кадр публикует AppApi, который использует сценарий.
step_app(&ctx, &mut app, vec![]);
fn window_commands_are_queued_for_the_view() {
let workspace = Rc::new(RefCell::new(Workspace::default()));
let (api, _keymap) = install_api(workspace);
// Очередь могла остаться от другого теста на этом потоке — очищаем.
let _ = drain_window_commands();
api.minimize();
api.toggle_maximize();
api.set_maximized(false);
api.close();
assert_eq!(
drain_window_commands(),
vec![
WindowCommand::Minimize,
WindowCommand::ToggleMaximize,
WindowCommand::SetMaximized(false),
WindowCommand::Close,
]
);
// Повторное чтение пустой очереди ничего не возвращает.
assert!(drain_window_commands().is_empty());
}
/// Временный каталог с уникальным именем для Lua-сценариев.
fn temp_script_dir(prefix: &str) -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!(
"egui-rust-test-lua-{}-{}",
"gpui-editor-test-{prefix}-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
@@ -356,7 +195,15 @@ fn lua_script_can_include_files_and_control_the_app() {
.as_nanos()
));
std::fs::create_dir_all(&dir).expect("временный каталог сценариев");
dir
}
#[test]
fn lua_script_can_include_files_and_control_the_app() {
let workspace = Rc::new(RefCell::new(Workspace::default()));
let (api, _keymap) = install_api(workspace.clone());
let dir = temp_script_dir("lua");
let helper = dir.join("helper.lua");
let main = dir.join("main.lua");
std::fs::write(
@@ -373,22 +220,22 @@ fn lua_script_can_include_files_and_control_the_app() {
)
.expect("main.lua");
let engine = ScriptEngine::new(AppApi::global()).expect("движок Lua");
let engine = ScriptEngine::new(api).expect("движок Lua");
engine.run_file(&main).expect("сценарий должен выполниться");
let editor = app.editor();
let state = workspace.borrow();
assert_eq!(
editor.documents()[0].content,
state.documents()[0].content,
"from lua",
"include должен выполнить подключённый файл в общем окружении"
);
assert_eq!(
editor.active_index(),
state.active_index(),
1,
"app:next_tab() не переключил вкладку"
);
assert_eq!(
editor.documents()[1].language,
state.documents()[1].language,
Some(Language::Python),
"app:set_language() не включил подсветку из Lua"
);
@@ -397,22 +244,11 @@ fn lua_script_can_include_files_and_control_the_app() {
}
#[test]
fn lua_key_bindings_use_physical_keys_and_modifiers() {
let ctx = egui::Context::default();
let mut app = MyApp::default();
// Первый кадр публикует AppApi с картой клавиш приложения.
step_app(&ctx, &mut app, vec![]);
let dir = std::env::temp_dir().join(format!(
"egui-rust-test-keys-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("системные часы")
.as_nanos()
));
std::fs::create_dir_all(&dir).expect("временный каталог сценариев");
fn lua_key_bindings_match_press_release_and_modifiers() {
let workspace = Rc::new(RefCell::new(Workspace::default()));
let (api, keymap) = install_api(workspace.clone());
let dir = temp_script_dir("keys");
let script = dir.join("keys.lua");
std::fs::write(
&script,
@@ -426,100 +262,80 @@ fn lua_key_bindings_use_physical_keys_and_modifiers() {
)
.expect("keys.lua");
let engine = ScriptEngine::new(AppApi::global()).expect("движок Lua");
let engine = ScriptEngine::new(api).expect("движок Lua");
engine
.run_file(&script)
.expect("привязки должны назначиться");
let text = |app: &MyApp| app.editor().active().content.clone();
let text = || workspace.borrow().active().content.clone();
let stroke = |key: &str, modifiers: gpui_kit::Modifiers| Keystroke {
modifiers,
key: key.to_owned(),
key_char: None,
};
let fire = |keystroke: &Keystroke, pressed: bool| {
for callback in keymap.borrow().callbacks_for(keystroke, pressed) {
callback.call::<()>(()).expect("Lua-обработчик");
}
};
// Логическая клавиша Z, физическая A: срабатывает именно физическая.
step_app(
&ctx,
&mut app,
vec![key_event(
egui::Key::A,
egui::Key::Z,
true,
egui::Modifiers::default(),
)],
);
assert_eq!(text(&app), "a pressed");
// Нажатие A.
fire(&stroke("a", Modifiers::default()), true);
assert_eq!(text(), "a pressed");
// Shift+A не должна срабатывать как обычная A.
step_app(
&ctx,
&mut app,
vec![key_event(
egui::Key::A,
egui::Key::A,
true,
egui::Modifiers {
fire(
&stroke(
"a",
Modifiers {
shift: true,
..Default::default()
},
)],
),
true,
);
assert_eq!(text(&app), "a pressed");
assert_eq!(text(), "a pressed");
// Отпускание цифры 1, логическая клавиша при этом другая.
step_app(
&ctx,
&mut app,
vec![key_event(
egui::Key::Num1,
egui::Key::Num2,
false,
egui::Modifiers::default(),
)],
);
assert_eq!(text(&app), "1 released");
// Отпускание цифры 1.
fire(&stroke("1", Modifiers::default()), false);
assert_eq!(text(), "1 released");
step_app(
&ctx,
&mut app,
vec![key_event(
egui::Key::C,
egui::Key::C,
true,
egui::Modifiers {
fire(
&stroke(
"c",
Modifiers {
shift: true,
..Default::default()
},
)],
),
true,
);
assert_eq!(text(&app), "shift c");
assert_eq!(text(), "shift c");
step_app(
&ctx,
&mut app,
vec![key_event(
egui::Key::Z,
egui::Key::Z,
true,
egui::Modifiers {
ctrl: true,
fire(
&stroke(
"z",
Modifiers {
control: true,
..Default::default()
},
)],
),
true,
);
assert_eq!(text(&app), "ctrl z");
assert_eq!(text(), "ctrl z");
// Отпускание R при зажатом Alt.
step_app(
&ctx,
&mut app,
vec![key_event(
egui::Key::R,
egui::Key::R,
false,
egui::Modifiers {
fire(
&stroke(
"r",
Modifiers {
alt: true,
..Default::default()
},
)],
),
false,
);
assert_eq!(text(&app), "alt r released");
assert_eq!(text(), "alt r released");
let _ = std::fs::remove_dir_all(&dir);
}
@@ -528,119 +344,151 @@ fn lua_key_bindings_use_physical_keys_and_modifiers() {
fn language_names_cover_all_supported_grammars() {
for (name, expected) in [
("rust", Language::Rust),
("rs", Language::Rust),
("Rust", Language::Rust),
("go", Language::Go),
("golang", Language::Go),
("js", Language::JavaScript),
("javascript", Language::JavaScript),
("json", Language::Json),
("python", Language::Python),
("py", Language::Python),
] {
assert_eq!(Language::from_name(name), Some(expected), "язык {name}");
assert_eq!(Language::from_name(&name.to_uppercase()), Some(expected));
assert_eq!(Language::from_name(name), Some(expected), "язык {name:?}");
}
// Распространённые короткие имена.
assert_eq!(Language::from_name("rs"), Some(Language::Rust));
assert_eq!(Language::from_name("golang"), Some(Language::Go));
assert_eq!(
Language::from_name("javascript"),
Some(Language::JavaScript)
);
assert_eq!(Language::from_name("py"), Some(Language::Python));
assert_eq!(Language::from_name("unknown"), None);
assert_eq!(Language::from_name(""), None);
assert_eq!(Language::from_name("cobol"), None);
}
#[test]
fn tree_sitter_highlights_all_supported_languages() {
let samples = [
(
Language::Rust,
"fn main() {\n let x = 42; // комментарий\n println!(\"hi\");\n}\n",
HighlightStyle::Keyword,
),
(
Language::Go,
"package main\n\nfunc main() {\n\tx := 42 // комментарий\n\t_ = x\n}\n",
HighlightStyle::Keyword,
),
(
Language::JavaScript,
"function main() {\n const x = 42; // comment\n console.log(\"hi\");\n}\n",
HighlightStyle::Keyword,
),
(
Language::Json,
"{\"name\": \"value\", \"count\": 42, \"ok\": true}\n",
HighlightStyle::Property,
),
(
Language::Python,
"def main():\n x = 42 # comment\n print(\"hi\")\n",
HighlightStyle::Keyword,
),
];
for (language, source, expected) in samples {
let mut syntax = SyntaxState::default();
let styles: Vec<_> = syntax
.spans(language, source)
.iter()
.map(|span| span.style)
.collect();
assert!(!styles.is_empty(), "{language:?}: подсветка пуста");
assert!(
styles.contains(&expected),
"{language:?}: нет стиля {expected:?} в {styles:?}"
);
}
}
#[test]
fn syntax_tree_is_available_for_tasks_beyond_highlighting() {
let mut syntax = SyntaxState::default();
let tree = syntax
.parse(Language::Rust, "fn main() {}\n")
.expect("дерево должно разобраться");
let root = tree.root_node();
assert_eq!(root.kind(), "source_file");
let mut cursor = root.walk();
assert!(
root.children(&mut cursor)
.any(|node| node.kind() == "function_item"),
"в дереве должна находиться функция — его можно обходить, а не только красить"
);
// Канонические имена, которые возвращает API и Lua.
assert_eq!(Language::Rust.name(), "rust");
assert_eq!(Language::JavaScript.name(), "js");
assert_eq!(Language::Python.name(), "python");
}
#[test]
fn highlighting_is_off_by_default_and_enabled_through_api() {
let ctx = egui::Context::default();
let mut app = MyApp::default();
step_app(&ctx, &mut app, vec![]);
let workspace = Rc::new(RefCell::new(Workspace::default()));
let (api, _keymap) = install_api(workspace.clone());
assert!(
app.editor()
.documents()
.iter()
.all(|doc| doc.language.is_none()),
"подсветка должна быть выключена по умолчанию"
assert_eq!(api.language(0), None);
assert_eq!(workspace.borrow().documents()[0].language, None);
assert!(api.set_language(0, "rs"));
assert_eq!(api.language(0), Some("rust".to_owned()));
assert_eq!(
workspace.borrow().documents()[0].language,
Some(Language::Rust)
);
let api = AppApi::global();
assert!(api.set_language(0, "rust"));
assert_eq!(api.language(0).as_deref(), Some("rust"));
assert_eq!(app.editor().documents()[0].language, Some(Language::Rust));
// Неизвестный язык и несуществующая вкладка не меняют состояние.
// Неизвестный язык и несуществующая вкладка.
assert!(!api.set_language(0, "cobol"));
assert!(!api.set_language(99, "rust"));
assert_eq!(api.language(0).as_deref(), Some("rust"));
// Кадр с включённой подсветкой должен отрисовываться без паники.
step_app(&ctx, &mut app, vec![]);
assert!(api.clear_language(0));
assert_eq!(api.language(0), None);
assert!(!api.clear_language(99));
}
#[test]
fn keymap_bindings_are_parsed_and_replaced() {
let plain = KeyBinding::parse("a").expect("a");
let ctrl = KeyBinding::parse("<C-s>").expect("ctrl-s");
assert_eq!(plain.modifiers, KeyModifiers::default());
assert!(ctrl.modifiers.ctrl);
assert!(!ctrl.on_release);
// Повторное назначение той же клавиши не увеличивает число привязок:
// проверить это можно только через KeyMap, поэтому создаём пару функций.
let lua = mlua::Lua::new();
let mut keymap = KeyMap::default();
let first = lua
.load("return function() end")
.eval::<mlua::Function>()
.unwrap();
let second = lua
.load("return function() end")
.eval::<mlua::Function>()
.unwrap();
keymap.bind(plain.clone(), first);
keymap.bind(plain, second);
let stroke = Keystroke {
modifiers: Modifiers::default(),
key: "a".to_owned(),
key_char: None,
};
assert_eq!(keymap.callbacks_for(&stroke, true).len(), 1);
}
#[gpui_kit::test]
fn lua_key_bindings_receive_keys_while_editor_is_focused(cx: &mut TestAppContext) {
cx.update(gpui_kit::init);
let mut workspace = None;
let (app, visual) = cx.add_window_view(|window, cx| {
let app = MyApp::new(window, cx);
workspace = Some(app.workspace_handle());
app
});
let workspace = workspace.expect("вид создан");
// Регистрируем привязку через Lua — так же, как это делает init.lua.
let dir = temp_script_dir("ui-keys");
let script = dir.join("keys.lua");
std::fs::write(
&script,
r#"app:map_key("<A-r>", function() app:set_active_text("alt r pressed") end)"#,
)
.expect("keys.lua");
let engine = ScriptEngine::new(AppApi::global()).expect("движок Lua");
engine.run_file(&script).expect("привязка");
visual.update(|window, cx| {
app.update(cx, |this, cx| {
this.editor_handle()
.update(cx, |state, cx| state.focus(window, cx));
});
});
// Событие клавиатуры идёт через фокус редактора вверх до корня вида,
// где его видит KeyMap.
visual.simulate_keystrokes("alt-r");
visual.run_until_parked();
assert_eq!(workspace.borrow().active().content, "alt r pressed");
drop(engine);
let _ = std::fs::remove_dir_all(&dir);
}
#[gpui_kit::test]
fn typing_into_editor_updates_active_document(cx: &mut TestAppContext) {
cx.update(gpui_kit::init);
let mut workspace = None;
let (app, visual) = cx.add_window_view(|window, cx| {
let app = MyApp::new(window, cx);
workspace = Some(app.workspace_handle());
app
});
let workspace = workspace.expect("вид создан");
// Фокус нужен до первого ввода: simulate_input отправляет текст в
// сфокусированный ввод.
visual.update(|window, cx| {
app.update(cx, |this, cx| {
this.editor_handle()
.update(cx, |state, cx| state.focus(window, cx));
});
});
visual.simulate_input("ZZZ");
let state = workspace.borrow();
let doc = state.active();
assert!(
doc.content.contains("ZZZ"),
"введённый текст не попал в документ: {:?}",
doc.content
);
assert!(doc.is_dirty(), "правка должна помечать документ изменённым");
}
src/ui/code_editor.rs
-298
View File
@@ -1,298 +0,0 @@
//! Область редактирования кода: нумерация строк и многострочное поле ввода.
use eframe::egui;
use crate::constants::CORNER_RADIUS;
use crate::editor::Document;
use crate::syntax::{HighlightStyle, Language, SyntaxState};
const FONT_SIZE: f32 = 13.0;
/// Отступы текста от краёв области (как у обычного `TextEdit`).
const MARGIN_X: i8 = 10;
const MARGIN_Y: i8 = 8;
/// Отступ номера строки от текста справа и минимальная ширина колонки.
const GUTTER_PADDING: f32 = 12.0;
/// Рисует редактор активного документа.
///
/// `focus` — запросить фокус у поля ввода (например, сразу после переключения вкладки).
pub fn render(ui: &mut egui::Ui, doc: &mut Document, focus: bool) {
let area = ui.available_rect_before_wrap();
// Фон на всю оставшуюся область; нижние углы повторяют скругление окна.
ui.painter().rect_filled(
area,
egui::CornerRadius {
nw: 0,
ne: 0,
sw: CORNER_RADIUS,
se: CORNER_RADIUS,
},
ui.visuals().extreme_bg_color,
);
let font_id = egui::FontId::monospace(FONT_SIZE);
let char_width = ui.fonts_mut(|fonts| fonts.glyph_width(&font_id, '0'));
let line_height =
ui.fonts_mut(|fonts| fonts.row_height(&font_id)) + ui.spacing().extra_text_line_spacing;
let line_count = doc.content.split('\n').count();
let gutter_width =
(line_count.to_string().len() as f32 * char_width + GUTTER_PADDING * 2.0).max(30.0);
// Сколько строк нужно, чтобы поле ввода заполнило пустую область целиком:
// клик ниже последней строки должен ставить курсор, а не попадать в пустоту.
let rows_to_fill =
(((area.height() - 2.0 * f32::from(MARGIN_Y)) / line_height).floor() as usize).max(1);
let doc_id = doc.id;
let language = doc.language;
// Поля берём по отдельности: `content` нужен `TextEdit`, а `syntax` —
// подсветке, и это разные заимствования одного документа.
let content = &mut doc.content;
let syntax = &mut doc.syntax;
egui::ScrollArea::vertical()
.id_salt(("code_scroll", doc_id))
.auto_shrink([false, false])
.show(ui, |ui| {
// Без отступов между гуттером и текстом: строка должна быть единой.
ui.spacing_mut().item_spacing = egui::Vec2::ZERO;
let gutter_left = ui.cursor().left();
let output = ui
.horizontal_top(|ui| {
ui.add_space(gutter_width);
let text_edit = egui::TextEdit::multiline(&mut *content)
.id_salt(("code_edit", doc_id))
.font(font_id.clone())
.frame(egui::Frame::NONE.inner_margin(egui::Margin {
left: MARGIN_X,
right: MARGIN_X,
top: MARGIN_Y,
bottom: MARGIN_Y,
}))
.desired_width(f32::INFINITY)
.desired_rows(rows_to_fill.max(line_count));
// Подсветка включается только для документов с выбранным
// языком; без него используется стандартный layouter.
if let Some(language) = language {
let theme = SyntaxTheme::from_visuals(ui.visuals());
let mut layouter =
|ui: &egui::Ui, text: &dyn egui::TextBuffer, wrap_width: f32| {
let job = highlighted_layout_job(
text.as_str(),
language,
syntax,
&theme,
&font_id,
line_height,
wrap_width,
);
ui.fonts_mut(|fonts| fonts.layout_job(job))
};
text_edit.layouter(&mut layouter).show(ui)
} else {
text_edit.show(ui)
}
})
.inner;
if focus {
output.response.response.request_focus();
}
paint_line_numbers(
ui,
&output,
content.as_str(),
&font_id,
gutter_left,
gutter_width,
);
});
}
/// Собирает `LayoutJob` для подсвеченного текста.
///
/// Форматирование повторяет стандартный layouter `TextEdit`, чтобы курсор,
/// перенос строк и номера строк работали так же, как без подсветки.
fn highlighted_layout_job(
text: &str,
language: Language,
syntax: &mut SyntaxState,
theme: &SyntaxTheme,
font_id: &egui::FontId,
line_height: f32,
wrap_width: f32,
) -> egui::text::LayoutJob {
let mut job = egui::text::LayoutJob::default();
job.wrap.max_width = wrap_width;
job.keep_trailing_whitespace = true;
let format = |color: egui::Color32| egui::TextFormat {
font_id: font_id.clone(),
color,
line_height: Some(line_height),
..Default::default()
};
let mut cursor = 0;
for span in syntax.spans(language, text) {
if span.start > cursor {
job.append(
text.get(cursor..span.start).unwrap_or_default(),
0.0,
format(theme.default),
);
}
job.append(
text.get(span.start..span.end).unwrap_or_default(),
0.0,
format(theme.color(span.style)),
);
cursor = span.end;
}
if cursor < text.len() {
job.append(
text.get(cursor..).unwrap_or_default(),
0.0,
format(theme.default),
);
}
if text.is_empty() {
// Пустой абзац нужен, чтобы у поля была строка для курсора.
job.append("", 0.0, format(theme.default));
}
job
}
/// Цвета подсветки, подобранные под текущую тему egui.
#[derive(Clone, Copy)]
struct SyntaxTheme {
default: egui::Color32,
keyword: egui::Color32,
string: egui::Color32,
escape: egui::Color32,
number: egui::Color32,
comment: egui::Color32,
function: egui::Color32,
type_: egui::Color32,
property: egui::Color32,
constant: egui::Color32,
operator: egui::Color32,
punctuation: egui::Color32,
variable: egui::Color32,
}
impl SyntaxTheme {
fn from_visuals(visuals: &egui::Visuals) -> Self {
let default = visuals.text_color();
if visuals.dark_mode {
Self {
default,
keyword: egui::Color32::from_rgb(0xC6, 0x78, 0xDD),
string: egui::Color32::from_rgb(0x98, 0xC3, 0x79),
escape: egui::Color32::from_rgb(0x56, 0xB6, 0xC2),
number: egui::Color32::from_rgb(0xD1, 0x9A, 0x66),
comment: egui::Color32::from_rgb(0x7F, 0x84, 0x8E),
function: egui::Color32::from_rgb(0x61, 0xAF, 0xEF),
type_: egui::Color32::from_rgb(0xE5, 0xC0, 0x7B),
property: egui::Color32::from_rgb(0xE0, 0x6C, 0x75),
constant: egui::Color32::from_rgb(0xD1, 0x9A, 0x66),
operator: egui::Color32::from_rgb(0x56, 0xB6, 0xC2),
punctuation: egui::Color32::from_rgb(0xAB, 0xB2, 0xBF),
variable: default,
}
} else {
Self {
default,
keyword: egui::Color32::from_rgb(0xA6, 0x26, 0xA4),
string: egui::Color32::from_rgb(0x50, 0xA1, 0x4F),
escape: egui::Color32::from_rgb(0x01, 0x84, 0xBC),
number: egui::Color32::from_rgb(0x98, 0x68, 0x01),
comment: egui::Color32::from_rgb(0xA0, 0xA1, 0xA7),
function: egui::Color32::from_rgb(0x40, 0x78, 0xF2),
type_: egui::Color32::from_rgb(0xC1, 0x84, 0x01),
property: egui::Color32::from_rgb(0xE4, 0x56, 0x49),
constant: egui::Color32::from_rgb(0x98, 0x68, 0x01),
operator: egui::Color32::from_rgb(0x01, 0x84, 0xBC),
punctuation: egui::Color32::from_rgb(0x38, 0x3A, 0x42),
variable: default,
}
}
}
fn color(&self, style: HighlightStyle) -> egui::Color32 {
match style {
HighlightStyle::Keyword => self.keyword,
HighlightStyle::String => self.string,
HighlightStyle::Escape => self.escape,
HighlightStyle::Number => self.number,
HighlightStyle::Comment => self.comment,
HighlightStyle::Function => self.function,
HighlightStyle::Type => self.type_,
HighlightStyle::Property => self.property,
HighlightStyle::Constant => self.constant,
HighlightStyle::Operator => self.operator,
HighlightStyle::Punctuation => self.punctuation,
HighlightStyle::Variable => self.variable,
}
}
}
/// Рисует номера строк вдоль гуттера.
///
/// Строки берутся из галереи `TextEdit`, поэтому номера совпадают с текстом даже
/// при переносе длинных строк: у перенесённой строки номер не повторяется.
fn paint_line_numbers(
ui: &egui::Ui,
output: &egui::widgets::text_edit::TextEditOutput,
content: &str,
font_id: &egui::FontId,
gutter_left: f32,
gutter_width: f32,
) {
let visuals = ui.visuals();
let number_color = visuals.weak_text_color();
let current_line_color = visuals.strong_text_color();
// Индекс курсора — в символах, а не в байтах.
let current_line = output.cursor_range.map(|range| {
content
.chars()
.take(range.primary.index.into())
.filter(|&c| c == '\n')
.count()
});
let has_focus = output.response.response.has_focus();
let right = gutter_left + gutter_width - GUTTER_PADDING;
let painter = ui.painter();
let mut line_number = 1;
let mut starts_new_line = true;
for row in &output.galley.rows {
if starts_new_line {
let is_current = has_focus && current_line == Some(line_number - 1);
painter.text(
egui::pos2(right, output.galley_pos.y + row.rect().center().y),
egui::Align2::RIGHT_CENTER,
line_number,
font_id.clone(),
if is_current {
current_line_color
} else {
number_color
},
);
line_number += 1;
}
starts_new_line = row.ends_with_newline;
}
}
src/ui/icons.rs
-93
View File
@@ -1,93 +0,0 @@
//! Векторные иконки кнопок заголовка (без шрифтов — рисуются через `Painter`).
use eframe::egui;
/// Тип иконки, отображаемой на кнопке заголовка.
pub enum IconType {
Minimize,
Maximize,
Restore,
Close,
Plus,
}
/// Кнопка с векторной иконкой внутри.
pub fn custom_icon_button(ui: &mut egui::Ui, size: egui::Vec2, icon: IconType) -> egui::Response {
let (rect, response) = ui.allocate_exact_size(size, egui::Sense::click());
if response.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
}
let visuals = ui.style().interact(&response);
// Подсветка кнопки при наведении мыши
if response.hovered() || response.is_pointer_button_down_on() {
ui.painter().rect_filled(rect, 4.0, visuals.bg_fill);
}
let stroke = egui::Stroke::new(1.5, visuals.fg_stroke.color);
let center = rect.center();
let r = 5.0; // Размер иконки относительно центра
match icon {
IconType::Minimize => {
ui.painter().line_segment(
[center - egui::vec2(r, 0.0), center + egui::vec2(r, 0.0)],
stroke,
);
}
IconType::Maximize => {
ui.painter().rect_stroke(
egui::Rect::from_center_size(center, egui::vec2(r * 2.0, r * 2.0)),
0.0,
stroke,
egui::StrokeKind::Middle,
);
}
IconType::Restore => {
// Два перекрывающихся квадрата — символ «восстановить»
let back = egui::Rect::from_center_size(
center + egui::vec2(2.0, -2.0),
egui::vec2(r * 2.0, r * 2.0),
);
let front = egui::Rect::from_center_size(
center + egui::vec2(-2.0, 2.0),
egui::vec2(r * 2.0, r * 2.0),
);
// Заливаем «передний» квадрат фоном, чтобы задний не просвечивал сквозь него
let fill = if response.hovered() || response.is_pointer_button_down_on() {
visuals.bg_fill
} else {
ui.visuals().window_fill()
};
ui.painter().rect_filled(front, 0.0, fill);
ui.painter()
.rect_stroke(back, 0.0, stroke, egui::StrokeKind::Middle);
ui.painter()
.rect_stroke(front, 0.0, stroke, egui::StrokeKind::Middle);
}
IconType::Close => {
ui.painter().line_segment(
[center - egui::vec2(r, r), center + egui::vec2(r, r)],
stroke,
);
ui.painter().line_segment(
[center - egui::vec2(-r, r), center + egui::vec2(-r, r)],
stroke,
);
}
IconType::Plus => {
ui.painter().line_segment(
[center - egui::vec2(4.0, 0.0), center + egui::vec2(4.0, 0.0)],
stroke,
);
ui.painter().line_segment(
[center - egui::vec2(0.0, 4.0), center + egui::vec2(0.0, 4.0)],
stroke,
);
}
}
response
}
src/ui/mod.rs
-8
View File
@@ -1,8 +0,0 @@
//! Виджеты окна: интегрированный заголовок, вкладки, редактор, иконки
//! и зоны изменения размера.
pub mod code_editor;
pub mod icons;
pub mod resize_handles;
pub mod tabs;
pub mod title_bar;
src/ui/resize_handles.rs
-121
View File
@@ -1,121 +0,0 @@
//! Невидимые зоны по периметру окна для изменения размера.
use eframe::egui;
use crate::api::AppApi;
use crate::constants::RESIZE_BORDER;
/// Невидимые полосы и уголки по периметру окна: тянут за них — меняется размер окна.
///
/// Регистрируются последними (в том же слое), поэтому выигрывают hit-test у содержимого.
/// Само изменение размера выполняет оконная система через `ViewportCommand::BeginResize`.
pub fn render(ui: &mut egui::Ui) {
use egui::viewport::ResizeDirection as Dir;
let api = AppApi::global();
let ctx = api.context();
// Развёрнутое окно уже занимает весь экран — тянуть нечего.
if api.is_maximized() {
return;
}
let b = RESIZE_BORDER;
let rect = ctx.content_rect();
if rect.width() <= 2.0 * b || rect.height() <= 2.0 * b {
return;
}
let north = egui::Rect::from_min_max(rect.left_top(), egui::pos2(rect.right(), rect.top() + b));
let south = egui::Rect::from_min_max(
egui::pos2(rect.left(), rect.bottom() - b),
rect.right_bottom(),
);
let west =
egui::Rect::from_min_max(rect.left_top(), egui::pos2(rect.left() + b, rect.bottom()));
let east = egui::Rect::from_min_max(
egui::pos2(rect.right() - b, rect.top()),
rect.right_bottom(),
);
let edges = [
(
Dir::North,
egui::CursorIcon::ResizeVertical,
north,
"resize_n",
),
(
Dir::South,
egui::CursorIcon::ResizeVertical,
south,
"resize_s",
),
(
Dir::West,
egui::CursorIcon::ResizeHorizontal,
west,
"resize_w",
),
(
Dir::East,
egui::CursorIcon::ResizeHorizontal,
east,
"resize_e",
),
];
// Углы идут после рёбер: в них должен побеждать диагональный ресайз.
let corners = [
(
Dir::NorthWest,
egui::CursorIcon::ResizeNwSe,
egui::Rect::from_min_size(rect.left_top(), egui::Vec2::splat(b)),
"resize_nw",
),
(
Dir::NorthEast,
egui::CursorIcon::ResizeNeSw,
egui::Rect::from_min_size(
egui::pos2(rect.right() - b, rect.top()),
egui::Vec2::splat(b),
),
"resize_ne",
),
(
Dir::SouthEast,
egui::CursorIcon::ResizeNwSe,
egui::Rect::from_min_size(
egui::pos2(rect.right() - b, rect.bottom() - b),
egui::Vec2::splat(b),
),
"resize_se",
),
(
Dir::SouthWest,
egui::CursorIcon::ResizeNeSw,
egui::Rect::from_min_size(
egui::pos2(rect.left(), rect.bottom() - b),
egui::Vec2::splat(b),
),
"resize_sw",
),
];
for (direction, cursor, handle_rect, id_salt) in edges.into_iter().chain(corners) {
// `Sense::drag()` (без click) — перетаскивание начинается сразу по нажатию,
// а именно этого требует `BeginResize`.
let response = ui.interact(
handle_rect,
ui.scope_id().with(id_salt),
egui::Sense::drag(),
);
if response.hovered() {
ctx.set_cursor_icon(cursor);
}
if response.drag_started() {
ctx.send_viewport_cmd(egui::ViewportCommand::BeginResize(direction));
}
}
}
src/ui/tabs.rs
-228
View File
@@ -1,228 +0,0 @@
//! Полоса вкладок над редактором.
use eframe::egui;
use crate::constants::TAB_BAR_HEIGHT;
use crate::editor::Document;
use crate::ui::icons::{IconType, custom_icon_button};
/// Действия пользователя с вкладками за текущий кадр.
#[derive(Default)]
pub struct TabBarActions {
/// Клик по вкладке: её нужно сделать активной.
pub clicked_tab: Option<usize>,
/// Клик по крестику: вкладку нужно закрыть.
pub closed_tab: Option<usize>,
/// Клик по «+»: нужно открыть новый документ.
pub add_clicked: bool,
}
const TAB_MIN_WIDTH: f32 = 96.0;
const TAB_MAX_WIDTH: f32 = 220.0;
const TAB_PADDING_LEFT: f32 = 12.0;
const TAB_PADDING_RIGHT: f32 = 6.0;
const TAB_LABEL_GAP: f32 = 6.0;
const TAB_CLOSE_SIZE: f32 = 18.0;
const TAB_CORNER_RADIUS: u8 = 6;
/// Рисует полосу вкладок и возвращает действия пользователя.
pub fn render(ui: &mut egui::Ui, documents: &[Document], active: usize) -> TabBarActions {
let mut actions = TabBarActions::default();
let bar_rect = egui::Rect::from_min_size(
ui.cursor().min,
egui::vec2(ui.available_width(), TAB_BAR_HEIGHT),
);
let visuals = ui.visuals().clone();
// Фон полосы совпадает с фоном заголовка, поэтому она выглядит его продолжением.
ui.painter()
.rect_filled(bar_rect, 0.0, visuals.window_fill());
// Тонкая линия-разделитель под вкладками. Активная вкладка перекрывает её
// и сливается с фоном редактора.
let separator = egui::Rect::from_min_max(
egui::pos2(bar_rect.left(), bar_rect.bottom() - 1.0),
bar_rect.right_bottom(),
);
ui.painter().rect_filled(
separator,
0.0,
visuals.widgets.noninteractive.bg_stroke.color,
);
ui.allocate_ui_with_layout(
egui::vec2(bar_rect.width(), TAB_BAR_HEIGHT),
egui::Layout::left_to_right(egui::Align::Center),
|ui| {
ui.spacing_mut().item_spacing.x = 2.0;
ui.add_space(6.0);
for (index, doc) in documents.iter().enumerate() {
let tab = tab(ui, doc, index == active);
if tab.close_clicked {
actions.closed_tab = Some(index);
} else if tab.clicked {
actions.clicked_tab = Some(index);
}
}
ui.add_space(4.0);
let add = custom_icon_button(ui, egui::vec2(20.0, 20.0), IconType::Plus);
if add.on_hover_text("Новая вкладка").clicked() {
actions.add_clicked = true;
}
},
);
actions
}
struct TabResponse {
clicked: bool,
close_clicked: bool,
}
/// Одна вкладка: фон, название и кнопка закрытия.
fn tab(ui: &mut egui::Ui, doc: &Document, is_active: bool) -> TabResponse {
let font_id = egui::FontId::proportional(12.5);
let label_width = ui.fonts_mut(|fonts| {
fonts
.layout_no_wrap(doc.name.clone(), font_id.clone(), egui::Color32::WHITE)
.size()
.x
});
let width =
(label_width + TAB_PADDING_LEFT + TAB_LABEL_GAP + TAB_CLOSE_SIZE + TAB_PADDING_RIGHT)
.clamp(TAB_MIN_WIDTH, TAB_MAX_WIDTH);
let (rect, response) =
ui.allocate_exact_size(egui::vec2(width, TAB_BAR_HEIGHT), egui::Sense::click());
if response.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
}
let visuals = ui.visuals().clone();
let corner = egui::CornerRadius {
nw: TAB_CORNER_RADIUS,
ne: TAB_CORNER_RADIUS,
sw: 0,
se: 0,
};
let fill = if is_active {
visuals.extreme_bg_color
} else if response.hovered() {
// Полтона от цвета hover-виджетов: вкладка должна подсвечиваться мягко.
visuals
.window_fill()
.lerp_to_gamma(visuals.widgets.hovered.weak_bg_fill, 0.5)
} else {
egui::Color32::TRANSPARENT
};
ui.painter().rect_filled(rect, corner, fill);
// Акцентная полоска у активной вкладки.
if is_active {
let stripe = egui::Rect::from_min_size(rect.left_top(), egui::vec2(rect.width(), 2.0));
ui.painter()
.rect_filled(stripe, corner, visuals.selection.bg_fill);
}
let close_rect = egui::Rect::from_center_size(
egui::pos2(
rect.right() - TAB_PADDING_RIGHT - TAB_CLOSE_SIZE / 2.0,
rect.center().y,
),
egui::Vec2::splat(TAB_CLOSE_SIZE),
);
let text_color = if is_active {
visuals.strong_text_color()
} else if response.hovered() {
visuals.text_color()
} else {
visuals.weak_text_color()
};
// Название рисуем через `LayoutJob`, чтобы длинные имена обрезались многоточием.
let mut job = egui::text::LayoutJob::single_section(
doc.name.clone(),
egui::TextFormat::simple(font_id, text_color),
);
job.wrap = egui::text::TextWrapping {
max_width: (close_rect.left() - TAB_LABEL_GAP - (rect.left() + TAB_PADDING_LEFT)).max(0.0),
max_rows: 1,
break_anywhere: true,
overflow_character: Some('…'),
};
let galley = ui.fonts_mut(|fonts| fonts.layout_job(job));
ui.painter().galley(
egui::pos2(
rect.left() + TAB_PADDING_LEFT,
rect.center().y - galley.size().y / 2.0,
),
galley,
text_color,
);
// Кнопка закрытия регистрируется после вкладки, поэтому выигрывает у неё hit-test
// в своей области (так же, как кнопки заголовка регистрируются после drag-зоны).
let close = close_button(
ui,
close_rect,
ui.scope_id().with(("tab_close", doc.id)),
is_active || response.hovered(),
doc.is_dirty(),
);
TabResponse {
clicked: response.clicked(),
close_clicked: close.clicked(),
}
}
/// Маленький крестик вкладки; у изменённого документа вместо него — точка.
fn close_button(
ui: &mut egui::Ui,
rect: egui::Rect,
id: egui::Id,
show_cross: bool,
dirty: bool,
) -> egui::Response {
// Невидимый крестик не должен ловить клики: иначе клик по пустому месту
// закрывал бы вкладку.
let sense = if show_cross {
egui::Sense::click()
} else {
egui::Sense::hover()
};
let response = ui.interact(rect, id, sense);
let visuals = ui.visuals();
let painter = ui.painter();
if response.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
painter.rect_filled(rect, 4.0, visuals.widgets.hovered.bg_fill);
}
let center = rect.center();
if dirty && !response.hovered() {
painter.circle_filled(center, 3.0, visuals.selection.bg_fill);
} else if show_cross {
let stroke = egui::Stroke::new(1.2, visuals.weak_text_color());
let r = 3.5;
painter.line_segment(
[center + egui::vec2(-r, r), center + egui::vec2(r, -r)],
stroke,
);
painter.line_segment(
[center + egui::vec2(-r, -r), center + egui::vec2(r, r)],
stroke,
);
}
response
}
src/ui/title_bar.rs
-121
View File
@@ -1,121 +0,0 @@
//! Интегрированный в окно заголовок: перетаскивание и кнопки управления.
use eframe::egui;
use crate::api::AppApi;
use crate::constants::TITLE_BAR_HEIGHT;
use crate::ui::icons::{IconType, custom_icon_button};
/// Ответы виджетов заголовка: нужны, чтобы отличать клик по кнопке от драга окна.
pub struct TitleBarResponses {
pub close: egui::Response,
pub maximize: egui::Response,
pub minimize: egui::Response,
pub drag: egui::Response,
}
impl TitleBarResponses {
fn any_button_hovered(&self) -> bool {
self.close.hovered() || self.maximize.hovered() || self.minimize.hovered()
}
}
/// Рисует заголовок окна с именем активного документа и применяет действия
/// кнопок через [`AppApi`].
pub fn render(ui: &mut egui::Ui, document_name: &str) -> TitleBarResponses {
let api = AppApi::global();
let ctx = api.context();
let is_maximized = api.is_maximized();
let bar_rect = egui::Rect::from_min_size(
ui.cursor().min,
egui::vec2(ui.available_width(), TITLE_BAR_HEIGHT),
);
// ВАЖНО: зона перетаскивания регистрируется ПЕРВОЙ.
// В egui hit-test побеждает виджет, добавленный последним, а `Response::hovered()`
// получают только виджеты из `hits.click` / `hits.drag`. Если зарегистрировать
// drag-зону после кнопок, она станет и клик-, и drag-целью — кнопки перестанут
// получать и клики, и подсветку при наведении.
let drag = ui.interact(
bar_rect,
ui.scope_id().with("title_bar_drag"),
egui::Sense::click_and_drag(),
);
let mut close = None;
let mut maximize = None;
let mut minimize = None;
ui.allocate_ui_with_layout(
egui::vec2(ui.available_width(), TITLE_BAR_HEIGHT),
egui::Layout::left_to_right(egui::Align::Center),
|ui| {
ui.spacing_mut().item_spacing = egui::vec2(4.0, 0.0);
// Текст заголовка (слева).
// `selectable(false)` обязателен: иначе лейбл получает Sense::click_and_drag,
// регистрируется поверх drag-зоны и перехватывает перетаскивание окна,
// а текст начинает выделяться мышкой.
ui.add_space(12.0);
ui.add(
egui::Label::new(
egui::RichText::new(format!("{document_name} — Custom Window App"))
.size(13.0)
.strong(),
)
.selectable(false),
);
// Блок кнопок управления окном (смещаем в правый край через right_to_left)
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
ui.add_space(8.0); // Отступ справа от крайней кнопки
let button_size = egui::vec2(24.0, 24.0);
// Порядок важен: в right_to_left первая добавленная кнопка — крайняя правая.
close = Some(custom_icon_button(ui, button_size, IconType::Close));
let max_icon = if is_maximized {
IconType::Restore
} else {
IconType::Maximize
};
maximize = Some(custom_icon_button(ui, button_size, max_icon));
minimize = Some(custom_icon_button(ui, button_size, IconType::Minimize));
});
},
);
let responses = TitleBarResponses {
close: close.expect("кнопка закрытия создаётся всегда"),
maximize: maximize.expect("кнопка разворота создаётся всегда"),
minimize: minimize.expect("кнопка сворачивания создаётся всегда"),
drag,
};
// Действия кнопок — только через глобальный API.
if responses.close.clicked() {
api.close();
}
if responses.maximize.clicked() {
api.toggle_maximize();
}
if responses.minimize.clicked() {
api.minimize();
}
// Перетаскивать окно можно за любую свободную часть заголовка (включая текст).
if !is_maximized
&& !responses.any_button_hovered()
&& responses.drag.drag_started_by(egui::PointerButton::Primary)
{
ctx.send_viewport_cmd(egui::ViewportCommand::StartDrag);
}
// Двойной клик по заголовку — стандартное разворачивание/восстановление
if responses.drag.double_clicked() && !responses.any_button_hovered() {
api.toggle_maximize();
}
responses
}