feat: add 'Hide Status Bar' setting and functionality to manage visibility

Author: murdercode

src-tauri/src/lib.rs

@@ -89,6 +89,8 @@ struct AppSettings {
     analytics_enabled: bool,
     #[serde(default)]
     hide_icon_on_close: bool,
+    #[serde(default)]
+    hide_status_bar: bool,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -177,6 +179,7 @@ impl Default for AppSettings {
             autostart: false,        // default to disabled
             analytics_enabled: true, // default to enabled
             hide_icon_on_close: false, // default to disabled
+            hide_status_bar: false, // default to disabled
         }
     }
 }
@@ -949,7 +952,8 @@ pub fn run() {
                 add_session_tag,
                 write_excel_file,
                 start_oauth_server,
-                set_dock_visibility
+                set_dock_visibility,
+                set_status_bar_visibility
             ])
             .setup(|app| {
                 // Track app started event (if enabled)
@@ -1373,3 +1377,184 @@ fn set_dock_visibility_native(visible: bool) {
         }
     }
 }
+
+// Status bar visibility management using Carbon APIs
+//
+// Implementation Notes:
+// This feature uses Apple's Carbon SetSystemUIMode API, which is a pure C function
+// from the ApplicationServices framework. This approach is much safer than using
+// Objective-C APIs because:
+//
+// 1. No foreign exceptions: C APIs return error codes instead of throwing exceptions
+// 2. Direct system integration: Carbon APIs are lower-level and more stable
+// 3. Robust fallback system: Multiple approaches with retry mechanisms
+// 4. Comprehensive error handling: Detailed OSStatus code interpretation
+//
+// The implementation uses:
+// - Primary: SetSystemUIMode with K_UI_MODE_CONTENT_SUPPRESSED (hides menu bar, keeps dock)
+// - Fallback 1: Retry with delay for transient errors
+// - Fallback 2: Conservative two-step approach for hiding
+// - Detailed error reporting with manual recovery instructions
+#[tauri::command]
+async fn set_status_bar_visibility(_app: AppHandle, visible: bool) -> Result<(), String> {
+    #[cfg(target_os = "macos")]
+    {
+        match set_system_ui_mode_safe(visible) {
+            Ok(_) => {
+                println!("✅ Status bar visibility successfully set to: {}", if visible { "visible" } else { "hidden" });
+                Ok(())
+            },
+            Err(e) => {
+                eprintln!("❌ Failed to set status bar visibility: {}", e);
+                Err(format!("Failed to set status bar visibility: {}", e))
+            }
+        }
+    }
+    
+    #[cfg(not(target_os = "macos"))]
+    {
+        return Err("Status bar visibility is only supported on macOS".to_string());
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn set_system_ui_mode_safe(visible: bool) -> Result<(), String> {
+    use libc::{c_int, c_uint};
+    use std::thread;
+    use std::time::Duration;
+    
+    // Carbon SetSystemUIMode constants
+    const K_UI_MODE_NORMAL: c_uint = 0;              // Normal mode - menu bar visible
+    const K_UI_MODE_CONTENT_SUPPRESSED: c_uint = 1;  // Menu bar hidden, dock visible
+    #[allow(dead_code)]
+    const K_UI_MODE_CONTENT_HIDDEN: c_uint = 2;      // Menu bar hidden, dock auto-hide
+    #[allow(dead_code)]
+    const K_UI_MODE_ALL_HIDDEN: c_uint = 3;          // Everything hidden
+    
+    // OSStatus codes
+    const NO_ERR: c_int = 0;
+    const PARAM_ERR: c_int = -50;
+    const MEM_FULL_ERR: c_int = -108;
+    
+    // SystemUIMode and SystemUIOptions are both UInt32 (c_uint)
+    type SystemUIMode = c_uint;
+    type SystemUIOptions = c_uint;
+    type OSStatus = c_int;
+    
+    // External declaration for Carbon SetSystemUIMode function
+    // This is a C function from ApplicationServices framework
+    extern "C" {
+        fn SetSystemUIMode(inMode: SystemUIMode, inOptions: SystemUIOptions) -> OSStatus;
+    }
+    
+    // Try the primary approach with Carbon SetSystemUIMode
+    let primary_result = unsafe {
+        let mode = if visible {
+            K_UI_MODE_NORMAL  // Show menu bar
+        } else {
+            K_UI_MODE_CONTENT_SUPPRESSED  // Hide menu bar but keep dock visible
+        };
+        
+        let options: SystemUIOptions = 0;  // No special options
+        
+        println!("🔧 Carbon API: Setting SystemUIMode to {} ({})", 
+                mode, if visible { "normal/visible" } else { "content suppressed/hidden" });
+        
+        // Call the Carbon function - this is a pure C API call
+        let result: OSStatus = SetSystemUIMode(mode, options);
+        
+        if result == NO_ERR {
+            println!("✅ Carbon API: SetSystemUIMode succeeded");
+            Ok(())
+        } else {
+            let error_msg = format!("Carbon API failed with OSStatus: {} ({})", 
+                                  result, get_osstatus_description(result));
+            eprintln!("❌ Carbon API: {}", error_msg);
+            Err((result, error_msg))
+        }
+    };
+    
+    // If primary approach succeeded, return success
+    if primary_result.is_ok() {
+        return Ok(());
+    }
+    
+    // If primary approach failed, try fallback methods
+    let (status_code, error_msg) = primary_result.unwrap_err();
+    
+    eprintln!("🔄 Primary method failed, attempting fallback approaches...");
+    
+    // Fallback 1: Try with a small delay and retry
+    if status_code == PARAM_ERR || status_code == MEM_FULL_ERR {
+        println!("🔄 Fallback 1: Retrying after brief delay...");
+        thread::sleep(Duration::from_millis(100));
+        
+        let retry_result = unsafe {
+            let mode = if visible { K_UI_MODE_NORMAL } else { K_UI_MODE_CONTENT_SUPPRESSED };
+            let result: OSStatus = SetSystemUIMode(mode, 0);
+            
+            if result == NO_ERR {
+                println!("✅ Fallback 1: Retry succeeded");
+                Ok(())
+            } else {
+                Err(format!("Retry failed with OSStatus: {}", result))
+            }
+        };
+        
+        if retry_result.is_ok() {
+            return Ok(());
+        }
+    }
+    
+    // Fallback 2: For hiding, try a more conservative approach
+    if !visible {
+        println!("🔄 Fallback 2: Trying conservative hide approach...");
+        
+        let conservative_result = unsafe {
+            // Try normal mode first, then content suppressed
+            SetSystemUIMode(K_UI_MODE_NORMAL, 0);
+            thread::sleep(Duration::from_millis(50));
+            let result: OSStatus = SetSystemUIMode(K_UI_MODE_CONTENT_SUPPRESSED, 0);
+            
+            if result == NO_ERR {
+                println!("✅ Fallback 2: Conservative approach succeeded");
+                Ok(())
+            } else {
+                Err(format!("Conservative approach failed with OSStatus: {}", result))
+            }
+        };
+        
+        if conservative_result.is_ok() {
+            return Ok(());
+        }
+    }
+    
+    // All methods failed - provide detailed error information
+    let detailed_error = format!(
+        "All status bar visibility methods failed. Primary error: {}. \
+         This might be due to system restrictions or macOS version compatibility. \
+         You can manually hide the menu bar using System Preferences > Dock & Menu Bar > 'Automatically hide and show the menu bar'.",
+        error_msg
+    );
+    
+    eprintln!("❌ {}", detailed_error);
+    Err(detailed_error)
+}
+
+#[cfg(target_os = "macos")]
+fn get_osstatus_description(status: libc::c_int) -> &'static str {
+    match status {
+        0 => "No error - Success",
+        -50 => "Parameter error - Invalid parameters passed to function",
+        -108 => "Memory full error - Insufficient memory available", 
+        -25291 => "Invalid system UI mode - The specified UI mode is not valid",
+        -25292 => "Operation not supported in current mode - Cannot change UI mode in current state",
+        -25293 => "System UI server not available - UI server is not responding",
+        -25294 => "System UI mode locked - UI mode changes are currently locked",
+        -128 => "User canceled - Operation was canceled by user",
+        -43 => "File not found - Required system component not found",
+        -5000 => "System policy error - Operation blocked by system policy",
+        -1 => "General error - Unspecified error occurred",
+        _ => "Unknown error - Undocumented error code"
+    }
+}

src/core/pomodoro-timer.js

@@ -2380,9 +2380,15 @@ export class PomodoroTimer {
             const overtimePrefix = isOvertime ? '+' : '';
             const fullTimerText = `${overtimePrefix}${timerText}`;
 
-            // Add session counter to timer text
+            // Show real timer but add invisible padding characters to maintain fixed width
             const sessionCounter = `(${this.completedPomodoros}/${this.totalSessions})`;
-            const completeTimerText = `${fullTimerText} ${sessionCounter}`;
+            const realText = `${fullTimerText} ${sessionCounter}`;
+            
+            // Add invisible characters (zero-width spaces) to pad to maximum possible length
+            // Maximum length would be: "+99:99 (99/99)" = 14 characters
+            const maxLength = 14;
+            const padding = '\u200B'.repeat(maxLength - realText.length); // zero-width space
+            const completeTimerText = realText + padding;
 
             // Define icons for different modes
             const modeIcons = {

src/index.html

@@ -806,6 +806,15 @@ <h3>System Integration</h3>
                 </label>
                 <p class="setting-description">Hide the app icon from the dock when closing the window with X. The app will continue running in the system tray.</p>
               </div>
+
+              <div class="setting-item">
+                <label class="checkbox-label">
+                  <input type="checkbox" id="hide-status-bar">
+                  <span class="checkmark"></span>
+                  Hide Status Bar
+                </label>
+                <p class="setting-description">Hide the status bar at the top of the screen when the app is focused. The status bar will be restored when switching to other apps.</p>
+              </div>
             </div>
 
             <div class="settings-section">

src/managers/settings-manager.js

@@ -84,7 +84,8 @@ export class SettingsManager {
             advanced: { ...defaultSettings.advanced, ...loadedSettings.advanced },
             autostart: loadedSettings.autostart !== undefined ? loadedSettings.autostart : defaultSettings.autostart,
             analytics_enabled: loadedSettings.analytics_enabled !== undefined ? loadedSettings.analytics_enabled : defaultSettings.analytics_enabled,
-            hide_icon_on_close: loadedSettings.hide_icon_on_close !== undefined ? loadedSettings.hide_icon_on_close : defaultSettings.hide_icon_on_close
+            hide_icon_on_close: loadedSettings.hide_icon_on_close !== undefined ? loadedSettings.hide_icon_on_close : defaultSettings.hide_icon_on_close,
+            hide_status_bar: loadedSettings.hide_status_bar !== undefined ? loadedSettings.hide_status_bar : defaultSettings.hide_status_bar
         };
     }
 
@@ -120,7 +121,8 @@ export class SettingsManager {
             },
             autostart: false, // default to disabled
             analytics_enabled: true, // Analytics enabled by default
-            hide_icon_on_close: false // Hide icon on close disabled by default
+            hide_icon_on_close: false, // Hide icon on close disabled by default
+            hide_status_bar: false // Hide status bar disabled by default
         };
     }
 
