FrameworkElement.ArrangeOverride(Size) Metodo

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

Parametri

Restituisce

Dimensione effettiva usata dopo che l'elemento è disposto nel layout.

Esempio

Questo esempio implementa ArrangeOverride per personalizzare la logica di passaggio "Arrange" per un'implementazione personalizzata del pannello. Si noti in particolare questi aspetti del codice:

• Scorre i bambini.
• Per ogni figlio, chiama Arrange, usando un oggetto Rect in cui Height e Width sono basati su DesiredSize e X e Y si basano sulla logica specifica del pannello.
• Restituisce le dimensioni (in questo caso, questo semplice pannello restituisce una dimensione fissa anziché una dimensione calcolata per accumulare le misurazioni dei valori rect disposti).

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

Questo metodo ha un'implementazione predefinita che esegue il layout predefinito per la maggior parte delle classi derivate di FrameworkElement . ArrangeOverride fornisce il comportamento per Arrange, ogni volta che Arrange viene chiamato dalla logica di layout interno o dal codice dell'app, inclusi i metodi ArrangeOverride personalizzati per altre classi. Se si produce un controllo modello, la logica ArrangeOverride definisce la logica di layout di pass "Arrange" specifica del controllo.

La progettazione generale di come gli elementi passano attraverso un processo di layout quando l'app viene eseguita è divisa in due passaggi: un passaggio "Misura" e quindi un passaggio "Arrange". Gli autori di controllo (o gli autori del pannello) che vogliono personalizzare il passaggio "Arrange" dell'elaborazione del layout devono eseguire l'override di ArrangeOverride. Il modello di implementazione deve chiamare Arrange su ogni oggetto figlio visibile e passare le dimensioni desiderate finali per ogni oggetto figlio come parametro finaleRect . Se Arrange non viene chiamato, l'oggetto figlio non viene eseguito il rendering.

Diverse classi non sigillate esistenti forniscono implementazioni di override di questo metodo. Quelli principali includono StackPanel e Grid. In genere, il comportamento di ArrangeOverride produce un oggetto finalSize che non viola i valori definiti dall'utente che vengono inseriti nel contenitore di layout stesso. Ad esempio, finalSize non è in genere più grande rispetto all'altezza e alla larghezza del contenitore, tenendo conto dei valori Margin o Padding che influiscono sull'area del contenuto. I controlli che in particolare hanno uno scenario per superare le dimensioni del contenitore potrebbero restituire un valore maggiore, ma chiunque usi tale controllo deve tenere conto dei problemi di ritaglio e posizionamento che ne derivano. Il valore che un'implementazione di ArrangeOverride passa a Arrange per ogni oggetto figlio è in genere il valore impostato in DesiredSize dalla chiamata Di misura precedente.

Si applica a

Vedi anche

• Arrange(Rect)
• MeasureOverride(Size)
• Definire layout con XAML