Tauri Window Utilities Crate

A cross-platform window manager crate for Tauri applications that provides workspace management, window tiling, and layout control.

Features

🖥️ Real System Window Control: Actually move, resize, minimize, maximize, and close system windows
🌍 Cross-platform: Works on Windows, macOS, and Linux
🏢 Workspace Management: Multiple workspaces with different layouts
📐 Layout Modes: Tiling, Floating, and Monocle layouts
⚙️ Configurable: Customizable gaps, borders, and behavior
🎯 Easy Integration: Simple plugin system for Tauri apps

Installation

Add this to your Cargo.toml:

[dependencies]

tauri-winutils-crate = "0.1.0"

Quick Start

1. Add to your Tauri app

use tauri_winutils_crate;

fn main() {
    tauri::Builder::default()
        .plugin(tauri_winutils_crate::init_window_manager())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

2. Use the convenience macro (alternative)

use tauri_winutils_crate::setup_window_manager;

fn main() {
    let app = tauri::Builder::default();
    
    setup_window_manager!(app)
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

3. Frontend Integration

import { invoke } from '@tauri-apps/api/tauri';

// Get all system windows
const systemWindows = await invoke('get_system_windows');

// Move a window
await invoke('move_system_window', { handle: windowHandle, x: 100, y: 100 });

// Resize a window
await invoke('resize_system_window', { handle: windowHandle, width: 800, height: 600 });

// Minimize/maximize/restore
await invoke('minimize_system_window', { handle: windowHandle });
await invoke('maximize_system_window', { handle: windowHandle });
await invoke('restore_system_window', { handle: windowHandle });

// Close a window
await invoke('close_system_window', { handle: windowHandle });

// Focus a window
await invoke('focus_system_window', { handle: windowHandle });

// Arrange multiple windows in a tiling layout
await invoke('arrange_system_windows', { windowHandles: [handle1, handle2, handle3] });

// Create a new workspace
const workspaceId = await invoke('create_workspace', {
    name: 'Development',
    layout: 'tiling'
});

// Switch to a workspace
await invoke('switch_workspace', { workspaceId });

// Add a window to management
const windowId = await invoke('add_window_to_manager', {
    title: 'My App',
    app_name: 'my-app'
});

// Arrange windows in current workspace
await invoke('arrange_windows', { workspaceId });

Available Commands

Window Management

get_system_windows() - Get all system windows
move_system_window(handle, x, y) - Move a window
resize_system_window(handle, width, height) - Resize a window
set_system_window_bounds(handle, x, y, width, height) - Set position and size
minimize_system_window(handle) - Minimize a window
maximize_system_window(handle) - Maximize a window
restore_system_window(handle) - Restore a window
close_system_window(handle) - Close a window
focus_system_window(handle) - Focus a window
hide_system_window(handle) - Hide a window
show_system_window(handle) - Show a window
arrange_system_windows(handles) - Arrange multiple windows in a tiling layout

Virtual Window Management (for internal app windows)

add_window_to_manager(title, app_name) - Add a window to management
remove_window_from_manager(window_id) - Remove a window
close_window(window_id) - Close a window
minimize_window(window_id) - Minimize a window
maximize_window(window_id) - Maximize a window
focus_window(window_id) - Focus a window

Workspace Management

get_workspaces() - Get all workspaces
create_workspace(name, layout) - Create a new workspace
switch_workspace(workspace_id) - Switch to a workspace
arrange_windows(workspace_id) - Arrange windows in a workspace

Configuration

get_config() - Get current configuration
update_config(config) - Update configuration

Layout Types

Tiling: Automatically arranges system windows in a grid layout
Floating: Windows maintain their positions
Monocle: Full-screen window mode

Configuration Options

use tauri_winutils_crate::Config;

let config = Config {
    window_gap: 10,
    screen_width: 1920,
    screen_height: 1080,
    auto_arrange: true,
    focus_follows_mouse: false,
    border_width: 2,
    border_color_active: "#0066cc".to_string(),
    border_color_inactive: "#666666".to_string(),
    // ... keybindings
};

Advanced Usage

Access Window Manager State

use tauri_winutils_crate::{get_window_manager, WindowManager};

#[tauri::command]
fn my_custom_command(app_handle: tauri::AppHandle) -> Result<Vec<String>, String> {
    if let Some(wm) = get_window_manager(&app_handle) {
        let system_windows = wm.get_system_windows()?;
        let titles: Vec<String> = system_windows.iter().map(|w| w.title.clone()).collect();
        Ok(titles)
    } else {
        Err("Window manager not initialized".to_string())
    }
}

Custom Window Operations

use tauri_winutils_crate::{WindowManager, SystemWindow};

// In your Tauri command
#[tauri::command]
fn tile_all_windows(wm: tauri::State<WindowManager>) -> Result<(), String> {
    let system_windows = wm.get_system_windows()?;
    let handles: Vec<u64> = system_windows.iter().map(|w| w.handle).collect();
    wm.arrange_system_windows(&handles)?;
    Ok(())
}

Examples

See the examples/ directory for complete example applications that demonstrate:

Real system window control
Automatic window tiling
Window management UI
Cross-platform compatibility

License

MIT License - see LICENSE file for details.

tauri-winutils 0.1.2