Érintéses interakciók fejlesztői útmutatója

Úgy tervezheti meg az alkalmazást, hogy az érintés lesz a felhasználók elsődleges bemeneti módszere. WinUI-vezérlők használata esetén az érintőpad, az egér és a toll/toll támogatása nem igényel további programozást, mivel a WinUI-alkalmazások ezt ingyenesen biztosítják.

Ne feledje azonban, hogy az érintésre optimalizált felhasználói felület nem mindig jobb a hagyományos felhasználói felületnél. Mindkettő olyan előnyöket és hátrányokat biztosít, amelyek egyediek a technológia és az alkalmazás számára. Az érintéses első felhasználói felületre lépéskor fontos megérteni az érintés, az érintőpárna, a toll/toll, az egér és a billentyűzet bemenete közötti alapvető különbségeket.

Important API-k: Microsoft. UI. Xaml.Input, Windows. UI. Core, Windows. Devices.Input

Sok eszköz több érintőképernyős képernyővel rendelkezik, amelyek támogatják egy vagy több ujj (vagy érintéses névjegy) bevitelét. Az érintési pontok és azok mozgása érintési gesztusokként és manipulációként értelmezik a különböző felhasználói interakciók támogatására.

A Windows app számos különböző mechanizmust tartalmaz az érintéses bevitel kezelésére, így olyan magával ragadó élményt hozhat létre, amelyet a felhasználók magabiztosan fedezhetnek fel. Itt bemutatjuk az érintéses bevitel használatának alapjait egy Windows app.

Az érintéses interakciókhoz három dolog szükséges:

• Érintésérzékeny kijelző.
• A kijelzőn egy vagy több ujj közvetlen érintése (vagy közelsége, ha a kijelző közelségérzékelőkkel rendelkezik és támogatja a lebegtetés érzékelését).
• Az érintési pontok mozgása (vagy annak hiánya egy meghatározott időkeret alapján).

Az érintésérzékelő által megadott bemeneti adatok a következőek lehetnek:

• Fizikai kézmozdulatként értelmezve egy vagy több felhasználói felületi elem közvetlen manipulálására, például görgetés, forgatás, átméretezés vagy mozgatás. (Ezzel szemben az elemekkel való interakció a tulajdonságablak, a párbeszédpanel vagy más használati elem útján közvetett manipulációnak minősül.)
• Felismerhető alternatív beviteli módszerként, mint például az egér vagy a toll.
• Más beviteli módszerek kiegészítésére vagy módosítására szolgál, például a tollal rajzolt tintavonal elmaszatolására.

Az érintéses bemenet általában egy elem közvetlen kezelését foglalja magában a képernyőn. Az elem azonnal reagál a találati tesztterületen belüli érintésekre, és megfelelően követi az érintések későbbi mozgását, beleértve azok eltávolítását is.

Az egyéni érintéses kézmozdulatokat és interakciókat gondosan kell megtervezni. Intuitívnak, rugalmasnak és felderíthetőnek kell lenniük, és lehetővé kell tenniük, hogy a felhasználók magabiztosan felfedezzék az alkalmazást.

Győződjön meg arról, hogy az alkalmazásfunkciók minden támogatott beviteli eszköztípuson egységesen elérhetők. Szükség esetén használjon valamilyen közvetett beviteli módot, például szövegbevitelt billentyűzet-interakciókhoz, vagy az egér és toll felhasználói felületét.

Ne feledje, hogy a hagyományos beviteli eszközök (például az egér és a billentyűzet) ismerősek és vonzóak sok felhasználó számára. Olyan sebességet, pontosságot és tapintásos visszajelzést nyújthatnak, amely érintéssel nem érhető el.

Az egyedi és egyedi interakciós élmény biztosítása minden bemeneti eszköz számára támogatja a képességek és beállítások legszélesebb körét, a lehető legszélesebb közönség számára vonzó, és több ügyfelet vonz az alkalmazáshoz.

Érintésvezérlési követelmények összehasonlítása

