simplify

Author: jacob-pro

app/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "solar-screen-brightness"
-version = "0.2.0"
+version = "2.0.0"
 authors = ["Jacob Halsey <[email protected]>"]
 edition = "2021"
 build = "build.rs"

app/Cargo.toml

@@ -2,7 +2,7 @@
 
 use anyhow::Context;
 use log::LevelFilter;
-use simplelog::{ColorChoice, CombinedLogger, Config, TermLogger, TerminalMode, WriteLogger};
+use simplelog::{ColorChoice, CombinedLogger, TermLogger, TerminalMode, WriteLogger};
 use std::fs;
 use std::fs::File;
 use std::path::PathBuf;
@@ -34,14 +34,14 @@ pub fn config_directory() -> anyhow::Result<PathBuf> {
 pub fn install_logger(filter: LevelFilter) -> anyhow::Result<()> {
     let path = local_data_directory()?.join("log.txt");
     let file = File::create(&path).context("Unable to create log file")?;
-    let file_logger = WriteLogger::new(filter, Config::default(), file);
+    let config = simplelog::ConfigBuilder::default()
+        .add_filter_ignore_str("wgpu")
+        .add_filter_ignore_str("naga")
+        .set_target_level(LevelFilter::Debug)
+        .build();
+    let file_logger = WriteLogger::new(filter, config.clone(), file);
     CombinedLogger::init(vec![
-        TermLogger::new(
-            filter,
-            Config::default(),
-            TerminalMode::Stderr,
-            ColorChoice::Auto,
-        ),
+        TermLogger::new(filter, config, TerminalMode::Stderr, ColorChoice::Auto),
         file_logger,
     ])?;
     Ok(())

app/src/common.rs

@@ -2,34 +2,24 @@ mod app;
 
 use crate::common::APP_NAME;
 use crate::gui::app::SsbEguiApp;
+use crate::tray::read_icon;
 use crate::UserEvent;
 use egui_winit::winit;
 use egui_winit::winit::event::{Event, WindowEvent};
 use egui_winit::winit::event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
+use egui_winit::winit::window::Icon;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
 #[derive(Debug)]
 pub enum NextPaint {
     /// Wait for an event
     Wait,
-
-    /// Causes a synchronous repaint inside the event handler. This should only
-    /// be used in special situations if the window must be repainted while
-    /// handling a specific event. This occurs on Windows when handling resizes.
-    ///
-    /// `RepaintNow` creates a new frame synchronously, and should therefore
-    /// only be used for extremely urgent repaints.
-    RepaintNow,
-
     /// Queues a repaint for once the event loop handles its next redraw. Exists
-    /// so that multiple input events can be handled in one frame. Does not
-    /// cause any delay like `RepaintNow`.
+    /// so that multiple input events can be handled in one frame.
     RepaintNext,
-
     /// Repaint at a particular time
     RepaintAt(Instant),
-
     /// Exit the event loop
     Exit,
 }
@@ -53,13 +43,17 @@ impl Drop for WgpuWinitRunning {
 pub struct WgpuWinitApp {
     repaint_proxy: Arc<Mutex<EventLoopProxy<UserEvent>>>,
     running: Option<WgpuWinitRunning>,
+    icon: Icon,
 }
 
 impl WgpuWinitApp {
     pub fn new(event_loop: &EventLoop<UserEvent>) -> Self {
+        let (buf, info) = read_icon();
+        let icon = Icon::from_rgba(buf, info.width, info.height).unwrap();
         Self {
             repaint_proxy: Arc::new(Mutex::new(event_loop.create_proxy())),
             running: None,
+            icon,
         }
     }
 
@@ -76,7 +70,9 @@ impl WgpuWinitApp {
                 width: 800,
                 height: 600,
             })
+            .with_window_icon(Some(self.icon.clone()))
             .build(&event_loop)?;
+
         window.set_ime_allowed(true);
 
         let mut painter =
@@ -122,7 +118,7 @@ impl WgpuWinitApp {
             egui_winit,
         });
 
-        Ok(NextPaint::RepaintNow)
+        Ok(NextPaint::RepaintNext)
     }
 
     pub fn frame_nr(&self) -> u64 {
@@ -191,27 +187,19 @@ impl WgpuWinitApp {
         Ok(match event {
             Event::Resumed if self.running.is_none() => self.launch_window(event_loop)?,
 
+            Event::UserEvent(UserEvent::RequestRepaint { when, frame_nr }) => {
+                if self.frame_nr() == *frame_nr {
+                    NextPaint::RepaintAt(*when)
+                } else {
+                    // old request - we've already repainted
+                    NextPaint::Wait
+                }
+            }
+
             Event::WindowEvent { event, .. } => {
                 if let Some(running) = &mut self.running {
-                    // On Windows, if a window is resized by the user, it should repaint synchronously, inside the
-                    // event handler.
-                    //
-                    // If this is not done, the compositor will assume that the window does not want to redraw,
-                    // and continue ahead.
-                    //
-                    // In eframe's case, that causes the window to rapidly flicker, as it struggles to deliver
-                    // new frames to the compositor in time.
-                    //
-                    // The flickering is technically glutin or glow's fault, but we should be responding properly
-                    // to resizes anyway, as doing so avoids dropping frames.
-                    //
-                    // See: https://github.com/emilk/egui/issues/903
-                    let mut repaint_asap = false;
-
                     match &event {
                         WindowEvent::Resized(physical_size) => {
-                            repaint_asap = true;
-
                             // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
                             // See: https://github.com/rust-windowing/winit/issues/208
                             // This solves an issue where the app would panic when minimizing on Windows.
@@ -222,7 +210,6 @@ impl WgpuWinitApp {
                             }
                         }
                         WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                            repaint_asap = true;
                             running
                                 .painter
                                 .on_window_resized(new_inner_size.width, new_inner_size.height);
@@ -242,11 +229,7 @@ impl WgpuWinitApp {
                     let event_response = running.egui_winit.on_event(&running.egui_ctx, event);
 
                     if event_response.repaint {
-                        if repaint_asap {
-                            NextPaint::RepaintNow
-                        } else {
-                            NextPaint::RepaintNext
-                        }
+                        NextPaint::RepaintNext
                     } else {
                         NextPaint::Wait
                     }

app/src/gui/mod.rs

@@ -4,23 +4,19 @@ mod calculator;
 mod common;
 mod config;
 mod gui;
-mod tray2;
+mod tray;
 mod unique;
 
 use crate::common::{install_logger, APP_NAME};
 use crate::gui::{NextPaint, WgpuWinitApp};
 use crate::unique::SsbUniqueInstance;
 use egui_winit::winit;
 use log::LevelFilter;
-use std::time::{Duration, Instant};
+use std::time::Instant;
 use winit::event::Event;
 use winit::event_loop::EventLoopBuilder;
 use winit::platform::run_return::EventLoopExtRunReturn;
 
-fn extremely_far_future() -> Instant {
-    Instant::now() + Duration::from_secs(10_000_000_000)
-}
-
 #[derive(Debug)]
 pub enum UserEvent {
     OpenWindow,
@@ -41,12 +37,12 @@ fn run() -> anyhow::Result<()> {
 
     let mut event_loop = EventLoopBuilder::<UserEvent>::with_user_event().build();
 
-    let _tray = tray2::create(&event_loop)?;
+    let _tray = tray::create(&event_loop)?;
 
-    let mut egui_app = WgpuWinitApp::new(&event_loop);
+    let mut framework = WgpuWinitApp::new(&event_loop);
 
     let mut returned_result = Ok(());
-    let mut next_repaint_time = Instant::now();
+    let mut next_repaint_time = Some(Instant::now());
 
     event_loop.run_return(|event, event_loop, control_flow| {
         let event_result = match &event {
@@ -55,23 +51,13 @@ fn run() -> anyhow::Result<()> {
             // See: https://github.com/rust-windowing/winit/issues/1619
             #[cfg(target_os = "windows")]
             Event::RedrawEventsCleared => {
-                next_repaint_time = extremely_far_future();
-                Ok(egui_app.paint())
+                next_repaint_time = None;
+                Ok(framework.paint())
             }
             #[cfg(not(target_os = "windows"))]
             Event::RedrawRequested(_) => {
-                next_repaint_time = extremely_far_future();
-                Ok(egui_app.paint())
-            }
-
-            Event::UserEvent(UserEvent::RequestRepaint { when, frame_nr }) => {
-                Ok(if egui_app.frame_nr() == *frame_nr {
-                    log::trace!("UserEvent::RequestRepaint scheduling repaint at {when:?}");
-                    NextPaint::RepaintAt(*when)
-                } else {
-                    log::trace!("Got outdated UserEvent::RequestRepaint");
-                    NextPaint::Wait // old request - we've already repainted
-                })
+                next_repaint_time = None;
+                Ok(framework.paint())
             }
 
             Event::UserEvent(UserEvent::Exit) => {
@@ -81,21 +67,16 @@ fn run() -> anyhow::Result<()> {
 
             Event::UserEvent(UserEvent::OpenWindow) => {
                 log::info!("Received OpenWindow action");
-                if let Some(window) = egui_app.window() {
+                if let Some(window) = framework.window() {
                     window.set_minimized(false);
                     window.focus_window();
                     Ok(NextPaint::Wait)
                 } else {
-                    egui_app.launch_window(event_loop)
+                    framework.launch_window(event_loop)
                 }
             }
 
-            Event::NewEvents(winit::event::StartCause::ResumeTimeReached { .. }) => {
-                log::trace!("Woke up to check next_repaint_time");
-                Ok(NextPaint::Wait)
-            }
-
-            event => egui_app.on_event(event_loop, event),
+            event => framework.on_event(event_loop, event),
         };
 
         match event_result {
@@ -106,41 +87,32 @@ fn run() -> anyhow::Result<()> {
                 return;
             }
             Ok(NextPaint::Wait) => {}
-            Ok(NextPaint::RepaintNow) => {
-                log::trace!("Repaint caused by winit::Event: {:?}", event);
-                if cfg!(target_os = "windows") {
-                    // Fix flickering on Windows, see https://github.com/emilk/egui/pull/2280
-                    next_repaint_time = extremely_far_future();
-                    egui_app.paint();
-                } else {
-                    // Fix for https://github.com/emilk/egui/issues/2425
-                    next_repaint_time = Instant::now();
-                }
-            }
             Ok(NextPaint::RepaintNext) => {
-                log::trace!("Repaint caused by winit::Event: {:?}", event);
-                next_repaint_time = Instant::now();
+                next_repaint_time = Some(Instant::now());
             }
             Ok(NextPaint::RepaintAt(repaint_time)) => {
-                next_repaint_time = next_repaint_time.min(repaint_time);
+                next_repaint_time =
+                    Some(next_repaint_time.unwrap_or(repaint_time).min(repaint_time));
             }
             Ok(NextPaint::Exit) => {
-                log::debug!("Asking to exit event loop…");
                 control_flow.set_exit();
                 return;
             }
         }
 
-        if next_repaint_time <= Instant::now() {
-            if let Some(window) = egui_app.window() {
-                log::trace!("request_redraw");
-                window.request_redraw();
-            }
-            next_repaint_time = extremely_far_future();
-            control_flow.set_poll();
+        if let Some(time) = next_repaint_time {
+            if time <= Instant::now() {
+                if let Some(window) = framework.window() {
+                    window.request_redraw();
+                }
+                next_repaint_time = None;
+                control_flow.set_poll();
+            } else {
+                control_flow.set_wait_until(time);
+            };
         } else {
-            control_flow.set_wait_until(next_repaint_time);
-        };
+            control_flow.set_wait();
+        }
     });
 
     return returned_result;
@@ -172,25 +144,6 @@ fn main() {
     }
 }
 
-// fn launch() -> i32 {
-//     init_logger();
-//     match unique::acquire() {
-//         Ok(lock) => {
-//             let config = SsbConfig::load().ok().unwrap_or_default();
-//             let controller = Arc::new(BrightnessController::new(config));
-//             controller.start();
-//             tray::run_tray_application(controller, lock, true);
-//             log::info!("Program exiting gracefully");
-//             EXIT_SUCCESS
-//         }
-//         Err(e) => {
-//             log::error!("Failed to acquire unique - the application is already running");
-//             e.show_console_in_owning_process();
-//             EXIT_FAILURE
-//         }
-//     }
-// }
-
 #[cfg(not(windows))]
 fn set_panic_hook() {}
 

app/src/main.rs

@@ -8,12 +8,17 @@ use tray_icon::{ClickType, Icon, TrayIcon, TrayIconBuilder, TrayIconEvent};
 const MENU_ID_OPEN: &str = "OPEN";
 const MENU_ID_EXIT: &str = "EXIT";
 
-pub fn create(event_loop: &EventLoop<UserEvent>) -> anyhow::Result<TrayIcon> {
+pub fn read_icon() -> (Vec<u8>, png::OutputInfo) {
     let mut decoder = png::Decoder::new(include_bytes!("../../assets/icon-256.png").as_slice());
     decoder.set_transformations(png::Transformations::EXPAND);
     let mut reader = decoder.read_info().unwrap();
     let mut buf = vec![0u8; reader.output_buffer_size()];
     let info = reader.next_frame(&mut buf).unwrap();
+    (buf, info)
+}
+
+pub fn create(event_loop: &EventLoop<UserEvent>) -> anyhow::Result<TrayIcon> {
+    let (buf, info) = read_icon();
     let icon = Icon::from_rgba(buf, info.width, info.height).unwrap();
 
     let tray_loop = Arc::new(Mutex::new(event_loop.create_proxy()));