PointerRoutedEventArgs Classe

Définition

Espace de noms:

Microsoft.UI.Xaml.Input

Contient les arguments retournés par le dernier message d’événement de pointeur.

public ref class PointerRoutedEventArgs sealed : RoutedEventArgs

/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.UI.Xaml.WinUIContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class PointerRoutedEventArgs final : RoutedEventArgs

[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class PointerRoutedEventArgs : RoutedEventArgs

Public NotInheritable Class PointerRoutedEventArgs
Inherits RoutedEventArgs

Héritage

Object Platform::Object IInspectable RoutedEventArgs PointerRoutedEventArgs

Attributs

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Exemples

L’exemple de code suivant illustre le scénario 2 de l’exemple Input. Ce code montre certains modèles d’utilisation pour la manipulation directe à l’aide des événements PointerPressed, PointerReleased, PointerEntered, PointerExited et PointerMoved .

<StackPanel x:Name="Scenario2Output" ManipulationMode="All">
  <StackPanel Orientation="Horizontal" Margin="0,10,0,0">
    <Button x:Name="scenario2Reset" Content="Reset" 
      Margin="0,0,10,0" Click="Scenario2Reset"/>
  </StackPanel>
  <StackPanel Orientation="Horizontal" >
    <ToggleSwitch x:Name="tbPointerCapture" 
      Header="Pointer Capture" FontSize="20"/>
    <TextBlock x:Name="txtCaptureStatus" 
      Style="{StaticResource BasicTextStyle}"/>
  </StackPanel>
  <Border x:Name="bEnteredExited" Background="Red" 
    Height="300" Width="450" CornerRadius="20" 
    HorizontalAlignment="Left">
    <Grid>
      <TextBlock Style="{StaticResource BasicTextStyle}" Text="" 
        HorizontalAlignment="Center" VerticalAlignment="Center" 
        x:Name="bEnteredExitedTextBlock"/>
      <Ellipse VerticalAlignment="Bottom" Stroke="Silver" 
        StrokeDashArray="2,2" StrokeThickness="2" Margin="2" 
        x:Name="bEnteredExitedTimer" Width="20" Height="20" 
        RenderTransformOrigin="0.5,0.5">
        <Ellipse.RenderTransform >
          <RotateTransform Angle="0" />
        </Ellipse.RenderTransform>
      </Ellipse>
    </Grid>
  </Border>
</StackPanel>

int _pointerCount;

public Scenario2()
{
    this.InitializeComponent();
    bEnteredExited.PointerEntered += bEnteredExited_PointerEntered;
    bEnteredExited.PointerExited += bEnteredExited_PointerExited;
    bEnteredExited.PointerPressed += bEnteredExited_PointerPressed;
    bEnteredExited.PointerReleased += bEnteredExited_PointerReleased;
    bEnteredExited.PointerMoved += bEnteredExited_PointerMoved;

    // To code for multiple Pointers (that is, fingers), 
    // we track how many entered/exited.
    _pointerCount = 0;
}

private void bEnteredExited_PointerMoved(object sender, 
    PointerRoutedEventArgs e)
{
    Scenario2UpdateVisuals(sender as Border, "Moved");
}

private void bEnteredExited_PointerReleased(object sender, 
    PointerRoutedEventArgs e)
{
    ((Border)sender).ReleasePointerCapture(e.Pointer);
    txtCaptureStatus.Text = string.Empty;
}

//Can only get capture on PointerPressed (i.e. touch down, mouse click, pen press)
private void bEnteredExited_PointerPressed(object sender, 
    PointerRoutedEventArgs e)
{
    if (tbPointerCapture.IsOn)
    {
        bool _hasCapture = ((Border)sender).CapturePointer(e.Pointer);
        txtCaptureStatus.Text = "Got Capture: " + _hasCapture;
    }
}

private void bEnteredExited_PointerExited(object sender, 
    PointerRoutedEventArgs e)
{
    _pointerCount--;
    Scenario2UpdateVisuals(sender as Border, "Exited");
}

private void bEnteredExited_PointerEntered(object sender, 
    PointerRoutedEventArgs e)
{
    _pointerCount++;
    Scenario2UpdateVisuals(sender as Border, "Entered");
}

private void Scenario2UpdateVisuals(Border border, 
    String eventDescription)
{
    switch (eventDescription.ToLower())
    {
        case "exited":
            if (_pointerCount <= 0)
            {
                border.Background = new SolidColorBrush(Colors.Red);
                bEnteredExitedTextBlock.Text = eventDescription;
            }
            break;
        case "moved":
            RotateTransform rt = 
                (RotateTransform)bEnteredExitedTimer.RenderTransform;
            rt.Angle += 2;
            if (rt.Angle > 360) rt.Angle -= 360;
            break;
        default:
            border.Background = new SolidColorBrush(Colors.Green);
            bEnteredExitedTextBlock.Text = eventDescription;
            break;
    }
}

private void Scenario2Reset(object sender, RoutedEventArgs e)
{
    Scenario2Reset();
}

private void Scenario2Reset()
{
    bEnteredExited.Background = new SolidColorBrush(Colors.Green);
    bEnteredExitedTextBlock.Text = string.Empty;
}

Remarques

Dans la plupart des cas, nous vous recommandons d’obtenir des informations de pointeur via l’argument d’événement des gestionnaires d’événements de pointeur.

Si l’argument événement n’expose pas intrinsèquement les détails du pointeur requis par votre application, vous pouvez accéder aux données de pointeur étendues via les méthodes GetCurrentPoint et GetIntermediatePoints de PointerRoutedEventArgs. Utilisez ces méthodes pour spécifier le contexte des données du pointeur.

La PointerRoutedEventArgs classe de données d’événement est utilisée pour ces événements :

• PointerPressed
• PointerCanceled
• PointerCaptureLost
• PointerEntered
• PointerExited
• PointerMoved
• PointerReleased
• PointerWheelChanged

Important

L’entrée de la souris est associée à un seul pointeur affecté lors de la première détection de l’entrée de la souris. Cliquer sur un bouton de souris (gauche, roulette ou droit) crée une association secondaire entre le pointeur et ce bouton via l’événement PointerPressed. L’événement PointerReleased est déclenché uniquement lorsque ce même bouton de souris est relâché (aucun autre bouton ne peut être associé au pointeur tant que cet événement n’est pas terminé). En raison de cette association exclusive, les autres clics de bouton de souris sont routés via l’événement PointerMoved. Vous pouvez tester l’état du bouton de la souris lors de la gestion de cet événement, comme illustré dans l’exemple suivant.

private void Target_PointerMoved(object sender, PointerRoutedEventArgs e)
{
    Pointer ptr = e.Pointer;

    // Multiple, simultaneous mouse button inputs are processed here.
    // Mouse input is associated with a single pointer assigned when 
    // mouse input is first detected. 
    // Clicking additional mouse buttons (left, wheel, or right) during 
    // the interaction creates secondary associations between those buttons 
    // and the pointer through the pointer pressed event. 
    // The pointer released event is fired only when the last mouse button 
    // associated with the interaction (not necessarily the initial button) 
    // is released. 
    // Because of this exclusive association, other mouse button clicks are 
    // routed through the pointer move event.          
    if (ptr.PointerDeviceType == PointerDeviceType.Mouse)
    {
        // To get mouse state, we need extended pointer details.
        // We get the pointer info through the getCurrentPoint method
        // of the event argument. 
        PointerPoint ptrPt = e.GetCurrentPoint(Target);
        if (ptrPt.Properties.IsLeftButtonPressed)
        {
            eventLog.Text += "\nLeft button: " + ptrPt.PointerId;
        }
        if (ptrPt.Properties.IsMiddleButtonPressed)
        {
            eventLog.Text += "\nWheel button: " + ptrPt.PointerId;
        }
        if (ptrPt.Properties.IsRightButtonPressed)
        {
            eventLog.Text += "\nRight button: " + ptrPt.PointerId;
        }
    }

    // Prevent most handlers along the event route from handling the same event again.
    e.Handled = true;

    // Display pointer details.
    updateInfoPop(e);
}

• Valeur de l’expéditeur (qui se trouve sur la signature du délégué, et non sur cette classe de données d’événement).
• Membres spécifiques de PointerRoutedEventArgs, tels que KeyModifiers ou GetCurrentPoint.
• Valeurs d’une classe de description d’appareil pointeur . Obtenez le pointeur à partir de la propriété Pointeur .
• Membres qui proviennent de la conceptualisation d’entrée système d’un Pointeur. Utilisez l’API GetCurrentPoint pour obtenir une valeur PointerPoint , puis appelez l’API PointerPoint , telle que PointerPoint.Position et PointerPointProperties.

Des événements spécifiques ont souvent des informations disponibles dans les différentes classes de pointeur et de pointeur qui sont principalement pertinentes pour cet événement. Par exemple, lorsque vous gérez PointerWheelChanged, le MouseWheelDelta de PointerPointProperties peut vous intéresser.

L’objet récupéré par les GetCurrentPoint méthodes et GetIntermediatePoints donne accès aux informations de pointeur étendues via la propriété Properties , qui obtient un objet PointerPointProperties .

Dans l’exemple suivant, nous obtenons des propriétés de pointeur étendues via les objets PointerPoint et PointerPointProperties . (Pour obtenir l’exemple complet, consultez Gérer l’entrée du pointeur .)

String queryPointer(PointerPoint ptrPt)
{
    String details = "";

    switch (ptrPt.PointerDeviceType)
    {
        case PointerDeviceType.Mouse:
            details += "\nPointer type: mouse";
            break;
        case PointerDeviceType.Pen:
            details += "\nPointer type: pen";
            if (ptrPt.IsInContact)
            {
                details += "\nPressure: " + ptrPt.Properties.Pressure;
                details += "\nrotation: " + ptrPt.Properties.Orientation;
                details += "\nTilt X: " + ptrPt.Properties.XTilt;
                details += "\nTilt Y: " + ptrPt.Properties.YTilt;
                details += "\nBarrel button pressed: " + ptrPt.Properties.IsBarrelButtonPressed;
            }
            break;
        case PointerDeviceType.Touch:
            details += "\nPointer type: touch";
            details += "\nrotation: " + ptrPt.Properties.Orientation;
            details += "\nTilt X: " + ptrPt.Properties.XTilt;
            details += "\nTilt Y: " + ptrPt.Properties.YTilt;
            break;
        default:
            details += "\nPointer type: n/a";
            break;
    }

    GeneralTransform gt = Target.TransformToVisual(panel);
    Point screenPoint;

    screenPoint = gt.TransformPoint(new Point(ptrPt.Position.X, ptrPt.Position.Y));
    details += "\nPointer Id: " + ptrPt.PointerId.ToString() +
        "\nPointer location (parent): " + ptrPt.Position.X + ", " + ptrPt.Position.Y +
        "\nPointer location (screen): " + screenPoint.X + ", " + screenPoint.Y;
    return details;
}

En règle générale, l’objet retourné par cette méthode est utilisé pour alimenter des données de pointeur vers un objet GestureRecognizer. Un autre scénario consiste à obtenir le MouseWheelDelta pour un événement PointerWheelChanged ; cette valeur se trouve dans PointerPointProperties.

Propriétés

Handled	Obtient ou définit une valeur qui marque l’événement routé comme étant géré et empêche la plupart des gestionnaires le long de l’itinéraire d’événements de gérer à nouveau le même événement.
IsGenerated	Obtient une valeur qui indique si l’événement de pointeur s’est produit à partir d’une interaction directe avec un objet par l’utilisateur ou a été généré par la plateforme en fonction des modifications apportées à l’interface utilisateur de l’application.
KeyModifiers	Obtient une valeur qui indique quels modificateurs de clé étaient actifs au moment où l’événement de pointeur a été lancé.
OriginalSource	Obtient une référence à l’objet qui a déclenché l’événement. Il s’agit souvent d’un modèle faisant partie d’un contrôle plutôt que d’un élément qui a été déclaré dans l’interface utilisateur de votre application. (Hérité de RoutedEventArgs)
Pointer	Obtient une référence à un jeton de pointeur.

Méthodes

GetCurrentPoint(UIElement)	Récupère un objet PointerPoint qui fournit des informations de base sur le pointeur associé à l’événement.
GetIntermediatePoints(UIElement)	Récupère une collection d’objets PointerPoint qui représentent l’historique des pointeurs du dernier événement de pointeur vers et y compris l’événement de pointeur actuel. Chaque Pointeur de la collection fournit des informations de base sur le pointeur associé à l’événement. Le dernier élément de la collection équivaut à l’objet PointerPoint retourné par GetCurrentPoint.

Voir aussi

• RoutedEventArgs
• PointerPressed