UIElement.PointerPressed Evento

Riferimento

Definizione

Spazio dei nomi:: Windows.UI.Xaml

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Modifica

Si verifica quando il dispositivo puntatore avvia un'azione Press all'interno di questo elemento.

public:
 virtual event PointerEventHandler ^ PointerPressed;

// Register
event_token PointerPressed(PointerEventHandler const& handler) const;

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

// Revoke with event_revoker
UIElement::PointerPressed_revoker PointerPressed(auto_revoke_t, PointerEventHandler const& handler) const;

public event PointerEventHandler PointerPressed;

function onPointerPressed(eventArgs) { /* Your code */ }
uIElement.addEventListener("pointerpressed", onPointerPressed);
uIElement.removeEventListener("pointerpressed", onPointerPressed);
- or -
uIElement.onpointerpressed = onPointerPressed;

Public Custom Event PointerPressed As PointerEventHandler

<uiElement PointerPressed="eventhandler"/>

Tipo evento

PointerEventHandler

Commenti

Le interazioni tocco, mouse e penna/stilo vengono ricevute, elaborate e gestite come input puntatore nell'app UWP. Una di queste interazioni può produrre un evento PointerPressed. Per altre informazioni, vedere Gestire l'input del puntatore. Gli eventi puntatore sono destinati a scenari in cui si è interessati a più puntatori e alle relative relazioni o quando si esaminano specifiche di ogni puntatore, ad esempio la posizione esatta delle coordinate. In caso contrario, è possibile gestire gli eventi di movimento, ad esempio Tapped.

Usare un gestore basato su PointerEventHandler per gestire questo evento.

L'input del mouse è associato a un singolo puntatore assegnato quando l'input in questione è stato rilevato. Quando si fa clic su un pulsante del mouse (sinistro, rotellina o destro), si crea un’associazione secondaria tra il puntatore e il pulsante premuto mediante l’evento PointerPressed. L’evento PointerReleased viene generato solo quando lo stesso pulsante del mouse viene rilasciato. Finché questo evento non è completato, nessun altro pulsante può essere associato al puntatore. A causa di questa associazione esclusiva, altri clic su un pulsante del mouse vengono instradati attraverso l’evento PointerMoved. È possibile testare lo stato del pulsante del mouse durante la gestione di questo evento, come illustrato nell'esempio seguente.

private void Target_PointerMoved(object sender, PointerRoutedEventArgs e)
{
    Windows.UI.Xaml.Input.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 == Windows.Devices.Input.PointerDeviceType.Mouse)
    {
        // To get mouse state, we need extended pointer details.
        // We get the pointer info through the getCurrentPoint method
        // of the event argument. 
        Windows.UI.Input.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);
}

private void Target_PointerMoved(object sender, PointerRoutedEventArgs e)
{
    Windows.UI.Xaml.Input.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 == Windows.Devices.Input.PointerDeviceType.Mouse)
    {
        // To get mouse state, we need extended pointer details.
        // We get the pointer info through the getCurrentPoint method
        // of the event argument. 
        Windows.UI.Input.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);
}

Gli eventi puntatore da un dispositivo di input del mouse in genere hanno lo stesso PuntatoreId nei dettagli dell'evento per la durata dell'app.

PointerPressed è un evento indirizzato. Per altre informazioni sul concetto di evento indirizzato, vedere Panoramica degli eventi e degli eventi indirizzati.

Per le azioni tocco e per gli eventi di modifica o specifici dell'interazione che sono la conseguenza di un'azione tocco, un elemento deve essere visibile tramite hit testing per poter essere l'origine dell'evento e attivare l'evento associato all'azione. UIElement.Visibility deve essere visibile. Altre proprietà dei tipi derivati influiscono anche sulla visibilità di hit test. Per altre informazioni, vedi Panoramica degli eventi e degli eventi indirizzati.

PointerPressed supporta la possibilità di collegare gestori eventi alla route che verrà richiamata anche se i dati dell'evento per l'evento sono contrassegnati come Handled. Vedere AddHandler.

