Attribute Macro gtk4_macros::template_callbacks
source · #[template_callbacks]
Expand description
Attribute macro for creating template callbacks from Rust methods.
Widgets with CompositeTemplate
can then make use of these callbacks from within their
template XML definition. The attribute must be applied to an impl
statement of a struct.
Functions marked as callbacks within the impl
will be stored in a static array. Then, in the
ObjectSubclass
implementation you will need to call bind_template_callbacks
and/or
bind_template_instance_callbacks
in the class_init
function.
Template callbacks can be specified on both a widget’s public wrapper impl
or on its private
subclass impl
, or from external types. If callbacks are specified on the public wrapper, then
bind_template_instance_callbacks
must be called in class_init
. If callbacks are specified
on the private subclass, then bind_template_callbacks
must be called in class_init
. To use
the callbacks from an external type, call T::bind_template_callbacks
in class_init
, where
T
is the other type. See the example below for usage of all three.
These callbacks can be bound using the <signal>
or <closure>
tags in the template file.
Note that the arguments and return type will only be checked at run time when the method is
invoked.
Template callbacks can optionally take self
or &self
as a first parameter. In this case,
the attribute swapped="true"
will usually have to be set on the <signal>
or <closure>
tag
in order to invoke the function correctly. Note that by-value self
will only work with
template callbacks on the wrapper type.
Template callbacks that have no return value can also be async
, in which case the callback
will be spawned as new future on the default main context using
glib::MainContext::spawn_local
. Invoking the callback multiple times will spawn an
additional future each time it is invoked. This means that multiple futures for an async
callback can be active at any given time, so care must be taken to avoid any kind of data
races. Async callbacks may prefer communicating back to the caller or widget over channels
instead of mutating internal widget state, or may want to make use of a locking flag to ensure
only one future can be active at once. Widgets may also want to show a visual indicator such as
a Spinner
while the future is active to communicate to the user that a background task is
running.
The following options are supported on the attribute:
functions
makes all callbacks use thefunction
attribute by default. (see below)
The template_callback
attribute is used to mark methods that will be exposed to the template
scope. It can take the following options:
name
renames the callback. Defaults to the function name if not defined.function
ignores the first value when calling the callback and disallowsself
. Useful for callbacks called from<closure>
tags.function = false
reverts the effects offunctions
used on theimpl
, so the callback gets the first value and can takeself
again. Mainly useful for callbacks that are invoked withswapped="true"
.
The rest
attribute can be placed on the last argument of a template callback. This attribute
must be used on an argument of type &[glib::Value]
and will pass in the
remaining arguments. The first and last values will be omitted from the slice if this callback
is a function
.
Arguments and return types in template callbacks have some special restrictions, similar to the
restrictions on glib::closure
. Each argument’s type must implement
From<Type> for glib::Value
. The last argument can also be
&[glib::Value]
annotated with #[rest]
as described above. The return type of
a callback, if present, must implement glib::FromValue
. Type-checking of inputs and outputs
is done at run-time; if the argument types or return type do not match the type of the signal
or closure then the callback will panic. To implement your own type checking or to use dynamic
typing, an argument’s type can be left as a &glib::Value
. This can also be used
if you need custom unboxing, such as if the target type does not implement FromValue
.
Example
use gtk::{glib, prelude::*, subclass::prelude::*};
mod imp {
use super::*;
#[derive(Debug, Default, gtk::CompositeTemplate)]
#[template(file = "test/template_callbacks.ui")]
pub struct MyWidget {
#[template_child]
pub label: TemplateChild<gtk::Label>,
#[template_child(id = "my_button_id")]
pub button: TemplateChild<gtk::Button>,
}
#[glib::object_subclass]
impl ObjectSubclass for MyWidget {
const NAME: &'static str = "MyWidget";
type Type = super::MyWidget;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {
klass.bind_template();
// Bind the private callbacks
klass.bind_template_callbacks();
// Bind the public callbacks
klass.bind_template_instance_callbacks();
// Bind callbacks from another struct
super::Utility::bind_template_callbacks(klass);
}
fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
obj.init_template();
}
}
#[gtk::template_callbacks]
impl MyWidget {
#[template_callback]
fn button_clicked(&self, button: >k::Button) {
button.set_label("I was clicked!");
self.label.set_label("The button was clicked!");
}
#[template_callback(function, name = "strlen")]
fn string_length(s: &str) -> u64 {
s.len() as u64
}
}
impl ObjectImpl for MyWidget {}
impl WidgetImpl for MyWidget {}
impl BoxImpl for MyWidget {}
}
glib::wrapper! {
pub struct MyWidget(ObjectSubclass<imp::MyWidget>) @extends gtk::Widget, gtk::Box;
}
#[gtk::template_callbacks]
impl MyWidget {
pub fn new() -> Self {
glib::Object::new()
}
#[template_callback]
pub fn print_both_labels(&self) {
let imp = self.imp();
println!("{} {}", imp.label.label(), imp.button.label().unwrap().as_str());
}
}
pub struct Utility {}
#[gtk::template_callbacks(functions)]
impl Utility {
#[template_callback]
fn concat_strs(#[rest] values: &[glib::Value]) -> String {
let mut res = String::new();
for (index, value) in values.iter().enumerate() {
res.push_str(value.get::<&str>().unwrap_or_else(|e| {
panic!("Expected string value for argument {}: {}", index, e);
}));
}
res
}
#[template_callback(function = false)]
fn reset_label(label: >k::Label) {
label.set_label("");
}
}