Az alábbi táblázat néhány olyan különbséget mutat be a bemeneti eszközök között, amelyeket érdemes figyelembe venni az érintésre optimalizált Windows-alkalmazások tervezésekor.

Érintéses visszajelzés használata

Az alkalmazással való interakciók során a megfelelő vizuális visszajelzések segítenek a felhasználóknak felismerni, megtanulni és alkalmazkodni ahhoz, hogy az alkalmazás és a Windows platform hogyan értelmezi az interakcióikat. A vizuális visszajelzések jelezhetik a sikeres interakciókat, a továbbítási rendszer állapotát, javíthatják az irányítás érzését, csökkenthetik a hibákat, segíthetnek a felhasználóknak megérteni a rendszert és a bemeneti eszközt, és ösztönözhetik az interakciót.

A vizuális visszajelzés kritikus fontosságú, ha a felhasználó érintéses bemenetre támaszkodik olyan tevékenységek esetében, amelyek helytől függően pontosságot és pontosságot igényelnek. Visszajelzést jeleníthet meg minden alkalommal és bárhol, amikor érintéses bemenetet észlel, hogy a felhasználó megértse az alkalmazás és annak vezérlői által meghatározott egyéni célzási szabályokat.

Célcsoportkezelés

A célzás az alábbiakra van optimalizálva:

• Érintési célpontok méretei

  A világos méretre vonatkozó irányelvek biztosítják, hogy az alkalmazások kényelmes felhasználói felületet biztosítsanak, amely könnyen és biztonságosan használható objektumokat és vezérlőket tartalmaz.

• Kapcsolati geometria

  Az ujj teljes érintkezési területe határozza meg a legvalószínűbb célobjektumot.

• Scrubbing

  A csoporton belüli elemeket egyszerűen újracélzhatja, ha az ujját húzza közéjük (például választógombokat). Az aktuális elem aktiválása az érintés feloldásakor történik.

• Hintáztatás

  A sűrűn elhelyezett elemek (például hivatkozások) könnyen újracélozhatók, ha az ujját lenyomva tartják, és csúsztatás nélkül oda-vissza billegetik az elemeken. Az elzáródás miatt az aktuális elemet egy tooltip vagy az állapotsor azonosítja, és az érintés feloldásakor aktiválódik.

Pontosság

A hanyag interakciók tervezése a következőkkel:

• Olyan illesztőpontok, amelyek megkönnyítik a kívánt helyeken való megállást, amikor a felhasználók tartalmat használnak.
• Irányított "sínek", amelyek segíthetnek a függőleges vagy vízszintes pásztázásban, még akkor is, ha a kéz enyhe ívben mozog. További információért lásd a irányelveket a pásztázáshoz.

Elzáródás

Az ujj- és kézelzáródás az alábbiakon keresztül kerülhető el:

• A felhasználói felület mérete és elhelyezése

  A felhasználói felület elemeit elég nagyra kell méretezni, hogy azokat ne fedje le teljesen egy ujjbegyes érintkezési terület.

  A menük és előugró ablakok elhelyezése a kapcsolati terület felett, amikor csak lehetséges.

• Tooltips

  Elemleírások megjelenítése, ha egy felhasználó ujját rajta tartja egy objektumon. Ez hasznos az objektumfunkciók leírásához. A felhasználó lehúzhatja az ujjhegyet az objektumról, hogy elkerülje az elemleírás meghívását.

  Kis objektumoknál az elemleírásokat úgy kell eltolni, hogy ne fedje el őket az ujjbegy érintkezési területe. Ez hasznos a célzáshoz.

• Fogantyúk a precizitás érdekében

  Ahol pontosságra van szükség (például szövegkijelölésnél), a pontosság érdekében használjon elmozdítva elhelyezett kijelölési markereket. További információért lásd: Útmutatások a szöveg és a képek kiválasztásához (Windows-futtatókörnyezet alkalmazások).

Időzítés

