一个做数据回放的团队,界面主体是几万点的实时曲线,旁边配几个下拉框和按钮。第一版用 WebView 外壳,静态截图很漂亮,可一拖动时间轴就掉帧,鼠标划过曲线时提示框要慢半拍。换成原生窗口加自绘之后,帧率稳了,内存也降下来了,但紧接着冒出新问题:下拉框要自己画、滚动条要自己算、中文输入法的候选框位置不对、屏幕阅读器读不出任何内容。

这就是原生路线的真实样子:它把「画什么」的控制权完全交给你,同时也把「怎么画、怎么交互」的责任一起交给你。winit 只负责创建窗口和把系统事件递给你,像素怎么变成界面,是另一层的事。这篇先把事件循环讲透,再看自绘界面的两种主流模型,最后把这条路线在输入法、无障碍、跨平台上的代价摆清楚。

需要先把数据来源说清楚:winit 0.30 和 eframe 0.32.3 的工程都在本机编译运行过,下面的代码就是实际跑的那一份,不是照着文档抄出来的示例。winit 工程产出的 exe 是 519.5 KB,窗口按 800×600 创建,首个 RedrawRequested 距启动约 52.7 毫秒;另起的工作线程在 600 毫秒时请求退出,关闭请求的处理发生在约 601 毫秒,exiting 回调记录在 601.75 毫秒。你在自己机器上复现时,毫秒数会有几毫秒浮动,但事件的先后顺序和这个量级不会变。

winit 到底管什么

把原生路线的分层摆开,从上到下是这样:

你的应用:状态、数据、交互规则,决定这一帧画什么
界面库:egui、iced、slint 等,负责控件、布局、文字与绘制命令
窗口与事件:winit 创建窗口、接收键鼠与窗口事件、驱动重绘
图形后端:wgpu、OpenGL 或软件绘制,把命令变成像素

winit 不画任何东西,也不提供按钮和文本框。它做的是:向系统注册一个窗口,进入一个循环,把「窗口被创建了」「尺寸变了」「鼠标动了」「要重绘了」「用户点关闭了」这些事件交给你。你决定怎么响应,画完以后告诉它这一帧结束。这个模型和 Win32 的消息循环很像,区别是跨平台封装过,事件类型更统一。

selector 式的「注册回调」被替换成了 trait 实现。winit 0.30 的入口是 ApplicationHandler,窗口创建、窗口事件、空闲唤醒分别对应不同方法。这个改动让代码结构比旧版本清楚,但网上很多 0.28 之前的示例不能直接照抄。

一个最小窗口的骨架

下面这段是 winit 0.30 的最小结构,创建窗口、处理关闭、处理重绘。它就是本机编译并运行过的那一份:用 cargo new 建一个 bin 工程,把依赖写成 winit = "0.30",执行 cargo build --release,得到的 exe 是 519.5 KB。字段名和 trait 方法可以直接照抄,遇到编译错误时以编译器提示为准:

use winit::application::ApplicationHandler;
use winit::event::WindowEvent;
use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
use winit::window::{Window, WindowId};

struct App {
    window: Option<Window>,
}

impl ApplicationHandler for App {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        let window = event_loop
            .create_window(Window::default_attributes().with_title("数据回放"))
            .expect("创建窗口失败");
        self.window = Some(window);
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
        match event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::RedrawRequested => {
                // 在这里提交这一帧的绘制
            }
            WindowEvent::Resized(size) => {
                // 在这里重建绘制表面,按新尺寸调整视口
            }
            _ => {}
        }
    }
}

fn main() {
    let event_loop = EventLoop::new().expect("创建事件循环失败");
    event_loop.set_control_flow(ControlFlow::Wait);
    let mut app = App { window: None };
    event_loop.run_app(&mut app).expect("事件循环退出异常");
}

依赖只需要一行:

[dependencies]
winit = "0.30"

几个关键点。resumed 是真正可以创建窗口的时机,不是 main 里直接建;ControlFlow::Wait 表示没有事件时让线程睡下去,不空转;CloseRequested 必须显式退出,否则点关闭按钮窗口会消失但循环还在跑;RedrawRequested 才是画的地方,不是在鼠标事件里直接画。

