FrameworkElement.EffectiveViewportChanged Événement

// Register
event_token EffectiveViewportChanged(TypedEventHandler<FrameworkElement, EffectiveViewportChangedEventArgs const&> const& handler) const;

// Revoke with event_token
void EffectiveViewportChanged(event_token const* cookie) const;

// Revoke with event_revoker
FrameworkElement::EffectiveViewportChanged_revoker EffectiveViewportChanged(auto_revoke_t, TypedEventHandler<FrameworkElement, EffectiveViewportChangedEventArgs const&> const& handler) const;

public event TypedEventHandler<FrameworkElement,EffectiveViewportChangedEventArgs> EffectiveViewportChanged;

function onEffectiveViewportChanged(eventArgs) { /* Your code */ }
frameworkElement.addEventListener("effectiveviewportchanged", onEffectiveViewportChanged);
frameworkElement.removeEventListener("effectiveviewportchanged", onEffectiveViewportChanged);
- or -
frameworkElement.oneffectiveviewportchanged = onEffectiveViewportChanged;

Public Custom Event EffectiveViewportChanged As TypedEventHandler(Of FrameworkElement, EffectiveViewportChangedEventArgs) 

Type d'événement

Remarques

Un contrôle de défilement permet à l’utilisateur de parcourir du contenu qui occupe plus d’espace que celui disponible dans l’interface utilisateur. La partie du contenu que l’utilisateur voit est appelée fenêtre d’affichage.

L’événement EffectiveViewportChanged fournit plusieurs informations :

1. EffectiveViewport réel
2. Calcul pour maxViewport
3. Valeurs scalaires pour BringIntoViewDistanceX et BringIntoViewDistanceY

EffectiveViewport

EffectiveViewport est l’intersection de toutes les fenêtres d’affichage connues qui contiennent l’élément FrameworkElement dans leur sous-arborescence. S’il existe au moins deux fenêtres d’affichage (par exemple, un ScrollViewer imbriqué à l’intérieur d’un autre ScrollViewer) qui ne se chevauchent pas, effectiveViewport est un rect vide.

EffectiveViewport est fourni dans l’espace de coordonnées de l’élément FrameworkElement. Il n’est pas nécessaire d’effectuer un TransformToVisual avec la fenêtre d’affichage Rect.

Dans un scénario simple où il existe un ScrollViewer qui contient un seul élément, l’événement EffectiveViewportChanged fournit des mises à jour de la fenêtre d’affichage similaires à l’événement ViewChanged . La main différence est que l’événement EffectiveViewportChanged est déclenché après la passe d’organisation de la disposition.

Par exemple, cette ...

<ScrollViewer>
    <Grid Height="4000" Width="4000"
          EffectiveViewportChanged="Grid_EffectiveViewportChanged"/>
</ScrollViewer>

... fournit des informations de fenêtre d’affichage similaires à celle-ci...

<ScrollViewer ViewChanged="ScrollViewer_ViewChanged">
    <Grid Height="4000" Width="4000"/>
</ScrollViewer>

MaxViewport

MaxViewport est similaire à EffectiveViewport, mais au lieu de représenter une simple intersection des fenêtres d’affichage connues, il représente l’intersection des fenêtres d’affichage comme si chacune d’elles avait été mise en vue d’une fenêtre d’affichage externe. Le Rect résultant représente deux choses :

1. la plus grande taille que peut être effectiveViewport (compte tenu des tailles de fenêtre d’affichage actuelles), et
2. position de la fenêtre d’affichage effective maximale par rapport à FrameworkElement.

Ces informations peuvent être utilisées pour évaluer l’emplacement et la quantité de contenu que l’élément FrameworkElement doit prégénérer pour remplir potentiellement la fenêtre d’affichage avant de le faire défiler vers l’affichage.

La position de MaxViewport est signalée dans l’espace de coordonnées de l’élément FrameworkElement. Si la fenêtre MaxViewport était transformée en espace de coordonnées de la première fenêtre d’affichage dans la chaîne d’ancêtres de FrameworkElement, la fenêtre Rect se trouverait dans les limites de cette première fenêtre d’affichage.

BringIntoViewDistanceX et Y

Ces valeurs indiquent à quel point FrameworkElement est proche de devenir visible au maximum dans toutes ses fenêtres d’affichage.

Si la valeur est supérieure à zéro, mais inférieure à actualWidth / ActualHeight , l’élément se trouve en partie dans la fenêtre d’affichage visible par l’utilisateur. Lorsque les valeurs sont égales à zéro, l’élément FrameworkElement se trouve entièrement dans la fenêtre d’affichage visible par l’utilisateur.

Plus formellement, ces valeurs sont la somme de la distance absolue que l’élément FrameworkElement serait traduit lors d’un appel à StartBringIntoView. Les valeurs ne tient pas compte de la possibilité qu’un contrôle de défilement ait désactivé le défilement.

<ListView x:Name="lv">
    <ListView.ItemTemplate>
        <DataTemplate x:DataType="x:String">
            <UserControl Tag="{x:Bind}"
                         EffectiveViewportChanged="Item_EffectiveViewportChanged"/>
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>

private void Item_EffectiveViewportChanged(FrameworkElement sender, EffectiveViewportChangedEventArgs args)
{
    // If we wanted to know if a list item (w/ vertical scrolling only) is partially within the viewport
    // then we can just check the BringIntoViewDistanceY of the event args.  If the distance is 0 then the item is fully within
    // the effective viewport.  If the BringIntoViewDistanceY is less than the sender's ActualHeight, then its
    // partially within the effective viewport.
    // The EffectiveViewport rect is relative to the sender, so we can use it to know where the element is within the viewport.  
    // NOTE: "Within the viewport" != visible to the user's eye, since another element may overlap and obscure it.
    if (args.BringIntoViewDistanceY < sender.ActualHeight)
    {
        Debug.WriteLine($"Item: {sender.Tag} has {sender.ActualHeight - args.BringIntoViewDistanceY} pixels within the viewport");
    }
    else
    {
        Debug.WriteLine($"Item: {sender.Tag} has {args.BringIntoViewDistanceY - sender.ActualHeight} pixels to go before it is even partially visible");
    }

    // Consider disconnecting from the effective viewport when not needed.  Otherwise, it is called on every viewport change.
    //lv.EffectiveViewportChanged -= Item_EffectiveViewportChanged;
}

Comportement

• Si la fenêtre d’affichage effective d’un parent et d’un enfant changent, le parent reçoit la notification avant l’enfant.
• L’événement est déclenché uniquement pour les éléments de l’arborescence d’interface utilisateur qui participent à la disposition. Par exemple, si l’élément ne se trouve pas dans l’arborescence dynamique, ou si la propriété Visibility de l’élément ou de l’un de ses ancêtres est définie sur Collapsed, cet événement ne sera pas déclenché.
• Bien que la fenêtre d’affichage effective prend en compte les transformations de rendu pour tous les ancêtres d’éléments, elle ne prend pas en compte les effets du découpage (autres que le découpage de l’élément inscrit par un contrôle de défilement comme fenêtre d’affichage).
• La fenêtre d’affichage effective ne tient pas compte de l’occlusion en raison du fait que d’autres éléments ont un ordre Z plus élevé.

S’applique à

Voir aussi

• InvalidateViewport()
• UIElement.RegisterAsScrollPort