Kerülje az időzított módváltásokat a közvetlen manipuláció érdekében. A közvetlen manipuláció egy objektum közvetlen, valós idejű fizikai kezelését szimulálja. Az objektum az ujjak mozgatása során válaszol.

Az időzított interakció viszont egy érintéses interakció után következik be. Az időzított interakciók általában láthatatlan küszöbértéktől függenek, például az időtől, a távolságtól vagy a sebességtől, hogy meghatározzák, milyen parancsot kell végrehajtani. Az időzított interakciók nem rendelkeznek vizuális visszajelzéssel, amíg a rendszer nem hajtja végre a műveletet.

A közvetlen manipuláció számos előnnyel jár az időzított interakciók során:

• Az interakciók során a felhasználók azonnali vizuális visszajelzései aktívabbá, magabiztosabbá és irányíthatóbbá teszik a felhasználókat.
• A közvetlen manipulációk biztonságosabbá teszik a rendszer felfedezését, mivel visszafordíthatók – a felhasználók egyszerűen, logikusan és intuitív módon léphetnek vissza a műveleteken.
• Az objektumokra közvetlenül ható és a valós interakciókat utánzó interakciók intuitívabbak, felderíthetők és emlékezetesebbek. Nem támaszkodnak homályos vagy absztrakt interakciókra.
• Az időzítendő interakciók végrehajtása nehéz lehet, mivel a felhasználóknak tetszőleges és láthatatlan küszöbértékeket kell elérniük.

Emellett erősen ajánlott a következő:

• A manipulációkat nem szabad megkülönböztetni a használt ujjak számától.
• Az interakcióknak támogatniuk kell az összetett manipulációkat. Például csippentéssel nagyíthat, miközben az ujjait mozgatja a pásztázáshoz.
• Az interakciókat nem szabad idő szerint megkülönböztetni. Ugyanannak az interakciónak ugyanazzal az eredménnyel kell rendelkeznie, függetlenül a végrehajtásához szükséges időtől. Az időalapú aktiválások kötelező késéseket vezetnek be a felhasználók számára, ami csökkenti a közvetlen manipuláció élményét és a rendszer válaszképességének érzékelését.

  Megjegyzés:

  Ez alól kivételt képeznek az adott időzített interakciók, amelyek segítenek a tanulásban és a feltárásban (például nyomja meg és tartsa lenyomva).

• A megfelelő leírások és vizuális jelek nagy hatással vannak a speciális interakciók használatára.

Alkalmazásnézetek

A felhasználói interakciós felület finomhangolása az alkalmazásnézetek pásztázási/görgetési és nagyítási beállításaival. Az alkalmazásnézetek azt határozzák meg, hogy a felhasználó hogyan fér hozzá és módosítsa az alkalmazást és annak tartalmát. A nézetek olyan viselkedéseket is biztosítanak, mint a tehetetlenség, a tartalomhatár visszapattanása és a rögzítési pontok.

A ScrollViewer vezérlő pásztázási és görgetési beállításai határozzák meg, hogy a felhasználók hogyan navigálnak egyetlen nézetben, ha a nézet tartalma nem fér el a nézetportban. Egyetlen nézet lehet például egy magazin vagy könyv lapja, a számítógép mappastruktúrája, egy dokumentumtár vagy egy fényképalbum.

A nagyítási beállítások az optikai nagyításra (a ScrollViewer vezérlő által támogatott) és a Szemantikai nagyítás vezérlőre is érvényesek. A szemantikai nagyítás érintésre optimalizált technika, a nagy mennyiségű kapcsolódó adat vagy tartalom egyetlen nézetben való bemutatására és navigálására. Két különböző besorolási mód vagy nagyítási szint használatával működik. Ez hasonló az egyetlen nézetben történő pásztázáshoz és görgetéshez. A pásztázás és a görgetés a szemantikai nagyítással együtt használható.

Alkalmazásnézetek és események használatával módosíthatja a pásztázási/görgetési és nagyítási viselkedést. Ez a mutató- és kézmozdulatesemények kezelésével a lehetségesnél zökkenőmentesebb interakciót biztosít.

