UIElement.Arrange(Rect) Metodo

Definizione

Spazio dei nomi:

Microsoft.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 desiredSize su qualsiasi elemento che si tenta di chiamare Arrange 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);
}

Commenti

La Arrange chiamata 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 Di misura e da una Arrange chiamata, in tale ordine. Durante la Measure chiamata, il sistema di layout determina i requisiti di dimensione di un elemento usando la availableSize misura. 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 generato per la prima volta, ha sempre una chiamata Measure che viene eseguita prima Arrangedi . Tuttavia, dopo il passaggio del primo layout, una Arrange chiamata può verificarsi senza precederla Measure . Ciò può verificarsi quando una proprietà che influisce solo Arrange su viene modificata ,ad esempio l'allineamento, o quando l'elemento padre riceve un oggetto Arrange senza un oggetto Measure.

Una chiamata di misura invaliderà automaticamente tutte le Arrange informazioni. 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 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 variazioni di layout tramite relazioni padre-figlio e le chiamate UpdateLayout possono funzionare con tali ottimizzazioni. Tuttavia, è possibile che le situazioni di layout esistano in scenari più complessi in cui la chiamata 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)