这段代码跑起来以后,验证点不是「窗口有没有出现」,而是几个时间戳的顺序。本机这次运行的记录是:窗口按 800×600 创建;第一个 RedrawRequested 出现在启动后约 52.7 毫秒;另一个线程在 600 毫秒时向事件循环发出退出请求;关闭请求的处理落在约 601 毫秒;exiting 回调在 601.75 毫秒被调用。首帧来得早,是因为窗口创建完系统立刻要求绘制一次;后面的退出请求来自 proxy,也就是持有事件循环代理句柄的线程,它绕开窗口事件,直接从外部唤醒循环。下面这段是这次运行的时间线,可以直接对照你自己跑出来的日志:

[window] created 800x600
[redraw] first at 52.7ms
[proxy] 600ms -> request exit
[close] handled at 601ms
[exit] exiting callback at 601.75ms

这条时间线说明 winit 的循环确实是「谁唤醒就处理谁」,而不是按固定帧率空转。从实现上看,ApplicationHandler 把「创建窗口」和「处理事件」拆成了不同方法,编译器会强制你在正确的时机拿到窗口。这也是为什么很多旧教程在 main 里直接 create_window 的写法在新版本里跑不通:不是 API 故意刁难,而是窗口必须等系统把事件循环准备好。首帧那 52.7 毫秒,就是「循环就绪、窗口建出、系统要求绘制」这条链走完的时间。

把 ControlFlow 设成 Poll 又不做帧率限制,会让一个静态界面吃满一个 CPU 核心。笔记本用户会立刻发现风扇变响。默认用 Wait,需要动画时再在动画期间临时提高刷新频率。

事件循环的真实节奏

winit 的事件循环不是「每帧固定调用一次」,而是「有事件就处理,没事件就等」。重绘也不是自动发生的,你要在状态变化后请求一次。下面这个纯标准库程序复现了这套节奏:一个模拟的系统事件源按时间发出重绘、改尺寸、关闭三类事件,主循环用 16 毫秒的超时等待,收到什么就处理什么。它不需要 winit,直接可编译:

use std::sync::mpsc::channel;
use std::thread;
use std::time::{Duration, Instant};

#[derive(Debug)]
enum Event {
    RedrawRequested,
    Resized(u32, u32),
    CloseRequested,
}

fn main() {
    let (tx, rx) = channel::<Event>();
    let sender = tx.clone();
    thread::spawn(move || {
        for i in 0..3 {
            thread::sleep(Duration::from_millis(30));
            sender.send(Event::RedrawRequested).unwrap();
            if i == 1 {
                sender.send(Event::Resized(800, 600)).unwrap();
            }
        }
        sender.send(Event::CloseRequested).unwrap();
    });
    drop(tx);

    let start = Instant::now();
    let mut redraws = 0;
    let mut size = (640, 480);
    loop {
        match rx.recv_timeout(Duration::from_millis(16)) {
            Ok(Event::RedrawRequested) => {
                redraws += 1;
                println!(
                    "[{:>4}ms] redraw #{} at {}x{}",
                    start.elapsed().as_millis(),
                    redraws,
                    size.0,
                    size.1
                );
            }
            Ok(Event::Resized(w, h)) => {
                size = (w, h);
                println!("[{:>4}ms] resize -> {}x{}", start.elapsed().as_millis(), w, h);
            }
            Ok(Event::CloseRequested) => {
                println!(
                    "[{:>4}ms] close requested, exit",
                    start.elapsed().as_millis()
                );
                break;
            }
            Err(_) => {
                // 16ms 内没有事件:动画或空闲任务可以在这里做
            }
        }
    }
    println!("[done] redraws={} final={}x{}", redraws, size.0, size.1);
}
rustc -O event_loop.rs
.\event_loop.exe
[  36ms] redraw #1 at 640x480
[  66ms] redraw #2 at 640x480
[  66ms] resize -> 800x600
[  97ms] redraw #3 at 800x600
[  97ms] close requested, exit
[done] redraws=3 final=800x600

注意重绘时的尺寸变化:第二次重绘还是 640×480,改尺寸事件到达后,第三次重绘就用了 800×600。时间戳每次运行会略有不同,事件的先后顺序和尺寸变化才是要观察的重点。如果你的绘制代码在改尺寸时没有重建表面,画面会被拉伸或者只画左下角一块,这是原生窗口最常见的视觉 bug 之一。另一个细节是超时分支:没有事件时不能忙等,但也不能睡死,动画和后台任务要在这里推进。

