#![deny(unsafe_code)]
pub mod canvas;
use std::cell::RefCell;
use std::collections::HashMap;
use std::path::PathBuf;
use std::rc::Rc;
pub use canvas::{Canvas, CELL_PX, GRID};
slint::include_modules!();
pub fn library_paths() -> HashMap<String, PathBuf> {
HashMap::from([(
"slint_pixel".to_string(),
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("ui/lib.slint"),
)])
}
pub trait PainterUi: slint::ComponentHandle {
fn set_canvas_image(&self, image: slint::Image);
fn set_status_text(&self, text: slint::SharedString);
fn get_brush_size(&self) -> i32;
fn get_eraser(&self) -> bool;
fn get_brush_color(&self) -> slint::Color;
fn on_paint(&self, cb: impl FnMut(f32, f32, bool) + 'static);
fn on_clear_canvas(&self, cb: impl FnMut() + 'static);
fn on_save_png(&self, cb: impl FnMut() + 'static);
}
#[macro_export]
macro_rules! impl_painter_ui {
($ty:ty) => {
impl $crate::PainterUi for $ty {
fn set_canvas_image(&self, image: ::slint::Image) {
self.set_canvas_image(image);
}
fn set_status_text(&self, text: ::slint::SharedString) {
self.set_status_text(text);
}
fn get_brush_size(&self) -> i32 {
self.get_brush_size()
}
fn get_eraser(&self) -> bool {
self.get_eraser()
}
fn get_brush_color(&self) -> ::slint::Color {
self.get_brush_color()
}
fn on_paint(&self, cb: impl FnMut(f32, f32, bool) + 'static) {
self.on_paint(cb);
}
fn on_clear_canvas(&self, cb: impl FnMut() + 'static) {
self.on_clear_canvas(cb);
}
fn on_save_png(&self, cb: impl FnMut() + 'static) {
self.on_save_png(cb);
}
}
};
}
pub trait TitleBarUi: slint::ComponentHandle {
fn on_drag_start(&self, cb: impl FnMut() + 'static);
fn on_minimize(&self, cb: impl FnMut() + 'static);
fn on_toggle_maximize(&self, cb: impl FnMut() + 'static);
fn on_close_window(&self, cb: impl FnMut() + 'static);
}
#[macro_export]
macro_rules! impl_title_bar_ui {
($ty:ty) => {
impl $crate::TitleBarUi for $ty {
fn on_drag_start(&self, cb: impl FnMut() + 'static) {
self.on_drag_start(cb);
}
fn on_minimize(&self, cb: impl FnMut() + 'static) {
self.on_minimize(cb);
}
fn on_toggle_maximize(&self, cb: impl FnMut() + 'static) {
self.on_toggle_maximize(cb);
}
fn on_close_window(&self, cb: impl FnMut() + 'static) {
self.on_close_window(cb);
}
}
};
}
crate::impl_painter_ui!(PixelPainterWindow);
crate::impl_title_bar_ui!(PixelPainterWindow);
pub fn install_painter<T: PainterUi + 'static>(ui: &T) -> Rc<RefCell<Canvas>> {
let canvas = Rc::new(RefCell::new(Canvas::new(GRID, CELL_PX)));
ui.set_canvas_image(canvas.borrow().render_display());
let weak = ui.as_weak();
let canvas_paint = canvas.clone();
ui.on_paint(move |x, y, erase| {
let Some(ui) = weak.upgrade() else { return };
let col = cell_index(x);
let row = cell_index(y);
let size = ui.get_brush_size().max(1) as usize;
let color = if erase || ui.get_eraser() {
None
} else {
Some(to_rgba(ui.get_brush_color()))
};
canvas_paint.borrow_mut().paint_brush(col, row, size, color);
ui.set_canvas_image(canvas_paint.borrow().render_display());
});
let weak = ui.as_weak();
let canvas_clear = canvas.clone();
ui.on_clear_canvas(move || {
let Some(ui) = weak.upgrade() else { return };
canvas_clear.borrow_mut().clear();
ui.set_canvas_image(canvas_clear.borrow().render_display());
ui.set_status_text("画布已清空".into());
});
let weak = ui.as_weak();
let canvas_save = canvas.clone();
ui.on_save_png(move || {
let Some(ui) = weak.upgrade() else { return };
let path = export_path();
match canvas_save.borrow().export_png(&path) {
Ok(()) => ui.set_status_text(format!("已保存: {}", path.display()).into()),
Err(e) => ui.set_status_text(format!("保存失败: {e}").into()),
}
});
canvas
}
pub fn install_title_bar_controls<T: TitleBarUi + 'static>(ui: &T) {
install_title_bar_controls_impl(ui, true);
}
pub fn install_title_bar_controls_no_quit<T: TitleBarUi + 'static>(ui: &T) {
install_title_bar_controls_impl(ui, false);
}
fn install_title_bar_controls_impl<T: TitleBarUi + 'static>(ui: &T, quit_on_close: bool) {
use slint::winit_030::WinitWindowAccessor;
let weak = ui.as_weak();
ui.on_drag_start(move || {
let Some(ui) = weak.upgrade() else { return };
ui.window().with_winit_window(|w| {
let _ = w.drag_window();
});
});
let weak = ui.as_weak();
ui.on_minimize(move || {
if let Some(ui) = weak.upgrade() {
ui.window().set_minimized(true);
}
});
let weak = ui.as_weak();
ui.on_toggle_maximize(move || {
if let Some(ui) = weak.upgrade() {
let maximized = ui.window().is_maximized();
ui.window().set_maximized(!maximized);
}
});
let weak = ui.as_weak();
ui.on_close_window(move || {
if let Some(ui) = weak.upgrade() {
let _ = ui.window().hide();
if quit_on_close {
let _ = slint::quit_event_loop();
}
}
});
}
pub trait ResizeUi: slint::ComponentHandle {
fn on_begin_resize(&self, cb: impl FnMut(slint::SharedString) + 'static);
}
#[macro_export]
macro_rules! impl_resize_ui {
($ty:ty) => {
impl $crate::ResizeUi for $ty {
fn on_begin_resize(&self, cb: impl FnMut(::slint::SharedString) + 'static) {
self.on_begin_resize(cb);
}
}
};
}
pub fn install_window_resize<T: ResizeUi + 'static>(ui: &T) {
use slint::winit_030::winit::window::ResizeDirection;
use slint::winit_030::WinitWindowAccessor;
let weak = ui.as_weak();
ui.on_begin_resize(move |dir| {
let Some(ui) = weak.upgrade() else { return };
let direction = match dir.as_str() {
"north" => ResizeDirection::North,
"south" => ResizeDirection::South,
"east" => ResizeDirection::East,
"west" => ResizeDirection::West,
"north-east" => ResizeDirection::NorthEast,
"north-west" => ResizeDirection::NorthWest,
"south-east" => ResizeDirection::SouthEast,
"south-west" => ResizeDirection::SouthWest,
_ => return,
};
ui.window().with_winit_window(|w| {
let _ = w.drag_resize_window(direction);
});
});
}
pub fn transparent_window(
attributes: slint::winit_030::winit::window::WindowAttributes,
) -> slint::winit_030::winit::window::WindowAttributes {
attributes.with_transparent(true)
}
#[cfg(target_os = "windows")]
pub fn attach_owner<C: slint::ComponentHandle, O: slint::ComponentHandle>(child: &C, owner: &O) {
use slint::winit_030::WinitWindowAccessor;
let child_hwnd = child.window().with_winit_window(win_hwnd);
let owner_hwnd = owner.window().with_winit_window(win_hwnd);
if let (Some(Some(c)), Some(Some(o))) = (child_hwnd, owner_hwnd) {
set_parent_hwnd(c, o);
}
}
#[cfg(not(target_os = "windows"))]
pub fn attach_owner<C: slint::ComponentHandle, O: slint::ComponentHandle>(_child: &C, _owner: &O) {}
#[cfg(target_os = "windows")]
#[allow(unsafe_code)]
fn win_hwnd(w: &slint::winit_030::winit::window::Window) -> Option<isize> {
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
let handle = w.window_handle().ok()?;
match handle.as_raw() {
RawWindowHandle::Win32(h) => Some(h.hwnd.get()),
_ => None,
}
}
#[cfg(target_os = "windows")]
#[allow(unsafe_code)]
fn set_parent_hwnd(child: isize, owner: isize) {
const GWLP_HWNDPARENT: i32 = -8;
unsafe extern "system" {
fn SetWindowLongPtrW(
hWnd: *const core::ffi::c_void,
nIndex: i32,
dwNewLong: isize,
) -> isize;
}
unsafe {
SetWindowLongPtrW(child as *const core::ffi::c_void, GWLP_HWNDPARENT, owner);
}
}
fn cell_index(pos: f32) -> usize {
let cell = (pos / CELL_PX as f32) as i32;
cell.clamp(0, GRID as i32 - 1) as usize
}
fn to_rgba(color: slint::Color) -> [u8; 4] {
[color.red(), color.green(), color.blue(), color.alpha()]
}
fn export_path() -> PathBuf {
let name = format!("pixel-art-{}.png", timestamp());
std::env::current_dir()
.unwrap_or_else(|_| PathBuf::from("."))
.join(name)
}
fn timestamp() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0)
}