További információ az alkalmazásnézetekről: Vezérlők, elrendezések és szöveg.

Egyéni érintéses interakciók

Ha saját interakciós támogatást valósít meg, vegye figyelembe, hogy a felhasználók intuitív felhasználói élményt várnak, amely az alkalmazás felhasználói felületi elemeivel való közvetlen interakciót foglalja magában. Javasoljuk, hogy modellezze az egyéni interakciókat a platformvezérlő kódtárakban, hogy a dolgok konzisztensek és felderíthetők legyenek. A kódtárak vezérlői teljes körű felhasználói interakciót biztosítanak, beleértve a standard interakciókat, az animált fizikai effektusokat, a vizuális visszajelzéseket és az akadálymentességet. Egyéni interakciókat csak akkor hozhat létre, ha egyértelmű, jól meghatározott követelmény áll fenn, és az alapszintű interakciók nem támogatják a forgatókönyvet.

A testre szabott érintéses támogatás érdekében különböző UIElement eseményeket kezelhet. Ezek az események három absztrakciós szintre vannak csoportosítva.

• A statikus kézmozdulat-események az interakció befejezése után aktiválódnak. A kézmozdulatos események közé tartozik a koppintott, a dupla koppintott, a jobb gombos koppintás, és a hosszan nyomott.

  Bizonyos elemek kézmozdulat-eseményeit letilthatja úgy, hogy IsTapEnabled, IsDoubleTapEnabled, IsRightTapEnabled, IsHoldingEnabled pedig hamis.

• Az olyan mutatóesemények, mint a PointerPressed és PointerMoved, minden érintési ponthoz alacsony szintű adatokat biztosítanak, beleértve a pointer mozgását, valamint a nyomás és kioldás események megkülönböztetésének képességét.

  A mutató egy egységes eseménymechanizmussal rendelkező általános bemeneti típus. Az aktív beviteli forráson alapvető információkat, például képernyőpozíciót tesz elérhetővé, amelyek lehetnek érintés, érintőpárna, egér vagy toll.

• A manipulációs kézmozdulatok eseményei (például ManipulationStarted) egy folyamatos interakcióra mutatnak. Addig működnek, amíg a felhasználó megérint egy elemet, és folytatódnak, amíg a felhasználó nem emeli fel az ujjait, vagy amíg a műveletet meg nem szakítják.

  A manipulációs események közé tartoznak a több érintéses interakciók, például a nagyítás, a pásztázás vagy a forgatás, valamint a tehetetlenségi és sebességadatokat, például a húzást használó interakciók. A manipulációs események által biztosított információk nem azonosítják a végrehajtott interakció formáját, hanem olyan adatokat tartalmaznak, mint a pozíció, a fordítási változás és a sebesség. Az érintéses adatok segítségével meghatározhatja a végrehajtandó interakció típusát.

Íme a WinUI által támogatott érintéses kézmozdulatok alapszintű készlete.

Kézmozdulat-események

Az egyes vezérlőkkel kapcsolatos részletekért tekintse meg a Vezérlők listát.

Mutatóesemények

A mutatóeseményeket számos aktív bemeneti forrás emeli ki, beleértve az érintést, az érintőpárnát, a tollat és az egeret (a hagyományos egéreseményeket helyettesítik).)

A mutatóesemények egyetlen bemeneti ponton (ujj, tollhegy, egérmutató) alapulnak, és nem támogatják a sebességalapú interakciókat.

Íme a mutatóesemények és a hozzájuk kapcsolódó eseményargumentumok listája.

Az alábbi példa bemutatja, hogyan kezelhetők a pointerPressed, a PointerReleased és a PointerExited események egy téglalap objektumon történő koppintásos műveletek.

Először létrejön egy téglalap az XAML (Extensible Application Markup Language) nyelven.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <Rectangle Name="touchRectangle"
           Height="100" Width="200" Fill="Blue" />
