Billentyűzetesemények

Billentyűzetesemények és fókusz

A következő billentyűzetes események hardveres és érintéses billentyűzeteken is előfordulhatnak.

Event Description
KeyDown A billentyű lenyomásakor fordul elő.
KeyUp Billentyű felengedésekor fordul elő.

Fontos

Egyes XAML-vezérlők belsőleg kezelik a bemeneti eseményeket. Ezekben az esetekben előfordulhat, hogy nem történik bemeneti esemény, mert az eseményfigyelő nem hívja meg a társított kezelőt. A kulcsok ezen részhalmazát általában az osztálykezelő dolgozza fel, hogy beépített támogatást nyújtson az alapvető billentyűzet-kisegítő lehetőségekhez. A Gomb osztály például felülbírálja a Szóköz és az Enter billentyű (valamint az OnPointerPressed) OnKeyDown-eseményeit, és átirányítja őket a vezérlő Kattintás eseményére. Ha a vezérlőosztály egy billentyűlenyomást kezel, a KeyDown és a KeyUp események nem lesznek aktiválva.
Ez egy beépített billentyűzet-megfelelőt biztosít a gomb meghívásához, hasonlóan az ujjal való koppintáshoz vagy az egérrel való kattintáshoz. A Szóköz vagy az Enter billentyűk kivételével a KeyDown és a KeyUp események továbbra is aktiválhatók. Az események osztályalapú kezeléséről (pontosabban az "Eseménykezelők bevitele a vezérlőkben" című szakaszban) az Események és az irányított események áttekintése című témakörben talál további információt.

A felhasználói felület vezérlői csak akkor hoznak létre billentyűzeteseményeket, ha a fókuszban van a bevitel. Az egyes vezérlők akkor kerülnek fókuszba, amikor a felhasználó közvetlenül az elrendezésben erre a vezérlőre kattint vagy koppint, vagy a Tab billentyűvel lép be a tartalomterületen belüli tabulátorütemezésbe.

A fókusz kényszerítéséhez egy vezérlő Fókusz metódusát is meghívhatja. Erre a billentyűparancsok implementálásakor van szükség, mert a billentyűzetfókusz alapértelmezés szerint nincs beállítva a felhasználói felület betöltésekor. További információért tekintse meg a Billentyűparancsok példát a jelen témakör későbbi részében.

Ahhoz, hogy egy vezérlő megkapja a bemeneti fókuszt, engedélyezettnek kell lennie, láthatónak kell lennie, és az IsTabStop és HitTestVisible tulajdonságainak igaznak (true) kell lennie. Ez a legtöbb vezérlő alapértelmezett állapota. Ha egy vezérlő bemeneti fókuszsal rendelkezik, a jelen témakör későbbi részében ismertetett módon emelheti és válaszolhatja meg a billentyűzet beviteli eseményeit. A GotFocus és a LostFocus események kezelésével reagálhat azokra a vezérlőkre is, amelyek a fókuszt fogadják vagy elveszítik.

Alapértelmezés szerint a vezérlők lapsorrendje az a sorrend, amelyben azok megjelennek az XAML (Extensible Application Markup Language, XAML) alkalmazásban. Ezt a sorrendet azonban a TabIndex tulajdonság használatával módosíthatja. További információ: A billentyűzet kisegítő lehetőségeinek megvalósítása.

Billentyűzetes eseménykezelők

A bemeneti eseménykezelő egy meghatalmazottat implementál, amely a következő információkat nyújtja:

  • Az esemény feladója. A feladó jelenti azt az objektumot, amelyhez az eseménykezelő csatlakoztatva van.
  • Eseményadatok. Billentyűzetesemények esetén az adatok a KeyRoutedEventArgs példányai lesznek. A kezelők meghatalmazottja a KeyEventHandler. A KeyRoutedEventArgs legfontosabb tulajdonságai a legtöbb kezelőforgatókönyv esetében a Key és esetleg a KeyStatus.
  • OriginalSource. Mivel a billentyűzetesemények irányított események, az eseményadatok az OriginalSource-t biztosítják. Ha szándékosan engedélyezi az eseményeknek, hogy egy objektumfán keresztül buborékoljanak, akkor az OriginalSource néha az érdeklődés tárgya, nem pedig a küldő. Ez azonban a kialakítástól függ. Ha többet szeretne megtudni arról, hogyan használhatja az OriginalSource-t feladó helyett, tekintse meg a témakör "Billentyűzet által irányított események" című szakaszát, illetve az Események és az irányított események áttekintését.