I controlli specifici Windows Runtime possono avere la gestione basata sulla classe per l'evento di input PointerPressed. In tal caso, il controllo ha probabilmente un override per il metodo OnPointerPressed. In genere l'evento viene contrassegnato come gestito dal gestore della classe e l'evento PointerPressed non viene generato per la gestione da parte dei gestori di codice utente su tale controllo. ButtonBase, ad esempio, gestisce la gestione delle classi che gestisce PointerPressed e attiva invece Click. Per altre informazioni sulla gestione basata sulla classe per gli eventi, vedere Panoramica degli eventi e degli eventi indirizzati.

I controlli possono anche avere un'animazione di personalità PointerDownThemeAnimation che viene eseguita indipendentemente dall'evento.

Acquisizione puntatore

PointerPressed viene talvolta usato come evento di avvio durante l'acquisizione del puntatore, in modo che altri eventi correlati al puntatore vengano acquisiti da un particolare elemento, purché il puntatore rimanga inattivo. Per acquisire un puntatore, si chiama il metodo CapturePointer in un elemento dell'interfaccia utente specifico che deve mantenere l'acquisizione. Questa operazione viene in genere eseguita all'interno di un gestore eventi PointerPressed e si chiama CapturePointer nel mittente dell'evento. Per altre informazioni su come acquisire un puntatore e sul motivo per cui si vuole eseguire questa operazione, vedere CapturePointer.

Eventi puntatorepressi e movimenti o eventi di manipolazione

L'azione dell'utente che genera un evento PointerPressed inizialmente può causare l'evento Holding che rappresenta un movimento di blocco , a meno che il dispositivo di input non sia un mouse. Se l'elemento in cui si verifica PointerPressed ha un valore ManipulationMode non predefinito, l'azione potrebbe anche causare vari eventi di manipolazione come ManipulationStarted. Per altre informazioni, vedere la sezione "Uso di eventi di manipolazione" in Input del puntatore di gestione.

Quando PointerPressed viene attivato, gli eventi di movimento come Tapped non verranno ancora attivati perché gli eventi di movimento diversi da Holding sono in attesa del rilascio del puntatore prima di avviare un evento.

Come regola generale di progettazione per le interazioni utente dell'app, è necessario esaminare se sono presenti eventi specifici del controllo che è possibile gestire per un'interazione o eventi di movimento appropriati. Ad esempio, se il controllo è un pulsante, tale controllo ha un evento Click destinato in modo specifico quando l'utente richiama l'azione del pulsante. In alternativa, se l'elemento non è un pulsante, ma si gestisce l'evento e l'evento per l'azione primaria di un elemento, si gestirà Tapped.

Gli eventi di movimento possono essere disabilitati in modo specifico sui singoli elementi impostando proprietà come IsTapEnabled. È possibile disabilitare gli eventi di movimento se si elaborano modifiche, ma in genere non è necessario disabilitare gli eventi di movimento se si gestiscono gli eventi del puntatore. Gli eventi del puntatore non possono essere disabilitati in modo specifico, ma è possibile scegliere di non gestirli.

PointerPressed e PointerReleased

Altri eventi anziché PointerReleased possono essere attivati alla fine dell'azione, ad esempio PointerCanceled o PointerCaptureLost. Non basarsi sugli eventi PointerPressed e PointerReleased che si verificano sempre in coppie. Per funzionare correttamente, l'app deve ascoltare e gestire tutti gli eventi che rappresentano probabilmente le conclusioni dell'azione Press . Alcuni dei motivi per cui non è possibile ottenere un'occorrenza PointerReleased sono:

Differenze nel modo in cui l'hardware specifico gestisce le azioni tocco e Premere azioni
Acquisizione del puntatore a livello di codice da un puntatore diverso
Azioni utente che modificano la relazione dell'area di visualizzazione, ad esempio la modifica della risoluzione o delle impostazioni di monitoraggio
Interazioni di input, ad esempio uno stilo che tocca la stessa superficie di un'azione tocco precedente

Si applica a