gtk4_macros/
composite_template_derive.rs
1#[cfg(feature = "xml_validation")]
4use std::collections::HashMap;
5
6use proc_macro2::{Span, TokenStream};
7#[cfg(feature = "xml_validation")]
8use quick_xml::name::QName;
9use quote::quote;
10use syn::{Data, Error, Result};
11
12#[cfg(feature = "blueprint")]
13use crate::blueprint::*;
14use crate::{attribute_parser::*, util::*};
15
16fn gen_set_template(source: &TemplateSource, crate_ident: &proc_macro2::Ident) -> TokenStream {
17 match source {
18 TemplateSource::File(file) => {
19 let template = if file.ends_with(".blp") {
20 if cfg!(feature = "blueprint") {
21 quote! {
22 #crate_ident::gtk4_macros::include_blueprint!(#file).as_bytes()
23 }
24 } else {
25 panic!("blueprint feature is disabled")
26 }
27 } else {
28 quote! {
29 include_bytes!(#file)
30 }
31 };
32
33 quote! {
34 #crate_ident::subclass::widget::WidgetClassExt::set_template_static(
35 klass,
36 #template,
37 );
38 }
39 }
40 TemplateSource::Resource(resource) => quote! {
41 #crate_ident::subclass::widget::WidgetClassExt::set_template_from_resource(
42 klass,
43 &#resource,
44 );
45 },
46 TemplateSource::Xml(template) => quote! {
47 #crate_ident::subclass::widget::WidgetClassExt::set_template_static(
48 klass,
49 #template.as_bytes(),
50 );
51 },
52 #[cfg(feature = "blueprint")]
53 TemplateSource::Blueprint(blueprint) => {
54 let template =
55 compile_blueprint(blueprint.as_bytes()).expect("can't compile blueprint");
56
57 quote! {
58 #crate_ident::subclass::widget::WidgetClassExt::set_template_static(
59 klass,
60 #template.as_bytes(),
61 );
62 }
63 }
64 }
65}
66
67#[cfg(feature = "xml_validation")]
68fn check_template_fields(source: &TemplateSource, fields: &[AttributedField]) -> Result<()> {
69 #[allow(unused_assignments)]
70 let xml = match source {
71 TemplateSource::Xml(template) => template,
72 _ => return Ok(()),
73 };
74
75 let mut reader = quick_xml::Reader::from_str(xml);
76 let mut ids_left = fields
77 .iter()
78 .map(|field| match field.attr.ty {
79 FieldAttributeType::TemplateChild => (field.id(), field.id_span()),
80 })
81 .collect::<HashMap<_, _>>();
82
83 loop {
84 use quick_xml::events::Event;
85
86 let event = reader.read_event();
87 let elem = match &event {
88 Ok(Event::Start(e)) => Some(e),
89 Ok(Event::Empty(e)) => Some(e),
90 Ok(Event::Eof) => break,
91 Err(e) => {
92 return Err(Error::new(
93 Span::call_site(),
94 format!(
95 "Failed reading template XML at position {}: {:?}",
96 reader.buffer_position(),
97 e
98 ),
99 ));
100 }
101 _ => None,
102 };
103 if let Some(e) = elem {
104 let name = e.name();
105 if name == QName(b"object") || name == QName(b"template") {
106 let id = e
107 .attributes()
108 .find_map(|a| a.ok().and_then(|a| (a.key == QName(b"id")).then_some(a)));
109 let id = id.as_ref().and_then(|a| std::str::from_utf8(&a.value).ok());
110 if let Some(id) = id {
111 ids_left.remove(id);
112 }
113 }
114 }
115 }
116
117 if let Some((name, span)) = ids_left.into_iter().next() {
118 return Err(Error::new(
119 span,
120 format!("Template child with id `{name}` not found in template XML",),
121 ));
122 }
123
124 Ok(())
125}
126
127fn gen_template_child_bindings(fields: &[AttributedField]) -> TokenStream {
128 let crate_ident = crate_ident_new();
129
130 let recurse = fields.iter().map(|field| match field.attr.ty {
131 FieldAttributeType::TemplateChild => {
132 let mut value_id = &field.ident.to_string();
133 let ident = &field.ident;
134 let mut value_internal = false;
135 field.attr.args.iter().for_each(|arg| match arg {
136 FieldAttributeArg::Id(value, _) => {
137 value_id = value;
138 }
139 FieldAttributeArg::Internal(internal) => {
140 value_internal = *internal;
141 }
142 });
143
144 quote! {
145 klass.bind_template_child_with_offset(
146 &#value_id,
147 #value_internal,
148 #crate_ident::offset_of!(Self => #ident),
149 );
150 }
151 }
152 });
153
154 quote! {
155 #(#recurse)*
156 }
157}
158
159fn gen_template_child_type_checks(fields: &[AttributedField]) -> TokenStream {
160 let crate_ident = crate_ident_new();
161
162 let recurse = fields.iter().map(|field| match field.attr.ty {
163 FieldAttributeType::TemplateChild => {
164 let ty = &field.ty;
165 let ident = &field.ident;
166 let type_err = format!("Template child with id `{}` has incompatible type. XML has {{:?}}, struct has {{:?}}", field.id());
167 quote! {
168 let ty = <<#ty as ::std::ops::Deref>::Target as #crate_ident::glib::prelude::StaticType>::static_type();
169 let child_ty = #crate_ident::glib::prelude::ObjectExt::type_(::std::ops::Deref::deref(&imp.#ident));
170 if !child_ty.is_a(ty) {
171 panic!(#type_err, child_ty, ty);
172 }
173 }
174 }
175 });
176
177 quote! {
178 #(#recurse)*
179 }
180}
181
182pub fn impl_composite_template(input: &syn::DeriveInput) -> Result<TokenStream> {
183 let name = &input.ident;
184 let crate_ident = crate_ident_new();
185
186 let template = match parse_template_source(input) {
187 Ok(v) => Some(v),
188 Err(e) => {
189 return Err(Error::new(
190 Span::call_site(),
191 format!("{}: derive(CompositeTemplate) requires #[template(...)] to specify 'file', 'resource', or 'string'",
192 e)
193 ));
194 }
195 };
196
197 let allow_without_attribute = template
198 .as_ref()
199 .map(|t| t.allow_template_child_without_attribute)
200 .unwrap_or(false);
201 let source = template.as_ref().map(|t| &t.source);
202
203 let set_template = source.map(|s| gen_set_template(s, &crate_ident));
204
205 let fields = match input.data {
206 Data::Struct(ref s) => Some(&s.fields),
207 _ => {
208 return Err(Error::new(
209 Span::call_site(),
210 "derive(CompositeTemplate) only supports structs",
211 ));
212 }
213 };
214
215 let attributed_fields = match fields.map(|f| parse_fields(f, allow_without_attribute)) {
216 Some(fields) => fields?,
217 None => vec![],
218 };
219
220 #[cfg(feature = "xml_validation")]
221 {
222 if let Some(source) = source {
223 check_template_fields(source, &attributed_fields)?;
224 }
225 }
226 let template_children = gen_template_child_bindings(&attributed_fields);
227 let checks = gen_template_child_type_checks(&attributed_fields);
228
229 Ok(quote! {
230 impl #crate_ident::subclass::widget::CompositeTemplate for #name {
231 fn bind_template(klass: &mut Self::Class) {
232 #set_template
233
234 unsafe {
235 #template_children
236 }
237 }
238 fn check_template_children(widget: &<Self as #crate_ident::glib::subclass::prelude::ObjectSubclass>::Type) {
239 let imp = #crate_ident::subclass::prelude::ObjectSubclassIsExt::imp(widget);
240 #checks
241 }
242 }
243 })
244}