Billentyűzetes eseménykezelő csatlakoztatása

Bármely olyan objektumhoz csatolhat billentyűzetes eseménykezelő függvényeket, amelyek tagként tartalmazzák az eseményt. Ebbe beletartozik minden UIElement származtatott osztály. Az alábbi XAML-példa bemutatja, hogyan csatolhat kezelőket a KeyUp eseményhez egy rácshoz.

<Grid KeyUp="Grid_KeyUp">
  ...
</Grid>

Az eseménykezelőt kódban is csatolhatja. További információért lásd: Események és irányított események áttekintése.

Billentyűzetes eseménykezelő definiálása

Az alábbi példa az előző példában csatolt KeyUp eseménykezelő hiányos eseménykezelő definícióját mutatja be.

void Grid_KeyUp(object sender, KeyRoutedEventArgs e)
{
    //handling code here
}

void MyProject::MainPage::Grid_KeyUp(
  winrt::Windows::Foundation::IInspectable const& sender,
  winrt::Microsoft::UI::Xaml::Input::KeyRoutedEventArgs const& e)
  {
      //handling code here
  }

A KeyRoutedEventArgs használata

Minden billentyűzetesemény a KeyRoutedEventArgst használja az eseményadatokhoz, a KeyRoutedEventArgs pedig a következő tulajdonságokat tartalmazza:

Virtuális kulcsok

A KeyDown esemény akkor jön létre, ha lenyom egy billentyűt. Hasonlóképpen, a KeyUp is előjön, ha egy kulcs ki van adva. Az eseményeket rendszerint azért figyeli, hogy egy adott kulcsértéket feldolgozzon. Annak megállapításához, hogy melyik kulcs van lenyomva vagy kiadva, ellenőrizze a kulcs értékét az eseményadatokban. A kulcs egy VirtualKey-értéket ad vissza. A VirtualKey enumerálása tartalmazza az összes támogatott kulcsot.

Módosító kulcsok

A módosítóbillentyűk olyan billentyűk, mint például a Ctrl vagy a Shift, amelyeket a felhasználók általában más billentyűkkel együtt lenyomnak. Az alkalmazás ezeket a kombinációkat használhatja egyéni billentyűparancsként az alkalmazásparancsok meghívásához.

Megjegyzés:

A beépített billentyűparancsokért lásd: Access-billentyűk és billentyűzetgyorsítók.

A KeyDown és a KeyUp eseménykezelőben billentyűparancs-kombinációkat észlelhet. Ha nem módosító billentyű esetén billentyűzetesemény történik, ellenőrizheti, hogy a módosító billentyű lenyomott állapotban van-e.

Másik lehetőségként a WinUI 3-ban az InputKeyboardSource.GetKeyStateForCurrentThread használatával ellenőrizheti a módosító állapotot, ha egy nem módosító kulcs van lenyomva.

Az alábbi példák implementálják ezt a második módszert, és az első implementációhoz is tartalmazzák a csonkkódot.

Megjegyzés:

Az Alt billentyűt a VirtualKey.Menu érték jelöli.

Példa billentyűparancsok

Az alábbi példa bemutatja, hogyan implementálhat egyéni billentyűparancsokat. Ebben a példában a felhasználók a Lejátszás, a Szüneteltetés és a Leállítás gombokkal, illetve a Ctrl+P, a Ctrl+A és a Ctrl+S billentyűparancsokkal szabályozhatják a médialejátszást. A gomb XAML eszköztippeket és AutomationProperties tulajdonságokat használva jeleníti meg a billentyűparancsokat a gombfeliratokban. Ez az öndokumentáció fontos az alkalmazás használhatóságának és akadálymentességének növeléséhez. További információt a Billentyűzet kisegítő lehetőségei című témakörben talál.

