Пользовательская автокалибровка класс Панели WPF

Я пытаюсь записать пользовательское Panel класс для WPF, путем переопределения MeasureOverride и ArrangeOverride но, в то время как это является главным образом рабочим, я испытываю одну странную проблему, которую я не могу объяснить.

В частности, после того, как я звоню Arrange на моих дочерних объектах в ArrangeOverride после выяснения, каковы их размеры должны быть, они не измеряют к размеру, который я даю им и, кажется, измеряю к размеру, переданному их Measure метод внутри MeasureOverride.

Я пропускаю что-то в том, как эта система, как предполагается, работает? Мое понимание является тем вызовом Measure просто заставляет ребенка оценивать DesiredSize на основе предоставленного availableSize, и не должен влиять на его фактический заключительный размер.

Вот мой полный код (Панель, btw, предназначается для расположения дочерних элементов самым эффективным пространством способом, давая меньше пространства строкам, которым не нужен он и разделяющий остающееся пространство равномерно среди остальных - это в настоящее время только поддерживает вертикальную ориентацию, но я планирую добавление горизонтального, после того как я получаю его работающий правильно):

Править: Спасибо за ответы. Я исследую их более тесно через мгновение. Однако позвольте мне разъяснить, как мой намеченный алгоритм работает, так как я не объяснил это.

В первую очередь, лучший способ думать, что я делаю, состоит в том, чтобы вообразить Сетку с каждым набором строк к *. Это делит пространство равномерно. Однако в некоторых случаях элементу подряд, возможно, не понадобится все то пространство; если это верно, я хочу занять любое оставшееся место и дать его тем строкам, которые могли использовать пространство. Если никаким строкам не нужно никакое дополнительное пространство, я просто пытаюсь расположить вещи с интервалами равномерно (это что extraSpace делает, это только для того случая).

Я делаю это в двух передачах. Окончательная точка первичной обработки должна определить заключительный "нормальный размер" строки - т.е. размер строк, которые будут уменьшены (учитывая размер, меньший, чем его желаемый размер). Я делаю это путем продвижения через самый маленький объект в самый большой и корректировки расчетного нормального размера на каждом шаге путем добавления оставшегося пространства от каждого небольшого объекта до каждого последующего большего объекта, пока больше объектов не "соответствует" и затем повреждается.

В следующей передаче я использую это нормальное значение, чтобы определить, может ли объект соответствовать или нет, просто путем взятия Min из нормального размера с желаемым размером объекта.

(Я также изменил анонимный метод на функцию лямбды для простоты.)

Редактирование 2: Мой алгоритм, кажется, работает отлично при определении надлежащего размера детей. Однако дети просто не принимают свой данный размер. Я попробовал Гоблина, предложил MeasureOverride путем передачи PositiveInfinity и возврата Размера (0,0), но это заставляет детей привлекать себя, как будто нет никаких пространственных ограничений вообще. Часть это не очевидно об этом, - то, что это происходит из-за вызова с Measure. Документация Microsoft относительно этого предмета нисколько не является четкой, поскольку я перечитывал по каждому классу и описанию свойства несколько раз. Однако это теперь ясно тот вызов Measure действительно на самом деле влияет на рендеринг ребенка, таким образом, я попытаюсь разделить логику среди двух функций как предложенный BladeWise.

Решенный!! Я получил его работа. Как я подозревал, я должен был назвать Меру () дважды на каждом ребенке (однажды для оценки DesiredSize и секунда, чтобы дать каждому ребенку ее надлежащую высоту). Это кажется нечетным мне, что расположение в WPF было бы разработано таким нечетным способом, где это разделено на две передачи, но передача Меры на самом деле делает две вещи: дети мер и размеров и передача Расположения делают почти ничего, кроме того, на самом деле, физически располагают детей. Очень причудливый.

Я отправлю рабочий код внизу.

Во-первых, исходный (взломанный) код:

protected override Size MeasureOverride( Size availableSize ) {
    foreach ( UIElement child in Children )
        child.Measure( availableSize );

    return availableSize;
}

protected override System.Windows.Size ArrangeOverride( System.Windows.Size finalSize ) {
    double extraSpace = 0.0;
    var sortedChildren = Children.Cast<UIElement>().OrderBy<UIElement, double>( child=>child.DesiredSize.Height; );
    double remainingSpace = finalSize.Height;
    double normalSpace = 0.0;
    int remainingChildren = Children.Count;
    foreach ( UIElement child in sortedChildren ) {
        normalSpace = remainingSpace / remainingChildren;
        if ( child.DesiredSize.Height < normalSpace ) // if == there would be no point continuing as there would be no remaining space
            remainingSpace -= child.DesiredSize.Height;
        else {
            remainingSpace = 0;
            break;
        }
        remainingChildren--;
    }

    // this is only for cases where every child item fits (i.e. the above loop terminates normally):
    extraSpace = remainingSpace / Children.Count;
    double offset = 0.0;

    foreach ( UIElement child in Children ) {
        //child.Measure( new Size( finalSize.Width, normalSpace ) );
        double value = Math.Min( child.DesiredSize.Height, normalSpace ) + extraSpace;
            child.Arrange( new Rect( 0, offset, finalSize.Width, value ) );
        offset += value;
    }

    return finalSize;
}

И вот рабочий код:

double _normalSpace = 0.0;
double _extraSpace = 0.0;

protected override Size MeasureOverride( Size availableSize ) {
    // first pass to evaluate DesiredSize given available size:
    foreach ( UIElement child in Children )
        child.Measure( availableSize );

    // now determine the "normal" size:
    var sortedChildren = Children.Cast<UIElement>().OrderBy<UIElement, double>( child => child.DesiredSize.Height );
    double remainingSpace = availableSize.Height;
    int remainingChildren = Children.Count;
    foreach ( UIElement child in sortedChildren ) {
        _normalSpace = remainingSpace / remainingChildren;
        if ( child.DesiredSize.Height < _normalSpace ) // if == there would be no point continuing as there would be no remaining space
            remainingSpace -= child.DesiredSize.Height;
        else {
            remainingSpace = 0;
            break;
        }
        remainingChildren--;
    }
    // there will be extra space if every child fits and the above loop terminates normally:
    _extraSpace = remainingSpace / Children.Count; // divide the remaining space up evenly among all children

    // second pass to give each child its proper available size:
    foreach ( UIElement child in Children )
        child.Measure( new Size( availableSize.Width, _normalSpace ) );

    return availableSize;
}

protected override System.Windows.Size ArrangeOverride( System.Windows.Size finalSize ) {
    double offset = 0.0;

    foreach ( UIElement child in Children ) {
        double value = Math.Min( child.DesiredSize.Height, _normalSpace ) + _extraSpace;
        child.Arrange( new Rect( 0, offset, finalSize.Width, value ) );
        offset += value;
    }

    return finalSize;
}

Это не может быть суперэффективно что с необходимостью звонить Measure дважды (и итерация Children три раза), но это работает. Любая оптимизация к алгоритму ценилась бы.