Rust Wayland窗口管理库wayland-window使用指南

简介

wayland-window是一个用于Rust的Wayland窗口管理库，它提供了创建和管理Wayland窗口的高级抽象，使开发者能够更简单地构建跨平台的图形界面应用。

该库主要特点：

• 简化Wayland客户端开发流程
• 提供窗口管理的高级抽象
• 支持跨平台图形界面开发
• 与Rust生态系统良好集成

安装

在Cargo.toml中添加依赖：

[dependencies]
wayland-window = "0.30.0"
wayland-client = "0.30.0"

基本使用方法

1. 创建简单窗口

use wayland_client::protocol::wl_surface::WlSurface;
use wayland_client::{Connection, QueueHandle};
use wayland_window::{Window, WindowDecorations, WindowConfig};

fn main() {
    // 建立Wayland连接
    let conn = Connection::connect_to_env().unwrap();
    let display = conn.display();
    
    // 创建事件队列
    let event_queue = conn.new_event_queue();
    let qh = event_queue.handle();
    
    // 窗口配置
    let window_config = WindowConfig {
        title: "Wayland Window Example".to_string(),
        size: (800, 600),
        decorations: WindowDecorations::RequestServer,
        ..Default::default()
    };
    
    // 创建窗口
    let window = Window::new(&display, &qh, window_config).unwrap();
    
    // 获取WlSurface用于绘制
    let surface = window.surface();
    
    // 主事件循环
    loop {
        event_queue.dispatch(None, &mut ()).unwrap();
        
        // 这里可以添加绘制逻辑
        draw_on_surface(&surface);
    }
}

fn draw_on_surface(surface: &WlSurface) {
    // 实现你的绘制逻辑
    // 通常使用wayland-egl或其他图形API
}

2. 处理窗口事件

use wayland_client::protocol::wl_surface::WlSurface;
use wayland_client::{Connection, QueueHandle};
use wayland_window::{Window, WindowDecorations, WindowConfig, WindowHandler};

struct MyWindowHandler;

impl WindowHandler for MyWindowHandler {
    fn configure(
        &mut self,
        conn: &Connection,
        qh: &QueueHandle<Self>,
        window: &Window,
        configure: wayland_window::WindowConfigure,
        _serial: u极,
    ) {
        println!("Window configured: {:?}", configure);
        
        // 处理窗口大小变化等配置事件
        if let Some(size) = configure.new_size {
            println!("New window size: {}x{}", size.0, size.1);
        }
    }
    
    fn close_requested(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _window: &Window) {
        println!("Window close requested");
        // 在这里可以处理关闭逻辑
    }
}

fn main() {
    let conn = Connection::connect_to_env().unwrap();
    let display = conn.display();
    let event_queue = conn.new_event_queue();
    let qh = event_queue.handle();
    
    let window_config = WindowConfig {
        title: "Event Handling Example".to_string(),
        size: (800, 600),
        ..Default::default()
    };
    
    let mut window = Window::new_with_handler(
        &display,
        &qh,
        window_config,
        MyWindowHandler
    ).unwrap();
    
    loop {
        event_queue.dispatch(None, &mut window).unwrap();
    }
}

3. 与EGL集成绘制

use wayland_client::protocol::wl_surface::WlSurface;
use wayland_client::{Connection, QueueHandle};
use wayland_window::{Window, WindowConfig};
use wayland_egl::{WlEglSurface, EGLContext};

fn main() {
    let conn = Connection::connect_to_env().unwrap();
    let display = conn.display();
    let event_queue = conn.new_event_queue();
    let qh = event_queue.handle();
    
    let window_config = WindowConfig {
        title: "EGL Integration Example".to_string(),
        size: (800, 600),
        ..Default::default()
    };
    
    let window = Window::new极display, &qh, window_config).unwrap();
    let surface = window.surface();
    
    // 创建EGL上下文
    let egl = EGLContext::new(&display).unwrap();
    
    // 创建EGL表面
    let egl_surface = WlEglSurface::new(
        surface,
        window.width(),
        window.height(),
        &egl
    ).unwrap();
    
    // 主循环
    loop {
        event_queue.dispatch(None, &mut ()).unwrap();
        
        // 使用EGL进行绘制
        egl.make_current(&egl_surface).unwrap();
        
        // 这里添加OpenGL绘制代码
        unsafe {
            gl::ClearColor(0.2, 0.3, 0.4, 1.0);
            gl::Clear(gl::COLOR_BUFFER_BIT);
        }
        
        egl.swap_buffers(&egl_surface).unwrap();
    }
}

高级功能

1. 多窗口管理

use wayland_client::{Connection, QueueHandle};
use wayland_window::{Window, WindowConfig};

struct AppState {
    windows: Vec<Window>,
}

fn main() {
    let conn = Connection::connect_to_env().unwrap();
    let display = conn.display();
    let event_queue = conn.new_event_queue();
    let qh = event_queue.handle();
    
    let mut app_state = AppState { windows: vec![] };
    
    // 创建多个窗口
    for i in 0..3 {
        let window_config = WindowConfig {
            title: format!("Window {}", i + 1),
            size: (400, 300),
            ..Default::default()
        };
        
        let window = Window::new(&display, &qh, window_config).unwrap();
        app_state.windows.push(window);
    }
    
    loop {
        event_queue.dispatch(None, &mut app_state).unwrap();
    }
}

2. 自定义窗口装饰

use wayland_client::{Connection, QueueHandle};
use wayland_window::{Window, WindowConfig, WindowDecorations};

fn main() {
    let conn = Connection::connect_to_env().unwrap();
    let display = conn.display();
    let event_queue = conn.new_event_queue();
    let qh = event_queue.handle();
    
    // 无装饰窗口
    let no_decorations = WindowConfig {
        title: "No Decorations".to_string(),
        size: (400, 300),
        decorations: WindowDecorations::None,
        ..Default::default()
    };
    
    // 客户端装饰窗口
    let client_decorations = WindowConfig {
        title: "Client Decorations".to_string(),
        size: (400, 300),
        decorations: WindowDecorations::Client,
        ..Default::default()
    };
    
    let _window1 = Window::new(&display, &qh, no_decorations).unwrap();
    let _window2 = Window::new(&display, &qh, client_decorations).unwrap();
    
    loop {
        event_queue.dispatch(None, &mut ()).unwrap();
    }
}

注意事项

1. Wayland环境要求：确保你的系统运行在Wayland会话中
2. 错误处理：生产代码中应妥善处理所有可能的错误
3. 性能考虑：避免在主线程中进行繁重的计算，以免阻塞事件循环
4. 多线程：Wayland客户端API不是线程安全的，所有操作应在主线程进行

总结

wayland-window库为Rust开发者提供了创建和管理Wayland窗口的便捷方式，通过高级抽象简化了Wayland客户端的开发流程。结合其他图形库如wayland-egl或smithay-client-toolkit，可以构建功能丰富的跨平台图形界面应用。

以上示例展示了基本窗口创建、事件处理和EGL集成等核心功能，开发者可以根据需要进一步扩展和定制。