Azt is vegye figyelembe, hogy a lap betöltésekor a bemeneti fókuszt önmagára állítja. E lépés nélkül egyetlen vezérlő sem rendelkezik kezdeti bemeneti fókuszsal, és az alkalmazás csak akkor indítja el a bemeneti eseményeket, ha a felhasználó manuálisan állítja be a bemeneti fókuszt (például egy vezérlőre való lapozással vagy kattintással).

<Grid KeyDown="Grid_KeyDown">

  <Grid.RowDefinitions>
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
  </Grid.RowDefinitions>

  <MediaElement x:Name="DemoMovie" Source="xbox.wmv"
    Width="500" Height="500" Margin="20" HorizontalAlignment="Center" />

  <StackPanel Grid.Row="1" Margin="10"
    Orientation="Horizontal" HorizontalAlignment="Center">

    <Button x:Name="PlayButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+P"
      AutomationProperties.AcceleratorKey="Control P">
      <TextBlock>Play</TextBlock>
    </Button>

    <Button x:Name="PauseButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+A"
      AutomationProperties.AcceleratorKey="Control A">
      <TextBlock>Pause</TextBlock>
    </Button>

    <Button x:Name="StopButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+S"
      AutomationProperties.AcceleratorKey="Control S">
      <TextBlock>Stop</TextBlock>
    </Button>

  </StackPanel>

</Grid>

// showing implementations but not header definitions
void MainPage::OnNavigatedTo(NavigationEventArgs const& e)
{
    this->Loaded([this](auto&&, auto&&) { ProgrammaticFocus(); });
}
void MainPage::ProgrammaticFocus()
{
    this->Focus(Microsoft::UI::Xaml::FocusState::Programmatic);
}

void MainPage::MediaButton_Click(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& e)
{
    auto fe = sender.as<Microsoft::UI::Xaml::FrameworkElement>();
    if (fe.Name() == L"PlayButton") { DemoMovie().Play(); }
    if (fe.Name() == L"PauseButton") { DemoMovie().Pause(); }
    if (fe.Name() == L"StopButton") { DemoMovie().Stop(); }
}


bool MainPage::IsCtrlKeyPressed()
{
    auto ctrlState = Microsoft::UI::Input::InputKeyboardSource::GetKeyStateForCurrentThread(VirtualKey::Control);
    return (ctrlState & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down;
}

void MainPage::Grid_KeyUp(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::Input::KeyRoutedEventArgs const& e)
{
    if (IsCtrlKeyPressed())
    {
        if (e.Key() == VirtualKey::P) { DemoMovie().Play(); }
        if (e.Key() == VirtualKey::A) { DemoMovie().Pause(); }
        if (e.Key() == VirtualKey::S) { DemoMovie().Stop(); }
    }
}

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    // Set the input focus to ensure that keyboard events are raised.
    this.Loaded += delegate { this.Focus(FocusState.Programmatic); };
}

private void MediaButton_Click(object sender, RoutedEventArgs e)
{
    switch ((sender as Button).Name)
    {
        case "PlayButton": DemoMovie.Play(); break;
        case "PauseButton": DemoMovie.Pause(); break;
        case "StopButton": DemoMovie.Stop(); break;
    }
}

private static bool IsCtrlKeyPressed()
{
    var ctrlState = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.Control);
    return (ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
}

private void Grid_KeyDown(object sender, KeyRoutedEventArgs e)
{
    if (IsCtrlKeyPressed())
    {
        switch (e.Key)
        {
            case VirtualKey.P: DemoMovie.Play(); break;
            case VirtualKey.A: DemoMovie.Pause(); break;
            case VirtualKey.S: DemoMovie.Stop(); break;
        }
    }
}

Private isCtrlKeyPressed As Boolean
Protected Overrides Sub OnNavigatedTo(e As Navigation.NavigationEventArgs)

End Sub

