Allow two-way binding to struct members

[Futsch1]

It is currently only possible to bind a current-value or checked attribute of a widget to a property. This requires creating single properties for each control in order to process their value in the host application or to create a struct and manually fill the values in a .60 callback.

It would be convenient to be able to map attributes to members of a struct property, like:

struct Settings {
    value_1: bool,
    value_2: bool
}

Window {
    property <Setttings> settings;

    Checkbox {
        text: "Value 1";
        checked <=> settings.value_1;
    }
    Checkbox {
        text: "Value 2";
        checked <=> settings.value_2;
    }

}

[ogoffart]

I have been thinking allowing two way binding with converstion.
As long as the compiler can invert the expression.
For example

foo <=> bar + 1;   // can be inverted to foo-1;
foo <=> -bar;  // can be inverted to -foo;
foo <=> 5 * bar; // can be inverted to foo / 5

(then implementation wise, in the generated code, there would be in the impl Property

pub fn link_two_way_with_conversion(prop1: Pin<&Property<T>>, prop2: Pin<&Property<U>>, conv1: impl Fn(U)->T, conv2: impl Fn(T)->U)

)

But unfortunately this is not enough because

foo <=> bar.xxx; // (with bar a struct that has a xxx field)

cannot be inverted....
... unless we pass the previous value in the conversion function:

pub fn link_two_way_with_conversion(prop1: Pin<&Property<T>>, prop2: Pin<&Property<U>>, conv1: impl Fn(U, &T)->T, conv2: impl Fn(T, &U)->U)

[FlorentBecker]

Since it's structs (aka product types) you're dealing with, you can always inline them. That is, it's always possible to compile this:

struct Settings {
    value_1: bool,
    value_2: bool
}

Window {
    property <Setttings> preferences;

    Checkbox {
        text: "Value 1";
        checked <=> preferences.value_1;
    }
    Checkbox {
        text: "Value 2";
        checked <=> preferences.value_2;
    }
}

into that:

Window {
    property<bool> preferences__value_1;
    property<bool> preferences__value_2;

    callback get_preferences() -> Settings;
    get_preferences => {
         return { value_1: self.preferences__value_1, value_2: self.preferences__value_2}
    }

   callback set_preferences(Settings);
   set_preferences(s) => {
        self.preferences__value_1 = s.value_1; self.preferences__value_2 = s.value_2;
   }

    Checkbox {
        text: "Value 1";
        checked <=> preferences__value_1;
    }
    Checkbox {
        text: "Value 2";
        checked <=> preferences__value_2;
    }

}

Then rewrite reads and writes of preferences into calls to get_preferences and set_preferences, which the compiler is bound to do at some point anyway.