UIElement.CapturePointer(Pointer) Methode

public:
 virtual bool CapturePointer(Pointer ^ value) = CapturePointer;

bool CapturePointer(Pointer const& value);

public bool CapturePointer(Pointer value);

function capturePointer(value)

Public Function CapturePointer (value As Pointer) As Boolean

Parameter

Gibt zurück

truewenn das Objekt Zeigererfassung hat; andernfalls . false

Beispiele

In diesem Beispiel wird das Aufrufen CapturePointer basierend auf der Behandlung von PointerPressed gezeigt. Außerdem wird ein Muster zum Nachverfolgen und Zählen von Zeigerbezügen angezeigt.

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;
}

Hinweise

Sie können den Zeiger nur erfolgreich erfassen, wenn sich dieser Zeiger in einem gedrückten Zustand befindet (Pointer.IsInContact sollte sein true). Was physisch als gedrückt gilt, hängt vom Zeigergerättyp ab (gedrückte Maustaste, Fingereingabepunkt, Eingabestift in Kontakt). Wenn Sie versuchen, einen Zeiger zu erfassen, der nicht gedrückt wurde oder wo der Zeiger zuvor gedrückt wurde, aber jetzt freigegeben ist, gibt CapturePointer zurück false. Vorhandene Erfassungen sind von einem CapturePointer zurückgegebenen falseAnruf nicht betroffen.

Normalerweise erfassen Sie den Zeiger in einem PointerPressed-Ereignishandler . Die Zeigerinstanz , die Sie aus den PointerRoutedEventArgs-Ereignisdaten des PointerPressed Handlers abrufen, ist der Wert, den Sie für den value Parameter übergeben sollten, wenn Sie den Code des Handlers aufrufen CapturePointer .

Normalerweise erfassen Sie den Zeiger, da die aktuelle Zeigeraktion ein Verhalten in Ihrer App initiieren soll. In diesem Fall möchten Sie in der Regel nicht, dass andere Elemente andere Ereignisse behandeln, die aus den Aktionen dieses Zeigers stammen, bis Ihr Verhalten abgeschlossen oder abgebrochen wird, indem Sie die Zeigererfassung freigeben. Wenn ein Zeiger erfasst wird, ruft nur das Element, das erfasst wurde, die Eingabeereignisse des Zeigers ab, und andere Elemente auslösen keine Ereignisse, auch wenn der Zeiger in ihre Grenzen wechselt. Betrachten Sie beispielsweise eine Benutzeroberfläche mit zwei angrenzenden Elementen. Wenn Sie den Zeiger normalerweise von einem Element zum anderen verschoben haben, erhalten Sie zunächst PointerMoved-Ereignisse aus dem ersten Element und dann aus dem zweiten Element. Wenn das erste Element jedoch den Zeiger erfasst hat, empfängt PointerMoved das erste Element weiterhin Ereignisse, auch wenn der erfasste Zeiger seine Grenzen verlässt. Außerdem löst das zweite Element keine PointerEntered-Ereignisse für einen erfassten Zeiger aus, wenn der erfasste Zeiger ihn eingibt.

Der Zeigererfassungszustand und das Generieren der Ereignisse, die mit der Zeigererfassung zusammenhängen, liegt nicht vollständig bei App-Code. Wenn der Benutzer den Zeiger loslässt, der ein PointerReleased-Ereignis generiert, und Zeigererfassungen, die diesem Zeiger zugeordnet sind, gehen verloren. Dadurch wird auch PointerCaptureLost für das ursprüngliche Aufnahmeelement ausgelöst.

In den meisten Fällen wird die Zeigererfassung automatisch losgelassen, wenn der Benutzer eine Eingabeaktion abschließt, die die vorherige Zeigererfassung loslässt (Heben eines Touchpunkts, Loslassen der linken Maustaste, Sodass der Eingabestift außerhalb des Zulässigen Bereichs genommen wird). Eine weitere Bedingung, die die Erfassung freigeben kann, ist jede Aktion, die auch ein PointerCanceled-Ereignis auslöst. Ihre App kann sich in der Regel auf das Verhalten der Erfassung verlassen, das Benutzereingabeaktionen zugeordnet ist, ohne eine Zeigeraufnahme mit ReleasePointerCaptures oder ReleasePointerCaptures explizit abbrechen zu müssen. Weitere Informationen finden Sie unter Mausinteraktionen.

Die CapturePointer Methode wird zurückgegeben false , wenn der Zeiger bereits erfasst wurde.

Ein UIElement kann mehrere Zeigerpunkte gleichzeitig erfassen. Verwenden Sie den value Parameter, um die Zeigerinstanz anzugeben, die Sie erfassen möchten.

Die Eingabeereignisse, die Gesten darstellen (z. B. Getippt oder DoubleTapped), werden normalerweise erst ausgelöst, nachdem ein Zeiger losgelassen wurde. Daher sollten Sie nicht versuchen, einen Zeiger in Ereignishandlern für Gestenereignisse zu erfassen. Der Zeigerverweis in Ereignisdaten für Gestikereignisse darf keine Zeigererfassung initiieren.

Weitere Informationen

• Pointer
• ReleasePointerCapture(Pointer)
• Behandeln von Zeigereingaben
• Relative Mausbewegung und CoreWindow
• Eingabebeispiel (UWP)