</Grid>

Ezután a PointerPressed, PointerReleasedés PointerExited események figyelői kerülnek meghatározásra.

MainPage::MainPage()
{
    InitializeComponent();

    // Pointer event listeners.
    touchRectangle->PointerPressed += ref new PointerEventHandler(this, &MainPage::touchRectangle_PointerPressed);
    touchRectangle->PointerReleased += ref new PointerEventHandler(this, &MainPage::touchRectangle_PointerReleased);
    touchRectangle->PointerExited += ref new PointerEventHandler(this, &MainPage::touchRectangle_PointerExited);
}

public MainPage()
{
    this.InitializeComponent();

    // Pointer event listeners.
    touchRectangle.PointerPressed += touchRectangle_PointerPressed;
    touchRectangle.PointerReleased += touchRectangle_PointerReleased;
    touchRectangle.PointerExited += touchRectangle_PointerExited;
}

Public Sub New()

    ' This call is required by the designer.
    InitializeComponent()

    ' Pointer event listeners.
    AddHandler touchRectangle.PointerPressed, AddressOf touchRectangle_PointerPressed
    AddHandler touchRectangle.PointerReleased, AddressOf Me.touchRectangle_PointerReleased
    AddHandler touchRectangle.PointerExited, AddressOf touchRectangle_PointerExited

End Sub

Végül a PointerPressed eseménykezelő növeli a téglalapMagasság és Szélesség, míg a PointerReleased és PointerExited eseménykezelők beállítják a Magasság és Szélesség vissza a kezdőértékekre.

// Handler for pointer exited event.
void MainPage::touchRectangle_PointerExited(Object^ sender, PointerRoutedEventArgs^ e)
{
    Rectangle^ rect = (Rectangle^)sender;

    // Pointer moved outside Rectangle hit test area.
    // Reset the dimensions of the Rectangle.
    if (nullptr != rect)
    {
        rect->Width = 200;
        rect->Height = 100;
    }
}

// Handler for pointer released event.
void MainPage::touchRectangle_PointerReleased(Object^ sender, PointerRoutedEventArgs^ e)
{
    Rectangle^ rect = (Rectangle^)sender;

    // Reset the dimensions of the Rectangle.
    if (nullptr != rect)
    {
        rect->Width = 200;
        rect->Height = 100;
    }
}

// Handler for pointer pressed event.
void MainPage::touchRectangle_PointerPressed(Object^ sender, PointerRoutedEventArgs^ e)
{
    Rectangle^ rect = (Rectangle^)sender;

    // Change the dimensions of the Rectangle.
    if (nullptr != rect)
    {
        rect->Width = 250;
        rect->Height = 150;
    }
}

// Handler for pointer exited event.
private void touchRectangle_PointerExited(object sender, PointerRoutedEventArgs e)
{
    Rectangle rect = sender as Rectangle;

    // Pointer moved outside Rectangle hit test area.
    // Reset the dimensions of the Rectangle.
    if (null != rect)
    {
        rect.Width = 200;
        rect.Height = 100;
    }
}
// Handler for pointer released event.
private void touchRectangle_PointerReleased(object sender, PointerRoutedEventArgs e)
{
    Rectangle rect = sender as Rectangle;

    // Reset the dimensions of the Rectangle.
    if (null != rect)
    {
        rect.Width = 200;
        rect.Height = 100;
    }
}

// Handler for pointer pressed event.
private void touchRectangle_PointerPressed(object sender, PointerRoutedEventArgs e)
{
    Rectangle rect = sender as Rectangle;

    // Change the dimensions of the Rectangle.
    if (null != rect)
    {
        rect.Width = 250;
        rect.Height = 150;
    }
}

' Handler for pointer exited event.
Private Sub touchRectangle_PointerExited(sender As Object, e As PointerRoutedEventArgs)
    Dim rect As Rectangle = CType(sender, Rectangle)

    ' Pointer moved outside Rectangle hit test area.
    ' Reset the dimensions of the Rectangle.
    If (rect IsNot Nothing) Then
        rect.Width = 200
        rect.Height = 100
    End If
