Using .ui template files

[Khelda]

Oi ! So, for a pet project, I was working with Cambalache and .ui files, loaded them in Rust structs, but I do have a problem. When I use my Window struct, it looks like it doesn't find the EditionPanel struct (custom widget) inner content and just displays an empty box. Does anyone have any idea why this happens ?

[Khelda]

Oh and I forgot, the files :

src/window/mod.rs : ```rs
mod actions;
mod dialogs;
mod imp;

use adw::{Application, subclass::prelude::ObjectSubclassIsExt};
use gtk::{
gio::{self},
glib::{self, Object},
prelude::EditableExt,
};

use crate::constants::NEWPROJ_SCREEN_NAME;

glib::wrapper! {
pub struct Window(ObjectSubclassimp::MDotWindow)
@extends adw::ApplicationWindow, gtk::ApplicationWindow,
gtk::Window, gtk::Widget,
@implements gio::ActionGroup, gio::ActionMap, gtk::Accessible,
gtk::Buildable, gtk::ConstraintTarget, gtk::Native,
gtk::Root, gtk::ShortcutManager;
}

// Setup methods
impl Window {
/// custom constructor to ensure we can have a link to our app
pub fn new(app: &Application) -> Self {
Object::builder().property("application", app).build()
}
}

// logic-related methods
impl Window {
/// Setting up window default values. It is meant to be called at launch.
fn set_defaults(&self) {
// load default app screen
self.set_screen(NEWPROJ_SCREEN_NAME);
}

pub fn set_screen(&self, name: impl ToString) {
    self.imp()
        .page_stack
        .set_visible_child_name(name.to_string().as_str());
}

pub fn clear_form(&self) {
    self.imp().path_lbl.set_label(""); // no more path label
    self.imp().proj_name.set_text(""); // no more project name
}

}

src/window/imp.rs : ```rs
use std::cell::RefCell;

use adw::{SplitButton, subclass::prelude::*};
use gtk::{
    Button, CompositeTemplate, DrawingArea, Entry, Label, MenuButton, Stack,
    glib::{self, subclass::InitializingObject},
};
use tracing::info;

use crate::{
    edition::EditionPanel,
    project::Project,
    window::{actions::mk_actions, dialogs::*},
};

#[derive(CompositeTemplate, Default)]
#[template(resource = "/com/github/merisedotdev/mdot/window.ui")]
pub struct MDotWindow {
    // logic-related elements (like app settings)
    pub project: RefCell<Project>,

    // template macro components
    #[template_child]
    pub page_stack: TemplateChild<Stack>,
    #[template_child]
    pub editor_pane: TemplateChild<EditionPanel>,
    #[template_child]
    pub graph_drawing: TemplateChild<DrawingArea>,

    // header controls
    #[template_child]
    pub menu_btn: TemplateChild<MenuButton>,
    #[template_child]
    pub newfile_btn: TemplateChild<Button>,
    #[template_child]
    pub open_btn: TemplateChild<SplitButton>,
    #[template_child]
    pub undo_btn: TemplateChild<Button>,
    #[template_child]
    pub redo_btn: TemplateChild<Button>,

    // newproj form controls
    #[template_child]
    pub proj_name: TemplateChild<Entry>,
    #[template_child]
    pub path_picker: TemplateChild<Button>,
    #[template_child]
    pub path_lbl: TemplateChild<Label>,
}

// subclassing our window
#[glib::object_subclass]
impl ObjectSubclass for MDotWindow {
    const NAME: &'static str = "MDotWindow";
    type Type = super::Window;
    type ParentType = adw::ApplicationWindow;

    fn class_init(klass: &mut Self::Class) {
        // link the template file to our window class
        klass.bind_template();
        // installing GActions
        for action in mk_actions() {
            klass.install_action(action.name(), None, move |win, txt, var| {
                // do NOT prefetch implementation
                action.handle_activate(win, txt, var);
            });
        }
        // install async actions
        klass.install_action_async(PICKPROJ_NAME, None, pickproj_dialog);
        klass.install_action_async(OPEN_NAME, None, open_dialog);
    }

    fn instance_init(obj: &InitializingObject<Self>) {
        obj.init_template(); // launching the window from template
    }
}

// GObject core trait
impl ObjectImpl for MDotWindow {
    fn constructed(&self) {
        // super() call
        self.parent_constructed();
        // inner setup
        let obj = self.obj();
        info!("Loading default values");
        obj.set_defaults();
    }
}

// GTK widget core trait
impl WidgetImpl for MDotWindow {}

// window core traits
impl WindowImpl for MDotWindow {
    fn close_request(&self) -> glib::Propagation {
        // pass saved thingies to parent class
        self.parent_close_request()
    }
}

// app window inheritance
impl ApplicationWindowImpl for MDotWindow {}

// adwaita ApplicationWindow inheritance
impl AdwApplicationWindowImpl for MDotWindow {}

src/edition/mod.rs : ```rs
mod imp;

use gtk::glib::{self, Object};

glib::wrapper! {
pub struct EditionPanel(ObjectSubclassimp::MDotEditionPanel)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget;
}

impl Default for EditionPanel {
fn default() -> Self {
Object::builder().build()
}
}

src/edition/imp.rs : ```rs
use adw::subclass::prelude::{ObjectImpl, ObjectImplExt, ObjectSubclass};
use gtk::{Box, CompositeTemplate, glib, subclass::prelude::*};

#[derive(CompositeTemplate, Default)]
#[template(resource = "/com/github/merisedotdev/mdot/editionpanel.ui")]
pub struct MDotEditionPanel {
    // TODO add important components
}

// subclass core trait
#[glib::object_subclass]
impl ObjectSubclass for MDotEditionPanel {
    const NAME: &'static str = "MDotEditionPanel";
    type Type = super::EditionPanel;
    type ParentType = Box;

    fn class_init(klass: &mut Self::Class) {
        // link the template file
        klass.bind_template();
        // TODO define actions (no async actions here)
    }
}

// main GObject trait
impl ObjectImpl for MDotEditionPanel {
    fn constructed(&self) {
        // parent constructor, always
        self.parent_constructed();
    }
}

// core widget trait
impl WidgetImpl for MDotEditionPanel {}

// Box subclassing
impl BoxImpl for MDotEditionPanel {}