@@ -203,6 +205,9 @@ export class SettingsManager {
 
         // Populate hide icon on close setting
         this.loadHideIconOnCloseSetting();
+
+        // Populate hide status bar setting
+        this.loadHideStatusBarSetting();
     }
 
     setupEventListeners() {
@@ -921,6 +926,65 @@ export class SettingsManager {
         }
     }
 
+    async loadHideStatusBarSetting() {
+        try {
+            // Get current hide status bar setting from our stored settings
+            const hideStatusBar = this.settings.hide_status_bar;
+
+            const checkbox = document.getElementById('hide-status-bar');
+            if (checkbox) {
+                checkbox.checked = hideStatusBar;
+
+                // Setup event listener for the hide status bar checkbox
+                checkbox.addEventListener('change', async (e) => {
+                    await this.toggleHideStatusBar(e.target.checked);
+                });
+            }
+        } catch (error) {
+            console.error('Failed to load hide status bar setting:', error);
+            // Default to disabled if we can't check the status
+            const checkbox = document.getElementById('hide-status-bar');
+            if (checkbox) {
+                checkbox.checked = false;
+                checkbox.addEventListener('change', async (e) => {
+                    await this.toggleHideStatusBar(e.target.checked);
+                });
+            }
+        }
+    }
+
+    async toggleHideStatusBar(enabled) {
+        try {
+            // Call the Tauri command to update the status bar visibility
+            await invoke('set_status_bar_visibility', { visible: !enabled });
+
+            // Update our settings
+            this.settings.hide_status_bar = enabled;
+
+            // Show user feedback
+            if (enabled) {
+                console.log('Hide status bar enabled');
+                NotificationUtils.showNotificationPing('✓ Status bar hidden - Will hide when app is focused', 'success');
+            } else {
+                console.log('Hide status bar disabled');
+                NotificationUtils.showNotificationPing('✓ Status bar visible - Will show when app is focused', 'success');
+            }
+
+            // Schedule auto-save to persist the setting
+            this.scheduleAutoSave();
+
+        } catch (error) {
+            console.error('Failed to toggle hide status bar:', error);
+            NotificationUtils.showNotificationPing('❌ Failed to toggle status bar visibility: ' + error, 'error');
+
+            // Revert the checkbox state on error
+            const checkbox = document.getElementById('hide-status-bar');
+            if (checkbox) {
+                checkbox.checked = !enabled;
+            }
+        }
+    }
+
     // Theme management functions
     async applyTheme(theme) {
         const html = document.documentElement;

src/utils/theme-loader.js

@@ -39,7 +39,7 @@ class ThemeLoader {
         // that gets updated by the build process or manually maintained
 
         // This could be enhanced to use a build-time script that generates this list
-                                                                                                                                                                                                                                                                                                                                const knownThemes = [
+                                                                                                                                                                                                                                                                                                                                                        const knownThemes = [
             'espresso.css',
             'pipboy.css',
             'pommodore64.css'