Factory for creating rows in a table

[chrsoo]

I would like to create a table based on a model that produces a row with multiple widgets, e.g. two labels, an entry, and a button. All widgets should be vertically aligned, producing a tabular format for the UI. Like a spreadsheet if you want, but I don't want visible cells.

Perhaps the solution is just to use a gtk::Box as the root and explicitly set the lengths of the widgets to the same in each column to make them align, but the problem seems to point to using a gtk::Grid as the parent widget of a factory.

If it is possible to use a grid as the parent, how do I position the individual widgets of each row given that the FactroyComponent trait and the view! macro produces a single root element?

Would it not mean that the view must produce more than one element instead of a single root widget?

Thanks!

[AaronErhardt]

I think you can use gtk::Box, actually. If you add the widgets to certain size groups, they will automatically have a uniform size across rows. To share the size groups more easily, you might use tricks like thread_local

[chrsoo]

Thanks for the reply!

I am afraid that it does not resolve the problem though... Seems like SizeGroup uses raw pointers and that LazyLock requires the Send trait. The code

static PROP_COLUMN_1: LazyLock<SizeGroup> = LazyLock::new(|| {
    SizeGroup::new(gtk::SizeGroupMode::Horizontal)
});

... does not compile with the following error:

error[E0277]: `*mut c_void` cannot be sent between threads safely
  --> relm/src/property.rs:9:23
   |
9  | static PROP_COLUMN_1: LazyLock<SizeGroup> = LazyLock::new(|| {
   |                       ^^^^^^^^^^^^^^^^^^^ `*mut c_void` cannot be sent between threads safely
   |
   = help: the trait `Send` is not implemented for `*mut c_void`, which is required by `LazyLock<SizeGroup>: Sync`
   = note: required for `TypedObjectRef<*mut c_void, ()>` to implement `Sync`
note: required because it appears within the type `SizeGroup`
  --> /Users/csoop/.cargo/registry/src/index.crates.io-6f17d22bba15001f/gtk4-0.9.2/src/auto/size_group.rs:15:16
   |
15 |     pub struct SizeGroup(Object<ffi::GtkSizeGroup>) @implements Buildable;
   |                ^^^^^^^^^
   = note: required for `LazyLock<SizeGroup>` to implement `Sync`
   = note: shared static variables must have a type that implements `Sync`

[AaronErhardt]

Apparently, it only works with constants, not statics. I found an old comment of mine that I had in mind the whole time, but I messed up the details: gtk-rs/gtk-rs-core#775

[chrsoo]

So... with the LazyLocal...

const PROP_COLUMN_1: LazyLock<SizeGroup> = LazyLock::new(|| {
    SizeGroup::new(gtk::SizeGroupMode::Horizontal)
});

... and the following assignment

set_size_group: &PROP_COLUMN_1,

... everything compiles.

However, the sizes of the widgets are all different. Using the GTK_DEBUG=interactive envar and checking in the GTK debug tool, they all seem to be different SizeGroup instances which would explain why the sizes are different.

Reading up on const vs static I find the following snippet in the Rust documentation:

const items looks remarkably similar to static items, which introduces some confusion as to which one should be used at which times. To put it simply, constants are inlined wherever they're used, making using them identical to simply replacing the name of the const with its value. Static variables, on the other hand, point to a single location in memory, which all accesses share. This means that, unlike with constants, they can't have destructors, and act as a single value across the entire codebase.

(added bold formatting to highlight the relevant text)

This makes me think that the LazyLock enclosure is called repeatedly as I guess that the LazyLock is "copy-pasted" by the compiler for the assignments and then executed only once when running the compiled binary. But perhaps I am getting this wrong.

Thoughts?

[AaronErhardt]

Mhh, we only progress from one problem to another. This is an particularly unpleasant problem in Rust and something I deal with rarely (which is why it took me so long to remember all the details).

I hope I've now considered all the potential problems. I think there are two possibilities:

• Use thread_local and then .with(|w| w.clone()) to access the widgets (since widgets can be cloned cheaply as they are smart pointers like Rc)
• Use a static sync::LazyLock with either Mutex or Fragile

Both solutions are not ideal, but somehow you have to satisfy the constraints of the compiler.

[chrsoo]

Use thread_local and then .with(|w| w.clone()) to access the widgets (since widgets can be cloned cheaply as they are smart pointers like Rc)

This... works! 🥇 Thanks a lot for all the help!

Not sure why this is not ideal though, given that that clones are cheap.

Speaking about ideal, I am more concerned with all the boxes. This is a screenshot from the GTK Debug tool, the last two boxes are from the two labels in the view! macro snippet above (I temporarily removed the entry)...

[AaronErhardt]

GTK often uses boxes internally, e.g. as a container to place child widgets inside. Yet, it seems to me like you have created most of the boxes yourself. In this case I think you should at least have created the following widgets yourself: Box -> Stack -> 3x Box -> Frame (probably one box as part of the frame) -> Box -> Stack -> 2x Box

In particular, I think you don't have to put the Frame into a Box and probably there are other places where you can just remove one Box and directly place the internal widget.

[chrsoo]

• The box wrapping the frame has been eliminated.
• I can't eliminate one of the two boxes after the first stack as it seems I cannot place the builder output in the root of the device property factory:

    view! {
        #[root]
        gtk::Box {
            set_orientation: gtk::Orientation::Vertical,
            // set_spacing: 10,
            self.props.widget() ->  // would be ideal if this could go in the root!
            &gtk::Box {
                set_orientation: gtk::Orientation::Vertical,
                set_spacing: 10,
            },
        },
        #[local_ref]
        returned_widget -> gtk::StackPage {
            set_name: self.device.name(),
            set_title: self.device.name(),
        }
    }

• Similar issues for the property item factory and here I also have the extra boxes introduced by the conditional widget:

    view! {
        #[root]
        gtk::Box {  // can't append the output of the conditional widget to the root
            set_orientation: gtk::Orientation::Horizontal,
            set_spacing: 10,
            append = match &self.item.value { 
                PropertyValue::Text(s) => {
                    gtk::Box {  // must return a single widget when using match
                        set_orientation: gtk::Orientation::Horizontal,
                        set_spacing: 10,
                        gtk::Box { //  `set_size_group` does not exist on gtk::Label
                            set_size_group: &PROP_COLUMN_1.with(|w| w.clone() ),
                            gtk::Label {
                                #[watch]
                                set_label: &self.item.name,
                            },
                        },

It would be great if it was possible to directly assign the match output to the root in the conditional widget, this would get rid of one more box.

[chrsoo]

Here is an annotated view of the UI: