HoldingRoutedEventArgs Clase

Definición

Espacio de nombres:

Microsoft.UI.Xaml.Input

Proporciona datos de eventos para el evento Holding .

public ref class HoldingRoutedEventArgs sealed : RoutedEventArgs

/// [Windows.Foundation.Metadata.Activatable(65536, "Microsoft.UI.Xaml.WinUIContract")]
/// [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 HoldingRoutedEventArgs final : RoutedEventArgs

[Windows.Foundation.Metadata.Activatable(65536, "Microsoft.UI.Xaml.WinUIContract")]
[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 HoldingRoutedEventArgs : RoutedEventArgs

Public NotInheritable Class HoldingRoutedEventArgs
Inherits RoutedEventArgs

Herencia

Object Platform::Object IInspectable RoutedEventArgs HoldingRoutedEventArgs

Atributos

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Ejemplos

Los fragmentos de código siguientes proceden del escenario 1: eventos de entrada del ejemplo de entrada básico.

Scenario1::Scenario1()
{
    InitializeComponent();

    // pointer press/release handlers
    pressedTarget.PointerPressed(this, &Scenario1::target_PointerPressed);
    pressedTarget.PointerReleased(this, &Scenario1::target_PointerReleased);

    // pointer enter/exit handlers
    enterExitTarget.PointerEntered(this, &Scenario1::target_PointerEntered);
    enterExitTarget.PointerExited(this, &Scenario1::target_PointerExited);

    // gesture handlers
    tapTarget.Tapped(this, &Scenario1::target_Tapped);
    tapTarget.DoubleTapped(this, &Scenario1::target_DoubleTapped);

    holdTarget.Holding(this, &Scenario1::target_Holding);
    holdTarget.RightTapped(this, &Scenario1::target_RightTapped);
}

void Scenario1::target_Holding(Windows::Foundation::IInspectable const&, Windows::UI::Xaml::Input::HoldingRoutedEventArgs const& args)
{
    if (args.HoldingState() == Windows::UI::Input::HoldingState::Started)
    {
        holdTarget.Background(Windows::UI::Xaml::Media::SolidColorBrush(Windows::UI::Colors::DeepSkyBlue()));
        holdTargetText.Text(L"Holding");
    }
    else if (args.HoldingState() == Windows::UI::Input::HoldingState::Completed)
    {
        holdTarget.Background(Windows::UI::Xaml::Media::SolidColorBrush(Windows::UI::Colors::LightGray()));
        holdTargetText.Text(L"Held");
    }
    else
    {
        holdTarget.Background(Windows::UI::Xaml::Media::SolidColorBrush(Windows::UI::Colors::LightGray()));
        holdTargetText.Text(L"Hold Canceled");
    }
}

Scenario1::Scenario1()
{
    InitializeComponent();

    // pointer press/release handlers
    pressedTarget->PointerPressed += ref new PointerEventHandler(this, &Scenario1::target_PointerPressed);
    pressedTarget->PointerReleased += ref new PointerEventHandler(this, &Scenario1::target_PointerReleased);

    // pointer enter/exit handlers
    enterExitTarget->PointerEntered += ref new PointerEventHandler(this, &Scenario1::target_PointerEntered);
    enterExitTarget->PointerExited += ref new PointerEventHandler(this, &Scenario1::target_PointerExited);

    // gesture handlers
    tapTarget->Tapped += ref new TappedEventHandler(this, &Scenario1::target_Tapped);
    tapTarget->DoubleTapped += ref new DoubleTappedEventHandler(this, &Scenario1::target_DoubleTapped);

    holdTarget->Holding += ref new HoldingEventHandler(this, &Scenario1::target_Holding);
    holdTarget->RightTapped += ref new RightTappedEventHandler(this, &Scenario1::target_RightTapped);
}

void Scenario1::target_Holding(Object^ sender, HoldingRoutedEventArgs^ e)
{
    if (e->HoldingState == Windows::UI::Input::HoldingState::Started)
    {
        holdTarget->Background = ref new SolidColorBrush(Windows::UI::Colors::DeepSkyBlue);
        holdTargetText->Text = "Holding";
    }
    else if (e->HoldingState == Windows::UI::Input::HoldingState::Completed)
    {
        holdTarget->Background = ref new SolidColorBrush(Windows::UI::Colors::LightGray);
        holdTargetText->Text = "Held";
    }
    else
    {
        holdTarget->Background = ref new SolidColorBrush(Windows::UI::Colors::LightGray);
        holdTargetText->Text = "Hold Canceled";
    }
}

public Scenario1()
{
    this.InitializeComponent();

    // pointer press/release handlers
    pressedTarget.PointerPressed += new PointerEventHandler(target_PointerPressed);
    pressedTarget.PointerReleased += new PointerEventHandler(target_PointerReleased);

    // pointer enter/exit handlers
    enterExitTarget.PointerEntered += new PointerEventHandler(target_PointerEntered);
    enterExitTarget.PointerExited += new PointerEventHandler(target_PointerExited);

    // gesture handlers
    tapTarget.Tapped += new TappedEventHandler(target_Tapped);
    tapTarget.DoubleTapped += new DoubleTappedEventHandler(target_DoubleTapped);
    holdTarget.Holding += new HoldingEventHandler(target_Holding);
    holdTarget.RightTapped += new RightTappedEventHandler(target_RightTapped);
}

void target_Holding(object sender, HoldingRoutedEventArgs e)
{
    if (e.HoldingState == Windows.UI.Input.HoldingState.Started)
    {
        holdTarget.Background = new SolidColorBrush(Windows.UI.Colors.DeepSkyBlue);
        holdTargetText.Text = "Holding";
    }
    else if (e.HoldingState == Windows.UI.Input.HoldingState.Completed)
    {
        holdTarget.Background = new SolidColorBrush(Windows.UI.Colors.LightGray);
        holdTargetText.Text = "Held";
    }
    else
    {
        holdTarget.Background = new SolidColorBrush(Windows.UI.Colors.LightGray);
        holdTargetText.Text = "Hold Canceled";
    }
}

Comentarios

Se envía un evento Holding cada vez que se presiona un dedo, un lápiz o un dispositivo señalador similar en un objeto.

Una vez transcurrido un umbral de tiempo corto, el evento se envía con un HoldingState de tipo Started.

Cuando se ha quitado el dispositivo (después de un evento Holding), se envía otro evento Holding con un HoldingState de tipo Completed.

Si el usuario cancela la suspensión después de que se haya iniciado, pero antes de que finalice, se envía un evento Holding con un HoldingState de tipo Canceled.

Constructores

HoldingRoutedEventArgs()

Inicializa una nueva instancia de la clase HoldingRoutedEventArgs .

Propiedades

Handled	Obtiene o establece un valor que marca el evento enrutado como controlado. Un true valor para Handled impide que la mayoría de los controladores a lo largo de la ruta de eventos controlen de nuevo el mismo evento.
HoldingState	Obtiene el HoldingState subyacente para la interacción.
OriginalSource	Obtiene una referencia al objeto que generó el evento. Suele ser una parte de plantilla de un control en lugar de un elemento que se declaró en la interfaz de usuario de la aplicación. (Heredado de RoutedEventArgs)
PointerDeviceType	Obtiene pointerDeviceType para el dispositivo de puntero que inició el evento de entrada asociado.

Métodos

GetPosition(UIElement)

Devuelve las coordenadas x e y de la posición del puntero, que opcionalmente se evalúan con respecto a un origen de coordenadas de un UIElement proporcionado.

Consulte también

• RoutedEventArgs
• Ejemplo de entrada básica