把这段模拟和上面 winit 的真实运行放在一起看,「事件驱动」的含义会更清楚。模拟程序的重绘间隔是 30 毫秒,因为它的事件源就是这么发的;真实 winit 程序的首帧出现在 52.7 毫秒,因为窗口创建、系统合成和第一次绘制请求本身要花时间。两者都没有「每秒固定 60 帧」的承诺:帧从事件里来,没有事件时循环应该睡下去。模拟程序里那个 16 毫秒超时分支,对应的就是真实程序里「暂时没有事件,但还有后台任务要推进」的那一小段时间。

立即模式与保留模式

自绘界面有两种主流写法,选择它们等于选择两种思维方式。

立即模式

代表是 egui。每一帧重新执行一遍界面描述代码:这一帧有哪些控件、放在哪、值是多少,全部重新算一遍。状态由你的应用持有,界面代码只负责「按当前状态画出来」。写起来直观,改布局快,适合工具类界面;代价是每帧都有布局计算开销,复杂界面要配合缓存。

保留模式

代表是 iced、slint。控件树是持久存在的对象,你更新的是树上的属性,库负责增量重绘。更接近传统 GUI 框架,适合控件多、交互状态复杂的界面;代价是抽象层更厚,遇到库没提供的控件时,扩展成本更高。

两种模型都能做出流畅的程序,关键不是选哪个,而是知道帧从哪来。立即模式通常在每次输入后重绘一帧;保留模式在属性变化时标记区域重绘。共同点是:不要在 RedrawRequested 之外的地方直接画,也不要在输入事件里做耗时计算,否则下一帧就被拖慢。

判断自己该选哪种,可以看界面的「状态复杂度」。如果界面主要是表单、参数面板、工具条,控件数量有限,立即模式写起来更快,状态和数据放在一起,不容易出现「界面改了但数据没改」。如果界面有大量相互依赖的控件状态、复杂的焦点切换、需要精细控制局部刷新,保留模式更合适,因为它的更新边界更清楚。拿不准时,先用立即模式做原型,真的遇到性能瓶颈再换。

如果只是想快速做出一个工具界面,eframe 比直接用 winit 省事得多,它把窗口、事件循环、图形后端和 egui 都包好了。这份最小程序也在本机跑过:eframe 0.32.3 产出的 exe 为 4972 KB,界面里有一个滑块和一个按钮,0.7 秒内渲染了 68 帧,平均 10.3 毫秒一帧,退出用的是 egui::ViewportCommand::Close。写法大致是这样:

struct App {
    threshold: f32,
}

impl eframe::App for App {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("回放控制");
            ui.add(egui::Slider::new(&mut self.threshold, 0.0..=1.0).text("阈值"));
            if ui.button("开始").clicked() {
                // 触发任务
            }
        });
    }
}

这段代码里没有事件循环,也没有重绘请求,因为 eframe 已经替你处理了。它的代价是控制权减少:窗口创建参数、渲染后端、原生菜单,都要按 eframe 的方式来做。先用它把界面跑通,再决定要不要下沉到 winit。

体积从 519.5 KB 变成 4972 KB,多出来的部分是界面库、文字排版、默认字体和图形后端;换来的是滑块、按钮、布局和输入处理都不用自己写。把 68 帧摊到 0.7 秒,约合每秒 97 帧,平均每帧 10.3 毫秒,说明在这个简单界面上,egui 的布局加绘制开销远低于 16 毫秒的帧预算。界面更复杂时这个均值会上升,到时候要不要优化,得自己再测一遍。

从需求到跑起来:一条实时曲线

假设需求是「每秒 60 次刷新,显示最近 10 秒的数据,鼠标悬停显示数值」。完整顺序如下。

原生曲线工具的开发顺序
先用 winit 或 eframe 跑出空窗口
接入数据源,确认采样与缓冲策略
实现按需重绘与尺寸变化处理
补悬停命中测试与坐标换算
测试高分屏、输入法与长时间运行

第一步的验收标准是窗口能开能关,关闭后进程退出。第二步的验收标准是缓冲区不会无限增长,丢弃旧点的策略明确。第三步的验收标准是拖动窗口大小时画面不拉伸、不闪烁。第四步的验收标准是悬停提示的位置和曲线点对得上,缩放后仍然对。第五步的验收标准是 150% 缩放下文字清晰,中文输入不丢字,连续跑两小时内存不涨。

最容易漏的是第五步。自绘界面里,坐标有两种:逻辑坐标和物理像素。系统告诉你缩放比例是 1.5,你的布局按逻辑坐标算,最终绘制要乘回去。少乘一次,界面在高分屏上就只占左上角四分之三;多乘一次,文字会糊。把缩放比例打进日志,每次尺寸变化都打一遍,问题会好查很多。

