diff --git a/.github/dependabot.yml b/.github/dependabot.yml deleted file mode 100644 index ac4bad3..0000000 --- a/.github/dependabot.yml +++ /dev/null @@ -1,13 +0,0 @@ -version: 2 -updates: - - package-ecosystem: "cargo" - directory: "/" - schedule: - interval: "weekly" - open-pull-requests-limit: 3 - - - package-ecosystem: "github-actions" - directory: "/" - schedule: - interval: "weekly" - open-pull-requests-limit: 3 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a66f4c7..c9d0255 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -36,9 +36,5 @@ jobs: with: components: rustfmt, clippy - uses: Swatinem/rust-cache@v2 - # TODO: remove continue-on-error once the code passes - run: cargo fmt --all -- --check - continue-on-error: true - # TODO: remove continue-on-error once the code passes - - run: cargo clippy --locked --all-targets -- -D warnings - continue-on-error: true + - run: cargo clippy --locked --all-targets -- -D warnings \ No newline at end of file diff --git a/src/config.rs b/src/config.rs index 371457a..df39abd 100644 --- a/src/config.rs +++ b/src/config.rs @@ -1,8 +1,8 @@ //! Persistent settings stored in %APPDATA%\Snowfall\settings.txt (simple key=value lines). +use crate::tray::AppState; use std::path::PathBuf; use std::sync::atomic::Ordering; -use crate::tray::AppState; fn config_path() -> Option { let base = std::env::var_os("APPDATA")?; @@ -30,12 +30,20 @@ pub fn snapshot(state: &AppState) -> [usize; 9] { /// Loads saved settings into `state`. Missing file or bad values are ignored. pub fn load(state: &AppState) { let Some(path) = config_path() else { return }; - let Ok(text) = std::fs::read_to_string(&path) else { return }; + let Ok(text) = std::fs::read_to_string(&path) else { + return; + }; for line in text.lines() { - let Some((key, value)) = line.split_once('=') else { continue }; - let Ok(v) = value.trim().parse::() else { continue }; + let Some((key, value)) = line.split_once('=') else { + continue; + }; + let Ok(v) = value.trim().parse::() else { + continue; + }; match key.trim() { - "flakes" => state.target_flakes.store(v.clamp(50, 3000), Ordering::Relaxed), + "flakes" => state + .target_flakes + .store(v.clamp(50, 3000), Ordering::Relaxed), "fps" => { if matches!(v, 20 | 30 | 60) { state.target_fps.store(v, Ordering::Relaxed); diff --git a/src/main.rs b/src/main.rs index 5dd89c5..c15d44f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,27 +1,29 @@ //! Main entry point for snowfall application. +mod config; mod overlay; -mod tracker; mod platform; +mod settings_ui; mod snow; +mod tracker; mod tray; -mod settings_ui; -mod config; use overlay::Overlay; -use snow::{Snow, bgra}; +use snow::{bgra, Snow}; +use std::collections::VecDeque; use std::sync::atomic::Ordering; use std::time::{Duration, Instant}; -use std::collections::VecDeque; -use windows::Win32::Foundation::{HWND, WPARAM, LPARAM, POINT}; -use windows::Win32::UI::HiDpi::{SetProcessDpiAwarenessContext, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2}; -use windows::Win32::UI::WindowsAndMessaging::{ - GetSystemMetrics, SM_CXVIRTUALSCREEN, SM_CYVIRTUALSCREEN, SM_XVIRTUALSCREEN, SM_YVIRTUALSCREEN, - ShowWindow, SW_HIDE, SW_SHOWNOACTIVATE, GetCursorPos -}; +use windows::Win32::Foundation::{HWND, LPARAM, POINT, WPARAM}; use windows::Win32::Media::{timeBeginPeriod, timeEndPeriod}; use windows::Win32::System::Threading::{ - GetCurrentThread, SetThreadPriority, THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_NORMAL + GetCurrentThread, SetThreadPriority, THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_NORMAL, +}; +use windows::Win32::UI::HiDpi::{ + SetProcessDpiAwarenessContext, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2, +}; +use windows::Win32::UI::WindowsAndMessaging::{ + GetCursorPos, GetSystemMetrics, ShowWindow, SM_CXVIRTUALSCREEN, SM_CYVIRTUALSCREEN, + SM_XVIRTUALSCREEN, SM_YVIRTUALSCREEN, SW_HIDE, SW_SHOWNOACTIVATE, }; const LATENCY_COMP: f32 = 0.025; @@ -64,7 +66,14 @@ fn main() { state.quit.store(true, Ordering::Relaxed); let tray_hwnd = HWND(state.tray_hwnd.load(Ordering::Acquire) as *mut std::ffi::c_void); if !tray_hwnd.is_invalid() { - let _ = unsafe { windows::Win32::UI::WindowsAndMessaging::PostMessageW(tray_hwnd, windows::Win32::UI::WindowsAndMessaging::WM_CLOSE, WPARAM(0), LPARAM(0)) }; + let _ = unsafe { + windows::Win32::UI::WindowsAndMessaging::PostMessageW( + tray_hwnd, + windows::Win32::UI::WindowsAndMessaging::WM_CLOSE, + WPARAM(0), + LPARAM(0), + ) + }; } let _ = tray_handle.join(); return; @@ -100,7 +109,11 @@ fn main() { let mut prev_acc_windows = acc_windows; let mut prev_acc_dock = acc_dock; let mut prev_acc_ground = acc_ground; - let raw_segments = platform::build_segments(&cached_windows, virt, (floor, acc_windows, acc_dock, acc_ground)); + let raw_segments = platform::build_segments( + &cached_windows, + virt, + (floor, acc_windows, acc_dock, acc_ground), + ); let mut cached_segments: Vec = raw_segments .into_iter() .map(|seg| platform::Segment { @@ -284,7 +297,9 @@ fn main() { let acc_dock = state.acc_dock.load(Ordering::Relaxed); let acc_ground = state.acc_ground.load(Ordering::Relaxed); - let flags_changed = acc_windows != prev_acc_windows || acc_dock != prev_acc_dock || acc_ground != prev_acc_ground; + let flags_changed = acc_windows != prev_acc_windows + || acc_dock != prev_acc_dock + || acc_ground != prev_acc_ground; if flags_changed { prev_acc_windows = acc_windows; prev_acc_dock = acc_dock; @@ -292,7 +307,11 @@ fn main() { } let mut segments_rebuilt = false; - let tracker_timer = if perf_mode { Some(Instant::now()) } else { None }; + let tracker_timer = if perf_mode { + Some(Instant::now()) + } else { + None + }; if is_dragging { if let Some(new_rect) = tracker::read_rect(moving_hwnd) { @@ -318,7 +337,11 @@ fn main() { if drag_samples.len() >= 8 { drag_samples.pop_front(); } - drag_samples.push_back(DragSample { time: sample_now, x: cur_x, y: cur_y }); + drag_samples.push_back(DragSample { + time: sample_now, + x: cur_x, + y: cur_y, + }); if drag_samples.len() >= 2 { let newest = drag_samples.back().unwrap(); @@ -431,7 +454,11 @@ fn main() { let virt = (origin_x, origin_y, origin_x + width, origin_y + height); let segments_windows = if is_dragging || ease_start_time.is_some() { let mut temp_wins = cached_windows.clone(); - let target_hwnd = if is_dragging { moving_hwnd } else { last_moving_hwnd }; + let target_hwnd = if is_dragging { + moving_hwnd + } else { + last_moving_hwnd + }; if target_hwnd != 0 { if let Some(win) = temp_wins.iter_mut().find(|w| w.hwnd == target_hwnd) { win.rect.left = (win.rect.left as f32 + comp_offset.0).round() as i32; @@ -445,7 +472,11 @@ fn main() { cached_windows.clone() }; - let raw_segments = platform::build_segments(&segments_windows, virt, (floor, acc_windows, acc_dock, acc_ground)); + let raw_segments = platform::build_segments( + &segments_windows, + virt, + (floor, acc_windows, acc_dock, acc_ground), + ); cached_segments = raw_segments .into_iter() .map(|seg| platform::Segment { @@ -460,16 +491,14 @@ fn main() { } win_rects.clear(); - win_rects.extend(cached_windows - .iter() - .filter_map(|win| { - let rx = win.rect.left - origin_x; - let ry = win.rect.top - origin_y; - let rw = win.rect.right - win.rect.left; - let rh = win.rect.bottom - win.rect.top; - tiny_skia::Rect::from_xywh(rx as f32, ry as f32, rw as f32, rh as f32) - .map(|rect| (win.hwnd, rect)) - })); + win_rects.extend(cached_windows.iter().filter_map(|win| { + let rx = win.rect.left - origin_x; + let ry = win.rect.top - origin_y; + let rw = win.rect.right - win.rect.left; + let rh = win.rect.bottom - win.rect.top; + tiny_skia::Rect::from_xywh(rx as f32, ry as f32, rw as f32, rh as f32) + .map(|rect| (win.hwnd, rect)) + })); let (steps, start_x, start_y) = if let Some(prev_pos) = prev_cursor_pos { let dx = cx - prev_pos.0; @@ -510,7 +539,11 @@ fn main() { if brushlog_mode && brushlog_last_print.elapsed() >= Duration::from_millis(500) { if let Some(ref d) = snow.brush_diag { if d.cursor_moved { - let avg_speed = if d.speed_count > 0 { d.speed_sum / d.speed_count as f32 } else { 0.0 }; + let avg_speed = if d.speed_count > 0 { + d.speed_sum / d.speed_count as f32 + } else { + 0.0 + }; let extra_count = snow.flakes.iter().filter(|f| f.extra).count(); let pile_h = snow.max_pile_height_under_cursor(cx, cy, &win_rects); println!( @@ -526,13 +559,21 @@ fn main() { let mut pixmap = overlay.pixmap_mut(); pixmap.data_mut().fill(0); - let update_timer = if perf_mode { Some(Instant::now()) } else { None }; + let update_timer = if perf_mode { + Some(Instant::now()) + } else { + None + }; snow.window_rects.clear(); snow.window_rects.extend_from_slice(&win_rects); snow.update(dt.min(0.1), &cached_segments); let update_duration = update_timer.map_or(0.0, |t| t.elapsed().as_secs_f32()); - let draw_timer = if perf_mode { Some(Instant::now()) } else { None }; + let draw_timer = if perf_mode { + Some(Instant::now()) + } else { + None + }; snow.draw(&mut pixmap, &win_rects); let draw_duration = draw_timer.map_or(0.0, |t| t.elapsed().as_secs_f32()); @@ -543,15 +584,19 @@ fn main() { let rw = win.rect.right - win.rect.left; let rh = win.rect.bottom - win.rect.top; - if let Some(rect) = tiny_skia::Rect::from_xywh(rx as f32, ry as f32, rw as f32, rh as f32) { + if let Some(rect) = + tiny_skia::Rect::from_xywh(rx as f32, ry as f32, rw as f32, rh as f32) + { let mut pb = tiny_skia::PathBuilder::new(); pb.push_rect(rect); if let Some(path) = pb.finish() { let mut paint = tiny_skia::Paint::default(); let color = bgra(1.0, 0.0, 0.0, 1.0); paint.set_color(color); - let mut stroke = tiny_skia::Stroke::default(); - stroke.width = 2.0; + let stroke = tiny_skia::Stroke { + width: 2.0, + ..Default::default() + }; pixmap.stroke_path( &path, &paint, @@ -570,8 +615,10 @@ fn main() { if let Some(path) = pb.finish() { let mut paint = tiny_skia::Paint::default(); paint.set_color(bgra(0.0, 1.0, 0.0, 1.0)); - let mut stroke = tiny_skia::Stroke::default(); - stroke.width = 3.0; + let stroke = tiny_skia::Stroke { + width: 3.0, + ..Default::default() + }; pixmap.stroke_path( &path, &paint, @@ -583,7 +630,11 @@ fn main() { } } - let present_timer = if perf_mode { Some(Instant::now()) } else { None }; + let present_timer = if perf_mode { + Some(Instant::now()) + } else { + None + }; overlay.present(); let present_duration = present_timer.map_or(0.0, |t| t.elapsed().as_secs_f32()); @@ -665,11 +716,31 @@ fn main() { state.quit.store(true, Ordering::Relaxed); let tray_hwnd = HWND(state.tray_hwnd.load(Ordering::Acquire) as *mut std::ffi::c_void); if !tray_hwnd.is_invalid() { - let _ = unsafe { windows::Win32::UI::WindowsAndMessaging::PostMessageW(tray_hwnd, windows::Win32::UI::WindowsAndMessaging::WM_CLOSE, WPARAM(0), LPARAM(0)) }; + let _ = unsafe { + windows::Win32::UI::WindowsAndMessaging::PostMessageW( + tray_hwnd, + windows::Win32::UI::WindowsAndMessaging::WM_CLOSE, + WPARAM(0), + LPARAM(0), + ) + }; } else { - let hwnd = unsafe { windows::Win32::UI::WindowsAndMessaging::FindWindowW(windows::core::w!("SnowfallTray"), None).unwrap_or_default() }; + let hwnd = unsafe { + windows::Win32::UI::WindowsAndMessaging::FindWindowW( + windows::core::w!("SnowfallTray"), + None, + ) + .unwrap_or_default() + }; if !hwnd.is_invalid() { - let _ = unsafe { windows::Win32::UI::WindowsAndMessaging::PostMessageW(hwnd, windows::Win32::UI::WindowsAndMessaging::WM_CLOSE, WPARAM(0), LPARAM(0)) }; + let _ = unsafe { + windows::Win32::UI::WindowsAndMessaging::PostMessageW( + hwnd, + windows::Win32::UI::WindowsAndMessaging::WM_CLOSE, + WPARAM(0), + LPARAM(0), + ) + }; } } let _ = tray_handle.join(); diff --git a/src/overlay.rs b/src/overlay.rs index 0ab089a..358564d 100644 --- a/src/overlay.rs +++ b/src/overlay.rs @@ -1,25 +1,25 @@ //! Overlay module for layered window and presentation. +use crate::tray::AppState; use std::ffi::c_void; use std::sync::Arc; -use windows::Win32::Foundation::{HWND, WPARAM, LPARAM, LRESULT, HINSTANCE, POINT, SIZE, COLORREF}; +use windows::Win32::Foundation::{COLORREF, HINSTANCE, HWND, LPARAM, LRESULT, POINT, SIZE, WPARAM}; use windows::Win32::Graphics::Gdi::{ - HDC, HBITMAP, HGDIOBJ, CreateCompatibleDC, CreateDIBSection, DeleteDC, DeleteObject, - GetDC, ReleaseDC, SelectObject, BITMAPINFO, BITMAPINFOHEADER, BI_RGB, DIB_RGB_COLORS, - BLENDFUNCTION, AC_SRC_OVER, AC_SRC_ALPHA + CreateCompatibleDC, CreateDIBSection, DeleteDC, DeleteObject, GetDC, ReleaseDC, SelectObject, + AC_SRC_ALPHA, AC_SRC_OVER, BITMAPINFO, BITMAPINFOHEADER, BI_RGB, BLENDFUNCTION, DIB_RGB_COLORS, + HBITMAP, HDC, HGDIOBJ, +}; +use windows::Win32::UI::Input::KeyboardAndMouse::{ + RegisterHotKey, UnregisterHotKey, MOD_ALT, MOD_CONTROL, }; use windows::Win32::UI::WindowsAndMessaging::{ - CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, - GetSystemMetrics, LoadCursorW, PeekMessageW, PostQuitMessage, RegisterClassW, - TranslateMessage, UnregisterClassW, ShowWindow, SW_SHOW, UpdateLayeredWindow, - ULW_ALPHA, - IDC_ARROW, MSG, PM_REMOVE, SM_CXVIRTUALSCREEN, SM_CYVIRTUALSCREEN, - SM_XVIRTUALSCREEN, SM_YVIRTUALSCREEN, WM_CLOSE, WM_DESTROY, WM_HOTKEY, - WM_QUIT, WNDCLASSW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOPMOST, - WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT, WS_POPUP + CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, GetSystemMetrics, + LoadCursorW, PeekMessageW, PostQuitMessage, RegisterClassW, ShowWindow, TranslateMessage, + UnregisterClassW, UpdateLayeredWindow, IDC_ARROW, MSG, PM_REMOVE, SM_CXVIRTUALSCREEN, + SM_CYVIRTUALSCREEN, SM_XVIRTUALSCREEN, SM_YVIRTUALSCREEN, SW_SHOW, ULW_ALPHA, WM_CLOSE, + WM_DESTROY, WM_HOTKEY, WM_QUIT, WNDCLASSW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, + WS_EX_TOPMOST, WS_EX_TRANSPARENT, WS_POPUP, }; -use windows::Win32::UI::Input::KeyboardAndMouse::{RegisterHotKey, UnregisterHotKey, MOD_CONTROL, MOD_ALT}; -use crate::tray::AppState; pub struct Overlay { hwnd: HWND, @@ -43,7 +43,9 @@ extern "system" fn wnd_proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM match msg { WM_HOTKEY => { if wparam.0 == 1 { - unsafe { QUIT_REQUESTED = true; } + unsafe { + QUIT_REQUESTED = true; + } } LRESULT(0) } @@ -84,7 +86,11 @@ impl Overlay { let width = GetSystemMetrics(SM_CXVIRTUALSCREEN); let height = GetSystemMetrics(SM_CYVIRTUALSCREEN); - let ex_style = WS_EX_LAYERED | WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE; + let ex_style = WS_EX_LAYERED + | WS_EX_TRANSPARENT + | WS_EX_TOPMOST + | WS_EX_TOOLWINDOW + | WS_EX_NOACTIVATE; let style = WS_POPUP; let hwnd = CreateWindowExW( @@ -100,9 +106,11 @@ impl Overlay { None, hinstance, None, - ).expect("Failed to create overlay window"); + ) + .expect("Failed to create overlay window"); - crate::tracker::OVERLAY_HWND.store(hwnd.0 as isize, std::sync::atomic::Ordering::Release); + crate::tracker::OVERLAY_HWND + .store(hwnd.0 as isize, std::sync::atomic::Ordering::Release); // Register global hotkey Ctrl+Alt+Q (ID 1) let _ = RegisterHotKey(hwnd, 1, MOD_CONTROL | MOD_ALT, 0x51); // 0x51 is 'Q' @@ -128,14 +136,8 @@ impl Overlay { }; let mut bits_ptr: *mut c_void = std::ptr::null_mut(); - let hbmp = CreateDIBSection( - hmem_dc, - &bmi, - DIB_RGB_COLORS, - &mut bits_ptr, - None, - 0, - ).expect("Failed to create DIB section"); + let hbmp = CreateDIBSection(hmem_dc, &bmi, DIB_RGB_COLORS, &mut bits_ptr, None, 0) + .expect("Failed to create DIB section"); let old_bmp = SelectObject(hmem_dc, HGDIOBJ(hbmp.0)); @@ -170,8 +172,14 @@ impl Overlay { unsafe { let pt_src = POINT { x: 0, y: 0 }; - let sz = SIZE { cx: self.width, cy: self.height }; - let pt_dst = POINT { x: self.origin_x, y: self.origin_y }; + let sz = SIZE { + cx: self.width, + cy: self.height, + }; + let pt_dst = POINT { + x: self.origin_x, + y: self.origin_y, + }; let blend = BLENDFUNCTION { BlendOp: AC_SRC_OVER as u8, BlendFlags: 0, @@ -229,7 +237,10 @@ impl Drop for Overlay { let _ = ReleaseDC(self.hwnd, self.hdc); } let _ = DestroyWindow(self.hwnd); - let _ = UnregisterClassW(windows::core::w!("SnowfallOverlayClass"), HINSTANCE(std::ptr::null_mut())); + let _ = UnregisterClassW( + windows::core::w!("SnowfallOverlayClass"), + HINSTANCE(std::ptr::null_mut()), + ); } } } diff --git a/src/platform.rs b/src/platform.rs index 9a45c23..ab6561f 100644 --- a/src/platform.rs +++ b/src/platform.rs @@ -159,15 +159,18 @@ fn build_segments_inner( // Skip a window only if its top <= virtual top + 2, or it is truly docked/maximized: // left <= virt left + 2 && right >= virt right - 2 && top <= work-area top + 2. - if top <= virt_top + 2.0 || (left <= virt_left + 2.0 && right >= virt_right - 2.0 && top <= work_area_top + 2.0) { + if top <= virt_top + 2.0 + || (left <= virt_left + 2.0 + && right >= virt_right - 2.0 + && top <= work_area_top + 2.0) + { continue; } // Occlusion: subtract from the top edge every x-interval of any window j with a smaller index (higher in z-order) // whose vertical range [top_j, bottom_j) contains the edge's y. let mut blockers = Vec::new(); - for j in 0..i { - let blocker_win = &windows_list[j]; + for blocker_win in windows_list.iter().take(i) { let top_j = blocker_win.rect.top as f32; let bottom_j = blocker_win.rect.bottom as f32; if top_j <= top && bottom_j > top { @@ -211,17 +214,19 @@ pub fn explain_occlusion(windows: &[WindowInfo], idx: usize) -> Vec { let top = win.rect.top as f32; let mut occluding = Vec::new(); - for j in 0..idx { - let blocker = &windows[j]; + for blocker in windows.iter().take(idx) { let top_j = blocker.rect.top as f32; let bottom_j = blocker.rect.bottom as f32; let bx1 = blocker.rect.left as f32; let bx2 = blocker.rect.right as f32; - if top_j <= top && bottom_j > top && bx1 < right && bx2 > left { - if !occluding.contains(&blocker.hwnd) { - occluding.push(blocker.hwnd); - } + if top_j <= top + && bottom_j > top + && bx1 < right + && bx2 > left + && !occluding.contains(&blocker.hwnd) + { + occluding.push(blocker.hwnd); } } occluding diff --git a/src/settings_ui.rs b/src/settings_ui.rs index 4d43583..ae00795 100644 --- a/src/settings_ui.rs +++ b/src/settings_ui.rs @@ -1,31 +1,29 @@ //! Settings UI module for snowfall configuration window. +use crate::tray::AppState; use std::sync::atomic::Ordering; use std::sync::Arc; -use windows::Win32::Foundation::{HWND, WPARAM, LPARAM, LRESULT, HINSTANCE, RECT, COLORREF}; +use windows::Win32::Foundation::{COLORREF, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM}; use windows::Win32::Graphics::Dwm::{DwmSetWindowAttribute, DWMWINDOWATTRIBUTE}; use windows::Win32::Graphics::Gdi::{ - CreateCompatibleDC, CreateCompatibleBitmap, CreateSolidBrush, CreateFontW, CreatePen, - DeleteDC, DeleteObject, SelectObject, BitBlt, FillRect, SetBkMode, SetTextColor, - DrawTextW, InvalidateRect, BeginPaint, EndPaint, DRAW_TEXT_FORMAT, - HGDIOBJ, TRANSPARENT, DT_CENTER, DT_VCENTER, DT_SINGLELINE, DT_LEFT, - FW_NORMAL, FW_BOLD, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, - RoundRect, Ellipse, Pie, MoveToEx, LineTo, PS_SOLID + BeginPaint, BitBlt, CreateCompatibleBitmap, CreateCompatibleDC, CreateFontW, CreatePen, + CreateSolidBrush, DeleteDC, DeleteObject, DrawTextW, Ellipse, EndPaint, FillRect, + InvalidateRect, LineTo, MoveToEx, Pie, RoundRect, SelectObject, SetBkMode, SetTextColor, + CLIP_DEFAULT_PRECIS, DEFAULT_CHARSET, DEFAULT_PITCH, DEFAULT_QUALITY, DRAW_TEXT_FORMAT, + DT_CENTER, DT_LEFT, DT_SINGLELINE, DT_VCENTER, FW_BOLD, FW_NORMAL, HGDIOBJ, OUT_DEFAULT_PRECIS, + PS_SOLID, TRANSPARENT, }; use windows::Win32::System::LibraryLoader::GetModuleHandleW; +use windows::Win32::UI::Input::KeyboardAndMouse::{ReleaseCapture, SetCapture}; use windows::Win32::UI::WindowsAndMessaging::{ - CreateWindowExW, DefWindowProcW, RegisterClassW, WNDCLASSW, ShowWindow, - SW_SHOW, SW_HIDE, IsWindowVisible, SetForegroundWindow, SetWindowLongPtrW, - GetWindowLongPtrW, GWLP_USERDATA, SetTimer, KillTimer, - GetClientRect, AdjustWindowRectEx, GetWindowRect, SetWindowPos, - SystemParametersInfoW, SPI_GETWORKAREA, - WS_POPUP, WS_CAPTION, WS_SYSMENU, WS_EX_TOPMOST, WS_EX_TOOLWINDOW, - HWND_TOPMOST, SWP_NOSIZE, SWP_NOACTIVATE, - WM_CLOSE, WM_DESTROY, WM_LBUTTONDOWN, WM_MOUSEMOVE, WM_LBUTTONUP, WM_PAINT, WM_TIMER, WM_CREATE, WM_ERASEBKGND, - LoadCursorW, LoadIconW, IDC_ARROW + AdjustWindowRectEx, CreateWindowExW, DefWindowProcW, GetClientRect, GetWindowLongPtrW, + GetWindowRect, IsWindowVisible, KillTimer, LoadCursorW, LoadIconW, RegisterClassW, + SetForegroundWindow, SetTimer, SetWindowLongPtrW, SetWindowPos, ShowWindow, + SystemParametersInfoW, GWLP_USERDATA, HWND_TOPMOST, IDC_ARROW, SPI_GETWORKAREA, SWP_NOACTIVATE, + SWP_NOSIZE, SW_HIDE, SW_SHOW, WM_CLOSE, WM_CREATE, WM_DESTROY, WM_ERASEBKGND, WM_LBUTTONDOWN, + WM_LBUTTONUP, WM_MOUSEMOVE, WM_PAINT, WM_TIMER, WNDCLASSW, WS_CAPTION, WS_EX_TOOLWINDOW, + WS_EX_TOPMOST, WS_POPUP, WS_SYSMENU, }; -use windows::Win32::UI::Input::KeyboardAndMouse::{SetCapture, ReleaseCapture}; -use crate::tray::AppState; // Layout constants const MARGIN_X: i32 = 20; @@ -106,6 +104,7 @@ pub fn toggle(state: &Arc) { } } +#[allow(clippy::manual_dangling_ptr)] pub fn create_hidden(state: &Arc) { let hwnd_val = state.settings_hwnd.load(Ordering::Acquire); if hwnd_val != 0 { @@ -116,6 +115,7 @@ pub fn create_hidden(state: &Arc) { let class_name = windows::core::w!("SnowfallSettings"); let hcursor = LoadCursorW(None, IDC_ARROW).unwrap_or_default(); + // 1 is a MAKEINTRESOURCE icon id, not a dangling pointer let hicon = GetModuleHandleW(None) .and_then(|h| LoadIconW(h, windows::core::PCWSTR(1 as *const u16))) .unwrap_or_default(); @@ -135,7 +135,12 @@ pub fn create_hidden(state: &Arc) { let _ = RegisterClassW(&wnd_class); - let mut rect = RECT { left: 0, top: 0, right: CLIENT_WIDTH, bottom: CLIENT_HEIGHT }; + let mut rect = RECT { + left: 0, + top: 0, + right: CLIENT_WIDTH, + bottom: CLIENT_HEIGHT, + }; let ex_style = WS_EX_TOPMOST | WS_EX_TOOLWINDOW; let style = WS_POPUP | WS_CAPTION | WS_SYSMENU; let _ = AdjustWindowRectEx(&mut rect, style, false, ex_style); @@ -147,16 +152,20 @@ pub fn create_hidden(state: &Arc) { class_name, windows::core::w!("Snowfall Settings"), style, - -32000, -32000, + -32000, + -32000, width, height, None, None, hinstance, None, - ).expect("Failed to create settings window"); + ) + .expect("Failed to create settings window"); - state.settings_hwnd.store(hwnd.0 as usize, Ordering::Release); + state + .settings_hwnd + .store(hwnd.0 as usize, Ordering::Release); let settings_data = Box::new(SettingsData { state: state.clone(), @@ -178,7 +187,12 @@ pub fn create_hidden(state: &Arc) { } } -unsafe extern "system" fn settings_wnd_proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT { +unsafe extern "system" fn settings_wnd_proc( + hwnd: HWND, + msg: u32, + wparam: WPARAM, + lparam: LPARAM, +) -> LRESULT { match msg { WM_CREATE => { let _ = SetTimer(hwnd, 1, 250, None); @@ -190,9 +204,7 @@ unsafe extern "system" fn settings_wnd_proc(hwnd: HWND, msg: u32, wparam: WPARAM } LRESULT(0) } - WM_ERASEBKGND => { - LRESULT(1) - } + WM_ERASEBKGND => LRESULT(1), WM_PAINT => { let mut ps = windows::Win32::Graphics::Gdi::PAINTSTRUCT::default(); let hdc = BeginPaint(hwnd, &mut ps); @@ -217,7 +229,17 @@ unsafe extern "system" fn settings_wnd_proc(hwnd: HWND, msg: u32, wparam: WPARAM draw_content(mem_dc, &data.state); } - let _ = BitBlt(hdc, 0, 0, cx, cy, mem_dc, 0, 0, windows::Win32::Graphics::Gdi::SRCCOPY); + let _ = BitBlt( + hdc, + 0, + 0, + cx, + cy, + mem_dc, + 0, + 0, + windows::Win32::Graphics::Gdi::SRCCOPY, + ); SelectObject(mem_dc, old_bmp); let _ = DeleteObject(HGDIOBJ(hbmp.0)); @@ -290,26 +312,41 @@ fn fps_btn_rect(fps: usize) -> RECT { _ => 1, }; let x = 160 + (idx * 50); - RECT { left: x, top: FPS_TOP, right: x + 45, bottom: FPS_TOP + 40 } + RECT { + left: x, + top: FPS_TOP, + right: x + 45, + bottom: FPS_TOP + 40, + } } fn pause_btn_rect() -> RECT { - RECT { left: 20, top: BUTTON_TOP, right: 160, bottom: BUTTON_TOP + 40 } + RECT { + left: 20, + top: BUTTON_TOP, + right: 160, + bottom: BUTTON_TOP + 40, + } } fn clear_btn_rect() -> RECT { - RECT { left: 180, top: BUTTON_TOP, right: 320, bottom: BUTTON_TOP + 40 } + RECT { + left: 180, + top: BUTTON_TOP, + right: 320, + bottom: BUTTON_TOP + 40, + } } fn hit_test_slider(x: i32, y: i32) -> Option { - if x >= MARGIN_X && x <= MARGIN_X + TRACK_WIDTH { - if y >= SLIDER1_TOP && y < SLIDER1_TOP + ROW_HEIGHT { + if (MARGIN_X..=MARGIN_X + TRACK_WIDTH).contains(&x) { + if (SLIDER1_TOP..SLIDER1_TOP + ROW_HEIGHT).contains(&y) { return Some(SliderKind::Intensity); } - if y >= SLIDER2_TOP && y < SLIDER2_TOP + ROW_HEIGHT { + if (SLIDER2_TOP..SLIDER2_TOP + ROW_HEIGHT).contains(&y) { return Some(SliderKind::Opacity); } - if y >= SLIDER3_TOP && y < SLIDER3_TOP + ROW_HEIGHT { + if (SLIDER3_TOP..SLIDER3_TOP + ROW_HEIGHT).contains(&y) { return Some(SliderKind::Strength); } } @@ -333,12 +370,19 @@ fn update_slider_from_mouse(data: &SettingsData, slider: SliderKind, x: i32) { } SliderKind::Strength => { let val = 25 + (ratio * 175.0).round() as usize; - data.state.strength.store(val.clamp(25, 200), Ordering::Relaxed); + data.state + .strength + .store(val.clamp(25, 200), Ordering::Relaxed); } } } -unsafe fn draw_text_str(hdc: windows::Win32::Graphics::Gdi::HDC, s: &str, rc: &mut RECT, format: DRAW_TEXT_FORMAT) { +unsafe fn draw_text_str( + hdc: windows::Win32::Graphics::Gdi::HDC, + s: &str, + rc: &mut RECT, + format: DRAW_TEXT_FORMAT, +) { let mut utf16: Vec = s.encode_utf16().chain(std::iter::once(0)).collect(); let _ = DrawTextW(hdc, &mut utf16, rc, format); } @@ -357,18 +401,46 @@ unsafe fn draw_slider( let track_y = row_top + 32; // 1. Label above (title left, value right) - let mut title_rc = RECT { left: MARGIN_X, top: row_top + 5, right: MARGIN_X + 150, bottom: row_top + 25 }; + let mut title_rc = RECT { + left: MARGIN_X, + top: row_top + 5, + right: MARGIN_X + 150, + bottom: row_top + 25, + }; let _ = SetTextColor(hdc, COLORREF(0x00DEDEDE)); - draw_text_str(hdc, title, &mut title_rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + title, + &mut title_rc, + DT_LEFT | DT_VCENTER | DT_SINGLELINE, + ); - let mut val_rc = RECT { left: MARGIN_X + 150, top: row_top + 5, right: MARGIN_X + TRACK_WIDTH, bottom: row_top + 25 }; + let mut val_rc = RECT { + left: MARGIN_X + 150, + top: row_top + 5, + right: MARGIN_X + TRACK_WIDTH, + bottom: row_top + 25, + }; let _ = SetTextColor(hdc, COLORREF(0x007C8084)); - draw_text_str(hdc, value_str, &mut val_rc, DRAW_TEXT_FORMAT(2) | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + value_str, + &mut val_rc, + DRAW_TEXT_FORMAT(2) | DT_VCENTER | DT_SINGLELINE, + ); // 2. Track (6 px high rounded track, RGB 70,72,78 -> BGR 0x004E4846) let track_brush = CreateSolidBrush(COLORREF(0x004E4846)); let old_brush = SelectObject(hdc, HGDIOBJ(track_brush.0)); - let _ = RoundRect(hdc, track_left, track_y, track_right, track_y + TRACK_HEIGHT, TRACK_HEIGHT, TRACK_HEIGHT); + let _ = RoundRect( + hdc, + track_left, + track_y, + track_right, + track_y + TRACK_HEIGHT, + TRACK_HEIGHT, + TRACK_HEIGHT, + ); SelectObject(hdc, old_brush); let _ = DeleteObject(HGDIOBJ(track_brush.0)); @@ -380,7 +452,15 @@ unsafe fn draw_slider( if fill_right > track_left { let fill_brush = CreateSolidBrush(COLORREF(0x00FFAA78)); let old_brush2 = SelectObject(hdc, HGDIOBJ(fill_brush.0)); - let _ = RoundRect(hdc, track_left, track_y, fill_right, track_y + TRACK_HEIGHT, TRACK_HEIGHT, TRACK_HEIGHT); + let _ = RoundRect( + hdc, + track_left, + track_y, + fill_right, + track_y + TRACK_HEIGHT, + TRACK_HEIGHT, + TRACK_HEIGHT, + ); SelectObject(hdc, old_brush2); let _ = DeleteObject(HGDIOBJ(fill_brush.0)); } @@ -415,7 +495,11 @@ unsafe fn draw_tile( // Background brush: RGB(45,46,50) -> BGR 0x00322E2D let bg_brush = CreateSolidBrush(COLORREF(0x00322E2D)); - let border_color = if is_on { COLORREF(0x00FFAA78) } else { COLORREF(0x008A8482) }; + let border_color = if is_on { + COLORREF(0x00FFAA78) + } else { + COLORREF(0x008A8482) + }; let pen = CreatePen(PS_SOLID, 1, border_color); let old_brush = SelectObject(hdc, HGDIOBJ(bg_brush.0)); @@ -429,7 +513,11 @@ unsafe fn draw_tile( let _ = DeleteObject(HGDIOBJ(bg_brush.0)); // Icon and label color - let fg_color = if is_on { COLORREF(0x00FFFFFF) } else { COLORREF(0x008A8482) }; + let fg_color = if is_on { + COLORREF(0x00FFFFFF) + } else { + COLORREF(0x008A8482) + }; let pen_fg = CreatePen(PS_SOLID, 1, fg_color); let brush_fg = CreateSolidBrush(fg_color); let old_pen2 = SelectObject(hdc, HGDIOBJ(pen_fg.0)); @@ -444,19 +532,31 @@ unsafe fn draw_tile( "windows" => { let _ = RoundRect(hdc, icon_l, icon_t, icon_r, icon_b, 4, 4); let bar_brush = CreateSolidBrush(fg_color); - let bar_rect = RECT { left: icon_l, top: icon_t, right: icon_r, bottom: icon_t + 5 }; + let bar_rect = RECT { + left: icon_l, + top: icon_t, + right: icon_r, + bottom: icon_t + 5, + }; let _ = FillRect(hdc, &bar_rect, bar_brush); let _ = DeleteObject(HGDIOBJ(bar_brush.0)); } "dock" => { let _ = RoundRect(hdc, icon_l, icon_t, icon_r, icon_b, 4, 4); let bar_brush = CreateSolidBrush(fg_color); - let bar_rect = RECT { left: icon_l, top: icon_b - 7, right: icon_r, bottom: icon_b }; + let bar_rect = RECT { + left: icon_l, + top: icon_b - 7, + right: icon_r, + bottom: icon_b, + }; let _ = FillRect(hdc, &bar_rect, bar_brush); let _ = DeleteObject(HGDIOBJ(bar_brush.0)); } "ground" => { - let _ = Pie(hdc, icon_l, icon_t, icon_r, icon_b, icon_r, icon_b, icon_l, icon_b); + let _ = Pie( + hdc, icon_l, icon_t, icon_r, icon_b, icon_r, icon_b, icon_l, icon_b, + ); let _ = MoveToEx(hdc, icon_l, icon_b, None); let _ = LineTo(hdc, icon_r, icon_b); } @@ -469,10 +569,20 @@ unsafe fn draw_tile( let _ = DeleteObject(HGDIOBJ(pen_fg.0)); // Label at bottom - let mut label_rc = RECT { left: left + 5, top: top + 36, right: right - 5, bottom: bottom - 4 }; + let mut label_rc = RECT { + left: left + 5, + top: top + 36, + right: right - 5, + bottom: bottom - 4, + }; let _ = SetTextColor(hdc, fg_color); SelectObject(hdc, hfont_normal); - draw_text_str(hdc, title, &mut label_rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + title, + &mut label_rc, + DT_CENTER | DT_VCENTER | DT_SINGLELINE, + ); } unsafe fn draw_switch( @@ -486,10 +596,20 @@ unsafe fn draw_switch( let row_right = MARGIN_X + TRACK_WIDTH; // Label on the left - let mut title_rc = RECT { left: row_left, top: row_top, right: row_left + 220, bottom: row_top + SWITCH_ROW_HEIGHT }; + let mut title_rc = RECT { + left: row_left, + top: row_top, + right: row_left + 220, + bottom: row_top + SWITCH_ROW_HEIGHT, + }; let _ = SetTextColor(hdc, COLORREF(0x00DEDEDE)); SelectObject(hdc, hfont_normal); - draw_text_str(hdc, title, &mut title_rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + title, + &mut title_rc, + DT_LEFT | DT_VCENTER | DT_SINGLELINE, + ); // Pill switch on the right let switch_l = row_right - SWITCH_WIDTH; @@ -497,13 +617,25 @@ unsafe fn draw_switch( let switch_r = row_right; let switch_b = switch_t + SWITCH_HEIGHT; - let track_color = if is_on { COLORREF(0x00FFAA78) } else { COLORREF(0x004E4846) }; + let track_color = if is_on { + COLORREF(0x00FFAA78) + } else { + COLORREF(0x004E4846) + }; let track_brush = CreateSolidBrush(track_color); let pen_null = CreatePen(PS_SOLID, 1, track_color); let old_brush = SelectObject(hdc, HGDIOBJ(track_brush.0)); let old_pen = SelectObject(hdc, HGDIOBJ(pen_null.0)); - let _ = RoundRect(hdc, switch_l, switch_t, switch_r, switch_b, SWITCH_HEIGHT, SWITCH_HEIGHT); + let _ = RoundRect( + hdc, + switch_l, + switch_t, + switch_r, + switch_b, + SWITCH_HEIGHT, + SWITCH_HEIGHT, + ); SelectObject(hdc, old_pen); SelectObject(hdc, old_brush); @@ -530,9 +662,14 @@ unsafe fn draw_switch( unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState) { let hfont_normal = CreateFontW( - 15, 0, 0, 0, + 15, + 0, + 0, + 0, FW_NORMAL.0 as i32, - 0, 0, 0, + 0, + 0, + 0, DEFAULT_CHARSET.0 as u32, OUT_DEFAULT_PRECIS.0 as u32, CLIP_DEFAULT_PRECIS.0 as u32, @@ -541,9 +678,14 @@ unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState windows::core::w!("Segoe UI"), ); let hfont_bold = CreateFontW( - 15, 0, 0, 0, + 15, + 0, + 0, + 0, FW_BOLD.0 as i32, - 0, 0, 0, + 0, + 0, + 0, DEFAULT_CHARSET.0 as u32, OUT_DEFAULT_PRECIS.0 as u32, CLIP_DEFAULT_PRECIS.0 as u32, @@ -584,13 +726,31 @@ unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState // Draw Strength slider let strength = state.strength.load(Ordering::Relaxed) as f32; let strength_str = format!("{}%", strength as usize); - draw_slider(hdc, "Strength", &strength_str, SLIDER3_TOP, 25.0, 200.0, strength); + draw_slider( + hdc, + "Strength", + &strength_str, + SLIDER3_TOP, + 25.0, + 200.0, + strength, + ); // Accumulate header - let mut acc_header_rc = RECT { left: MARGIN_X, top: ACC_HEADER_TOP, right: MARGIN_X + TRACK_WIDTH, bottom: ACC_HEADER_TOP + 20 }; + let mut acc_header_rc = RECT { + left: MARGIN_X, + top: ACC_HEADER_TOP, + right: MARGIN_X + TRACK_WIDTH, + bottom: ACC_HEADER_TOP + 20, + }; let _ = SetTextColor(hdc, COLORREF(0x00DEDEDE)); SelectObject(hdc, HGDIOBJ(hfont_bold.0)); - draw_text_str(hdc, "Accumulate", &mut acc_header_rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + "Accumulate", + &mut acc_header_rc, + DT_LEFT | DT_VCENTER | DT_SINGLELINE, + ); // Accumulate tiles let acc_w = state.acc_windows.load(Ordering::Relaxed); @@ -601,29 +761,79 @@ unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState let t1_l = t0_l + TILE_WIDTH + TILE_GAP; let t2_l = t1_l + TILE_WIDTH + TILE_GAP; - draw_tile(hdc, "Windows", acc_w, t0_l, TILES_TOP, HGDIOBJ(hfont_normal.0), "windows"); - draw_tile(hdc, "Dock", acc_d, t1_l, TILES_TOP, HGDIOBJ(hfont_normal.0), "dock"); - draw_tile(hdc, "Ground", acc_g, t2_l, TILES_TOP, HGDIOBJ(hfont_normal.0), "ground"); + draw_tile( + hdc, + "Windows", + acc_w, + t0_l, + TILES_TOP, + HGDIOBJ(hfont_normal.0), + "windows", + ); + draw_tile( + hdc, + "Dock", + acc_d, + t1_l, + TILES_TOP, + HGDIOBJ(hfont_normal.0), + "dock", + ); + draw_tile( + hdc, + "Ground", + acc_g, + t2_l, + TILES_TOP, + HGDIOBJ(hfont_normal.0), + "ground", + ); // Height limit switch let height_lmt = state.height_limit.load(Ordering::Relaxed); - draw_switch(hdc, "Height limit", height_lmt, SWITCH1_TOP, HGDIOBJ(hfont_normal.0)); + draw_switch( + hdc, + "Height limit", + height_lmt, + SWITCH1_TOP, + HGDIOBJ(hfont_normal.0), + ); // Mouse pushes snow switch let mouse_flk = state.mouse_flakes.load(Ordering::Relaxed); - draw_switch(hdc, "Mouse pushes snow", mouse_flk, SWITCH2_TOP, HGDIOBJ(hfont_normal.0)); + draw_switch( + hdc, + "Mouse pushes snow", + mouse_flk, + SWITCH2_TOP, + HGDIOBJ(hfont_normal.0), + ); // Frame rate row label let _ = SetTextColor(hdc, COLORREF(0x00DEDEDE)); - let mut rc_fps = RECT { left: 20, top: FPS_TOP, right: 150, bottom: FPS_TOP + 40 }; + let mut rc_fps = RECT { + left: 20, + top: FPS_TOP, + right: 150, + bottom: FPS_TOP + 40, + }; SelectObject(hdc, HGDIOBJ(hfont_normal.0)); - draw_text_str(hdc, "Frame rate", &mut rc_fps, DT_LEFT | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + "Frame rate", + &mut rc_fps, + DT_LEFT | DT_VCENTER | DT_SINGLELINE, + ); let current_fps = state.target_fps.load(Ordering::Relaxed); for &fps in &[20, 30, 60] { let r = fps_btn_rect(fps); let active = current_fps == fps; - let bg_color = if active { COLORREF(0x00F48442) } else { COLORREF(0x003A3D41) }; + let bg_color = if active { + COLORREF(0x00F48442) + } else { + COLORREF(0x003A3D41) + }; let brush = CreateSolidBrush(bg_color); let mut r_sys = r; FillRect(hdc, &r_sys, brush); @@ -636,7 +846,12 @@ unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState 60 => "60", _ => "?", }; - draw_text_str(hdc, text_str, &mut r_sys, DT_CENTER | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + text_str, + &mut r_sys, + DT_CENTER | DT_VCENTER | DT_SINGLELINE, + ); } // Pause / Resume button @@ -648,7 +863,12 @@ unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState let _ = DeleteObject(HGDIOBJ(p_brush.0)); let _ = SetTextColor(hdc, COLORREF(0x00FFFFFF)); let pause_str = if is_paused { "Resume" } else { "Pause" }; - draw_text_str(hdc, pause_str, &mut p_sys, DT_CENTER | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + pause_str, + &mut p_sys, + DT_CENTER | DT_VCENTER | DT_SINGLELINE, + ); // Clear snow button let clear_r = clear_btn_rect(); @@ -657,7 +877,12 @@ unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState FillRect(hdc, &c_sys, c_brush); let _ = DeleteObject(HGDIOBJ(c_brush.0)); let _ = SetTextColor(hdc, COLORREF(0x00FFFFFF)); - draw_text_str(hdc, "Clear snow", &mut c_sys, DT_CENTER | DT_VCENTER | DT_SINGLELINE); + draw_text_str( + hdc, + "Clear snow", + &mut c_sys, + DT_CENTER | DT_VCENTER | DT_SINGLELINE, + ); SelectObject(hdc, old_font); let _ = DeleteObject(HGDIOBJ(hfont_normal.0)); @@ -673,7 +898,7 @@ fn handle_click(state: &AppState, x: i32, y: i32) -> bool { let t2_l = t1_r + TILE_GAP; let t2_r = t2_l + TILE_WIDTH; - if y >= TILES_TOP && y <= TILES_TOP + TILE_HEIGHT { + if (TILES_TOP..=TILES_TOP + TILE_HEIGHT).contains(&y) { if x >= t0_l && x <= t0_r { let cur = state.acc_windows.load(Ordering::Relaxed); state.acc_windows.store(!cur, Ordering::Relaxed); @@ -692,13 +917,13 @@ fn handle_click(state: &AppState, x: i32, y: i32) -> bool { } // Check switches - if x >= MARGIN_X && x <= MARGIN_X + TRACK_WIDTH { - if y >= SWITCH1_TOP && y <= SWITCH1_TOP + SWITCH_ROW_HEIGHT { + if (MARGIN_X..=MARGIN_X + TRACK_WIDTH).contains(&x) { + if (SWITCH1_TOP..=SWITCH1_TOP + SWITCH_ROW_HEIGHT).contains(&y) { let cur = state.height_limit.load(Ordering::Relaxed); state.height_limit.store(!cur, Ordering::Relaxed); return true; } - if y >= SWITCH2_TOP && y <= SWITCH2_TOP + SWITCH_ROW_HEIGHT { + if (SWITCH2_TOP..=SWITCH2_TOP + SWITCH_ROW_HEIGHT).contains(&y) { let cur = state.mouse_flakes.load(Ordering::Relaxed); state.mouse_flakes.store(!cur, Ordering::Relaxed); return true; diff --git a/src/snow.rs b/src/snow.rs index 9ef1740..2040985 100644 --- a/src/snow.rs +++ b/src/snow.rs @@ -1,9 +1,9 @@ //! Snow module for flakes, piles, physics, and drawing. +use crate::platform::Segment; use rand::Rng; use std::collections::{HashMap, HashSet}; use tiny_skia::{Color, FillRule, Paint, PathBuilder, Pixmap, PixmapMut, Stroke, Transform}; -use crate::platform::Segment; pub const GROUND_ID: isize = -1; @@ -77,8 +77,6 @@ fn relax_range(heights: &mut [f32], lo: usize, hi: usize, max_slope: f32) -> boo changed } - - pub fn bgra(r: f32, g: f32, b: f32, a: f32) -> Color { Color::from_rgba(b, g, r, a).unwrap() } @@ -115,7 +113,11 @@ pub struct Pile { } impl Pile { - pub fn update_cache(&mut self, owner: Option, owner_data: &HashMap, OwnerData>) { + pub fn update_cache( + &mut self, + owner: Option, + owner_data: &HashMap, OwnerData>, + ) { let intervals = if is_floor_like(owner) { vec![(self.x_start, self.x_start + self.heights.len() as f32 * 2.0)] } else { @@ -150,7 +152,8 @@ impl Pile { while i < self.heights.len() { let col_x = self.x_start + i as f32 * 2.0 + 1.0; let h = self.heights[i]; - let is_visible = h > 0.05 && intervals.iter().any(|&(v1, v2)| col_x >= v1 && col_x <= v2); + let is_visible = + h > 0.05 && intervals.iter().any(|&(v1, v2)| col_x >= v1 && col_x <= v2); if !is_visible { i += 1; @@ -165,7 +168,10 @@ impl Pile { let next_i = end_idx + 1; let next_col_x = self.x_start + next_i as f32 * 2.0 + 1.0; let next_h = self.heights[next_i]; - let next_visible = next_h > 0.05 && intervals.iter().any(|&(v1, v2)| next_col_x >= v1 && next_col_x <= v2); + let next_visible = next_h > 0.05 + && intervals + .iter() + .any(|&(v1, v2)| next_col_x >= v1 && next_col_x <= v2); if next_visible { end_idx = next_i; if next_h > max_h { @@ -227,12 +233,15 @@ impl Pile { tiny_skia::Point::from_xy(run_start_x_all, self.y), vec![ tiny_skia::GradientStop::new(0.0, bgra(1.0, 1.0, 1.0, 1.0)), - tiny_skia::GradientStop::new(1.0, bgra(230.0/255.0, 238.0/255.0, 250.0/255.0, 1.0)), + tiny_skia::GradientStop::new( + 1.0, + bgra(230.0 / 255.0, 238.0 / 255.0, 250.0 / 255.0, 1.0), + ), ], tiny_skia::SpreadMode::Pad, Transform::identity(), ) { - self.cached_shader = Some(shader.into()); + self.cached_shader = Some(shader); } } else { self.cached_shader = None; @@ -304,7 +313,11 @@ impl Snow { fn landing_cap(height_limit: bool, owner: Option, pile_y: f32) -> f32 { if height_limit { - if is_floor_like(owner) { 36.0 } else { 16.0 } + if is_floor_like(owner) { + 36.0 + } else { + 16.0 + } } else { (pile_y - 8.0).max(36.0) } @@ -312,7 +325,11 @@ impl Snow { fn hard_cap(height_limit: bool, owner: Option, pile_y: f32) -> f32 { if height_limit { - if is_floor_like(owner) { 60.0 } else { 32.0 } + if is_floor_like(owner) { + 60.0 + } else { + 32.0 + } } else { (pile_y - 8.0).max(36.0) } @@ -413,10 +430,19 @@ impl Snow { } } - pub fn max_pile_height_under_cursor(&self, cx: f32, cy: f32, win_rects: &[(isize, tiny_skia::Rect)]) -> f32 { + pub fn max_pile_height_under_cursor( + &self, + cx: f32, + cy: f32, + win_rects: &[(isize, tiny_skia::Rect)], + ) -> f32 { let mut found_hwnd = None; for &(hwnd, ref rect) in win_rects.iter().rev() { - if cx >= rect.x() && cx <= rect.x() + rect.width() && cy >= rect.y() && cy <= rect.y() + rect.height() { + if cx >= rect.x() + && cx <= rect.x() + rect.width() + && cy >= rect.y() + && cy <= rect.y() + rect.height() + { found_hwnd = Some(hwnd); break; } @@ -440,7 +466,11 @@ impl Snow { } pub fn start_clear(&mut self) { - let dir: f32 = if rand::thread_rng().gen_bool(0.5) { 1.0 } else { -1.0 }; + let dir: f32 = if rand::thread_rng().gen_bool(0.5) { + 1.0 + } else { + -1.0 + }; self.clear_dir = dir; self.clearing = true; self.clear_front = if dir > 0.0 { 0.0 } else { self.width }; @@ -468,7 +498,7 @@ impl Snow { }; let spacing = 12; - let num_controls = (len + spacing - 1) / spacing + 1; + let num_controls = len.div_ceil(spacing) + 1; let mut controls = Vec::with_capacity(num_controls); for _ in 0..num_controls { controls.push(rng.gen_range(min_h..max_h)); @@ -488,6 +518,7 @@ impl Snow { } } + #[allow(clippy::chunks_exact_to_as_chunks)] fn create_sprites() -> Vec { let mut sprites = Vec::with_capacity(128); for i in 0..8 { @@ -515,7 +546,13 @@ impl Snow { if let Some(shader) = radial_shader { paint.shader = shader; } - base_sprite.fill_path(&path, &paint, FillRule::Winding, Transform::identity(), None); + base_sprite.fill_path( + &path, + &paint, + FillRule::Winding, + Transform::identity(), + None, + ); } let base_data = base_sprite.data(); @@ -700,11 +737,12 @@ impl Snow { } } + #[allow(clippy::too_many_arguments)] fn distribute_berm( berm_amt: f32, start_c: isize, step: isize, - pile_heights: &mut Vec, + pile_heights: &mut [f32], min_c_ref: &mut usize, max_c_ref: &mut usize, full_l: f32, @@ -725,9 +763,9 @@ impl Snow { let mut rng = rand::thread_rng(); let mut sum_weights = 0.0f32; let mut weights = vec![0.0f32; w_cols]; - for k in 0..w_cols { + for (k, weight) in weights.iter_mut().enumerate().take(w_cols) { let w = 0.5 * (1.0 + (std::f32::consts::PI * k as f32 / w_cols as f32).cos()); - weights[k] = w; + *weight = w; sum_weights += w; } if sum_weights > 0.0 { @@ -737,8 +775,8 @@ impl Snow { } let len = pile_heights.len() as isize; - for k in 0..w_cols { - let amt = berm_amt * weights[k]; + for (k, &w) in weights.iter().enumerate().take(w_cols) { + let amt = berm_amt * w; let target_col = start_c + (k as isize) * step; if target_col >= 0 && target_col < len { let idx = target_col as usize; @@ -751,7 +789,8 @@ impl Snow { let col_x = pile_x_start + idx as f32 * 2.0 + 1.0; let surface_y = base_y - max_allowed; let bvx = if dir != 0 { - ((dir as f32) * (30.0 + 0.1 * speed)).clamp(-350.0, 350.0) + rng.gen_range(-40.0..40.0) + ((dir as f32) * (30.0 + 0.1 * speed)).clamp(-350.0, 350.0) + + rng.gen_range(-40.0..40.0) } else { let s_sign = (col_x - cx).signum(); let s_sign = if s_sign == 0.0 { 1.0 } else { s_sign }; @@ -841,7 +880,8 @@ impl Snow { let patch_w = rng.gen_range(6..=12); let half_width = patch_w as f32 / 2.0; let start_c = (center_col as isize - half_width as isize).max(0) as usize; - let end_c = (center_col as isize + half_width as isize).min(pile.heights.len() as isize - 1) as usize; + let end_c = (center_col as isize + half_width as isize) + .min(pile.heights.len() as isize - 1) as usize; for c in start_c..=end_c { let h = pile.heights[c]; @@ -862,16 +902,22 @@ impl Snow { let surface_y = pile.y - (h - reduction); let bvx = -wvx * 0.35 + rng.gen_range(-80.0..80.0); let bvy = -wvy * 0.35 - rng.gen_range(20.0..120.0); - self.scratch_spawn_actions.push((col_x, surface_y, bvx, bvy, owner)); + self.scratch_spawn_actions + .push((col_x, surface_y, bvx, bvy, owner)); } } } } - if min_c <= max_c { - if relax_range(&mut pile.heights, min_c.saturating_sub(4), max_c + 4, MAX_SLOPE) { - pile.dirty = true; - } + if min_c <= max_c + && relax_range( + &mut pile.heights, + min_c.saturating_sub(4), + max_c + 4, + MAX_SLOPE, + ) + { + pile.dirty = true; } } @@ -904,7 +950,14 @@ impl Snow { } } - pub fn brush(&mut self, cx: f32, cy: f32, cvx: f32, cvy: f32, win_rects: &[(isize, tiny_skia::Rect)]) { + pub fn brush( + &mut self, + cx: f32, + cy: f32, + cvx: f32, + cvy: f32, + win_rects: &[(isize, tiny_skia::Rect)], + ) { let speed = (cvx * cvx + cvy * cvy).sqrt(); if let Some(ref mut d) = self.brush_diag { d.speed_sum += speed; @@ -925,7 +978,11 @@ impl Snow { let mut hidden = false; if is_floor_like(owner) { for (_, rect) in win_rects { - if cx >= rect.x() && cx <= rect.x() + rect.width() && cy >= rect.y() && cy <= rect.y() + rect.height() { + if cx >= rect.x() + && cx <= rect.x() + rect.width() + && cy >= rect.y() + && cy <= rect.y() + rect.height() + { hidden = true; break; } @@ -933,9 +990,12 @@ impl Snow { } else { if let Some(hwnd) = owner { if let Some(pos) = win_rects.iter().position(|(h, _)| *h == hwnd) { - for i in 0..pos { - let rect = win_rects[i].1; - if cx >= rect.x() && cx <= rect.x() + rect.width() && cy >= rect.y() && cy <= rect.y() + rect.height() { + for (_, rect) in win_rects.iter().take(pos) { + if cx >= rect.x() + && cx <= rect.x() + rect.width() + && cy >= rect.y() + && cy <= rect.y() + rect.height() + { hidden = true; break; } @@ -990,7 +1050,12 @@ impl Snow { if let Some(ref mut d) = self.brush_diag { d.snow_removed += floor_removed; } - let _ = relax_range(&mut pile.heights, min_c.saturating_sub(4), max_c + 4, MAX_SLOPE); + let _ = relax_range( + &mut pile.heights, + min_c.saturating_sub(4), + max_c + 4, + MAX_SLOPE, + ); pile.dirty = true; } } else { @@ -1021,7 +1086,11 @@ impl Snow { let col_x = pile.x_start + i as f32 * 2.0 + 1.0; let dx = col_x - cx; if dx.abs() < radius { - let s = if radius * radius > dx * dx { (radius * radius - dx * dx).sqrt() } else { 0.0 }; + let s = if radius * radius > dx * dx { + (radius * radius - dx * dx).sqrt() + } else { + 0.0 + }; let surface = base - h; if cy - s <= base && cy + s >= surface { let arc_h = (base - (cy + s)).max(0.0); @@ -1043,11 +1112,16 @@ impl Snow { if total_removed > 0.0 { let speed_val = (cvx * cvx + cvy * cvy).sqrt(); - let dir = if cvx.abs() > 40.0 { cvx.signum() as i32 } else { 0 }; + let dir = if cvx.abs() > 40.0 { + cvx.signum() as i32 + } else { + 0 + }; let fling_frac = ((speed_val - 600.0) / 1400.0).clamp(0.0, 0.8); let thrown_part = total_removed * fling_frac; - let flake_count = ((thrown_part / 1.5).round() as usize).min(40 - total_spawned); + let flake_count = + ((thrown_part / 1.5).round() as usize).min(40 - total_spawned); let skip_hwnd = owner.unwrap_or(0); for _ in 0..flake_count { if touched_points.is_empty() || total_spawned >= 40 { @@ -1056,14 +1130,24 @@ impl Snow { let p_idx = rng.gen_range(0..touched_points.len()); let (col_x, surface_y, dx) = touched_points[p_idx]; let bvx = if dir != 0 { - ((dir as f32) * (30.0 + 0.1 * speed_val)).clamp(-350.0, 350.0) + rng.gen_range(-40.0..40.0) + ((dir as f32) * (30.0 + 0.1 * speed_val)).clamp(-350.0, 350.0) + + rng.gen_range(-40.0..40.0) } else { let s_sign = (col_x - cx).signum(); - let s_sign = if s_sign == 0.0 { if dx >= 0.0 { 1.0 } else { -1.0 } } else { s_sign }; + let s_sign = if s_sign == 0.0 { + if dx >= 0.0 { + 1.0 + } else { + -1.0 + } + } else { + s_sign + }; s_sign * rng.gen_range(30.0..90.0) }; let bvy = rng.gen_range(-20.0..40.0); - self.scratch_spawn_actions.push((col_x, surface_y, bvx, bvy, skip_hwnd)); + self.scratch_spawn_actions + .push((col_x, surface_y, bvx, bvy, skip_hwnd)); total_spawned += 1; } @@ -1075,7 +1159,8 @@ impl Snow { let remaining_part = total_removed * (1.0 - fling_frac); let o_data = self.owner_data.get(&owner); let full_left = o_data.map_or(pile.x_start, |d| d.full_left); - let full_right = o_data.map_or(pile.x_start + len as f32 * 2.0, |d| d.full_right); + let full_right = + o_data.map_or(pile.x_start + len as f32 * 2.0, |d| d.full_right); let touched_columns = touched_points.len(); let w_cols = (1.5 * touched_columns as f32).max(24.0).round() as usize; @@ -1084,19 +1169,87 @@ impl Snow { if dir != 0 { let edge_x = cx + (dir as f32) * radius; let start_c = ((edge_x - pile.x_start - 1.0) / 2.0).round() as isize; - Self::distribute_berm(remaining_part, start_c, dir as isize, &mut pile.heights, &mut min_c, &mut max_c, full_left, full_right, base, &mut self.scratch_curtain_actions, &mut self.scratch_spawn_actions, &mut total_spawned, plow_cap, &mut diag_ref, w_cols, skip_hwnd, cx, speed_val, dir, pile.x_start); + Self::distribute_berm( + remaining_part, + start_c, + dir as isize, + &mut pile.heights, + &mut min_c, + &mut max_c, + full_left, + full_right, + base, + &mut self.scratch_curtain_actions, + &mut self.scratch_spawn_actions, + &mut total_spawned, + plow_cap, + &mut diag_ref, + w_cols, + skip_hwnd, + cx, + speed_val, + dir, + pile.x_start, + ); } else { let half_rem = remaining_part * 0.5; let cx_col_b = ((cx - pile.x_start - 1.0) / 2.0).round() as isize; - Self::distribute_berm(half_rem, cx_col_b, 1, &mut pile.heights, &mut min_c, &mut max_c, full_left, full_right, base, &mut self.scratch_curtain_actions, &mut self.scratch_spawn_actions, &mut total_spawned, plow_cap, &mut diag_ref, w_cols, skip_hwnd, cx, speed_val, dir, pile.x_start); - Self::distribute_berm(half_rem, cx_col_b, -1, &mut pile.heights, &mut min_c, &mut max_c, full_left, full_right, base, &mut self.scratch_curtain_actions, &mut self.scratch_spawn_actions, &mut total_spawned, plow_cap, &mut diag_ref, w_cols, skip_hwnd, cx, speed_val, dir, pile.x_start); + Self::distribute_berm( + half_rem, + cx_col_b, + 1, + &mut pile.heights, + &mut min_c, + &mut max_c, + full_left, + full_right, + base, + &mut self.scratch_curtain_actions, + &mut self.scratch_spawn_actions, + &mut total_spawned, + plow_cap, + &mut diag_ref, + w_cols, + skip_hwnd, + cx, + speed_val, + dir, + pile.x_start, + ); + Self::distribute_berm( + half_rem, + cx_col_b, + -1, + &mut pile.heights, + &mut min_c, + &mut max_c, + full_left, + full_right, + base, + &mut self.scratch_curtain_actions, + &mut self.scratch_spawn_actions, + &mut total_spawned, + plow_cap, + &mut diag_ref, + w_cols, + skip_hwnd, + cx, + speed_val, + dir, + pile.x_start, + ); } self.brush_diag = diag_ref; - if min_c <= max_c { - if relax_range(&mut pile.heights, min_c.saturating_sub(4), max_c + 4, 2.6) { - pile.dirty = true; - } + if min_c <= max_c + && relax_range( + &mut pile.heights, + min_c.saturating_sub(4), + max_c + 4, + 2.6, + ) + { + pile.dirty = true; } } } @@ -1120,36 +1273,41 @@ impl Snow { let height_limit = self.height_limit; let strength = self.strength; - let global_wind = (self.wind_time * 0.6).sin() * 20.0 + (self.wind_time * 0.25).sin() * 35.0; + let global_wind = + (self.wind_time * 0.6).sin() * 20.0 + (self.wind_time * 0.25).sin() * 35.0; if self.clearing || self.clear_hold { self.clear_gust = 1.0; } else if self.clear_gust > 0.0 { self.clear_gust = (self.clear_gust - dt / 0.8).max(0.0); } - for (_, data) in self.owner_data.iter_mut() { + for data in self.owner_data.values_mut() { data.visible_intervals.clear(); } self.scratch_current_owners.clear(); for seg in segments { self.scratch_current_owners.insert(seg.owner); - let data = self.owner_data.entry(seg.owner).or_insert_with(|| OwnerData { - y: seg.y, - full_left: seg.full_left, - full_right: seg.full_right, - visible_intervals: Vec::new(), - }); + let data = self + .owner_data + .entry(seg.owner) + .or_insert_with(|| OwnerData { + y: seg.y, + full_left: seg.full_left, + full_right: seg.full_right, + visible_intervals: Vec::new(), + }); data.y = seg.y; data.full_left = seg.full_left; data.full_right = seg.full_right; data.visible_intervals.push((seg.x1, seg.x2)); } - self.owner_data.retain(|owner, _| self.scratch_current_owners.contains(owner)); + self.owner_data + .retain(|owner, _| self.scratch_current_owners.contains(owner)); // 1. Remove piles whose owner is no longer present let mut owners_to_remove = Vec::new(); - for (owner, _) in &self.piles { + for owner in self.piles.keys() { if !self.scratch_current_owners.contains(owner) { owners_to_remove.push(*owner); } @@ -1284,7 +1442,7 @@ impl Snow { let front = self.clear_front; let extra_count = self.flakes.iter().filter(|f| f.extra).count(); let mut new_flakes = Vec::new(); - for (_, pile) in self.piles.iter_mut() { + for pile in self.piles.values_mut() { let mut changed = false; for i in 0..pile.heights.len() { let h = pile.heights[i]; @@ -1292,7 +1450,11 @@ impl Snow { continue; } let col_x = pile.x_start + i as f32 * 2.0 + 1.0; - let passed = if dir > 0.0 { col_x <= front } else { col_x >= front }; + let passed = if dir > 0.0 { + col_x <= front + } else { + col_x >= front + }; if !passed { continue; } @@ -1329,7 +1491,9 @@ impl Snow { } } self.flakes.extend(new_flakes); - if (dir > 0.0 && self.clear_front > self.width + 200.0) || (dir < 0.0 && self.clear_front < -200.0) { + if (dir > 0.0 && self.clear_front > self.width + 200.0) + || (dir < 0.0 && self.clear_front < -200.0) + { self.clearing = false; self.clear_front = 0.0; } @@ -1352,7 +1516,11 @@ impl Snow { let dir_now = self.clear_dir; self.scratch_remove_indices.clear(); - let alive_count = self.flakes.iter().filter(|f| !f.extra && f.fade_target > 0.0).count(); + let alive_count = self + .flakes + .iter() + .filter(|f| !f.extra && f.fade_target > 0.0) + .count(); for (i, flake) in self.flakes.iter_mut().enumerate() { if flake.fade < flake.fade_target { flake.fade = (flake.fade + 1.5 * dt).min(flake.fade_target); @@ -1369,7 +1537,11 @@ impl Snow { let sway = flake.sway_phase.sin() * (5.0 + flake.depth * 10.0); let effective_wind = global_wind * (0.5 + 0.5 * flake.depth); // A flake is swept by the clearing gust once the wave front has passed it - let passed_front = if dir_now > 0.0 { flake.x <= front_now } else { flake.x >= front_now }; + let passed_front = if dir_now > 0.0 { + flake.x <= front_now + } else { + flake.x >= front_now + }; let swept = hold && (!clearing_now || passed_front); if swept { flake.bvx += CLEAR_GUST_WIND * 2.5 * dt * dir_now; @@ -1380,14 +1552,18 @@ impl Snow { let dir = if flake.depth < 0.7 { 1.0 } else { -1.0 }; let ang = flake.sway_phase * CLEAR_SWIRL_RATE * dir; swirl_x = ang.cos() * CLEAR_SWIRL_SPEED * clear_gust; - swirl_y = (ang.sin() * CLEAR_SWIRL_SPEED + (flake.x * 0.008 - wind_time * 6.0 * dir_now).sin() * 300.0) * clear_gust; + swirl_y = (ang.sin() * CLEAR_SWIRL_SPEED + + (flake.x * 0.008 - wind_time * 6.0 * dir_now).sin() * 300.0) + * clear_gust; } - flake.x += (flake.vx * strength + (effective_wind + sway) * strength + flake.bvx + swirl_x) * dt; + flake.x += + (flake.vx * strength + (effective_wind + sway) * strength + flake.bvx + swirl_x) + * dt; flake.y += (flake.vy * strength + flake.bvy + swirl_y) * dt; if flake.extra && flake.ballistic > 0.0 { flake.bvy += 520.0 * dt; - flake.bvx *= (-1.0 * dt).exp(); + flake.bvx *= (-dt).exp(); flake.bvy *= (-0.8 * dt).exp(); flake.ballistic -= dt; if flake.ballistic <= 0.0 { @@ -1419,8 +1595,10 @@ impl Snow { // let the flake fall down to the base line. let probe_y = pile.y - 1.0; let hidden = self.window_rects.iter().any(|(_, r)| { - flake.x >= r.x() && flake.x <= r.x() + r.width() - && probe_y >= r.y() && probe_y <= r.y() + r.height() + flake.x >= r.x() + && flake.x <= r.x() + r.width() + && probe_y >= r.y() + && probe_y <= r.y() + r.height() }); if hidden { surface_y = pile.y - 1.0; @@ -1452,23 +1630,31 @@ impl Snow { if target_col > 0 { let c_left = target_col - 1; - pile.heights[c_left] = (pile.heights[c_left] + 0.25 * amount).min(max_h); + pile.heights[c_left] = + (pile.heights[c_left] + 0.25 * amount).min(max_h); touched_min = touched_min.min(c_left); touched_max = touched_max.max(c_left); } - pile.heights[target_col] = (pile.heights[target_col] + 0.5 * amount).min(max_h); + pile.heights[target_col] = + (pile.heights[target_col] + 0.5 * amount).min(max_h); touched_min = touched_min.min(target_col); touched_max = touched_max.max(target_col); if target_col + 1 < len { let c_right = target_col + 1; - pile.heights[c_right] = (pile.heights[c_right] + 0.25 * amount).min(max_h); + pile.heights[c_right] = + (pile.heights[c_right] + 0.25 * amount).min(max_h); touched_min = touched_min.min(c_right); touched_max = touched_max.max(c_right); } - let _ = relax_range(&mut pile.heights, touched_min.saturating_sub(4), touched_max + 4, MAX_SLOPE); + let _ = relax_range( + &mut pile.heights, + touched_min.saturating_sub(4), + touched_max + 4, + MAX_SLOPE, + ); pile.dirty = true; } } @@ -1480,7 +1666,11 @@ impl Snow { flake.x = rng.gen_range(0.0..self.width); let depth = rng.gen_range(0.0..1.0); flake.depth = depth; - flake.r = if depth < 0.5 { rng.gen_range(0.8..1.5) } else { rng.gen_range(2.5..4.0) }; + flake.r = if depth < 0.5 { + rng.gen_range(0.8..1.5) + } else { + rng.gen_range(2.5..4.0) + }; flake.bucket_idx = Self::get_bucket_idx(flake.r); flake.vy = 40.0 + depth * 100.0; flake.bvx = 0.0; @@ -1491,7 +1681,10 @@ impl Snow { } else { flake.fade_target = 0.0; } - } else if flake.x < -flake.r || flake.x > self.width + flake.r || flake.y > self.height + flake.r { + } else if flake.x < -flake.r + || flake.x > self.width + flake.r + || flake.y > self.height + flake.r + { if flake.extra { self.scratch_remove_indices.push(i); } else if !hold && alive_count <= self.target_flake_count { @@ -1499,7 +1692,11 @@ impl Snow { flake.x = rng.gen_range(0.0..self.width); let depth = rng.gen_range(0.0..1.0); flake.depth = depth; - flake.r = if depth < 0.5 { rng.gen_range(0.8..1.5) } else { rng.gen_range(2.5..4.0) }; + flake.r = if depth < 0.5 { + rng.gen_range(0.8..1.5) + } else { + rng.gen_range(2.5..4.0) + }; flake.bucket_idx = Self::get_bucket_idx(flake.r); flake.vy = 40.0 + depth * 100.0; flake.bvx = 0.0; @@ -1514,14 +1711,19 @@ impl Snow { } if !self.scratch_remove_indices.is_empty() { - self.scratch_remove_indices.sort_unstable_by(|a, b| b.cmp(a)); + self.scratch_remove_indices + .sort_unstable_by(|a, b| b.cmp(a)); for &idx in &self.scratch_remove_indices { self.flakes.swap_remove(idx); } } // 4. Intensity decrease - let alive_count = self.flakes.iter().filter(|f| !f.extra && f.fade_target > 0.0).count(); + let alive_count = self + .flakes + .iter() + .filter(|f| !f.extra && f.fade_target > 0.0) + .count(); if alive_count > self.target_flake_count { let excess = alive_count - self.target_flake_count; let n = ((excess as f32 * (1.0 - (-dt / 1.5).exp())).ceil() as usize).min(alive_count); @@ -1538,16 +1740,28 @@ impl Snow { } // 5. Intensity increase - let mut current_alive = self.flakes.iter().filter(|f| !f.extra && f.fade_target > 0.0).count(); + let mut current_alive = self + .flakes + .iter() + .filter(|f| !f.extra && f.fade_target > 0.0) + .count(); while !hold && current_alive < self.target_flake_count { let depth = rng.gen_range(0.0..1.0); - let r = if depth < 0.5 { rng.gen_range(0.8..1.5) } else { rng.gen_range(2.5..4.0) }; + let r = if depth < 0.5 { + rng.gen_range(0.8..1.5) + } else { + rng.gen_range(2.5..4.0) + }; let bucket_idx = Self::get_bucket_idx(r); let vy = 40.0 + depth * 100.0; let alpha = 0.3 + depth * 0.65; self.flakes.push(Flake { x: rng.gen_range(0.0..self.width), - y: if self.refill_from_top { rng.gen_range((-0.4 * self.height)..0.0) } else { rng.gen_range((-0.1 * self.height)..self.height) }, + y: if self.refill_from_top { + rng.gen_range((-0.4 * self.height)..0.0) + } else { + rng.gen_range((-0.1 * self.height)..self.height) + }, vx: rng.gen_range(-10.0..10.0), vy, bvx: 0.0, @@ -1613,10 +1827,15 @@ impl Snow { if spill_flakes_count < 24 { spill_flakes_count += 1; let nearest_is_left = left_dist < right_dist; - let edge_x = if nearest_is_left { full_left } else { full_right }; + let edge_x = if nearest_is_left { + full_left + } else { + full_right + }; let outward = if nearest_is_left { -1.0 } else { 1.0 }; let y = pile.y - cap; - self.scratch_curtain_actions.push((edge_x, y, outward, excess)); + self.scratch_curtain_actions + .push((edge_x, y, outward, excess)); } } } else { @@ -1629,10 +1848,15 @@ impl Snow { } } - if pile_modified { - if relax_range(&mut pile.heights, min_c.saturating_sub(4), max_c + 4, MAX_SLOPE) { - pile.dirty = true; - } + if pile_modified + && relax_range( + &mut pile.heights, + min_c.saturating_sub(4), + max_c + 4, + MAX_SLOPE, + ) + { + pile.dirty = true; } } @@ -1650,7 +1874,13 @@ impl Snow { if let Some(ref shadow_path) = pile.cached_shadow_path { let mut paint = Paint::default(); paint.set_color(bgra(0.0, 0.0, 0.0, 0.18)); - pixmap.fill_path(shadow_path, &paint, FillRule::Winding, Transform::identity(), None); + pixmap.fill_path( + shadow_path, + &paint, + FillRule::Winding, + Transform::identity(), + None, + ); } if let Some(ref body_path) = pile.cached_body_path { let mut paint = Paint::default(); @@ -1659,13 +1889,21 @@ impl Snow { } else { paint.set_color(bgra(1.0, 1.0, 1.0, 1.0)); } - pixmap.fill_path(body_path, &paint, FillRule::Winding, Transform::identity(), None); + pixmap.fill_path( + body_path, + &paint, + FillRule::Winding, + Transform::identity(), + None, + ); } if let Some(ref top_path) = pile.cached_top_path { let mut paint = Paint::default(); paint.set_color(bgra(1.0, 1.0, 1.0, 0.85)); - let mut stroke = Stroke::default(); - stroke.width = 1.5; + let stroke = Stroke { + width: 1.5, + ..Default::default() + }; pixmap.stroke_path(top_path, &paint, &stroke, Transform::identity(), None); } } @@ -1679,13 +1917,21 @@ impl Snow { } for &(hwnd, ref rect) in win_rects.iter().rev() { - let mut clear_paint = Paint::default(); - clear_paint.blend_mode = tiny_skia::BlendMode::Clear; - clear_paint.anti_alias = false; + let clear_paint = Paint { + blend_mode: tiny_skia::BlendMode::Clear, + anti_alias: false, + ..Default::default() + }; let mut pb = PathBuilder::new(); pb.push_rect(*rect); if let Some(path) = pb.finish() { - pixmap.fill_path(&path, &clear_paint, FillRule::Winding, Transform::identity(), None); + pixmap.fill_path( + &path, + &clear_paint, + FillRule::Winding, + Transform::identity(), + None, + ); } if let Some(pile) = self.piles.get(&Some(hwnd)) { @@ -1758,8 +2004,10 @@ impl Snow { } else { let inv_a = 255 - sa as u32; let b = sprite.data[si] as u32 + (dst_data[di] as u32 * inv_a + 127) / 255; - let g = sprite.data[si + 1] as u32 + (dst_data[di + 1] as u32 * inv_a + 127) / 255; - let r = sprite.data[si + 2] as u32 + (dst_data[di + 2] as u32 * inv_a + 127) / 255; + let g = sprite.data[si + 1] as u32 + + (dst_data[di + 1] as u32 * inv_a + 127) / 255; + let r = sprite.data[si + 2] as u32 + + (dst_data[di + 2] as u32 * inv_a + 127) / 255; let a = sa as u32 + (dst_data[di + 3] as u32 * inv_a + 127) / 255; dst_data[di] = b as u8; dst_data[di + 1] = g as u8; diff --git a/src/tracker.rs b/src/tracker.rs index 7b5d053..054f90c 100644 --- a/src/tracker.rs +++ b/src/tracker.rs @@ -1,29 +1,28 @@ //! Tracker module for enumerating real application windows. -use crate::platform::{WindowInfo, WinRect}; -use windows::Win32::Foundation::{HWND, LPARAM, BOOL, RECT}; -use windows::Win32::Graphics::Dwm::{DwmGetWindowAttribute, DWMWA_CLOAKED, DWMWA_EXTENDED_FRAME_BOUNDS}; -use windows::Win32::Graphics::Gdi::{MonitorFromWindow, GetMonitorInfoW, MONITORINFO, MONITOR_DEFAULTTONEAREST}; -use windows::Win32::UI::WindowsAndMessaging::{ - EnumWindows, IsWindowVisible, IsIconic, GetWindowTextW, GetWindowTextLengthW, - GetClassNameW, GetWindowLongW, GetWindowRect, GWL_EXSTYLE, WS_EX_TOOLWINDOW, - WINEVENT_OUTOFCONTEXT, WINEVENT_SKIPOWNPROCESS, - EVENT_OBJECT_LOCATIONCHANGE, EVENT_OBJECT_SHOW, EVENT_OBJECT_HIDE, - EVENT_OBJECT_CLOAKED, EVENT_OBJECT_UNCLOAKED, EVENT_SYSTEM_FOREGROUND, - EVENT_SYSTEM_MINIMIZESTART, EVENT_SYSTEM_MINIMIZEEND, - EVENT_SYSTEM_MOVESIZESTART, EVENT_SYSTEM_MOVESIZEEND, - GetSystemMetrics, GetForegroundWindow, - OBJID_WINDOW, CHILDID_SELF, IsWindow, - GetWindowThreadProcessId -}; -use windows::Win32::System::Threading::GetCurrentProcessId; -use windows::Win32::UI::Accessibility::{ - SetWinEventHook, HWINEVENTHOOK -}; +use crate::platform::{WinRect, WindowInfo}; use std::ffi::c_void; use std::sync::atomic::{AtomicBool, AtomicIsize, Ordering}; use std::sync::Mutex; -use std::time::{Instant, Duration}; +use std::time::{Duration, Instant}; +use windows::Win32::Foundation::{BOOL, HWND, LPARAM, RECT}; +use windows::Win32::Graphics::Dwm::{ + DwmGetWindowAttribute, DWMWA_CLOAKED, DWMWA_EXTENDED_FRAME_BOUNDS, +}; +use windows::Win32::Graphics::Gdi::{ + GetMonitorInfoW, MonitorFromWindow, MONITORINFO, MONITOR_DEFAULTTONEAREST, +}; +use windows::Win32::System::Threading::GetCurrentProcessId; +use windows::Win32::UI::Accessibility::{SetWinEventHook, HWINEVENTHOOK}; +use windows::Win32::UI::WindowsAndMessaging::{ + EnumWindows, GetClassNameW, GetForegroundWindow, GetSystemMetrics, GetWindowLongW, + GetWindowRect, GetWindowTextLengthW, GetWindowTextW, GetWindowThreadProcessId, IsIconic, + IsWindow, IsWindowVisible, CHILDID_SELF, EVENT_OBJECT_CLOAKED, EVENT_OBJECT_HIDE, + EVENT_OBJECT_LOCATIONCHANGE, EVENT_OBJECT_SHOW, EVENT_OBJECT_UNCLOAKED, + EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_MINIMIZEEND, EVENT_SYSTEM_MINIMIZESTART, + EVENT_SYSTEM_MOVESIZEEND, EVENT_SYSTEM_MOVESIZESTART, GWL_EXSTYLE, OBJID_WINDOW, + WINEVENT_OUTOFCONTEXT, WINEVENT_SKIPOWNPROCESS, WS_EX_TOOLWINDOW, +}; struct EnumData { own_hwnd: HWND, @@ -102,15 +101,7 @@ pub fn init() { ]; let flags = WINEVENT_OUTOFCONTEXT | WINEVENT_SKIPOWNPROCESS; for (i, &event) in events.iter().enumerate() { - let hook = SetWinEventHook( - event, - event, - None, - Some(winevent_callback), - 0, - 0, - flags, - ); + let hook = SetWinEventHook(event, event, None, Some(winevent_callback), 0, 0, flags); if !hook.is_invalid() { HOOKS[i] = hook; } @@ -196,8 +187,10 @@ unsafe fn fullscreen_active_inner() -> bool { if hmonitor.is_invalid() { return false; } - let mut mi = MONITORINFO::default(); - mi.cbSize = std::mem::size_of::() as u32; + let mut mi = MONITORINFO { + cbSize: std::mem::size_of::() as u32, + ..Default::default() + }; if !GetMonitorInfoW(hmonitor, &mut mi).as_bool() { return false; } @@ -337,7 +330,12 @@ pub fn classify(hwnd: HWND, own: HWND) -> Result { Ok(WindowInfo { hwnd: hwnd.0 as isize, - rect: WinRect { left, top, right, bottom }, + rect: WinRect { + left, + top, + right, + bottom, + }, }) } } @@ -356,7 +354,10 @@ pub fn snapshot(own_hwnd: HWND) -> Vec { windows: Vec::new(), }; unsafe { - let _ = EnumWindows(Some(enum_window_callback), LPARAM(&mut data as *mut EnumData as isize)); + let _ = EnumWindows( + Some(enum_window_callback), + LPARAM(&mut data as *mut EnumData as isize), + ); } data.windows } @@ -400,8 +401,11 @@ pub fn refresh_rects(windows: &mut Vec) -> bool { bottom: win_rect.bottom, }; - if new_rect.left != win.rect.left || new_rect.top != win.rect.top || - new_rect.right != win.rect.right || new_rect.bottom != win.rect.bottom { + if new_rect.left != win.rect.left + || new_rect.top != win.rect.top + || new_rect.right != win.rect.right + || new_rect.bottom != win.rect.bottom + { changed = true; win.rect = new_rect; } @@ -518,10 +522,14 @@ pub fn dump_all(own: HWND) -> String { records: Vec::new(), }; unsafe { - let _ = EnumWindows(Some(dump_enum_window_callback), LPARAM(&mut data as *mut DumpEnumData as isize)); + let _ = EnumWindows( + Some(dump_enum_window_callback), + LPARAM(&mut data as *mut DumpEnumData as isize), + ); } - let accepted_windows: Vec = data.records + let accepted_windows: Vec = data + .records .iter() .filter_map(|r| match r.res { Ok(ref info) => Some(info.clone()), @@ -529,10 +537,14 @@ pub fn dump_all(own: HWND) -> String { }) .collect(); - let width = unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN) }; - let height = unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_CYVIRTUALSCREEN) }; - let origin_x = unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_XVIRTUALSCREEN) }; - let origin_y = unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_YVIRTUALSCREEN) }; + let width = + unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN) }; + let height = + unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_CYVIRTUALSCREEN) }; + let origin_x = + unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_XVIRTUALSCREEN) }; + let origin_y = + unsafe { GetSystemMetrics(windows::Win32::UI::WindowsAndMessaging::SM_YVIRTUALSCREEN) }; let virt = (origin_x, origin_y, origin_x + width, origin_y + height); let floor = crate::platform::floor_y(); let segments = crate::platform::build_segments(&accepted_windows, virt, floor); @@ -569,20 +581,41 @@ pub fn dump_all(own: HWND) -> String { if rec.res.is_ok() { let hwnd_isize = rec.hwnd.0 as isize; - let win_segs: Vec<_> = segments.iter().filter(|s| s.owner == Some(hwnd_isize)).collect(); + let win_segs: Vec<_> = segments + .iter() + .filter(|s| s.owner == Some(hwnd_isize)) + .collect(); if !win_segs.is_empty() { - let seg_strs: Vec = win_segs.iter().map(|s| format!("{:.1}..{:.1} @ {:.1}", s.x1 + origin_x as f32, s.x2 + origin_x as f32, s.y + origin_y as f32)).collect(); + let seg_strs: Vec = win_segs + .iter() + .map(|s| { + format!( + "{:.1}..{:.1} @ {:.1}", + s.x1 + origin_x as f32, + s.x2 + origin_x as f32, + s.y + origin_y as f32 + ) + }) + .collect(); output.push_str(&format!(" segments: [{}]\n", seg_strs.join(", "))); } else { let occluders = crate::platform::explain_occlusion(&accepted_windows, accepted_idx); if !occluders.is_empty() { - let occ_details: Vec = occluders.iter().map(|&occ_hwnd| { - if let Some(occ_rec) = data.records.iter().find(|r| r.hwnd.0 as isize == occ_hwnd) { - format!("0x{:X} ({}) \"{}\"", occ_hwnd, occ_rec.class_name, occ_rec.title) - } else { - format!("0x{:X}", occ_hwnd) - } - }).collect(); + let occ_details: Vec = occluders + .iter() + .map(|&occ_hwnd| { + if let Some(occ_rec) = + data.records.iter().find(|r| r.hwnd.0 as isize == occ_hwnd) + { + format!( + "0x{:X} ({}) \"{}\"", + occ_hwnd, occ_rec.class_name, occ_rec.title + ) + } else { + format!("0x{:X}", occ_hwnd) + } + }) + .collect(); output.push_str(&format!(" occluded by: [{}]\n", occ_details.join(", "))); } else { output.push_str(" segments: [] (no occlusion found)\n"); diff --git a/src/tray.rs b/src/tray.rs index fd49eed..459bb14 100644 --- a/src/tray.rs +++ b/src/tray.rs @@ -3,23 +3,23 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::sync::Arc; use std::thread::{self, JoinHandle}; -use windows::Win32::System::LibraryLoader::GetModuleHandleW; -use windows::Win32::Foundation::{HWND, POINT, TRUE, WPARAM, LPARAM, LRESULT, HINSTANCE}; +use windows::Win32::Foundation::{HINSTANCE, HWND, LPARAM, LRESULT, POINT, TRUE, WPARAM}; use windows::Win32::Graphics::Gdi::{ - CreateBitmap, CreateDIBSection, DeleteObject, GetDC, ReleaseDC, HGDIOBJ, - BITMAPINFO, BITMAPINFOHEADER, BI_RGB, DIB_RGB_COLORS + CreateBitmap, CreateDIBSection, DeleteObject, GetDC, ReleaseDC, BITMAPINFO, BITMAPINFOHEADER, + BI_RGB, DIB_RGB_COLORS, HGDIOBJ, }; +use windows::Win32::System::LibraryLoader::GetModuleHandleW; use windows::Win32::UI::Shell::{ - Shell_NotifyIconW, NIM_ADD, NIM_DELETE, NIF_ICON, NIF_MESSAGE, NIF_TIP, NOTIFYICONDATAW + Shell_NotifyIconW, NIF_ICON, NIF_MESSAGE, NIF_TIP, NIM_ADD, NIM_DELETE, NOTIFYICONDATAW, }; use windows::Win32::UI::WindowsAndMessaging::{ - AppendMenuW, CheckMenuItem, CreateIconIndirect, CreatePopupMenu, DestroyIcon, DestroyMenu, GetCursorPos, - LoadIconW, PostMessageW, PostQuitMessage, SetForegroundWindow, TrackPopupMenu, - HICON, IDI_APPLICATION, ICONINFO, WM_NULL, - MF_BYCOMMAND, MF_CHECKED, MF_SEPARATOR, MF_STRING, TPM_BOTTOMALIGN, TPM_LEFTALIGN, TPM_NONOTIFY, TPM_RETURNCMD, - CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, GetMessageW, - RegisterClassW, TranslateMessage, UnregisterClassW, WNDCLASSW, HWND_MESSAGE, MSG, - WM_CLOSE, WM_DESTROY, WM_RBUTTONUP, WM_LBUTTONUP, GetWindowLongPtrW, SetWindowLongPtrW, GWLP_USERDATA + AppendMenuW, CheckMenuItem, CreateIconIndirect, CreatePopupMenu, CreateWindowExW, + DefWindowProcW, DestroyIcon, DestroyMenu, DestroyWindow, DispatchMessageW, GetCursorPos, + GetMessageW, GetWindowLongPtrW, LoadIconW, PostMessageW, PostQuitMessage, RegisterClassW, + SetForegroundWindow, SetWindowLongPtrW, TrackPopupMenu, TranslateMessage, UnregisterClassW, + GWLP_USERDATA, HICON, HWND_MESSAGE, ICONINFO, IDI_APPLICATION, MF_BYCOMMAND, MF_CHECKED, + MF_SEPARATOR, MF_STRING, MSG, TPM_BOTTOMALIGN, TPM_LEFTALIGN, TPM_NONOTIFY, TPM_RETURNCMD, + WM_CLOSE, WM_DESTROY, WM_LBUTTONUP, WM_NULL, WM_RBUTTONUP, WNDCLASSW, }; pub const WM_TRAY_CALLBACK: u32 = windows::Win32::UI::WindowsAndMessaging::WM_APP + 1; @@ -72,13 +72,15 @@ impl TrayIcon { pub fn new(hwnd: HWND) -> Self { let hicon = unsafe { create_tray_icon() }; unsafe { - let mut nid = NOTIFYICONDATAW::default(); - nid.cbSize = std::mem::size_of::() as u32; - nid.hWnd = hwnd; - nid.uID = TRAY_ID; - nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP; - nid.uCallbackMessage = WM_TRAY_CALLBACK; - nid.hIcon = hicon; + let mut nid = NOTIFYICONDATAW { + cbSize: std::mem::size_of::() as u32, + hWnd: hwnd, + uID: TRAY_ID, + uFlags: NIF_MESSAGE | NIF_ICON | NIF_TIP, + uCallbackMessage: WM_TRAY_CALLBACK, + hIcon: hicon, + ..Default::default() + }; let tip = windows::core::w!("Snowfall"); let dest = &mut nid.szTip; @@ -100,10 +102,12 @@ impl TrayIcon { impl Drop for TrayIcon { fn drop(&mut self) { unsafe { - let mut nid = NOTIFYICONDATAW::default(); - nid.cbSize = std::mem::size_of::() as u32; - nid.hWnd = self.hwnd; - nid.uID = TRAY_ID; + let nid = NOTIFYICONDATAW { + cbSize: std::mem::size_of::() as u32, + hWnd: self.hwnd, + uID: TRAY_ID, + ..Default::default() + }; let _ = Shell_NotifyIconW(NIM_DELETE, &nid); if !self.hicon.is_invalid() { @@ -113,7 +117,12 @@ impl Drop for TrayIcon { } } -unsafe extern "system" fn tray_wnd_proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT { +unsafe extern "system" fn tray_wnd_proc( + hwnd: HWND, + msg: u32, + wparam: WPARAM, + lparam: LPARAM, +) -> LRESULT { match msg { WM_TRAY_CALLBACK => { let l = lparam.0 as u32; @@ -137,67 +146,70 @@ unsafe extern "system" fn tray_wnd_proc(hwnd: HWND, msg: u32, wparam: WPARAM, lp } pub fn spawn_tray_thread(state: Arc) -> JoinHandle<()> { - thread::spawn(move || { - unsafe { - let hinstance = HINSTANCE(std::ptr::null_mut()); - let class_name = windows::core::w!("SnowfallTray"); - - let wnd_class = WNDCLASSW { - style: Default::default(), - lpfnWndProc: Some(tray_wnd_proc), - cbClsExtra: 0, - cbWndExtra: 0, - hInstance: hinstance, - hIcon: Default::default(), - hCursor: Default::default(), - hbrBackground: Default::default(), - lpszMenuName: windows::core::PCWSTR::null(), - lpszClassName: class_name, - }; - - let _ = RegisterClassW(&wnd_class); + thread::spawn(move || unsafe { + let hinstance = HINSTANCE(std::ptr::null_mut()); + let class_name = windows::core::w!("SnowfallTray"); + + let wnd_class = WNDCLASSW { + style: Default::default(), + lpfnWndProc: Some(tray_wnd_proc), + cbClsExtra: 0, + cbWndExtra: 0, + hInstance: hinstance, + hIcon: Default::default(), + hCursor: Default::default(), + hbrBackground: Default::default(), + lpszMenuName: windows::core::PCWSTR::null(), + lpszClassName: class_name, + }; - let hwnd = CreateWindowExW( - Default::default(), - class_name, - windows::core::w!("SnowfallTrayWindow"), - Default::default(), - 0, 0, 0, 0, - HWND_MESSAGE, - None, - hinstance, - None, - ).expect("Failed to create tray window"); + let _ = RegisterClassW(&wnd_class); - state.tray_hwnd.store(hwnd.0 as usize, Ordering::Release); + let hwnd = CreateWindowExW( + Default::default(), + class_name, + windows::core::w!("SnowfallTrayWindow"), + Default::default(), + 0, + 0, + 0, + 0, + HWND_MESSAGE, + None, + hinstance, + None, + ) + .expect("Failed to create tray window"); - let state_box = Box::new(state.clone()); - let state_ptr = Box::into_raw(state_box) as isize; - SetWindowLongPtrW(hwnd, GWLP_USERDATA, state_ptr); + state.tray_hwnd.store(hwnd.0 as usize, Ordering::Release); - let tray_icon = TrayIcon::new(hwnd); + let state_box = Box::new(state.clone()); + let state_ptr = Box::into_raw(state_box) as isize; + SetWindowLongPtrW(hwnd, GWLP_USERDATA, state_ptr); - crate::settings_ui::create_hidden(&state); + let tray_icon = TrayIcon::new(hwnd); - let mut msg = MSG::default(); - while GetMessageW(&mut msg, None, 0, 0).into() { - let _ = TranslateMessage(&msg); - DispatchMessageW(&msg); - } + crate::settings_ui::create_hidden(&state); - drop(tray_icon); + let mut msg = MSG::default(); + while GetMessageW(&mut msg, None, 0, 0).into() { + let _ = TranslateMessage(&msg); + DispatchMessageW(&msg); + } - let ptr = SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0); - if ptr != 0 { - let _ = Box::from_raw(ptr as *mut Arc); - } + drop(tray_icon); - let _ = DestroyWindow(hwnd); - let _ = UnregisterClassW(class_name, hinstance); + let ptr = SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0); + if ptr != 0 { + let _ = Box::from_raw(ptr as *mut Arc); } + + let _ = DestroyWindow(hwnd); + let _ = UnregisterClassW(class_name, hinstance); }) } +#[allow(clippy::manual_dangling_ptr)] // 1 is a MAKEINTRESOURCE icon id, not a dangling pointer unsafe fn create_tray_icon() -> HICON { if let Ok(hinst) = GetModuleHandleW(None) { if let Ok(hicon) = LoadIconW(hinst, windows::core::PCWSTR(1 as *const u16)) { @@ -229,25 +241,19 @@ unsafe fn create_tray_icon() -> HICON { }; let mut bits_ptr: *mut std::ffi::c_void = std::ptr::null_mut(); - let hbmp_color = match CreateDIBSection( - hdc_compat, - &bmi, - DIB_RGB_COLORS, - &mut bits_ptr, - None, - 0, - ) { - Ok(h) => h, - Err(_) => { - let _ = windows::Win32::Graphics::Gdi::DeleteDC(hdc_compat); - return LoadIconW(None, IDI_APPLICATION).unwrap_or_default(); - } - }; + let hbmp_color = + match CreateDIBSection(hdc_compat, &bmi, DIB_RGB_COLORS, &mut bits_ptr, None, 0) { + Ok(h) => h, + Err(_) => { + let _ = windows::Win32::Graphics::Gdi::DeleteDC(hdc_compat); + return LoadIconW(None, IDI_APPLICATION).unwrap_or_default(); + } + }; if !bits_ptr.is_null() { let pixels = std::slice::from_raw_parts_mut(bits_ptr as *mut u8, 16 * 16 * 4); for i in (0..pixels.len()).step_by(4) { - pixels[i] = 255; + pixels[i] = 255; pixels[i + 1] = 128; pixels[i + 2] = 0; pixels[i + 3] = 255; @@ -256,7 +262,7 @@ unsafe fn create_tray_icon() -> HICON { let draw_pixel = |px: usize, py: usize, pxls: &mut [u8]| { if px < 16 && py < 16 { let idx = (py * 16 + px) * 4; - pxls[idx] = 255; + pxls[idx] = 255; pxls[idx + 1] = 255; pxls[idx + 2] = 255; pxls[idx + 3] = 255; @@ -287,7 +293,8 @@ unsafe fn create_tray_icon() -> HICON { hbmColor: hbmp_color, }; - let hicon = CreateIconIndirect(&icon_info).unwrap_or_else(|_| LoadIconW(None, IDI_APPLICATION).unwrap_or_default()); + let hicon = CreateIconIndirect(&icon_info) + .unwrap_or_else(|_| LoadIconW(None, IDI_APPLICATION).unwrap_or_default()); let _ = DeleteObject(HGDIOBJ(hbmp_color.0)); let _ = DeleteObject(HGDIOBJ(hbmp_mask.0)); @@ -341,7 +348,12 @@ pub unsafe fn show_context_menu(hwnd: HWND, state: &Arc) { None, ); - let _ = PostMessageW(hwnd, WM_NULL, windows::Win32::Foundation::WPARAM(0), windows::Win32::Foundation::LPARAM(0)); + let _ = PostMessageW( + hwnd, + WM_NULL, + windows::Win32::Foundation::WPARAM(0), + windows::Win32::Foundation::LPARAM(0), + ); let _ = DestroyMenu(hmenu);