Preferred size for controls?

[niabot]

I come from JavaFX, which has the concept of a "preferred size" that can be used to override a control's desired size. For example, a TextBox could have a preferred width of 300 px. The parent is still free to resize the control within its min/max width constraints if necessary. Avalonia does not seem to have such a property.

JavaFX:

• Width (fixed width if set)
• MinWidth
• MaxWidth
• PreferredWidth (overrides desired size of control if set)

So far i only found two ways to add/enforce a preferred size:

1. Subclass the controls (TextBox, etc.) and override MeasureOverride.
2. Create a Decorator that ignores the child's desired size when a preferred size is set on the decorator itself.

Maybe I'm missing something simpler to achieve the same effect?

[robloo]

I think you are missing HorizontalAlignment. You can set that to Left, Right or Stretch (to fit the parent). Then you also have the Width, MinWidth and MaxWidth properties in Avalonia that will override that.

You generally don't layout a TextBox by itself though, it would be nested in a parent layout control like a Grid or StackPanel.

So what you would normally do is have something like:

  <Grid RowDefinitions="Auto,Auto,Auto" MaxWidth="300" HorizontalAlignment="Stretch">
    <TextBox Grid.Row="0" HorizontalAlignment="Stretch" />
    <TextBox Grid.Row="1" HorizontalAlignment="Stretch" />
    <TextBox Grid.Row="2" HorizontalAlignment="Stretch" />
  </Grid>

[niabot]

The stretching works fine, but it requires to define a fixed width somewhere up the hierarchy to be stable. Otherwise the desired size of the TextBox makes the layout resize (wiggle) with the content of the TextBox while the user is typing. I prefer to not use fixed dimensions, if possible, so that the layout can adapt to size changes.

This would be much easier, if i could override the desired size of TextBox, ComboBox, etc., so that it does not depend on the content. Other toolkits solve this with a preferred size or a fixed character count (both override the default desired size). The control can still be resized by the parent within min/max limits.

Note: I use the desired size to measure/prepare the initial dialog size.

[identity-wael]

Your follow-up describes a measure-pass preference, so MaxWidth=300 + Stretch isn't equivalent: it caps growth but still allows a short TextBox's content-dependent desired width below that cap. Likewise MinWidth=300 establishes a lower bound rather than a preference that the parent may shrink.

For an initial size-to-content dialog whose fields should request a stable width but still stretch later, your decorator approach is a reasonable reusable solution. Keep the distinction explicit:

• During MeasureOverride, measure the child at the preferred width constrained by the available width, then report that preferred/constrained width and the child's measured height.
• During ArrangeOverride, arrange the child into the width actually allocated by the parent, rather than forcing the preferred width again.
• Keep the child's Width unset and its horizontal alignment stretched. Put the intended min/max bounds on the wrapper; account for padding/margins when calculating its inner size.

Avalonia's layout documentation describes that measure/arrange split, and the stock Decorator already supplies the child-arrangement plumbing. If you add a configurable preferred-width styled property, make changes to it invalidate measure.

That preserves the semantics you want without subclassing every input control. It is still a custom layout policy, not a built-in JavaFX-style PreferredWidth setting.

[niabot]

This is correct. I'm currently solving it using the following Decorator. But i hoped that there would be an more elegant way that i overlooked.

public class PreferredSizeDecorator : Decorator {

    public static readonly StyledProperty<double> PreferredWidthProperty =
        AvaloniaProperty.Register<PreferredSizeDecorator, double>(nameof(PreferredWidth), double.NaN);

    public static readonly StyledProperty<double> PreferredHeightProperty =
        AvaloniaProperty.Register<PreferredSizeDecorator, double>(nameof(PreferredHeight), double.NaN);

    public double PreferredHeight {
        get => GetValue(PreferredHeightProperty);
        set => SetValue(PreferredHeightProperty, value);
    }

    public double PreferredWidth {
        get => GetValue(PreferredWidthProperty);
        set => SetValue(PreferredWidthProperty, value);
    }

    public PreferredSizeDecorator() {
    }

    protected override Size MeasureOverride(Size availableSize) {
        if (Child is null)
            return default;

        Child.Measure(availableSize);
        var desiredSize = Child.DesiredSize;

        if (!double.IsNaN(PreferredWidth)) {
            var w = Math.Clamp(PreferredWidth, Child.MinWidth, Child.MaxWidth);
            var h = desiredSize.Height;
            desiredSize = new Size(w, h);
        }
        if (!double.IsNaN(PreferredHeight)) {
            var w = desiredSize.Width;
            var h = Math.Clamp(PreferredHeight, Child.MinHeight, Child.MaxHeight);
            desiredSize = new Size(w, h);
        }

        desiredSize = new Size(
            width: desiredSize.Width + Padding.Left + Padding.Right,
            height: desiredSize.Height + Padding.Top + Padding.Bottom
        );

        return desiredSize;
    }

    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change) {
        base.OnPropertyChanged(change);

        if (change.Property == PreferredWidthProperty
            || change.Property == PreferredHeightProperty
            || change.Property == PaddingProperty) {
            InvalidateMeasure();
        }

        if (change.Property == ChildProperty) {
            if (change.OldValue is Control oldChild)
                oldChild.PropertyChanged -= ChildPropertyChanged;
            if (change.NewValue is Control newChild)
                newChild.PropertyChanged += ChildPropertyChanged;
            InvalidateMeasure();
        }
    }

    private void ChildPropertyChanged(object? sender, AvaloniaPropertyChangedEventArgs e) {
        if (e.Property == MinWidthProperty
            || e.Property == MaxWidthProperty
            || e.Property == MinHeightProperty
            || e.Property == MaxHeightProperty) {
            InvalidateMeasure();
        }
    }

}