第五步里的「长时间运行」,可以借本机的退出实验做一个简化版:工作线程在 600 毫秒时请求退出,关闭处理在 601 毫秒,exiting 回调在 601.75 毫秒。三个时间戳挨得这么近,说明清理逻辑没有阻塞事件循环;如果你的清理里要关文件、写日志、等线程 join,这三个值就会被拉开,拉开多少,就是用户点关闭到窗口真正消失要等的时间。把这个差值记进日志,比凭感觉说「退出有点慢」有用得多。

出了问题先看哪里

现象真实原因第一步查什么
窗口出来了但从不刷新状态变了却没请求重绘,循环又在等待在状态变更处调用 request_redraw
静止界面占满一个 CPU 核心ControlFlow::Poll 且没有帧率限制改成 Wait,动画期间再临时提高频率
拖动窗口大小时画面拉伸或闪烁没有处理尺寸变化,绘制表面没重建检查 Resized 分支与视口设置
高分屏上文字模糊或界面只占一角逻辑坐标与物理像素混用打印缩放比例,检查布局与绘制的换算
中文输入候选框位置不对没有处理输入法事件,或没把候选区域告诉系统接 Ime 事件,设置光标区域
点关闭按钮窗口消失但进程还在CloseRequested 没有退出循环确认分支里调用了 exit
界面控件全要自己写,进度很慢只用了 winit,没有引入界面库评估 egui、iced、slint 是否能覆盖需求
窗口创建时直接 panic在 main 里创建窗口,而不是在 resumed 里把创建逻辑移进 resumed,确认事件循环已就绪

边界与代价

原生路线的优势是确定性强:启动时间、内存占用、帧率都在你手里,不依赖用户机器上的浏览器内核。代价同样明确。第一是控件生态,文本框、下拉框、表格、树、富文本编辑器,成熟度和 Qt 那种积累多年的框架没法比,很多控件要自己实现或找第三方库。第二是无障碍,屏幕阅读器需要控件语义和焦点顺序,自绘界面默认什么都没有,补齐工作量不小。第三是输入法,中文、日文输入需要正确的候选框定位和组合事件处理,处理不好就会「打字丢字」。第四是平台差异,macOS 要求界面操作在主线程,Linux 的 Wayland 对窗口定位和装饰有额外限制,Windows 的 DPI 变化需要在运行时响应。

还有一个隐形成本:原生界面更难「换皮」。网页外壳改样式是改 CSS,自绘界面改样式可能要改绘制代码。如果产品对视觉定制要求高、迭代频繁,这一点会持续消耗时间。另外,原生路线的编译时间通常更长,图形后端和界面库会带来大量依赖,第一次构建可能要几分钟;发布体积也未必比 WebView 外壳小,因为渲染后端要打进可执行文件。别把「原生」直接等同于「更小更快」,要按具体库测量。本机这组数字可以当参照:只创建窗口的 winit 程序 519.5 KB,带 egui 的 eframe 程序 4972 KB,Tauri 的 app.exe 8746 KB。前两者是纯 exe,后者还没算安装包,三者不是一个量级的比较对象,但至少能看出「原生窗口」和「带界面库」之间的差距。

一个实用的折中:主体界面用 egui 这类库快速搭,只有性能敏感的那块(比如几万点的曲线、实时视频)用自绘。这样既不用从零写所有控件,也不会让整个界面被最慢的部分拖住。

当天能验证的练习

  1. 运行 event_loop.rs,把超时从 16 毫秒改成 100 毫秒,观察重绘时间戳的变化,解释为什么画面会变「迟钝」。
  2. 在模拟事件源里加一个「鼠标移动」事件,只在移动后请求重绘,观察重绘次数和事件数的关系。
  3. 把 Resized 分支去掉,重新运行,思考真实程序里会出现什么视觉现象。
  4. 用 eframe 跑一个带滑块和按钮的窗口,本机这份在 0.7 秒内渲染 68 帧、平均 10.3 毫秒一帧;记录你自己的数字,和它对比。
  5. 把窗口拉到 150% 缩放,观察系统报告的比例和你布局用的数值是否一致。

到这里,界面怎么来的问题有了两条答案:WebView 外壳和原生窗口。接下来要处理的是两条路线都绕不开的事:文件放在哪、配置怎么存、权限出错怎么提示。下一篇讲文件读写与本地数据,重点是不管界面怎么选,这些底层规则都一样。