Can we access a base component from the backend?

[antis81]

The context (use case) for my question is a (C++/CMake) Project that generates multilple executable targets.

add_executable(application-foo …)
add_executable(application-bar …)

Both applications have some common behaviour (e.g. a product-version, accepted, rejected, get_theme_icon, …).

// file: base.slint
export MyWindow inherits Window {
  callback rejected();
}

// file: application-foo.slint
import {MyWindow} from "base.slint";

export ApplicationFooWindow inherits MyWindow {}

// file: application-bar.slint
import {MyWindow} from "base.slint";

export ApplicationBarWindow inherits MyWindow {}

I am looking for something in the fashion of a "super" function (maybe super<Type>() in backend) in addition to the window() function.

Is there a way to access the "rejected" callback from the backend with current Slint version (1.12.1)?

[soulchainer]

@antis81 I was also expecting something similar to that. If a component is inheriting another, I would expect to have access to its "methods" / callbacks somehow, without needing to resort to globals.

For now, the only way I have found is to declare such things in an exported global. For example:

// file: base.slint
export global MyWindowGlobals {
	callback rejected();
}

export MyWindow inherits Window {
	// some code
	// use rejected whenever it's needed with MyWindowGlobals.rejected();
}

// file: application-foo.slint
import { MyWindow } from "base.slint";
export { MyWindowGlobals } from "base.slint";

export ApplicationFooWindow inherits MyWindow {}

And then, in the backend, you can access and call the callback stored in the given globals as explained in the documentation.
(Sorry, I don't know C++ and I'm slowly learning Rust.)

So, for now, it seems the only options are to either declare lots of globals across files or create a single globals.slint file and import/re-export it where needed.

[antis81]

Quite interesting… didn't think about putting this in an interface. Thanks for the inspiration! 👍