End Sub

' Handler for pointer released event.
Private Sub touchRectangle_PointerReleased(sender As Object, e As PointerRoutedEventArgs)
    Dim rect As Rectangle = CType(sender, Rectangle)

    ' Reset the dimensions of the Rectangle.
    If (rect IsNot Nothing) Then
        rect.Width = 200
        rect.Height = 100
    End If
End Sub

' Handler for pointer pressed event.
Private Sub touchRectangle_PointerPressed(sender As Object, e As PointerRoutedEventArgs)
    Dim rect As Rectangle = CType(sender, Rectangle)

    ' Change the dimensions of the Rectangle.
    If (rect IsNot Nothing) Then
        rect.Width = 250
        rect.Height = 150
    End If
End Sub

Manipulációs események

Használjon manipulációs eseményeket az alkalmazásban, ha több ujjal végzett interakciót vagy sebességadatokat igénylő interakciókat kell támogatnia.

A manipulációs események segítségével észlelheti az olyan interakciókat, mint a húzás, a nagyítás és a fogás.

Íme a manipulációs események és a kapcsolódó eseményargumentumok listája.

A kézmozdulatok manipulációs események sorozatából állnak. Minden kézmozdulat egy ManipulationStarted eseménysel kezdődik, például amikor egy felhasználó megérinti a képernyőt.

Ezután egy vagy több ManipulationDelta események aktiválódnak. Ha például megérinti a képernyőt, majd húzza az ujját a képernyőn. Végül egy ManipulationCompleted esemény jön létre, amikor az interakció befejeződik.

Az alábbi példa bemutatja, hogyan használható a ManipulationDelta-események egy téglalapon történő dia-interakció kezelésére és a képernyőn való mozgatására.

Először egy téglalap hozódik létre az XAML-ben, amelynek neve touchRectangle, magassága és szélessége , 200.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <Rectangle Name="touchRectangle"
               Width="200" Height="200" Fill="Blue" 
               ManipulationMode="All"/>
</Grid>

Ezután létrejön egy globális TranslateTransform, amelyet dragTranslation-nek nevezünk a téglalap áthelyezésére. A ManipulationDelta eseményfigyelő a Téglalapvan megadva, és dragTranslation hozzáadódik a RenderTransform a Téglalapesetén.

// Global translation transform used for changing the position of 
// the Rectangle based on input data from the touch contact.
Windows::UI::Xaml::Media::TranslateTransform^ dragTranslation;

// Global translation transform used for changing the position of 
// the Rectangle based on input data from the touch contact.
private TranslateTransform dragTranslation;

' Global translation transform used for changing the position of 
' the Rectangle based on input data from the touch contact.
Private dragTranslation As TranslateTransform

MainPage::MainPage()
{
    InitializeComponent();

    // Listener for the ManipulationDelta event.
    touchRectangle->ManipulationDelta += 
        ref new ManipulationDeltaEventHandler(
            this, 
            &MainPage::touchRectangle_ManipulationDelta);
    // New translation transform populated in 
    // the ManipulationDelta handler.
    dragTranslation = ref new TranslateTransform();
    // Apply the translation to the Rectangle.
    touchRectangle->RenderTransform = dragTranslation;
}

public MainPage()
{
    this.InitializeComponent();

    // Listener for the ManipulationDelta event.
    touchRectangle.ManipulationDelta += touchRectangle_ManipulationDelta;
    // New translation transform populated in 
    // the ManipulationDelta handler.
    dragTranslation = new TranslateTransform();
    // Apply the translation to the Rectangle.
    touchRectangle.RenderTransform = this.dragTranslation;
}

