FrameworkElement.ArrangeOverride(Size) Methode

protected:
 virtual Size ArrangeOverride(Size finalSize) = ArrangeOverride;

Size ArrangeOverride(Size const& finalSize);

protected virtual Size ArrangeOverride(Size finalSize);

function arrangeOverride(finalSize)

Protected Overridable Function ArrangeOverride (finalSize As Size) As Size

Parameter

Gibt zurück

Die tatsächliche Größe, die verwendet wird, nachdem das Element im Layout angeordnet ist.

Beispiele

In diesem Beispiel wird ArrangeOverride implementiert, um die Passlogik "Anordnen" für eine benutzerdefinierte Panelimplementierung anzupassen. Beachten Sie insbesondere die folgenden Aspekte des Codes:

• Iteriert kinder.
• Ruft für jedes untergeordnete Element Anordnenauf, wobei Höhe und Breite auf DesiredSize basieren, und X und Y auf logik basieren, die für den Bereich spezifisch ist.
• Gibt seine Größe zurück (in diesem Fall gibt dieser einfache Bereich eine feste Größe und nicht eine Größe zurück, die beim Akkumulieren der angeordneten Rect-Wert-Messungen berechnet wird).

// Second arrange all children and return final size of panel
protected override Size ArrangeOverride(Size finalSize)
{
    // Get the collection of children
    UIElementCollection mychildren = Children;

    // Get total number of children
    int count = mychildren.Count;

    // Arrange children
    // We're only allowing 9 children in this panel.  More children will get a 0x0 layout slot.
    int i;
    for (i = 0; i < 9; i++)
    {

        // Get (left, top) origin point for the element in the 3x3 block
        Point cellOrigin = GetOrigin(i, 3, new Size(100, 100));

        // Arrange child
        // Get desired height and width. This will not be larger than 100x100 as set in MeasureOverride.
        double dw = mychildren[i].DesiredSize.Width;
        double dh = mychildren[i].DesiredSize.Height;

        mychildren[i].Arrange(new Rect(cellOrigin.X, cellOrigin.Y, dw, dh));

    }

    // Give the remaining children a 0x0 layout slot
    for (i = 9; i < count; i++)
    {
        mychildren[i].Arrange(new Rect(0, 0, 0, 0));
    }


    // Return final size of the panel
    return new Size(300, 300);
}

'Second arrange all children and return final size of panel 
Protected Overrides Function ArrangeOverride(ByVal finalSize As Size) As Size
    'Get the collection of children 
    Dim mychildren As UIElementCollection = Children
    'Get total number of children 
    Dim count As Integer = mychildren.Count
    'Arrange children 
    'only allowing 9 children in this panel. More children will get a 0x0 layout slot. 
    Dim i As Integer
    For i = 0 To 8
        'Get (left, top) origin point for the element in the 3x3 block 
        Dim cellOrigin As Point = GetOrigin(i, 3, New Size(100, 100))
        'Arrange child 
        'Get desired height and width. This will not be larger than 100x100 as set in MeasureOverride. 
        Dim dw As Double = mychildren(i).DesiredSize.Width
        Dim dh As Double = mychildren(i).DesiredSize.Height
        mychildren(i).Arrange(New Rect(cellOrigin.X, cellOrigin.Y, dw, dh))
    Next
    For i = 9 To count - 1
        'Give the remaining children a 0x0 layout slot 
        mychildren(i).Arrange(New Rect(0, 0, 0, 0))
    Next
    'Return final size of the panel 
    Return New Size(300, 300)
End Function
'Calculate point origin of the Block you are in 
Protected Function GetOrigin(ByVal blockNum As Integer, ByVal blocksPerRow As Integer, ByVal itemSize As Size) As Point
    'Get row number (zero-based) 
    Dim row As Integer = CInt(Math.Floor(blockNum / blocksPerRow))
    'Get column number (zero-based) 
    Dim column As Integer = blockNum - blocksPerRow * row
    'Calculate origin 
    Dim origin As New Point(itemSize.Width * column, itemSize.Height * row)
    Return origin
End Function

Hinweise

Diese Methode verfügt über eine Standardimplementierung, die ein integriertes Layout für die meisten von FrameworkElement abgeleiteten Klassen ausführt. ArrangeOverride stellt das Verhalten für Arrange bereit, wenn Arrange entweder durch die interne Layoutlogik oder den Code Ihrer eigenen App aufgerufen wird, einschließlich aller Eigenen ArrangeOverride-Methoden für andere Klassen. Wenn Sie ein vorlagenbasiertes Steuerelement erstellen, definiert die ArrangeOverride-Logik die spezifische Passlayoutlogik "Anordnen" Ihres Steuerelements.

Der allgemeine Entwurf, wie Elemente einen Layoutprozess durchlaufen, wenn Ihre App ausgeführt wird, gliedert sich in zwei Schritte: einen "Measure"-Durchlauf und dann einen Durchgang "Anordnen". Steuerelementautoren (oder Panelautoren), die den Durchgang "Anordnen" der Layoutverarbeitung anpassen möchten, sollten ArrangeOverride überschreiben. Das Implementierungsmuster sollte Arrange für jedes sichtbare untergeordnete Objekt aufrufen und die endgültige gewünschte Größe für jedes untergeordnete Objekt als finalRect-Parameter übergeben. Wenn Arrange nicht aufgerufen wird, wird das untergeordnete Objekt nicht gerendert.

Mehrere vorhandene nicht versiegelte Klassen bieten Überschreibungsimplementierungen dieser Methode. Zu den prominenten gehören StackPanel und Grid. In der Regel erzeugt das Verhalten von ArrangeOverride eine finalSize , die keine benutzerdefinierten Werte verletzt, die im Layoutcontainer selbst platziert werden. Beispielsweise ist finalSize in der Regel nicht größer als die Höhe und Breite des Containers, wobei die Werte "Margin" oder "Padding" berücksichtigt werden, die sich auf den Inhaltsbereich auswirken. Steuerelemente, die speziell ein Szenario für die Überschreitung der Containergröße aufweisen, können einen größeren Wert zurückgeben, aber jeder, der dieses Steuerelement verwendet, muss die daraus resultierenden Probleme beim Ausschneiden und Positionieren berücksichtigen. Der Wert, den eine ArrangeOverride-Implementierung für jedes untergeordnete Objekt an Arrange übergibt, ist im Allgemeinen der Wert, der in DesiredSize durch den vorherigen Measure-Aufruf festgelegt wird.

Gilt für:

Weitere Informationen

• Arrange(Rect)
• MeasureOverride(Size)
• Definieren von Layouts mit XAML