UIElement.Arrange(Rect) Método

Definição

Namespace:

Windows.UI.Xaml

Posiciona objetos filho e determina um tamanho para um UIElement. Objetos pai que implementam layout personalizado para seus elementos filho devem chamar esse método de suas implementações de substituição de layout para formar uma atualização de layout recursivo.

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)

Parâmetros

finalRect

Rect

O tamanho final que o pai calcula para o filho no layout, fornecido como um valor rect .

Exemplos

Este exemplo mostra como você usaria Arrange dentro de uma implementação ArrangeOverride . A ideia básica é que você deve consultar DesiredSize em qualquer coisa em que tentar chamar Arrange para que você tenha um valor para finalRect, a menos que sua implementação de layout tenha algum design específico que altere ou ignore o tamanho desejado antes de passá-lo como 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

Comentários

A chamada Arrange atinge potencialmente uma implementação ArrangeOverride dessa classe específica. Caso contrário, a maioria das classes FrameworkElement tem um comportamento de layout padrão implícito para Arrange.

A computação do posicionamento inicial do layout em uma interface do usuário XAML consiste em uma chamada measure e uma chamada Arrange, nessa ordem. Durante a chamada Measure , o sistema de layout determina os requisitos de tamanho de um elemento usando a medida availableSize . Durante a chamada Organizar, o sistema de layout finaliza o tamanho e a posição da caixa delimitadora de um elemento.

Quando um layout é produzido pela primeira vez, ele sempre tem uma chamada measure que acontece antes de Arrange. No entanto, após a primeira passagem de layout, uma chamada Arrange pode ocorrer sem uma Medida antes dela. Isso pode acontecer quando uma propriedade que afeta apenas Arrange é alterada (como alinhamento) ou quando o pai recebe um Arrange sem uma Medida.

Uma chamada de Medida invalidará automaticamente qualquer informação de Organização. As atualizações de layout geralmente ocorrem de forma assíncrona (em um momento determinado pelo sistema de layout). Um elemento pode não refletir imediatamente as alterações nas propriedades que afetam o dimensionamento do elemento (como Width).

As atualizações de layout podem ser forçadas pelo código do aplicativo em vez de depender do comportamento interno do sistema de layout usando o método UpdateLayout . No entanto, isso não é recomendado. Geralmente, isso é desnecessário e pode causar baixo desempenho se usado em excesso. Em muitas situações em que chamar UpdateLayout do código do aplicativo pode ser apropriado devido a alterações nas propriedades, o sistema de layout provavelmente já estará processando atualizações. O sistema de layout também tem otimizações para lidar com cascatas de alterações de layout por meio de relações pai-filho e chamar UpdateLayout pode funcionar com essas otimizações. No entanto, é possível que existam situações de layout em cenários mais complicados em que chamar UpdateLayout é a melhor opção para resolver um problema de tempo ou outro problema com layout. Use-o deliberadamente e com moderação.

Confira também

• ArrangeOverride(Size)
• MeasureOverride(Size)