UIElement.Arrange(Rect) Méthode

Définition

Espace de noms:

Windows.UI.Xaml

Positionne les objets enfants et détermine la taille d’un élément UIElement. Les objets parents qui implémentent une disposition personnalisée pour leurs éléments enfants doivent appeler cette méthode à partir de leurs implémentations de remplacement de disposition pour former une mise à jour de disposition récursive.

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)

Paramètres

finalRect

Rect

Taille finale que le parent calcule pour l’enfant dans la disposition, fournie sous forme de valeur Rect .

Exemples

Cet exemple montre comment utiliser Arrange dans une implémentation ArrangeOverride . L’idée de base est que vous devez interroger DesiredSize sur tout ce que vous essayez d’appeler Arrange sur afin d’avoir une valeur pour finalRect, sauf si votre implémentation de disposition a une conception spécifique qui modifie ou ignore la taille souhaitée avant de la passer comme finalRect.

// 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

Remarques

L’appel Arrange atteint potentiellement une implémentation ArrangeOverride de cette classe spécifique. Sinon, la plupart des classes FrameworkElement ont un comportement de disposition par défaut implicite pour Arrange.

Le calcul du positionnement initial de la disposition dans une interface utilisateur XAML se compose d’un appel Measure et d’un appel Arrange, dans cet ordre. Pendant l’appel measure , le système de disposition détermine les exigences de taille d’un élément à l’aide de la mesure availableSize . Pendant l’appel Arranger, le système de disposition finalise la taille et la position du cadre englobant d’un élément.

Lorsqu’une disposition est produite pour la première fois, elle a toujours un appel De mesure qui se produit avant Arrange. Toutefois, une fois la première disposition passée, un appel Arrange peut se produire sans qu’une mesure ne la précède. Cela peut se produire lorsqu’une propriété qui affecte uniquement Arrange est modifiée (par exemple, l’alignement) ou lorsque le parent reçoit un objet Arrange sans mesure.

Un appel measure invalide automatiquement toutes les informations Arrange. Les mises à jour de disposition se produisent généralement de manière asynchrone (à un moment déterminé par le système de disposition). Un élément peut ne pas refléter immédiatement les modifications apportées aux propriétés qui affectent le dimensionnement de l’élément (par exemple , Width).

Les mises à jour de disposition peuvent être forcées par le code d’application au lieu de s’appuyer sur le comportement du système de disposition intégré à l’aide de la méthode UpdateLayout . Toutefois, cela n’est pas recommandé. Il est généralement inutile et peut entraîner des performances médiocres en cas de surutilis. Dans de nombreuses situations où l’appel de UpdateLayout à partir du code de l’application peut être approprié en raison de modifications apportées aux propriétés, le système de disposition traite probablement déjà les mises à jour. Le système de disposition dispose également d’optimisations pour gérer les cascades de modifications de disposition par le biais de relations parent-enfant, et l’appel de UpdateLayout peut fonctionner sur ces optimisations. Néanmoins, il est possible que des situations de disposition existent dans des scénarios plus complexes où l’appel de UpdateLayout est la meilleure option pour résoudre un problème de minutage ou un autre problème de disposition. Il suffit de l’utiliser délibérément et avec parcimonie.

Voir aussi

• ArrangeOverride(Size)
• MeasureOverride(Size)