GUI development with Rust and GTK4 阅读笔记
简记
这是我第二次从头开始阅读，有第一次的印象要容易不少。
如果只关心具体的做法，而不思考为什么这样做，以及整体的框架，阅读的过程将会举步维艰。
简略记录 gtk-rs 的书中提到的点。对同一个问题书中所演示了多种处理方法，而且跨度比较大，第一次阅读的时候经常出现忘记之前的内容。
fn signals() -> &'static [Signal] {
static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
SIGNALS.get_or_init(|| {
vec![Signal::builder("max-number-reached")
.param_types([i32::static_type()])
.build()]
})
}
signals:
max-number-reached(i32)
GTK GObject 的缺点
- Reference cycles
- Not thread safe
使用异步块/函数一般是通过 glib::spawn_future_local() spawn.
异步函数之间的通信是使用 async_channel。
有些异步库依赖 tokio runtime 不能直接通过 GLib 的主线程 spawn。 通过这样一个函数返回的 runtime 来 spawn。
use std::sync::OnceLock;
use tokio::runtime::Runtime;
fn runtime() -> &'static Runtime {
static RUNTIME: OnceLock<Runtime> = OnceLock::new();
RUNTIME.get_or_init(|| {
Runtime::new().expect("Setting up tokio runtime needs to succeed.")
})
}
设置(Settings)
GTK 应用的设置是通过一个 .gschema.xml 文件描述。
<?xml version="1.0" encoding="utf-8"?>
<schemalist>
<schema id="org.gtk_rs.Settings1" path="/org/gtk_rs/Settings1/">
<key name="is-switch-enabled" type="b">
<default>false</default>
<summary>Default switch state</summary>
</key>
</schema>
</schemalist>
设置是在应用关闭后再打开，仍然保持关闭前的状态。这个 GSchema xml 需要编译安装。
mkdir -p $HOME/.local/share/glib-2.0/schemas
cp org.gtk_rs.Settings1.gschema.xml $HOME/.local/share/glib-2.0/schemas/
glib-compile-schemas $HOME/.local/share/glib-2.0/schemas/
settings 的状态绑定到 widget，是调用 settings 的 bind() 方法。把某个属性绑定到某一个属性是通过源对象 bind_property() 方法
第8章 Saving Window State 还是使用 GTK 的设置，只不过在 GTK 的对象系统中使用了自己定义的方法（在 Rust 中我分不出哪个是class struct 和 instance struct，不过我知道状态放在 imp.rs，方法一般是 mod.rs ，如果实际写的时候放在一个文件里面就是把 imp.rs 中的内容放到对应的 mod.rs 并且用 mod imp {} 包裹）。
List Widgets
当 ListView 创建 ListItem 的时候会调 factory.connect_setup 注册的回调，
factory.connect_bind 是将 Model 中的数据绑定到单独的 List Item,
绑定数据到 Widget：
- 设置 Widget 的效果
label.set_label(&integer_object.number().to_string()); - 将数据的属性绑定到 Widget 的属性
integer_object
.bind_property("number", &label, "label")
.sync_create()
.build();
- 在
connect_setup里面完成绑定，可以解决上一个解决方案的问题
list_item
.property_expression("item")
.chain_property::<IntegerObject>("number")
.bind(&label, "label", Widget::NONE);
// 拿到 list_item 中的 item (data) 中的 number 属性，绑定到实际的 Widget
Composite Templates
除了直接编写 Rust 代码创造界面，还可以使用 XML 文件描述窗口组件。在 XML 文件里面可以使用直接在 Rust 代码中继承的组件。
如果要手动设置组件中的child的信号处理，需要在 Rust 中声明。
You use it by adding a struct member with the same name as one
idattribute in the template.
#[derive(CompositeTemplate, Default)]
#[template(resource = "/org/gtk_rs/example/window.ui")]
pub struct Window {
#[template_child]
pub button: TemplateChild<CustomButton>,
}
在XML文件中， signal 标签声明组件的信号的处理函数。
fn class_init(klass: &mut Self::Class) {
klass.bind_template();
klass.bind_template_callbacks(); // 使用了 callback 就必须要有这一句
}
<object class="MyGtkAppCustomButton" id="button">
<signal name="clicked" handler="handle_button_clicked"/>
<property name="label">Press me!</property>
<property name="margin-top">12</property>
<property name="margin-bottom">12</property>
<property name="margin-start">12</property>
<property name="margin-end">12</property>
</object>
而具体的回调函数在哪里定义？在 imp （模）块的结构体的 impl 中定义。
#[gtk::template_callbacks]
impl Window {
#[template_callback]
fn handle_button_clicked(button: &CustomButton) {
// Set the label to "Hello World!" after the button has been clicked on
button.set_label("Hello World!");
}
}
In order to access the widget's state we have to add
swapped="true"to thesignaltag.
要访问 XML 中定义 signal 标签的组件的状态，说直白一点，就是回调函数访问 self (ui文件对应的表达状态的结构体，impl Window 的 Window 就是 self)，需要在 XML 中的 signal 中添加 swapped="true"。有了swapped="true" handle_button_clicked() 的第一个参数就可以是 self。
#[gtk::template_callbacks]
impl Window {
#[template_callback]
fn handle_button_clicked(&self, button: &CustomButton) {
let number_increased = self.number.get() + 1;
self.number.set(number_increased);
button.set_label(&number_increased.to_string())
}
}
在 Rust 中移除继承的 GTK widget 中的 Child，通过模板中的回调函数来访问组件中的child，而不在结构体中注册 template_child，。 class_init() 里必须添加 CustomButton::ensure_type();
Actions
app.set_accels_for_action("win.close", &["<Ctrl>W"]); 设置快捷键
创建一个 Action 不只是可以接收参数还可以设置状态。而状态也可以在设置的回调函数里面获取到，并且可以改变。 ActionEntry这里的activate接收的回调函数有 3 个参数。
// Add action "count" to `window` taking an integer as parameter
let action_count = ActionEntry::builder("count")
.parameter_type(Some(&i32::static_variant_type()))
.state(original_state.to_variant())
.activate(move |_, action, parameter| {
// Get state
let mut state = action
.state()
.expect("Could not get state.")
.get::<i32>()
.expect("The variant needs to be of type `i32`.");
// Get parameter
let parameter = parameter
.expect("Could not get parameter.")
.get::<i32>()
.expect("The variant needs to be of type `i32`.");
// Increase state by parameter and store state
state += parameter;
action.set_state(&state.to_variant());
// Update label with new state
label.set_label(&format!("Counter: {state}"));
})
.build();
用 Action 这里少了很多的绑定的操作，这里只声明按钮点击的信号处理和 Action。状态是直接将普通变量 to_variant() 转换一下，不需要声明一个属性，也不需要声明额外的信号处理不同的状态，可以直接在这个注册给 Action 的回调里面做。所以处理用户的输入不止是可以注册一个信号的处理，还可以将信号的处理再委托给 Action。
所有的 Button 都实现了 Actionable 接口，可以给 Button 指定 action_name()，action_target() 是指定 Action 的参数。
在 UI （xml）文件 内部可以指定 "action-name" 和 "action-target"。只需在 Rust 中构造组件后注册对应的 Action 即可。
<object class="GtkButton" id="button">
<property name="label">Press me!</property>
<property name="action-name">win.count</property>
<property name="action-target">1</property>
</object>
也就是说，读代码的时候看到 XML 文件里面有指定 action, 那么在 Rust 里面肯定是注册了这个Action处理函数的。
// setup_actions() in impl Window block of mod.rs
self.add_action_entries([action_count]);
// Trait shared by all GObjects
impl ObjectImpl for Window {
fn constructed(&self) {
// Call "constructed" on parent
self.parent_constructed();
// Add actions
self.obj().setup_actions();
}
}
覆盖父类的方法，在imp.rs的对应的trait的实现里实现覆盖的方法。
自定义组件方法，在mod.rs的模块的impl块里定义，自定义的 setup 的方法都在 constructed() 里面调用。
Menu
如果要创建菜单，就必须用 Action。一个菜单项符合3种描述：
- no parameter and no state, or
- no parameter and boolean state, or
- string parameter and string state.
menu 标签声明菜单的 model，在 GtkMenuButton 中指定菜单的 model, 菜单的具体行为是 action 去做的。
<template class="MyGtkAppWindow" parent="GtkApplicationWindow">
<property name="title">My GTK App</property>
+ <property name="width-request">360</property>
+ <child type="titlebar">
+ <object class="GtkHeaderBar">
+ <child type ="end">
+ <object class="GtkMenuButton">
+ <property name="icon-name">open-menu-symbolic</property>
+ <property name="menu-model">main-menu</property>
+ </object>
+ </child>
+ </object>
+ </child>
菜单可以很好的显示我们的有状态的action，菜单的action的状态需要通过设置来保存。
设置提供了一个 create_action 的方法可以很方便的创建 action.
