FrameworkElement.ArrangeOverride(Size) Método

Definição

Namespace:

Windows.UI.Xaml

Fornece o comportamento para a passagem de layout "Organizar". As classes podem substituir esse método para definir seu próprio comportamento de passagem "Organizar".

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

Parâmetros

finalSize

Size

A área final dentro do pai que esse objeto deve usar para organizar a si mesmo e seus filhos.

Retornos

Size

O tamanho real usado depois que o elemento é organizado no layout.

Exemplos

Este exemplo implementa ArrangeOverride para personalizar a lógica de passagem "Organizar" para uma implementação de painel personalizado. Observe, em particular, estes aspectos do código:

• Itera sobre crianças.
• Para cada filho, as chamadas Arrange, usando um Rect em que Height e Width são baseadas em DesiredSize, e X e Y são baseadas na lógica específica do painel.
• Retorna seu tamanho (nesse caso, esse painel simples retorna um tamanho fixo em vez de um tamanho calculado ao acumular as medidas de valor de Rect organizadas).

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

Esse método tem uma implementação padrão que executa o layout interno para a maioria das classes derivadas de FrameworkElement . ArrangeOverride fornece o comportamento de Arrange, sempre que Arrange é chamado pela lógica de layout interno ou pelo código do seu próprio aplicativo, incluindo quaisquer métodos ArrangeOverride próprios para outras classes. Se você estiver produzindo um controle modelo, a lógica ArrangeOverride definirá a lógica de layout de passagem "Organizar" específica do controle.

O design geral de como os elementos passam por um processo de layout quando o aplicativo é executado é dividido em duas etapas: uma passagem "Medida" e, em seguida, uma passagem "Organizar". Os autores de controle (ou autores de painel) que desejam personalizar a passagem "Organizar" do processamento de layout devem substituir ArrangeOverride. O padrão de implementação deve chamar Arrange em cada objeto filho visível e passar o tamanho desejado final para cada objeto filho como o parâmetro finalRect . Se Arrange não for chamado, o objeto filho não será renderizado.

Várias classes não lacradas existentes fornecem implementações de substituição desse método. Os destaques incluem StackPanel e Grid. Normalmente, o comportamento de ArrangeOverride produz um finalSize que não viola valores definidos pelo usuário que são colocados no próprio contêiner de layout. Por exemplo, o finalSize normalmente não é maior que a Altura e Largura do contêiner, contabilizando valores de Margem ou Preenchimento que afetam a área de conteúdo. Controles que têm especificamente um cenário para exceder o tamanho do contêiner podem retornar um valor maior, mas qualquer pessoa que use esse controle deve considerar os problemas de recorte e posicionamento resultantes dele. O valor que uma implementação ArrangeOverride passa para Arrange para cada objeto filho geralmente é o valor definido em DesiredSize pela chamada measure anterior.

Confira também

• Arrange(Rect)
• MeasureOverride(Size)
• Definir layouts com XAML