use std::cell::{Cell, RefCell};
use std::path::PathBuf;
use std::rc::{Rc, Weak};
use std::sync::Arc;
use std::time::Duration;
use slint::{
CloseRequestResponse, ComponentHandle, LogicalPosition, LogicalSize, Model, ModelRc,
PhysicalPosition, PhysicalSize, RenderingState, Rgba8Pixel, SharedPixelBuffer, SharedString,
VecModel,
};
use wafu_core::{
App, Color, Colors, Effect, InputField, IoError, IoEvent, ItemKind, KeyInput, LineRanges,
LogView, MenuAnchor, MouseInput, Msg, PaneView, PopupLines, PopupView, PreviewContent,
PreviewPlacement, PreviewView, RequestId, ResolvedFont, RowKind, RowView, SharedImage, Side,
StateFile, Style, Theme as ConfigTheme, View, WindowState,
};
use wafu_io::{Paths, Runtime};
use crate::keys::{Modifiers, key_input};
use crate::{
AppWindow, LogLine, PaneData, PopupData, PopupField, PopupItem, PopupLine, PreviewData,
PreviewLine, Row, Theme, ThemeColors,
};
const MAX_POPUP_FIELDS: usize = 2;
const WHEEL_PIXELS_PER_NOTCH: f32 = 60.0;
const WHEEL_ROWS_PER_NOTCH: f32 = 3.0;
const WHEEL_LEFT: usize = 0;
const WHEEL_RIGHT: usize = 1;
const WHEEL_LOG: usize = 2;
const WHEEL_PREVIEW: usize = 3;
const WHEEL_POPUP: usize = 4;
const MENU_INSET: f32 = 16.0;
thread_local! {
static UI: RefCell<Option<Rc<Ui>>> = const { RefCell::new(None) };
}
pub struct Ui {
app: RefCell<App>,
window: AppWindow,
runtime: Runtime,
left_rows: Rc<VecModel<Row>>,
right_rows: Rc<VecModel<Row>>,
left_marks: Rc<VecModel<bool>>,
right_marks: Rc<VecModel<bool>>,
log_shown: Rc<VecModel<LogLine>>,
log_before: Rc<VecModel<LogLine>>,
log_tail: Rc<VecModel<LogLine>>,
popup_items: Rc<VecModel<PopupItem>>,
popup_fields: Rc<VecModel<PopupField>>,
popup_lines_shown: Rc<VecModel<PopupLine>>,
popup_lines_before: Rc<VecModel<PopupLine>>,
popup_lines_tail: Rc<VecModel<PopupLine>>,
preview_lines: Rc<VecModel<PreviewLine>>,
preview_before: Rc<VecModel<PreviewLine>>,
preview_tail: Rc<VecModel<PreviewLine>>,
line_rows: RefCell<LineRowsQueue>,
rendered: RefCell<Rendered>,
wheel_remainder: RefCell<[f32; 5]>,
last_pointer: Cell<(f32, f32)>,
after_render: RefCell<Vec<Box<dyn FnOnce()>>>,
has_rendering_notifier: bool,
startup_window: RefCell<Option<WindowState>>,
repositioned: Cell<bool>,
}
impl Ui {
pub fn install(window: AppWindow, paths: Paths) -> Rc<Self> {
let runtime = Runtime::new(paths, |event| {
let _ = slint::invoke_from_event_loop(move || {
UI.with(|ui| {
if let Some(ui) = ui.borrow().as_ref() {
ui.dispatch(Msg::Io(event));
}
});
});
});
let ui = Rc::new_cyclic(|weak: &Weak<Self>| {
let weak = weak.clone();
let has_rendering_notifier = window
.window()
.set_rendering_notifier(move |state, _| {
let Some(ui) = weak.upgrade() else {
return;
};
match state {
RenderingState::BeforeRendering => ui.reposition_window(),
RenderingState::AfterRendering => ui.flush_after_render(),
_ => {}
}
})
.is_ok();
Self {
app: RefCell::new(App::new()),
window,
runtime,
left_rows: Rc::new(VecModel::default()),
right_rows: Rc::new(VecModel::default()),
left_marks: Rc::new(VecModel::default()),
right_marks: Rc::new(VecModel::default()),
log_shown: Rc::new(VecModel::default()),
log_before: Rc::new(VecModel::default()),
log_tail: Rc::new(VecModel::default()),
popup_items: Rc::new(VecModel::default()),
popup_fields: Rc::new(VecModel::default()),
popup_lines_shown: Rc::new(VecModel::default()),
popup_lines_before: Rc::new(VecModel::default()),
popup_lines_tail: Rc::new(VecModel::default()),
preview_lines: Rc::new(VecModel::default()),
preview_before: Rc::new(VecModel::default()),
preview_tail: Rc::new(VecModel::default()),
line_rows: RefCell::new(LineRowsQueue::default()),
rendered: RefCell::new(Rendered::default()),
wheel_remainder: RefCell::new([0.0; 5]),
last_pointer: Cell::new((0.0, 0.0)),
after_render: RefCell::new(Vec::new()),
has_rendering_notifier,
startup_window: RefCell::new(None),
repositioned: Cell::new(false),
}
});
let weak = Rc::downgrade(&ui);
ui.run_after_render(move || {
if let Some(ui) = weak.upgrade() {
set_small_icon(&ui.window);
}
});
ui.window
.set_left_rows(ModelRc::from(Rc::clone(&ui.left_rows)));
ui.window
.set_right_rows(ModelRc::from(Rc::clone(&ui.right_rows)));
ui.window
.set_left_marks(ModelRc::from(Rc::clone(&ui.left_marks)));
ui.window
.set_right_marks(ModelRc::from(Rc::clone(&ui.right_marks)));
ui.window
.set_log_shown(ModelRc::from(Rc::clone(&ui.log_shown)));
ui.window
.set_log_before(ModelRc::from(Rc::clone(&ui.log_before)));
ui.window
.set_log_tail(ModelRc::from(Rc::clone(&ui.log_tail)));
ui.window
.set_popup_items(ModelRc::from(Rc::clone(&ui.popup_items)));
ui.window
.set_popup_fields(ModelRc::from(Rc::clone(&ui.popup_fields)));
ui.window
.set_popup_lines_shown(ModelRc::from(Rc::clone(&ui.popup_lines_shown)));
ui.window
.set_popup_lines_before(ModelRc::from(Rc::clone(&ui.popup_lines_before)));
ui.window
.set_popup_lines_tail(ModelRc::from(Rc::clone(&ui.popup_lines_tail)));
ui.window
.set_preview_lines(ModelRc::from(Rc::clone(&ui.preview_lines)));
ui.window
.set_preview_before(ModelRc::from(Rc::clone(&ui.preview_before)));
ui.window
.set_preview_tail(ModelRc::from(Rc::clone(&ui.preview_tail)));
ui.window.set_menu_bar_visible(cfg!(target_os = "macos"));
Self::connect(&ui);
UI.with(|slot| *slot.borrow_mut() = Some(Rc::clone(&ui)));
ui
}
pub fn window(&self) -> &AppWindow {
&self.window
}
pub fn dispatch(self: &Rc<Self>, msg: Msg) {
let effects = self.app.borrow_mut().update(msg);
for effect in effects {
match effect {
Effect::ShellMenu { paths, anchor } => self.shell_menu(paths, anchor),
Effect::PickDirectory { dir, request } => self.pick_directory(dir, request),
Effect::StartOperation(spec) => {
self.runtime.set_owner_window(window_handle(&self.window));
self.runtime.run(Effect::StartOperation(spec));
}
Effect::SaveState(state) => {
self.runtime.run(Effect::SaveState(self.with_window(state)));
}
Effect::SpawnNewWindow { state, as_admin } => {
self.runtime.run(Effect::SpawnNewWindow {
state: self.with_window(state),
as_admin,
});
}
Effect::Quit => {
let _ = slint::quit_event_loop();
}
effect => self.runtime.run(effect),
}
}
self.render(&self.app.borrow().view());
}
pub fn restore_window(&self, state: Option<&WindowState>) {
self.startup_window.replace(state.cloned());
let Some(state) = state else {
return;
};
let window = self.window.window();
if let (Some(width), Some(height)) = (state.width, state.height) {
#[allow(clippy::cast_precision_loss)]
window.set_size(LogicalSize::new(width as f32, height as f32));
}
if let (Some(x), Some(y)) = (state.x, state.y)
&& !wafu_io::is_wayland()
{
#[allow(clippy::cast_precision_loss)]
window.set_position(LogicalPosition::new(x as f32, y as f32));
}
}
fn shell_menu(self: &Rc<Self>, paths: Vec<PathBuf>, anchor: MenuAnchor) {
let weak = Rc::downgrade(self);
self.run_after_render(move || {
if let Some(ui) = weak.upgrade() {
let (x, y) = ui.menu_position(anchor);
let error = show_shell_menu(&ui.window, &paths, x, y);
ui.dispatch(Msg::Io(IoEvent::ShellMenuClosed { error }));
}
});
}
fn pick_directory(self: &Rc<Self>, dir: PathBuf, request: RequestId) {
let weak = Rc::downgrade(self);
self.run_after_render(move || {
let Some(ui) = weak.upgrade() else {
return;
};
let picking = rfd::AsyncFileDialog::new()
.set_directory(&dir)
.set_parent(&ui.window.window().window_handle())
.pick_folder();
let weak = Rc::downgrade(&ui);
let _ = slint::spawn_local(async move {
let path = picking.await.map(|handle| handle.path().to_path_buf());
if let Some(ui) = weak.upgrade() {
ui.dispatch(Msg::Io(IoEvent::DirectoryPicked { request, path }));
}
});
});
}
fn run_after_render(&self, task: impl FnOnce() + 'static) {
if self.has_rendering_notifier {
self.after_render.borrow_mut().push(Box::new(task));
self.window.window().request_redraw();
} else {
slint::Timer::single_shot(Duration::ZERO, task);
}
}
fn flush_after_render(&self) {
let tasks = std::mem::take(&mut *self.after_render.borrow_mut());
if !tasks.is_empty() {
slint::Timer::single_shot(Duration::ZERO, move || {
for task in tasks {
task();
}
});
}
}
fn reposition_window(&self) {
if !cfg!(target_os = "macos") || self.repositioned.replace(true) {
return;
}
let state = self.startup_window.borrow();
if let Some((x, y)) = state.as_ref().and_then(|state| state.x.zip(state.y)) {
#[allow(clippy::cast_precision_loss)]
self.window
.window()
.set_position(LogicalPosition::new(x as f32, y as f32));
}
}
fn menu_position(&self, anchor: MenuAnchor) -> (f32, f32) {
match anchor {
MenuAnchor::Pointer => self.last_pointer.get(),
MenuAnchor::Row { side, row } => {
let (list_x, top_row_y, scroll_top) = match side {
Side::Left => (
self.window.get_left_list_x(),
self.window.get_left_top_row_y(),
self.window.get_left_scroll_top(),
),
Side::Right => (
self.window.get_right_list_x(),
self.window.get_right_top_row_y(),
self.window.get_right_scroll_top(),
),
};
let row = i32::try_from(row).unwrap_or(i32::MAX);
let visible_row = (row - scroll_top).max(0);
let row_height = self.window.global::<Theme>().get_row_height();
#[allow(clippy::cast_precision_loss)]
let y = top_row_y + (visible_row + 1) as f32 * row_height;
(list_x + MENU_INSET, y)
}
}
}
fn with_window(&self, mut state: StateFile) -> StateFile {
let window = self.window.window();
state.window = if window.is_minimized() || window.is_maximized() {
normal_window_state(&self.window).or_else(|| self.startup_window.borrow().clone())
} else {
Some(window_state(
window.scale_factor(),
window.position(),
window.size(),
))
};
state
}
fn connect(ui: &Rc<Self>) {
Self::connect_window(ui);
Self::connect_log(ui);
Self::connect_preview(ui);
Self::connect_popup(ui);
Self::connect_dividers(ui);
let weak = Rc::downgrade(ui);
ui.window.on_viewport_rows_changed(move |side, rows| {
if let Some(ui) = Weak::upgrade(&weak) {
let rows = usize::try_from(rows).unwrap_or(0);
ui.dispatch(Msg::ViewportRows {
side: side_of(side),
rows,
});
}
});
let weak = Rc::downgrade(ui);
ui.window.on_row_clicked(move |side, row| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::Click {
side: side_of(side),
row: row_of(row),
}));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_row_double_clicked(move |side, row| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::DoubleClick {
side: side_of(side),
row: row_of(row),
}));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_row_right_clicked(move |side, row, x, y| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.last_pointer.set((x, y));
ui.dispatch(Msg::Mouse(MouseInput::RightClick {
side: side_of(side),
row: row_of(row),
}));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_wheel(move |side, delta| {
if let Some(ui) = Weak::upgrade(&weak) {
let side = side_of(side);
let area = match side {
Side::Left => WHEEL_LEFT,
Side::Right => WHEEL_RIGHT,
};
if let Some(rows) = ui.wheel_rows(area, delta) {
ui.dispatch(Msg::Mouse(MouseInput::Wheel { side, rows }));
}
}
});
let weak = Rc::downgrade(ui);
ui.window.on_scroll_to(move |side, top| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::ScrollTo {
side: side_of(side),
top: top_of(top),
}));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_input_edited(move |field, text| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::InputChanged {
field: usize::try_from(field).unwrap_or(0),
text: text.to_string(),
});
}
});
let weak = Rc::downgrade(ui);
ui.window.on_input_accepted(move || {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Key(KeyInput {
text: "Enter".to_owned(),
ctrl: false,
shift: false,
alt: false,
}));
}
});
}
fn connect_window(ui: &Rc<Self>) {
let weak = Rc::downgrade(ui);
ui.window.window().on_close_requested(move || {
if let Some(ui) = weak.upgrade() {
ui.dispatch(Msg::CloseRequested);
}
CloseRequestResponse::KeepWindowShown
});
let weak = Rc::downgrade(ui);
ui.window.on_quit_requested(move || {
if let Some(ui) = weak.upgrade() {
ui.dispatch(Msg::CloseRequested);
}
});
let weak = Rc::downgrade(ui);
ui.window
.on_key_input(move |text, control, shift, alt, meta| {
let modifiers = Modifiers {
control,
shift,
alt,
meta,
};
if let Some(ui) = weak.upgrade()
&& let Some(input) = key_input(&text, modifiers)
{
ui.dispatch(Msg::Key(input));
}
});
}
fn connect_log(ui: &Rc<Self>) {
let weak = Rc::downgrade(ui);
ui.window.on_log_wheel(move |delta| {
if let Some(ui) = Weak::upgrade(&weak)
&& let Some(rows) = ui.wheel_rows(WHEEL_LOG, delta)
{
ui.dispatch(Msg::Mouse(MouseInput::LogWheel { rows }));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_log_scroll_to(move |top| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::LogScrollTo { top: top_of(top) }));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_log_line_rows(move |index, rows| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.queue_line_rows(|queue| &mut queue.log, index, rows);
}
});
}
fn connect_preview(ui: &Rc<Self>) {
let weak = Rc::downgrade(ui);
ui.window.on_preview_rows_changed(move |rows| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.queue_preview_rows(usize::try_from(rows).unwrap_or(1));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_preview_double_clicked(move || {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::PreviewDoubleClick));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_preview_wheel(move |delta| {
if let Some(ui) = Weak::upgrade(&weak)
&& let Some(rows) = ui.wheel_rows(WHEEL_PREVIEW, delta)
{
ui.dispatch(Msg::Mouse(MouseInput::PreviewWheel { rows }));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_preview_scroll_to(move |top| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::PreviewScrollTo { top: top_of(top) }));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_preview_line_rows(move |index, rows| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.queue_line_rows(|queue| &mut queue.preview, index, rows);
}
});
}
fn connect_popup(ui: &Rc<Self>) {
let weak = Rc::downgrade(ui);
ui.window.on_popup_rows_changed(move |rows| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::PopupRows {
rows: usize::try_from(rows).unwrap_or(1),
});
}
});
let weak = Rc::downgrade(ui);
ui.window.on_popup_row_clicked(move |row| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::PopupClick { row: row_of(row) }));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_popup_row_double_clicked(move |row| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::PopupDoubleClick {
row: row_of(row),
}));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_popup_wheel(move |delta| {
if let Some(ui) = Weak::upgrade(&weak)
&& let Some(rows) = ui.wheel_rows(WHEEL_POPUP, delta)
{
ui.dispatch(Msg::Mouse(MouseInput::PopupWheel { rows }));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_popup_lines_rows_changed(move |rows| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.queue_popup_rows(usize::try_from(rows).unwrap_or(1));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_popup_line_rows(move |index, rows| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.queue_line_rows(|queue| &mut queue.popup, index, rows);
}
});
let weak = Rc::downgrade(ui);
ui.window.on_popup_lines_scroll_to(move |top| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::PopupScrollTo { top: top_of(top) }));
}
});
}
fn connect_dividers(ui: &Rc<Self>) {
let weak = Rc::downgrade(ui);
ui.window.on_split_dragged(move |percent| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::SplitTo {
percent: u8::try_from(percent.clamp(0, 100)).unwrap_or(0),
}));
}
});
let weak = Rc::downgrade(ui);
ui.window.on_log_resized(move |rows| {
if let Some(ui) = Weak::upgrade(&weak) {
ui.dispatch(Msg::Mouse(MouseInput::LogRowsTo {
rows: usize::try_from(rows).unwrap_or(0),
}));
}
});
}
fn queue_line_rows(
self: &Rc<Self>,
area: fn(&mut LineRowsQueue) -> &mut Vec<(usize, usize)>,
index: i32,
rows: i32,
) {
area(&mut self.line_rows.borrow_mut())
.push((row_of(index), usize::try_from(rows).unwrap_or(1)));
self.arm_line_rows();
}
fn queue_preview_rows(self: &Rc<Self>, rows: usize) {
self.line_rows.borrow_mut().preview_area = Some(rows);
self.arm_line_rows();
}
fn queue_popup_rows(self: &Rc<Self>, rows: usize) {
self.line_rows.borrow_mut().popup_area = Some(rows);
self.arm_line_rows();
}
fn arm_line_rows(self: &Rc<Self>) {
let mut queue = self.line_rows.borrow_mut();
if !queue.armed {
queue.armed = true;
let weak = Rc::downgrade(self);
slint::Timer::single_shot(Duration::ZERO, move || {
if let Some(ui) = weak.upgrade() {
ui.flush_line_rows();
}
});
}
}
fn flush_line_rows(self: &Rc<Self>) {
let LineRowsQueue {
log,
preview,
preview_area,
popup,
popup_area,
..
} = std::mem::take(&mut *self.line_rows.borrow_mut());
if !log.is_empty() {
self.dispatch(Msg::LogLineRows { reports: log });
}
if preview_area.is_some() || !preview.is_empty() {
self.dispatch(Msg::PreviewRows {
area: preview_area,
lines: preview,
});
}
if popup_area.is_some() || !popup.is_empty() {
self.dispatch(Msg::PopupLineRows {
area: popup_area,
lines: popup,
});
}
}
fn wheel_rows(&self, index: usize, delta: f32) -> Option<i32> {
let mut remainder = self.wheel_remainder.borrow_mut();
let total = remainder[index] - delta / WHEEL_PIXELS_PER_NOTCH * WHEEL_ROWS_PER_NOTCH;
let rows = total.trunc();
remainder[index] = total - rows;
#[allow(clippy::cast_possible_truncation)]
let rows = rows as i32;
(rows != 0).then_some(rows)
}
fn render(&self, view: &View) {
self.window.set_left(pane_data(&view.left));
self.window.set_right(pane_data(&view.right));
self.window
.set_left_scroll_top(i32::try_from(view.left.scroll_top).unwrap_or(i32::MAX));
self.window
.set_right_scroll_top(i32::try_from(view.right.scroll_top).unwrap_or(i32::MAX));
self.window.set_split_percent(i32::from(view.split_percent));
self.window
.set_log_rows(i32::try_from(view.log_rows).unwrap_or(i32::MAX));
self.window
.set_log_scroll_top(i32::try_from(view.log.scroll_top).unwrap_or(i32::MAX));
self.window
.set_log_line_count(i32::try_from(view.log.lines.len()).unwrap_or(i32::MAX));
self.window
.set_log_end(i32::try_from(view.log.end).unwrap_or(i32::MAX));
self.window.set_hide_log(view.hide_log);
self.window.set_status(view.status.as_str().into());
let mut rendered = self.rendered.borrow_mut();
if rendered.title != view.title {
self.window.set_window_title(view.title.as_str().into());
rendered.title.clone_from(&view.title);
}
if rendered
.style
.as_ref()
.is_none_or(|style| !Arc::ptr_eq(style, &view.style))
{
self.apply_style(&view.style);
rendered.style = Some(Arc::clone(&view.style));
}
if !Arc::ptr_eq(&rendered.left_rows, &view.left.rows) {
self.left_rows
.set_vec(view.left.rows.iter().map(row).collect::<Vec<_>>());
rendered.left_rows = Arc::clone(&view.left.rows);
}
if !Arc::ptr_eq(&rendered.right_rows, &view.right.rows) {
self.right_rows
.set_vec(view.right.rows.iter().map(row).collect::<Vec<_>>());
rendered.right_rows = Arc::clone(&view.right.rows);
}
if !Arc::ptr_eq(&rendered.left_marks, &view.left.marks) {
update_marks(&self.left_marks, &rendered.left_marks, &view.left.marks);
rendered.left_marks = Arc::clone(&view.left.marks);
}
if !Arc::ptr_eq(&rendered.right_marks, &view.right.marks) {
update_marks(&self.right_marks, &rendered.right_marks, &view.right.marks);
rendered.right_marks = Arc::clone(&view.right.marks);
}
if !Arc::ptr_eq(&rendered.log, &view.log.lines) || rendered.log_ranges != view.log.ranges {
self.render_log(&mut rendered, &view.log);
}
let fields = view
.popup
.as_ref()
.map(|popup| popup.fields.as_slice())
.unwrap_or_default();
for (index, field) in fields.iter().enumerate().take(MAX_POPUP_FIELDS) {
let current = if index == 0 {
self.window.get_popup_text()
} else {
self.window.get_popup_text_2()
};
if current != field.text {
let text = SharedString::from(field.text.as_str());
if index == 0 {
self.window.set_popup_text(text);
} else {
self.window.set_popup_text_2(text);
}
}
}
if rendered.preview != view.preview {
self.render_preview(&mut rendered, view.preview.as_ref());
rendered.preview.clone_from(&view.preview);
}
if rendered.popup != view.popup {
let new_fields = popup_fields(view.popup.as_ref());
if popup_fields(rendered.popup.as_ref()) != new_fields {
self.popup_fields.set_vec(new_fields);
}
self.window.set_popup(popup_data(view.popup.as_ref()));
let items = popup_items(view.popup.as_ref());
if popup_items(rendered.popup.as_ref()) != items {
self.popup_items
.set_vec(items.iter().map(popup_item).collect::<Vec<_>>());
}
self.render_popup_lines(rendered.popup.as_ref(), view.popup.as_ref());
rendered.popup.clone_from(&view.popup);
}
}
fn render_log(&self, rendered: &mut Rendered, log: &LogView) {
let models = [
(&self.log_shown, log.ranges.shown.clone()),
(&self.log_before, log.ranges.before.clone()),
(&self.log_tail, log.ranges.tail.clone()),
];
for (model, range) in models {
let lines = log_lines(&log.lines, range);
if rendered.log_generation == log.generation {
set_if_changed(model, lines);
} else {
model.set_vec(lines);
}
}
rendered.log = Arc::clone(&log.lines);
rendered.log_ranges = log.ranges.clone();
rendered.log_generation = log.generation;
}
fn render_popup_lines(&self, before: Option<&PopupView>, after: Option<&PopupView>) {
let remeasure = before.map(|popup| popup.generation) != after.map(|popup| popup.generation);
let empty = PopupLines::default();
let lines = after
.and_then(|popup| popup.lines.as_ref())
.unwrap_or(&empty);
let models = [
(&self.popup_lines_shown, &lines.shown),
(&self.popup_lines_before, &lines.before),
(&self.popup_lines_tail, &lines.tail),
];
for (model, lines) in models {
let lines = lines.iter().map(popup_line).collect();
if remeasure {
model.set_vec(lines);
} else {
set_if_changed(model, lines);
}
}
}
fn render_preview(&self, rendered: &mut Rendered, preview: Option<&PreviewView>) {
let none: &[wafu_core::PreviewLine] = &[];
let remeasure = lines_generation(rendered.preview.as_ref()) != lines_generation(preview);
let (lines, digits, image, data) = match preview {
None => ([none; 3], 0, None, PreviewData::default()),
Some(preview) => {
let (kind, lines, scroll, digits, hex_dump, image, message) = match &preview.content
{
PreviewContent::Lines {
lines,
before,
tail,
scroll_top,
line_count,
end,
digits,
hex_dump,
..
} => (
0,
[lines.as_slice(), before, tail],
[*scroll_top, *line_count, *end],
*digits,
*hex_dump,
None,
"",
),
PreviewContent::Image(image) => {
(1, [none; 3], [0; 3], 0, false, image.clone(), "")
}
PreviewContent::Message(message) => {
(2, [none; 3], [0; 3], 0, false, None, message.as_str())
}
};
let [scroll_top, line_count, end] =
scroll.map(|value| i32::try_from(value).unwrap_or(i32::MAX));
let (covers_left, covers_right) = match preview.placement {
PreviewPlacement::Full => (true, true),
PreviewPlacement::LeftPane => (true, false),
PreviewPlacement::RightPane => (false, true),
};
let data = PreviewData {
visible: true,
covers_left,
covers_right,
kind,
hex_dump,
scroll_top,
line_count,
end,
message: message.into(),
marked: preview.marked,
};
(lines, digits, image, data)
}
};
if rendered.image != image {
self.window.set_preview_image(match &image {
Some(image) => slint_image(&image.0),
None => slint::Image::default(),
});
rendered.image = image;
}
self.window.set_preview_has_image(rendered.image.is_some());
self.window
.set_preview_number_sample("0".repeat(digits).into());
let models = [
&self.preview_lines,
&self.preview_before,
&self.preview_tail,
];
for (model, lines) in models.into_iter().zip(lines) {
let lines = lines.iter().map(preview_line).collect();
if remeasure {
model.set_vec(lines);
} else {
set_if_changed(model, lines);
}
}
self.window.set_preview(data);
}
fn apply_style(&self, style: &Style) {
self.window
.set_size_sample(style.size_sample.as_str().into());
self.window
.set_time_sample(style.time_sample.as_str().into());
self.window
.set_extension_sample(style.extension_sample.as_str().into());
self.window
.set_name_sample(style.name_sample.as_str().into());
self.window.set_theme(match style.theme {
ConfigTheme::Auto => 0,
ConfigTheme::Light => 1,
ConfigTheme::Dark => 2,
});
let theme = self.window.global::<Theme>();
theme.set_light(theme_colors(&style.colors.light));
theme.set_dark(theme_colors(&style.colors.dark));
theme.set_hidden_opacity(f32::from(style.hidden_opacity) / 100.0);
let (family, size) = font(&style.fonts.path);
theme.set_path_font_family(family);
theme.set_path_font_size(size);
let (family, size) = font(&style.fonts.filelist);
theme.set_filelist_font_family(family);
theme.set_filelist_font_size(size);
let (family, size) = font(&style.fonts.info);
theme.set_info_font_family(family);
theme.set_info_font_size(size);
let (family, size) = font(&style.fonts.log);
theme.set_log_font_family(family);
theme.set_log_font_size(size);
let (family, size) = font(&style.fonts.status);
theme.set_status_font_family(family);
theme.set_status_font_size(size);
let (family, size) = font(&style.fonts.preview);
theme.set_preview_font_family(family);
theme.set_preview_font_size(size);
let (family, size) = font(&style.fonts.popup);
theme.set_popup_font_family(family);
theme.set_popup_font_size(size);
}
}
struct Rendered {
left_rows: Arc<[RowView]>,
right_rows: Arc<[RowView]>,
left_marks: Arc<[bool]>,
right_marks: Arc<[bool]>,
log: Arc<[Arc<str>]>,
log_ranges: LineRanges,
log_generation: usize,
popup: Option<PopupView>,
preview: Option<PreviewView>,
image: Option<SharedImage>,
style: Option<Arc<Style>>,
title: String,
}
impl Default for Rendered {
fn default() -> Self {
Self {
left_rows: Arc::from([]),
right_rows: Arc::from([]),
left_marks: Arc::from([]),
right_marks: Arc::from([]),
log: Arc::from([]),
log_ranges: LineRanges::default(),
log_generation: 0,
popup: None,
preview: None,
image: None,
style: None,
title: String::new(),
}
}
}
#[derive(Default)]
struct LineRowsQueue {
log: Vec<(usize, usize)>,
preview: Vec<(usize, usize)>,
preview_area: Option<usize>,
popup: Vec<(usize, usize)>,
popup_area: Option<usize>,
armed: bool,
}
fn window_state(scale: f32, position: PhysicalPosition, size: PhysicalSize) -> WindowState {
let size = size.to_logical(scale);
let position = position.to_logical(scale);
let (x, y) = if wafu_io::is_wayland() {
(None, None)
} else {
(Some(round(position.x)), Some(round(position.y)))
};
WindowState {
x,
y,
width: Some(round(size.width).unsigned_abs()),
height: Some(round(size.height).unsigned_abs()),
}
}
#[cfg(windows)]
fn normal_window_state(window: &AppWindow) -> Option<WindowState> {
let place = wafu_io::normal_window_place(window_handle(window)?).ok()?;
Some(window_state(
window.window().scale_factor(),
PhysicalPosition::new(place.x, place.y),
PhysicalSize::new(place.width, place.height),
))
}
#[cfg(not(windows))]
fn normal_window_state(_window: &AppWindow) -> Option<WindowState> {
None
}
#[cfg(windows)]
fn window_handle(window: &AppWindow) -> Option<isize> {
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
let handle = window.window().window_handle();
match handle.window_handle().map(|handle| handle.as_raw()) {
Ok(RawWindowHandle::Win32(handle)) => Some(handle.hwnd.get()),
_ => None,
}
}
#[cfg(not(windows))]
fn window_handle(_window: &AppWindow) -> Option<isize> {
None
}
#[cfg(windows)]
fn set_small_icon(window: &AppWindow) {
if let Some(hwnd) = window_handle(window) {
let _ = wafu_io::set_small_icon(hwnd);
}
}
#[cfg(not(windows))]
fn set_small_icon(_window: &AppWindow) {}
#[cfg(windows)]
fn show_shell_menu(window: &AppWindow, paths: &[PathBuf], x: f32, y: f32) -> Option<IoError> {
let Some(hwnd) = window_handle(window) else {
return Some(IoError::new("the window has no handle"));
};
let scale = window.window().scale_factor();
wafu_io::shell_menu(hwnd, paths, round(x * scale), round(y * scale))
.err()
.map(|error| IoError::new(error.to_string()))
}
#[cfg(not(windows))]
fn show_shell_menu(_window: &AppWindow, _paths: &[PathBuf], _x: f32, _y: f32) -> Option<IoError> {
None
}
fn lines_generation(preview: Option<&PreviewView>) -> Option<usize> {
match preview?.content {
PreviewContent::Lines { generation, .. } => Some(generation),
_ => None,
}
}
fn preview_line(line: &wafu_core::PreviewLine) -> PreviewLine {
PreviewLine {
index: i32::try_from(line.index).unwrap_or(i32::MAX),
number: line.number.as_str().into(),
text: line.text.as_str().into(),
}
}
fn slint_image(image: &wafu_core::ImageData) -> slint::Image {
let buffer =
SharedPixelBuffer::<Rgba8Pixel>::clone_from_slice(&image.rgba, image.width, image.height);
slint::Image::from_rgba8(buffer)
}
fn theme_colors(colors: &Colors) -> ThemeColors {
ThemeColors {
fg: color(colors.fg),
bg: color(colors.bg),
line_number: color(colors.line_number),
mark: color(colors.mark),
cursor: color(colors.cursor),
cursor_inactive: color(colors.cursor_inactive),
dir: color(colors.dir),
link: color(colors.link),
exec: color(colors.exec),
broken: color(colors.broken),
fifo: color(colors.fifo),
socket: color(colors.socket),
}
}
fn color(color: Color) -> slint::Color {
slint::Color::from_rgb_u8(color.r, color.g, color.b)
}
fn font(font: &ResolvedFont) -> (SharedString, f32) {
(font.family.as_str().into(), f32::from(font.size))
}
fn round(value: f32) -> i32 {
#[allow(clippy::cast_possible_truncation)]
let rounded = value.round() as i32;
rounded
}
fn log_lines(lines: &[Arc<str>], range: std::ops::Range<usize>) -> Vec<LogLine> {
range
.map(|index| LogLine {
index: i32::try_from(index).unwrap_or(i32::MAX),
text: SharedString::from(&*lines[index]),
})
.collect()
}
fn set_if_changed<T: Clone + PartialEq + 'static>(model: &VecModel<T>, rows: Vec<T>) {
if model.iter().ne(rows.iter().cloned()) {
model.set_vec(rows);
}
}
fn update_marks(model: &VecModel<bool>, before: &[bool], after: &[bool]) {
if model.row_count() != after.len() {
model.set_vec(after.to_vec());
return;
}
for (index, (&was, &is)) in before.iter().zip(after).enumerate() {
if was != is {
model.set_row_data(index, is);
}
}
}
fn side_of(side: i32) -> Side {
if side == 0 { Side::Left } else { Side::Right }
}
fn row_of(row: i32) -> usize {
usize::try_from(row).unwrap_or(usize::MAX)
}
fn top_of(top: i32) -> usize {
usize::try_from(top).unwrap_or(0)
}
fn pane_data(pane: &PaneView) -> PaneData {
PaneData {
path: pane.path.as_str().into(),
info: pane.info.as_str().into(),
cursor: pane
.cursor
.and_then(|cursor| i32::try_from(cursor).ok())
.unwrap_or(-1),
}
}
fn row(row: &RowView) -> Row {
Row {
kind: match row.kind {
RowKind::Dir => 0,
RowKind::File => 1,
RowKind::Exec => 2,
RowKind::Link => 3,
RowKind::Broken => 4,
RowKind::Fifo => 5,
RowKind::Socket => 6,
},
name: row.name.as_str().into(),
extension: row.extension.as_str().into(),
marker: row.marker.into(),
size: row.size.as_str().into(),
modified: row.modified.as_str().into(),
hidden: row.hidden,
has_light_color: row.extension_color.light.is_some(),
light_color: row.extension_color.light.map(color).unwrap_or_default(),
has_dark_color: row.extension_color.dark.is_some(),
dark_color: row.extension_color.dark.map(color).unwrap_or_default(),
}
}
fn popup_data(popup: Option<&PopupView>) -> PopupData {
match popup {
Some(popup) => PopupData {
visible: true,
title: popup.title.as_str().into(),
message: popup.message.as_deref().unwrap_or_default().into(),
note: popup.note.as_deref().unwrap_or_default().into(),
has_input: !popup.fields.is_empty(),
has_list: popup.items.is_some(),
has_lines: popup.lines.is_some(),
cursor: popup
.cursor
.and_then(|cursor| i32::try_from(cursor).ok())
.unwrap_or(-1),
scroll_top: i32::try_from(popup.scroll_top).unwrap_or(i32::MAX),
line_top: line_scroll(popup, |lines| lines.scroll_top),
line_count: line_scroll(popup, |lines| lines.count),
line_end: line_scroll(popup, |lines| lines.end),
progress: popup.progress,
generation: i32::try_from(popup.generation).unwrap_or(i32::MAX),
},
None => PopupData {
visible: false,
title: SharedString::default(),
message: SharedString::default(),
note: SharedString::default(),
has_input: false,
has_list: false,
has_lines: false,
cursor: -1,
scroll_top: 0,
line_top: 0,
line_count: 0,
line_end: 0,
progress: false,
generation: 0,
},
}
}
fn line_scroll(popup: &PopupView, value: fn(&PopupLines) -> usize) -> i32 {
i32::try_from(popup.lines.as_ref().map_or(0, value)).unwrap_or(i32::MAX)
}
fn popup_fields(popup: Option<&PopupView>) -> Vec<PopupField> {
popup
.map(|popup| popup.fields.as_slice())
.unwrap_or_default()
.iter()
.take(MAX_POPUP_FIELDS)
.map(popup_field)
.collect()
}
fn popup_items(popup: Option<&PopupView>) -> &[wafu_core::PopupItem] {
popup
.and_then(|popup| popup.items.as_deref())
.unwrap_or_default()
}
fn popup_field(field: &InputField) -> PopupField {
let (start, end) = field.select.unwrap_or((0, 0));
PopupField {
label: field.label.into(),
secret: field.secret,
select_all: field.select.is_none(),
select_start: i32::try_from(start).unwrap_or(0),
select_end: i32::try_from(end).unwrap_or(0),
}
}
fn popup_line(line: &wafu_core::PopupLine) -> PopupLine {
PopupLine {
index: i32::try_from(line.index).unwrap_or(i32::MAX),
text: line.text.as_str().into(),
}
}
fn popup_item(item: &wafu_core::PopupItem) -> PopupItem {
let (kind, on) = match item.kind {
ItemKind::Choice => (0, false),
ItemKind::Check(on) => (1, on),
ItemKind::Separator => (2, false),
};
PopupItem {
label: item.label.as_str().into(),
detail: item.detail.as_str().into(),
kind,
on,
}
}