Public Sub New()

    ' This call is required by the designer.
    InitializeComponent()

    ' Listener for the ManipulationDelta event.
    AddHandler touchRectangle.ManipulationDelta,
        AddressOf testRectangle_ManipulationDelta
    ' New translation transform populated in 
    ' the ManipulationDelta handler.
    dragTranslation = New TranslateTransform()
    ' Apply the translation to the Rectangle.
    touchRectangle.RenderTransform = dragTranslation

End Sub

Végül a ManipulationDelta eseménykezelőben a Téglalap pozíciója frissül a Delta tulajdonság TranslateTransformjával.

// Handler for the ManipulationDelta event.
// ManipulationDelta data is loaded into the
// translation transform and applied to the Rectangle.
void MainPage::touchRectangle_ManipulationDelta(Object^ sender,
    ManipulationDeltaRoutedEventArgs^ e)
{
    // Move the rectangle.
    dragTranslation->X += e->Delta.Translation.X;
    dragTranslation->Y += e->Delta.Translation.Y;
    
}

// Handler for the ManipulationDelta event.
// ManipulationDelta data is loaded into the
// translation transform and applied to the Rectangle.
void touchRectangle_ManipulationDelta(object sender,
    ManipulationDeltaRoutedEventArgs e)
{
    // Move the rectangle.
    dragTranslation.X += e.Delta.Translation.X;
    dragTranslation.Y += e.Delta.Translation.Y;
}

' Handler for the ManipulationDelta event.
' ManipulationDelta data Is loaded into the
' translation transform And applied to the Rectangle.
Private Sub testRectangle_ManipulationDelta(
    sender As Object,
    e As ManipulationDeltaRoutedEventArgs)

    ' Move the rectangle.
    dragTranslation.X = (dragTranslation.X + e.Delta.Translation.X)
    dragTranslation.Y = (dragTranslation.Y + e.Delta.Translation.Y)

End Sub

Irányított útvonalú események

Az itt említett összes mutatóesemény, gesztusesemény és manipulációs esemény irányított eseménykéntvalósul meg. Ez azt jelenti, hogy az eseményt az eredeti eseményt eredetileg felhozótól eltérő objektumok is kezelhetik. Az objektumfában lévő egymást követő szülők, mint például a UIElement szülőtárolói vagy az alkalmazásod gyökérként szolgáló oldal, akkor is képesek kezelni ezeket az eseményeket, ha az eredeti elem nem teszi. Ezzel szemben minden olyan objektum, amely kezeli az eseményt, megjelölheti a kezelt eseményt, hogy többé ne érje el a szülőelemet. Az irányított esemény fogalmáról és az irányított események kezelőinek írási módjáról további információt az Események és az irányított események áttekintése című témakörben talál.

Amit szabad és amit nem

• Tervezzen érintéses interakcióval rendelkező alkalmazásokat az elsődleges elvárt bemeneti módszerként.
• Vizuális visszajelzés küldése minden típusú interakcióhoz (érintés, toll, toll, egér stb.)
• Optimalizálja a célzást az érintéses cél méretének, a kapcsolati geometriának, a súrolásnak és a ringatásnak a beállításával.
• Optimalizálja a pontosságot a illesztési pontok és az irányított "sínek" használatával.
• Adjon meg elemleírásokat és fogópontokat a szorosan csomagolt felhasználói felületi elemek érintési pontosságának javításához.
• Ne használjon időzított interakciókat, amikor csak lehetséges (például megfelelő használat: érintés és tartás).
• Ne használja a manipuláció megkülönböztetéséhez használt ujjak számát, amikor csak lehetséges.

Kapcsolódó cikkek

• Mutató bemenetének kezelése
• Bemeneti eszközök azonosítása

Samples

• Bemeneti alapkészlet
• Alacsony késleltetésű bemeneti minta
• Felhasználói interakciós mód mintája
• Fókusz vizuális elemek mintája

Archivált minták

• Input: Eszköz képességeinek mintája
• Input: XAML felhasználói bemeneti események minta
• XAML görgetési, pásztázó és nagyítási minta
• Input: Kézmozdulatok és manipulációk a GestureRecognizerrel