UIElement.Arrange(Rect) Metodo

Definizione

Spazio dei nomi:

Windows.UI.Xaml

Posiziona gli oggetti figlio e determina una dimensione per un OGGETTO UIElement. Gli oggetti padre che implementano il layout personalizzato per gli elementi figlio devono chiamare questo metodo dalle implementazioni di override del layout per formare un aggiornamento del layout ricorsivo.

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)

Parametri

finalRect

Rect

Dimensione finale calcolata dall'elemento padre per l'elemento figlio nel layout, fornito come valore Rect .

Esempio

In questo esempio viene illustrato come usare Arrange all'interno di un'implementazione ArrangeOverride . L'idea di base è che è necessario eseguire una query su DesiredSize su qualsiasi elemento che si tenta di chiamare Arrange su in modo da avere un valore per finalRect, a meno che l'implementazione del layout non abbia una progettazione specifica che modifica o ignora le dimensioni desiderate prima di passarla come 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

Commenti

La chiamata Arrange raggiunge potenzialmente un'implementazione ArrangeOverride di tale classe specifica. In caso contrario, la maggior parte delle classi FrameworkElement ha un comportamento di layout predefinito implicito per Arrange.

Il calcolo del posizionamento iniziale del layout in un'interfaccia utente XAML è costituito da una chiamata Measure e da una chiamata Arrange, in tale ordine. Durante la chiamata a Measure , il sistema di layout determina i requisiti di dimensione di un elemento usando la misura availableSize . Durante la chiamata Arrange, il sistema di layout finalizza le dimensioni e la posizione del rettangolo di selezione di un elemento.

Quando un layout viene prodotto per la prima volta, ha sempre una chiamata Measure che viene eseguita prima di Arrange. Tuttavia, dopo il passaggio del primo layout, una chiamata Arrange può essere eseguita senza una misura precedente. Ciò può verificarsi quando viene modificata una proprietà che influisce solo su Arrange (ad esempio l'allineamento) o quando l'elemento padre riceve un oggetto Arrange senza una misura.

Una chiamata di misura invaliderà automaticamente tutte le informazioni di disposizione. Gli aggiornamenti del layout vengono in genere eseguiti in modo asincrono (alla volta determinati dal sistema di layout). Un elemento potrebbe non riflettere immediatamente le modifiche apportate alle proprietà che influiscono sul ridimensionamento degli elementi, ad esempio Width.

Gli aggiornamenti del layout possono essere forzati dal codice dell'app anziché basarsi sul comportamento del sistema di layout predefinito usando il metodo UpdateLayout . Tuttavia, questo non è consigliato. In genere non è necessario e può causare prestazioni scarse se sovrautilizzate. In molte situazioni in cui la chiamata a UpdateLayout dal codice dell'app potrebbe essere appropriata a causa delle modifiche apportate alle proprietà, il sistema di layout probabilmente sta già elaborando gli aggiornamenti. Il sistema di layout include anche ottimizzazioni per gestire le modifiche di layout tramite relazioni padre-figlio e la chiamata a UpdateLayout può funzionare su tali ottimizzazioni. Tuttavia, è possibile che le situazioni di layout esistano in scenari più complessi in cui la chiamata a UpdateLayout è l'opzione migliore per risolvere un problema di temporizzazione o un altro problema con il layout. Usalo deliberatamente e con moderazione.

Vedi anche

• ArrangeOverride(Size)
• MeasureOverride(Size)