Private Function IsCtrlKeyPressed As Boolean
    Dim ctrlState As CoreVirtualKeyStates = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.Control);
    Return (ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
End Function

Private Sub Grid_KeyDown(sender As Object, e As KeyRoutedEventArgs)
    If IsCtrlKeyPressed() Then
        Select Case e.Key
            Case Windows.System.VirtualKey.P
                DemoMovie.Play()
            Case Windows.System.VirtualKey.A
                DemoMovie.Pause()
            Case Windows.System.VirtualKey.S
                DemoMovie.Stop()
        End Select
    End If
End Sub

Private Sub MediaButton_Click(sender As Object, e As RoutedEventArgs)
    Dim fe As FrameworkElement = CType(sender, FrameworkElement)
    Select Case fe.Name
        Case "PlayButton"
            DemoMovie.Play()
        Case "PauseButton"
            DemoMovie.Pause()
        Case "StopButton"
            DemoMovie.Stop()
    End Select
End Sub

Megjegyzés:

Az AutomationProperties.AcceleratorKey vagy AutomationProperties.AccessKey beállítása az XAML-ben sztringinformációkat biztosít, amelyek az adott művelet meghívásához szükséges billentyűparancsot dokumentálják. Az adatokat a Microsoft UI-automatizálás-ügyfelek, például a Narrátor rögzítik, és általában közvetlenül a felhasználónak adják meg.

Az AutomationProperties.AcceleratorKey vagy az AutomationProperties.AccessKey beállítása önmagában nem rendelkezik semmilyen művelettal. Ahhoz, hogy ténylegesen megvalósíthassa a billentyűparancsok viselkedését az alkalmazásában, továbbra is hozzá kell csatolnia a KeyDown- vagy KeyUp események kezelőit. Emellett a hozzáférési kulcs aláhúzásos szövegdekorációja nem lesz automatikusan megadva. Ha aláhúzott szöveget szeretne megjeleníteni a felhasználói felületen, explicit módon alá kell aláhúznia az adott kulcs szövegét beágyazott aláhúzásos formázásként a mnemonicában.

 

Billentyűzet által irányított események

Bizonyos események irányított események, például a KeyDown és a KeyUp. Az útvonalvezérelt események a buborékoló útválasztási stratégiát alkalmazzák. A buborékos útválasztási stratégia azt jelenti, hogy egy esemény egy gyermekobjektumból származik, majd az objektumfa egymást követő szülőobjektumaihoz lesz irányítva. Ez egy másik lehetőséget kínál arra, hogy ugyanazt az eseményt kezelje, és ugyanazokat az eseményadatokat kezelje.

Vegye figyelembe a következő XAML-példát, amely egy vászon és két gombobjektumKeyUp-eseményeit kezeli. Ebben az esetben, ha kiad egy kulcsot, miközben a fókuszt valamelyik Gomb objektum tartja, az aktiválja a KeyUp eseményt. Az esemény ezután továbbítódik a szülő Canvas-ra.

<StackPanel KeyUp="StackPanel_KeyUp">
  <Button Name="ButtonA" Content="Button A"/>
  <Button Name="ButtonB" Content="Button B"/>
  <TextBlock Name="statusTextBlock"/>
</StackPanel>

Az alábbi példa bemutatja, hogyan implementálhatja a KeyUp eseménykezelőt az előző példában szereplő megfelelő XAML-tartalomhoz.

void StackPanel_KeyUp(object sender, KeyRoutedEventArgs e)
{
    statusTextBlock.Text = String.Format(
        "The key {0} was pressed while focus was on {1}",
        e.Key.ToString(), (e.OriginalSource as FrameworkElement).Name);
}

Figyelje meg az OriginalSource tulajdonság használatát az előző kezelőben. Itt az OriginalSource jelenti az eseményt okozó objektumot. Az objektum nem lehet a StackPanel , mert a StackPanel nem vezérlőelem, és nem rendelkezhet fókuszsal. A StackPanelben lévő két gomb közül csak az egyik emelhette volna ki az eseményt, de melyik? Az OriginalSource használatával megkülönböztetheti a tényleges eseményforrás-objektumot, ha egy szülőobjektumon kezeli az eseményt.

A Kezelt tulajdonság az eseményadatokban

Az eseménykezelési stratégiától függően előfordulhat, hogy csak egy eseménykezelőnek kell reagálnia egy buborékos eseményre. Ha például egy adott KeyUp-kezelő van csatlakoztatva az egyik Button vezérlőhöz, ez kapná meg először az esélyt az esemény kezelésére. Ebben az esetben előfordulhat, hogy nem szeretné, hogy a szülőpanel is kezelje az eseményt. Ebben a forgatókönyvben a Handled tulajdonságot használhatja az eseményadatokban.

Az irányított eseményadatosztály Kezelt tulajdonságának célja, hogy jelentse, hogy az eseményútvonalon korábban regisztrált másik kezelő már járt el. Ez befolyásolja az irányított eseményrendszer viselkedését. Amikor az eseménykezelőben a Handled értéket true-ra állítja, az esemény leállítja az útválasztást, és nem küldi el az egymást követő szülőelemeknek.

AddHandler és már kezelt billentyűzetesemények

Speciális technikával csatolhat kezelőket, amelyek képesek a már kezeltként megjelölt eseményekre reagálni. Ez a technika az AddHandler metódussal regisztrál egy kezelőt, nem pedig XAML-attribútumokat vagy nyelvspecifikus szintaxist használ a kezelők hozzáadásához, például += a C#-ban.

A technika általános korlátozása, hogy az AddHandler API egy RoutedEvent típusú paramétert használ, amely azonosítja a szóban forgó irányított eseményt. Nem minden átirányított esemény biztosít RoutedEvent-azonosítót , ezért ez a szempont befolyásolja, hogy mely átirányított események kezelhetők továbbra is a Kezelt esetben. A KeyDown - és KeyUp-események átirányított eseményazonosítókkal (KeyDownEvent és KeyUpEvent) rendelkeznek a UIElementen. Más események, például a TextBox.TextChanged azonban nem rendelkeznek irányított eseményazonosítókkal, ezért nem használhatók az AddHandler technikával.

A billentyűzetesemények és a viselkedés felülbírálása

Az egyes vezérlők (például a GridView) fő eseményeit felülbírálhatja, így konzisztens fókusznavigációt biztosíthat a különböző beviteli eszközökhöz, például a billentyűzethez és a játékpadhoz.

A következő példában a vezérlőt alásoroljuk, és felülbíráljuk a KeyDown viselkedést, hogy a fókuszt a GridView-tartalomra helyezzük, amikor bármelyik nyílbillentyűt lenyomjuk.

  public class CustomGridView : GridView
  {
    protected override void OnKeyDown(KeyRoutedEventArgs e)
    {
      // Override arrow key behaviors.
      if (e.Key != Windows.System.VirtualKey.Left && e.Key !=
        Windows.System.VirtualKey.Right && e.Key !=
          Windows.System.VirtualKey.Down && e.Key !=
            Windows.System.VirtualKey.Up)
              base.OnKeyDown(e);
      else
        FocusManager.TryMoveFocus(FocusNavigationDirection.Down);
    }
  }

Megjegyzés:

Ha csak elrendezéshez használ GridView-t, fontolja meg más vezérlők használatát, például az ItemsControl és az ItemsWrapGrid parancsot.

Irányítás

Kevés felhasználói felületi elem biztosít beépített támogatást a parancsoláshoz. A parancsolás a mögöttes implementációban bemenethez kapcsolódó irányított eseményeket használ. Lehetővé teszi a kapcsolódó felhasználói felületi bemenetek, például egy adott mutatóművelet vagy egy adott gyorsítókulcs feldolgozását egyetlen parancskezelő meghívásával.

Ha a parancsolás elérhető egy felhasználói felületi elemhez, fontolja meg a parancsoló API-k használatát a különálló bemeneti események helyett. További információ: ButtonBase.Command.

Az ICommand implementálható a szokásos eseménykezelőktől meghívott parancsfunkciók beágyazásához is. Ez lehetővé teszi a parancsok használatát akkor is, ha nincs elérhető Command tulajdonság.

Szövegbevitel és vezérlők

Egyes vezérlők önálló kezelésükkel reagálnak a billentyűzet eseményeire. A TextBox például egy vezérlő, amely a billentyűzettel beírt szöveg rögzítésére, majd vizuális megjelenítésére szolgál. A KeyUp és KeyDown eseményeket saját logikája alapján használja a billentyűleütések rögzítésére, majd a szöveg tényleges módosítása esetén saját TextChanged eseményt is aktivál.

A KeyUp és a KeyDown kezelői továbbra is felvehetők a Szövegdobozba, vagy bármely kapcsolódó vezérlőhöz, amely a szövegbevitel feldolgozására szolgál. A tervezett kialakítás részeként azonban előfordulhat, hogy egy vezérlőelem nem válaszol az összes kulcsértékre, amelyek billentyűesemények során irányulnak hozzá. A viselkedés minden vezérlőre jellemző.

Például a ButtonBase (a Button alaposztálya) feldolgozza a KeyUpot , hogy ellenőrizze a szóköz vagy az Enter billentyűt. A ButtonBase úgy tekint a KeyUp-ra, mint ami az egér bal gombjának lenyomásával egyenértékű a Click esemény indításának céljából. Az esemény feldolgozása akkor történik meg, ha a ButtonBase felülírja az OnKeyUp virtuális metódust. Implementációjában a kezeltetigaz értékre állítja. A gomb bármelyik szülője, amely kulcsesemény figyelésére van beállítva, például a szóköz esetén, nem kapja meg a már kezelt eseményt a saját kezelői számára.

Egy másik példa a TextBox. Egyes kulcsokat, például a nyílbillentyűket, a TextBox nem tekinti szövegnek, és inkább a vezérlő felhasználói felületének viselkedésére jellemzőnek tekinti őket. A TextBox kezeli ezeket az eseményeseményeket.

Az egyéni vezérlők az OnKeyDown / OnKeyUp felülbírálásával saját hasonló felülbírálási viselkedést valósíthatnak meg a kulcsesemények esetében. Ha az egyéni vezérlő meghatározott gyorsítókulcsokat dolgoz fel, vagy a TextBoxhoz leírt forgatókönyvhöz hasonló vezérlési vagy fókuszi viselkedéssel rendelkezik, ezt a logikát a saját OnKeyDown / OnKeyUp felülbírálásaiban kell elhelyeznie.

Az érintőbillentyűzet

A szövegbeviteli vezérlők automatikusan támogatják az érintőbillentyűzetet. Amikor a felhasználó érintéses bevitellel egy szövegvezérlőre állítja a beviteli fókuszt, az érintőbillentyűzet automatikusan megjelenik. Ha a beviteli fókusz nem szövegvezérlőn van, az érintőbillentyűzet rejtett.

Amikor megjelenik az érintőbillentyűzet, automatikusan áthelyezi a felhasználói felületet, hogy a szűrt elem látható maradjon. Ez a felhasználói felület egyéb fontos területeit is kimozdíthatja a képernyőről. Az érintéses billentyűzet megjelenésekor azonban letilthatja az alapértelmezett viselkedést, és saját felhasználói felületi módosításokat végezhet. További információ: Touch billentyűzet minta.

Ha olyan egyéni vezérlőt hoz létre, amely szövegbevitelt igényel, de nem szabványos szövegbeviteli vezérlőből származik, akkor a megfelelő felhasználói felületi automatizálási vezérlőminták implementálásával érintéses billentyűzettámogatást adhat hozzá. További információ: Touch billentyűzet minta.

Az érintőbillentyűzeten lenyomva a KeyDown és a KeyUp események ugyanúgy lépnek fel, mint a hardveres billentyűzeteken. Az érintőbillentyűzet azonban nem indítja el a beviteli eseményeket a Ctrl+A, a Ctrl+Z, a Ctrl+X, a Ctrl+C és a Ctrl+V billentyűkombinációhoz, amelyek a beviteli vezérlőben lévő szövegmódosításra vannak fenntartva.

A felhasználók sokkal gyorsabban és egyszerűbben adhatnak meg adatokat az alkalmazásban, ha a szövegvezérlő bemeneti hatókörét úgy állítja be, hogy az megfeleljen a felhasználó által várt adattípusnak. A bemeneti hatókör a vezérlő által várt szövegbevitel típusára utal, hogy a rendszer speciális érintőbillentyűzet-elrendezést biztosítson a beviteli típushoz. Ha például egy szövegdobozt csak négyjegyű PIN-kód megadására használ, állítsa az InputScope tulajdonságot Szám értékre. Ez azt jelzi a rendszernek, hogy megjeleníti a numerikus billentyűzet elrendezését, ami megkönnyíti a felhasználó számára a PIN-kód megadását. További információ: Beviteli hatókör használata az érintőbillentyűzet módosításához.

Developers

Tervezők

Samples

Archivált minták

  • Last updated on