Remove println, move to logging

Author: fschutt

dll/src/desktop/app.rs

@@ -54,26 +54,18 @@ impl App {
     }
 
     pub fn run(&self, root_window: WindowCreateOptions) {
-        println!("[TRACE] App::run() called");
         debug_server::log(
             debug_server::LogLevel::Info,
             debug_server::LogCategory::EventLoop,
             "Starting App::run",
             None,
         );
-        println!("[TRACE] App::run() - after debug_server::log");
         let data = self.ptr.data.clone();
-        println!("[TRACE] App::run() - cloned data");
-        println!("[TRACE] App::run() - cloned data");
         let config = self.ptr.config.clone();
-        println!("[TRACE] App::run() - cloned config");
         let fc_cache = (*self.ptr.fc_cache).clone();
-        println!("[TRACE] App::run() - cloned fc_cache");
 
         // Use shell2 for the actual run loop
-        println!("[TRACE] App::run() - calling shell2::run");
         let err = crate::desktop::shell2::run(data, config, fc_cache, root_window);
-        println!("[TRACE] App::run() - returned from shell2::run");
 
         if let Err(e) = err {
             crate::desktop::dialogs::msg_box(&format!("Error: {:?}", e));

dll/src/desktop/shell2/run.rs

@@ -10,7 +10,8 @@ use azul_layout::window_state::WindowCreateOptions;
 use rust_fontconfig::FcFontCache;
 
 use super::common::debug_server;
-use crate::{log_debug, log_error, log_info};
+use super::common::debug_server::LogCategory;
+use crate::{log_debug, log_error, log_info, log_trace};
 
 #[cfg(target_os = "macos")]
 use super::macos::MacOSWindow;
@@ -274,52 +275,52 @@ pub fn run(
     fc_cache: Arc<FcFontCache>,
     root_window: WindowCreateOptions,
 ) -> Result<(), WindowError> {
-    println!("[TRACE] shell2::run (Windows) called");
+    log_trace!(LogCategory::Window, "[shell2::run] Windows run() called");
     use std::cell::RefCell;
 
     use azul_core::resources::AppTerminationBehavior;
 
     use super::windows::{dlopen::MSG, registry, Win32Window};
 
-    println!("[TRACE] shell2::run - imports done");
+    log_trace!(LogCategory::Window, "[shell2::run] imports done");
     // Wrap app_data in Arc<RefCell<>> for shared access
-    println!("[TRACE] shell2::run - wrapping app_data in Arc<RefCell<>>");
+    log_trace!(LogCategory::Window, "[shell2::run] wrapping app_data in Arc<RefCell<>>");
     let app_data_arc = Arc::new(RefCell::new(app_data));
-    println!("[TRACE] shell2::run - app_data wrapped");
+    log_trace!(LogCategory::Window, "[shell2::run] app_data wrapped");
 
     // Create the root window
-    println!("[TRACE] shell2::run - calling Win32Window::new");
+    log_trace!(LogCategory::Window, "[shell2::run] calling Win32Window::new");
     let window = Win32Window::new(root_window, fc_cache.clone(), app_data_arc.clone())?;
-    println!("[TRACE] shell2::run - Win32Window::new returned successfully");
+    log_trace!(LogCategory::Window, "[shell2::run] Win32Window::new returned successfully");
 
     // Store the window pointer in the user data field for the window procedure
     // and register in global registry for multi-window support
     // SAFETY: We are boxing the window and then leaking it. This is necessary
     // so that the pointer remains valid for the lifetime of the window.
-    println!("[TRACE] shell2::run - boxing window");
+    log_trace!(LogCategory::Window, "[shell2::run] boxing window");
     let window_ptr = Box::into_raw(Box::new(window));
-    println!("[TRACE] shell2::run - getting hwnd");
+    log_trace!(LogCategory::Window, "[shell2::run] getting hwnd");
     let hwnd = unsafe { (*window_ptr).hwnd };
-    println!("[TRACE] shell2::run - got hwnd: {:?}", hwnd);
+    log_trace!(LogCategory::Window, "[shell2::run] got hwnd: {:?}", hwnd);
 
     unsafe {
         use super::windows::dlopen::constants::GWLP_USERDATA;
-        println!("[TRACE] shell2::run - calling SetWindowLongPtrW");
+        log_trace!(LogCategory::Window, "[shell2::run] calling SetWindowLongPtrW");
         ((*window_ptr).win32.user32.SetWindowLongPtrW)(hwnd, GWLP_USERDATA, window_ptr as isize);
-        println!("[TRACE] shell2::run - SetWindowLongPtrW done");
+        log_trace!(LogCategory::Window, "[shell2::run] SetWindowLongPtrW done");
 
         // Register in global window registry
-        println!("[TRACE] shell2::run - registering window in global registry");
+        log_trace!(LogCategory::Window, "[shell2::run] registering window in global registry");
         registry::register_window(hwnd, window_ptr);
-        println!("[TRACE] shell2::run - window registered");
+        log_trace!(LogCategory::Window, "[shell2::run] window registered");
 
         // NOTE: Window is NOT shown here! It will be shown automatically by
         // render_and_present() after the first SwapBuffers completes.
         // This ensures the window appears with content, not a black/white flash.
-        println!("[TRACE] shell2::run - window will be shown after first frame renders");
+        log_trace!(LogCategory::Window, "[shell2::run] window will be shown after first frame renders");
     }
 
-    println!("[TRACE] shell2::run - entering main event loop");
+    log_trace!(LogCategory::Window, "[shell2::run] entering main event loop");
     // Main event loop with multi-window support and V2 state diffing
     // Uses WaitMessage() to block efficiently when idle (no busy-waiting)
     // Architecture:

dll/src/desktop/shell2/windows/mod.rs

@@ -193,33 +193,33 @@ impl Win32Window {
         macro_rules! timing_log {
             ($step:expr) => {{
                 let elapsed = step_start.elapsed();
-                println!("[TIMING] {} took {:?}", $step, elapsed);
+                log_debug!(LogCategory::Window, "[Win32] {} took {:?}", $step, elapsed);
                 step_start = std::time::Instant::now();
             }};
         }
 
-        println!("[TRACE] Win32Window::new() called");
+        log_trace!(LogCategory::Window, "[Win32] Win32Window::new() called");
         // Load Win32 libraries
         let win32 = dlopen::Win32Libraries::load().map_err(|e| {
-            eprintln!("[ERROR] Failed to load Win32 libraries: {}", e);
+            log_error!(LogCategory::Platform, "[Win32] Failed to load Win32 libraries: {}", e);
             WindowError::PlatformError(format!("Failed to load Win32 libraries: {}", e))
         })?;
         timing_log!("Load Win32 libraries");
 
         // Get HINSTANCE from GetModuleHandleW(NULL)
-        println!("[TRACE] Win32Window::new() - getting HINSTANCE");
+        log_trace!(LogCategory::Window, "[Win32] getting HINSTANCE");
         let hinstance = if let Some(ref k32) = win32.kernel32 {
             unsafe { (k32.GetModuleHandleW)(ptr::null()) }
         } else {
-            eprintln!("[ERROR] kernel32.dll not available");
+            log_error!(LogCategory::Platform, "[Win32] kernel32.dll not available");
             return Err(WindowError::PlatformError(
                 "kernel32.dll not available".into(),
             ));
         };
         timing_log!("Get HINSTANCE");
 
         if hinstance.is_null() {
-            eprintln!("[ERROR] Failed to get HINSTANCE");
+            log_error!(LogCategory::Platform, "[Win32] Failed to get HINSTANCE");
             return Err(WindowError::PlatformError("Failed to get HINSTANCE".into()));
         }
 
@@ -276,7 +276,7 @@ impl Win32Window {
                     gl_context = Some(hglrc);
                     let hdc = unsafe { (win32.user32.GetDC)(hwnd) };
                     if !hdc.is_null() {
-                        println!("[TRACE] Win32Window::new() - activating GL context for WebRender init");
+                        log_trace!(LogCategory::Rendering, "[Win32] activating GL context for WebRender init");
                         #[cfg(target_os = "windows")]
                         unsafe {
                             use winapi::um::wingdi::wglMakeCurrent;
@@ -299,7 +299,7 @@ impl Win32Window {
                 }
                 Err(e) => {
                     // Fall back to software rendering
-                    eprintln!("[WARN] GL context creation failed: {:?}, falling back to software", e);
+                    log_warn!(LogCategory::Rendering, "[Win32] GL context creation failed: {:?}, falling back to software", e);
                     gl_context_ptr = OptionGlContextPtr::None;
                 }
             }
@@ -416,7 +416,7 @@ impl Win32Window {
         // We'll show the window AFTER a11y is set up.
         let should_show_window = layout_window.current_window_state.flags.is_visible;
         let window_frame = layout_window.current_window_state.flags.frame;
-        println!("[TRACE] Win32Window::new() - deferring show_window until after a11y init (is_visible: {})", should_show_window);
+        log_trace!(LogCategory::Window, "[Win32] deferring show_window until after a11y init (is_visible: {})", should_show_window);
 
         // Position window on requested monitor (or center on primary)
         // This can be done before showing
@@ -488,7 +488,7 @@ impl Win32Window {
         {
             if let Err(e) = result.accessibility_adapter.initialize(hwnd) {
                 // Don't fail window creation if a11y fails, just log and continue
-                eprintln!("[WARN] a11y adapter init failed: {}, continuing without a11y", e);
+                log_warn!(LogCategory::Platform, "[Win32] a11y adapter init failed: {}, continuing without a11y", e);
             }
         }
         timing_log!("Initialize accessibility adapter");
@@ -572,7 +572,7 @@ impl Win32Window {
         }
         timing_log!("Final setup (callback + debug timer)");
 
-        println!("[TIMING] ===== TOTAL Win32Window::new() took {:?} =====", total_start.elapsed());
+        log_debug!(LogCategory::Window, "[Win32] ===== TOTAL Win32Window::new() took {:?} =====", total_start.elapsed());
         Ok(result)
     }
 
@@ -687,19 +687,19 @@ impl Win32Window {
             if !self.first_frame_shown {
                 // Check if user wants the window visible
                 if self.current_window_state.flags.is_visible {
-                    println!("[TRACE] First frame rendered + SwapBuffers done - showing window NOW");
+                    log_trace!(LogCategory::Rendering, "[Win32] First frame rendered + SwapBuffers done - showing window NOW");
 
                     // Force DWM to latch the new frame buffer before making the window visible.
                     // This prevents the "Black Frame" flash by blocking until DWM composition is done.
                     if let Some(ref dwmapi) = self.win32.dwmapi_funcs {
                         (dwmapi.DwmFlush)();
-                        println!("[TRACE] DwmFlush completed");
+                        log_trace!(LogCategory::Rendering, "[Win32] DwmFlush completed");
                     }
 
                     use dlopen::constants::SW_SHOW;
                     (self.win32.user32.ShowWindow)(self.hwnd, SW_SHOW);
                     (self.win32.user32.UpdateWindow)(self.hwnd);
-                    println!("[TRACE] Window shown after first real frame");
+                    log_trace!(LogCategory::Rendering, "[Win32] Window shown after first real frame");
                 }
                 self.first_frame_shown = true;
             }
@@ -1496,57 +1496,23 @@ unsafe extern "system" fn window_proc(
     let window = &mut *window_ptr;
     // Now we can use window.win32 instead of temp_win32 for the rest of the function
 
-    // Debug: Log all WM messages
-    let msg_name = match msg {
-        0x0001 => "WM_CREATE",
-        0x0002 => "WM_DESTROY",
-        0x0005 => "WM_SIZE",
-        0x0007 => "WM_SETFOCUS",
-        0x0008 => "WM_KILLFOCUS",
-        0x000F => "WM_PAINT",
-        0x0010 => "WM_CLOSE",
-        0x0014 => "WM_ERASEBKGND",
-        0x0100 => "WM_KEYDOWN",
-        0x0101 => "WM_KEYUP",
-        0x0102 => "WM_CHAR",
-        0x0104 => "WM_SYSKEYDOWN",
-        0x0105 => "WM_SYSKEYUP",
-        0x0106 => "WM_SYSCHAR",
-        0x0111 => "WM_COMMAND",
-        0x0113 => "WM_TIMER",
-        0x0200 => "WM_MOUSEMOVE",
-        0x0201 => "WM_LBUTTONDOWN",
-        0x0202 => "WM_LBUTTONUP",
-        0x0204 => "WM_RBUTTONDOWN",
-        0x0205 => "WM_RBUTTONUP",
-        0x0207 => "WM_MBUTTONDOWN",
-        0x0208 => "WM_MBUTTONUP",
-        0x020A => "WM_MOUSEWHEEL",
-        0x0233 => "WM_DROPFILES",
-        0x02A3 => "WM_MOUSELEAVE",
-        0x02E0 => "WM_DPICHANGED",
-        _ => "OTHER",
-    };
-    println!("[WM] msg=0x{:04X} ({}) wparam={} lparam={}", msg, msg_name, wparam, lparam);
-
     // Handle messages
     match msg {
         WM_CREATE => {
-            println!("[WM_CREATE] Window created");
-            // Window created
+            log_debug!(LogCategory::Window, "[Win32] WM_CREATE - Window created");
             0
         }
 
         WM_DESTROY => {
-            println!("[WM_DESTROY] Window destroyed");
+            log_debug!(LogCategory::Window, "[Win32] WM_DESTROY - Window destroyed");
             // Window destroyed - unregister from global registry
             window.is_open = false;
             registry::unregister_window(hwnd);
             0
         }
 
         WM_CLOSE => {
-            println!("[WM_CLOSE] Close requested");
+            log_debug!(LogCategory::Window, "[Win32] WM_CLOSE - Close requested");
             // User clicked close button - set close_requested flag
             // and process callbacks to allow cancellation
             window.current_window_state.flags.close_requested = true;