Partage via

FrameworkElement.ArrangeOverride(Size) Méthode

  • Référence

Définition

Espace de noms:
Windows.UI.Xaml
Modifier

Fournit le comportement de la passe « Organiser » de la disposition. Les classes peuvent remplacer cette méthode pour définir leur propre comportement de passage « Arrange ».

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

Paramètres

finalSize
Size

Dernière zone au sein du parent que cet objet doit utiliser pour organiser lui-même et ses enfants.

Retours

Size

Taille réelle utilisée après l’organisation de l’élément dans la disposition.

Exemples

Cet exemple implémente ArrangeOverride pour personnaliser la logique de passage « Arrange » pour une implémentation de panneau personnalisé. Notez en particulier les aspects suivants du code :

  • Itère sur les enfants.
  • Pour chaque enfant, appelle Arrange, à l’aide d’un rect où Height et Width sont basés sur DesiredSize, et X et Y sont basés sur une logique spécifique au panneau.
  • Retourne sa taille (dans ce cas, ce panneau simple renvoie une taille fixe plutôt qu’une taille calculée lors de l’accumulation des mesures de valeur Rect organisées).
// 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

Remarques

Cette méthode a une implémentation par défaut qui effectue une disposition intégrée pour la plupart des classes dérivées de FrameworkElement . ArrangeOverride fournit le comportement de Arrange, chaque fois que Arrange est appelé par la logique de disposition interne ou par le code de votre propre application, y compris les méthodes ArrangeOverride propres pour d’autres classes. Si vous produisez un contrôle modèle, la logique ArrangeOverride définit la logique de disposition de passe « Arrange » spécifique de votre contrôle.

La conception générale de la façon dont les éléments passent par un processus de disposition lors de l’exécution de votre application est divisée en deux étapes : une passe « Mesure », puis une passe « Organiser ». Les auteurs de contrôles (ou auteurs de panneau) qui souhaitent personnaliser la passe « Arranger » du traitement de la disposition doivent remplacer ArrangeOverride. Le modèle d’implémentation doit appeler Arrange sur chaque objet enfant visible et passer la taille finale souhaitée pour chaque objet enfant comme paramètre finalRect . Si Arrange n’est pas appelé, l’objet enfant n’est pas rendu.

Plusieurs classes non scellées existantes fournissent des implémentations de remplacement de cette méthode. Les principaux sont StackPanel et Grid. En règle générale, le comportement de ArrangeOverride produit une finalSize qui ne viole pas les valeurs définies par l’utilisateur qui sont placées sur le conteneur de disposition lui-même. Par exemple, finalSize n’est généralement pas plus grand que la hauteur et la largeur du conteneur, prenant en compte les valeurs Margin ou Padding qui affectent la zone de contenu. Les contrôles qui ont spécifiquement un scénario de dépassement de la taille du conteneur peuvent retourner une valeur plus élevée, mais toute personne utilisant ce contrôle doit tenir compte des problèmes de découpage et de positionnement qui en résultent. La valeur qu’une implémentation ArrangeOverride transmet à Arrange pour chaque objet enfant est généralement la valeur définie dans DesiredSize par l’appel de mesure précédent.

S’applique à

Voir aussi