UIElement.Arrange(Rect) Methode

Definition

Namespace:

Windows.UI.Xaml

Positioniert untergeordnete Objekte und bestimmt eine Größe für ein UIElement. Übergeordnete Objekte, die ein benutzerdefiniertes Layout für ihre untergeordneten Elemente implementieren, sollten diese Methode aus ihren Layoutüberschreibungsimplementierungen aufrufen, um ein rekursives Layoutupdate zu bilden.

public:
 virtual void Arrange(Rect finalRect) = Arrange;

void Arrange(Rect const& finalRect);

public void Arrange(Rect finalRect);

function arrange(finalRect)

Public Sub Arrange (finalRect As Rect)

Parameter

finalRect

Rect

Die endgültige Größe, die das übergeordnete Element für das untergeordnete Element im Layout berechnet, das als Rect-Wert bereitgestellt wird.

Beispiele

In diesem Beispiel wird gezeigt, wie Sie Anordnen innerhalb einer ArrangeOverride-Implementierung verwenden würden. Die Grundidee besteht darin, dass Sie DesiredSize für alles abfragen sollten, was Sie versuchen, Arrange on aufzurufen, damit Sie über einen Wert für finalRect verfügen, es sei denn, Ihre Layoutimplementierung verfügt über einen bestimmten Entwurf, der die gewünschte Größe ändert oder ignoriert, bevor sie als finalRect übergeben 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

Der Arrange-Aufruf erreicht möglicherweise eine ArrangeOverride-Implementierung dieser spezifischen Klasse. Andernfalls weisen die meisten FrameworkElement-Klassen ein implizites Standardlayoutverhalten für Arrange auf.

Die Berechnung der anfänglichen Layoutpositionierung in einer XAML-Benutzeroberfläche besteht aus einem Measure-Aufruf und einem Anordnen-Aufruf in dieser Reihenfolge. Während des Measure-Aufrufs bestimmt das Layoutsystem die Größenanforderungen eines Elements mithilfe der availableSize-Messung . Während des Anordnen-Aufrufs finalisiert das Layoutsystem die Größe und Position des Begrenzungsrahmens eines Elements.

Wenn ein Layout zum ersten Mal erstellt wird, verfügt es immer über einen Measure-Aufruf , der vor Anordnen erfolgt. Nach dem ersten Layoutdurchlauf kann ein Anordnen-Aufruf jedoch ohne Measure erfolgen. Dies kann vorkommen, wenn eine Eigenschaft, die sich nur auf Anordnen auswirkt, geändert wird (z. B. Ausrichtung), oder wenn das übergeordnete Element ein Anordnen ohne Measure empfängt.

Bei einem Measure-Aufruf werden alle Anordnungsinformationen automatisch ungültig. Layoutupdates erfolgen in der Regel asynchron (zu einem zeitpunkt, der vom Layoutsystem bestimmt wird). Ein Element spiegelt Möglicherweise nicht sofort Änderungen an Eigenschaften wider, die sich auf die Elementdimensionierung (z. B. Width) auswirken.

Layoutupdates können durch App-Code erzwungen werden, anstatt sich mithilfe der UpdateLayout-Methode auf das integrierte Layoutsystemverhalten zu verlassen. Dies wird jedoch nicht empfohlen. Es ist in der Regel unnötig und kann bei Überlastung zu einer schlechten Leistung führen. In vielen Situationen, in denen das Aufrufen von UpdateLayout aus App-Code aufgrund von Eigenschaftenänderungen möglicherweise angemessen ist, verarbeitet das Layoutsystem wahrscheinlich bereits Updates. Das Layoutsystem verfügt auch über Optimierungen für den Umgang mit Kaskaden von Layoutänderungen über übergeordnete und untergeordnete Beziehungen, und das Aufrufen von UpdateLayout kann für solche Optimierungen verwendet werden. Dennoch ist es möglich, dass Layoutsituationen in komplizierteren Szenarien auftreten, in denen der Aufruf von UpdateLayout die beste Option zum Beheben eines Zeitzeitproblems oder eines anderen Layoutproblems ist. Verwenden Sie es einfach bewusst und sparsam.

Weitere Informationen

• ArrangeOverride(Size)
• MeasureOverride(Size)