Share via

Peristiwa keyboard

  • Artikel

Peristiwa keyboard dan fokus

Peristiwa keyboard berikut dapat terjadi untuk perangkat keras dan keyboard sentuh.

Kejadian Deskripsi
KeyDown Terjadi ketika tombol ditekan.
KeyUp Terjadi ketika kunci dirilis.

Penting

Beberapa kontrol XAML menangani peristiwa input secara internal. Dalam kasus ini, mungkin muncul bahwa peristiwa input tidak terjadi karena pendengar peristiwa Anda tidak memanggil handler terkait. Biasanya, subset kunci ini diproses oleh handler kelas untuk menyediakan dukungan bawaan aksesibilitas keyboard dasar. Misalnya, kelas Tombol mengambil alih peristiwa OnKeyDown untuk kunci Spasi dan tombol Enter (serta OnPointerPressed) dan merutekannya ke peristiwa Klik kontrol. Saat penekanan tombol ditangani oleh kelas kontrol, peristiwa KeyDown dan KeyUp tidak dinaikkan.
Ini menyediakan keyboard bawaan yang setara untuk memanggil tombol, mirip dengan mengetuknya dengan jari atau mengkliknya dengan mouse. Kunci selain Spasi atau Enter masih mengaktifkan peristiwa KeyDown dan KeyUp . Untuk informasi selengkapnya tentang cara kerja penanganan peristiwa berbasis kelas (khususnya, bagian "Penangan peristiwa input dalam kontrol"), lihat Gambaran umum peristiwa dan peristiwa yang dirutekan.

Kontrol di UI Anda hanya menghasilkan peristiwa keyboard saat mereka memiliki fokus input. Kontrol individual mendapatkan fokus saat pengguna mengklik atau mengetuk langsung kontrol tersebut di tata letak, atau menggunakan tombol Tab untuk melangkah ke urutan tab dalam area konten.

Anda juga dapat memanggil metode Fokus kontrol untuk memaksa fokus. Ini diperlukan saat Anda menerapkan tombol pintasan, karena fokus keyboard tidak diatur secara default saat UI Anda dimuat. Untuk informasi selengkapnya, lihat Contoh kunci pintasan nanti dalam topik ini.

Agar kontrol menerima fokus input, kontrol harus diaktifkan, terlihat, dan memiliki nilai properti IsTabStop dan HitTestVisibletrue. Ini adalah status default untuk sebagian besar kontrol. Ketika kontrol memiliki fokus input, kontrol dapat menaikkan dan merespons peristiwa input keyboard seperti yang dijelaskan nanti dalam topik ini. Anda juga dapat merespons kontrol yang menerima atau kehilangan fokus dengan menangani peristiwa GotFocus dan LostFocus .

Secara default, urutan tab kontrol adalah urutan kemunculannya dalam Extensible Application Markup Language (XAML). Namun, Anda dapat mengubah pesanan ini dengan menggunakan properti TabIndex . Untuk informasi selengkapnya, lihat Menerapkan aksesibilitas keyboard.

Penanganan aktivitas keyboard

Penanganan aktivitas input mengimplementasikan delegasi yang menyediakan informasi berikut:

  • Pengirim peristiwa. Pengirim melaporkan objek tempat penanganan aktivitas dilampirkan.
  • Data peristiwa. Untuk peristiwa keyboard, data tersebut akan menjadi instans KeyRoutedEventArgs. Delegasi untuk handler adalah KeyEventHandler. Properti KeyRoutedEventArgs yang paling relevan untuk sebagian besar skenario handler adalah Key dan mungkin KeyStatus.
  • OriginalSource. Karena peristiwa keyboard adalah peristiwa yang dirutekan, data peristiwa menyediakan OriginalSource. Jika Anda sengaja mengizinkan peristiwa untuk menggelembung melalui pohon objek, OriginalSource terkadang menjadi objek perhatian daripada pengirim. Namun, itu tergantung pada desain Anda. Untuk informasi selengkapnya tentang bagaimana Anda mungkin menggunakan OriginalSource daripada pengirim, lihat bagian "Peristiwa Yang Dirutekan Keyboard" dari topik ini, atau Peristiwa dan gambaran umum peristiwa yang dirutekan.

Melampirkan penanganan aktivitas keyboard

Anda dapat melampirkan fungsi penanganan aktivitas keyboard untuk objek apa pun yang menyertakan peristiwa sebagai anggota. Ini termasuk kelas turunan UIElement apa pun. Contoh XAML berikut menunjukkan cara melampirkan handler untuk peristiwa KeyUp untuk Grid.

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

Anda juga dapat melampirkan penanganan aktivitas dalam kode. Untuk informasi selengkapnya, lihat Gambaran umum peristiwa dan peristiwa yang dirutekan.

Menentukan penanganan aktivitas keyboard

Contoh berikut menunjukkan definisi penanganan aktivitas yang tidak lengkap untuk penanganan aktivitas KeyUp yang dilampirkan dalam contoh sebelumnya.

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

Private Sub Grid_KeyUp(ByVal sender As Object, ByVal e As KeyRoutedEventArgs)
    ' handling code here
End Sub

void MyProject::MainPage::Grid_KeyUp(
  Platform::Object^ sender,
  Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
  {
      //handling code here
  }

Menggunakan KeyRoutedEventArgs

Semua peristiwa keyboard menggunakan KeyRoutedEventArgs untuk data peristiwa, dan KeyRoutedEventArgs berisi properti berikut:

Kunci virtual

Peristiwa KeyDown dinaikkan jika tombol ditekan. Demikian juga, KeyUp dinaikkan jika kunci dirilis. Biasanya, Anda mendengarkan peristiwa untuk memproses nilai kunci tertentu. Untuk menentukan tombol mana yang ditekan atau dirilis, periksa nilai Kunci dalam data peristiwa. Kunci mengembalikan nilai VirtualKey . Enumerasi VirtualKey mencakup semua kunci yang didukung.

Tombol pengubah

Tombol pengubah adalah tombol seperti Ctrl atau Shift yang biasanya ditekan pengguna dalam kombinasi dengan tombol lain. Aplikasi Anda dapat menggunakan kombinasi ini sebagai pintasan keyboard kustom untuk memanggil perintah aplikasi.

Catatan

Untuk pintasan keyboard bawaan, lihat Tombol akses dan Akselerator keyboard.

Anda dapat mendeteksi kombinasi tombol pintasan di penanganan aktivitas KeyDown dan KeyUp . Saat peristiwa keyboard terjadi untuk tombol non-pengubah, Anda kemudian dapat memeriksa apakah tombol pengubah dalam keadaan ditekan.

Atau, fungsi GetKeyState()coreWindow (diperoleh melalui CoreWindow.GetForCurrentThread()) juga dapat digunakan untuk memeriksa status pengubah saat tombol non-pengubah ditekan.

Contoh berikut menerapkan metode kedua ini sekaligus menyertakan kode stub untuk implementasi pertama.

Catatan

Kunci Alt diwakili oleh nilai VirtualKey.Menu .

Contoh tombol pintasan

Contoh berikut menunjukkan cara mengimplementasikan sekumpulan kunci pintasan kustom. Dalam contoh ini, pengguna dapat mengontrol pemutaran media menggunakan tombol Putar, Jeda, dan Hentikan atau pintasan keyboard Ctrl+P, Ctrl+A, dan Ctrl+S. Tombol XAML memperlihatkan pintasan dengan menggunakan tipsalat dan properti AutomationProperties di label tombol. Dokumentasi mandiri ini penting untuk meningkatkan kegunaan dan aksesibilitas aplikasi Anda. Untuk informasi selengkapnya, lihat Aksesibilitas keyboard.

Perhatikan juga bahwa halaman mengatur fokus input ke dirinya sendiri saat dimuat. Tanpa langkah ini, tidak ada kontrol yang memiliki fokus input awal, dan aplikasi tidak menaikkan peristiwa input hingga pengguna mengatur fokus input secara manual (misalnya, dengan menab ke atau mengklik kontrol).

<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^ e)
{
    (void) e;    // Unused parameter
    this->Loaded+=ref new RoutedEventHandler(this,&amp;MainPage::ProgrammaticFocus);
}
void MainPage::ProgrammaticFocus(Object^ sender, RoutedEventArgs^ e) 
{
    this->Focus(Windows::UI::Xaml::FocusState::Programmatic);
}

void KeyboardSupport::MainPage::MediaButton_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    FrameworkElement^ fe = safe_cast<FrameworkElement^>(sender);
    if (fe->Name == "PlayButton") {DemoMovie->Play();}
    if (fe->Name == "PauseButton") {DemoMovie->Pause();}
    if (fe->Name == "StopButton") {DemoMovie->Stop();}
}


bool KeyboardSupport::MainPage::IsCtrlKeyPressed()
{
    auto ctrlState = CoreWindow::GetForCurrentThread()->GetKeyState(VirtualKey::Control);
    return (ctrlState & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down;
}

void KeyboardSupport::MainPage::Grid_KeyDown(Platform::Object^ sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
{
    if (e->Key == VirtualKey::Control) isCtrlKeyPressed = true;
}


void KeyboardSupport::MainPage::Grid_KeyUp(Platform::Object^ sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs^ 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 = CoreWindow.GetForCurrentThread().GetKeyState(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 = CoreWindow.GetForCurrentThread().GetKeyState(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

Catatan

Mengatur AutomationProperties.AcceleratorKey atau AutomationProperties.AccessKey di XAML menyediakan informasi string, yang mendokumen kunci pintasan untuk memanggil tindakan tertentu tersebut. Informasi ini ditangkap oleh klien Microsoft UI Automation seperti Narator, dan biasanya diberikan langsung kepada pengguna.

Mengatur AutomationProperties.AcceleratorKey atau AutomationProperties.AccessKey tidak memiliki tindakan sendiri. Anda masih perlu melampirkan handler untuk peristiwa KeyDown atau KeyUp untuk benar-benar mengimplementasikan perilaku pintasan keyboard di aplikasi Anda. Selain itu, dekorasi teks garis bawah untuk kunci akses tidak disediakan secara otomatis. Anda harus secara eksplisit menggaris bawahi teks untuk kunci tertentu dalam mnemonic Anda sebagai pemformatan Garis Bawah sebaris jika Anda ingin menampilkan teks bergaris bawah di UI.

 

Peristiwa keyboard yang dirutekan

Peristiwa tertentu adalah peristiwa yang dirutekan, termasuk KeyDown dan KeyUp. Peristiwa yang dirutekan menggunakan strategi perutean yang menggelegak. Strategi perutean yang menggelegak berarti bahwa peristiwa berasal dari objek anak dan kemudian dirutekan ke objek induk berturut-turut di pohon objek. Ini menyajikan kesempatan lain untuk menangani peristiwa yang sama dan berinteraksi dengan data peristiwa yang sama.

Pertimbangkan contoh XAML berikut, yang menangani peristiwa KeyUp untuk Kanvas dan dua objek Tombol . Dalam hal ini, jika Anda merilis kunci saat fokus dipegang oleh salah satu objek Tombol , itu akan meningkatkan peristiwa KeyUp . Acara ini kemudian ditumpangi ke Kanvas induk.

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

Contoh berikut menunjukkan cara mengimplementasikan penanganan aktivitas KeyUp untuk konten XAML yang sesuai dalam contoh sebelumnya.

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

Perhatikan penggunaan properti OriginalSource di handler sebelumnya. Di sini, OriginalSource melaporkan objek yang menaikkan peristiwa. Objek tidak dapat menjadi StackPanel karena StackPanel bukan kontrol dan tidak dapat memiliki fokus. Hanya salah satu dari dua tombol dalam StackPanel yang mungkin dapat meningkatkan peristiwa, tetapi yang mana? Anda menggunakan OriginalSource untuk membedakan objek sumber peristiwa yang sebenarnya, jika Anda menangani peristiwa pada objek induk.

Properti Yang Ditangani dalam data peristiwa

Bergantung pada strategi penanganan peristiwa, Anda mungkin hanya ingin satu penanganan aktivitas bereaksi terhadap peristiwa yang menggelegak. Misalnya, jika Anda memiliki handler KeyUp tertentu yang dilampirkan ke salah satu kontrol Tombol , itu akan memiliki kesempatan pertama untuk menangani peristiwa tersebut. Dalam hal ini, Anda mungkin tidak ingin panel induk juga menangani peristiwa. Untuk skenario ini, Anda dapat menggunakan properti Ditangani dalam data peristiwa.

Tujuan properti Ditangani dalam kelas data peristiwa yang dirutekan adalah untuk melaporkan bahwa handler lain yang Anda daftarkan sebelumnya pada rute peristiwa telah bertindak. Ini memengaruhi perilaku sistem peristiwa yang dirutekan. Saat Anda mengatur Ditangani ke true dalam penanganan aktivitas, peristiwa tersebut menghentikan perutean dan tidak dikirim ke elemen induk berturut-turut.

Peristiwa addHandler dan keyboard yang sudah ditangani

Anda dapat menggunakan teknik khusus untuk melampirkan handler yang dapat bertindak pada peristiwa yang sudah Anda tandai sebagai ditangani. Teknik ini menggunakan metode AddHandler untuk mendaftarkan handler, daripada menggunakan atribut XAML atau sintaks khusus bahasa untuk menambahkan handler, seperti += di C#.

Batasan umum dari teknik ini adalah bahwa API AddHandler mengambil parameter jenis RoutedEvent yang mengidnentifikasi peristiwa yang dirutekan yang dimaksud. Tidak semua peristiwa yang dirutekan menyediakan pengidentifikasi RoutedEvent , dan pertimbangan ini sehingga memengaruhi peristiwa rute mana yang masih dapat ditangani dalam kasus Yang Ditangani . Peristiwa KeyDown dan KeyUp telah merutekan pengidentifikasi peristiwa (KeyDownEvent dan KeyUpEvent) di UIElement. Namun, peristiwa lain seperti TextBox.TextChanged tidak memiliki pengidentifikasi peristiwa yang dirutekan dan dengan demikian tidak dapat digunakan dengan teknik AddHandler .

Mengesampingkan peristiwa dan perilaku keyboard

Anda dapat mengganti peristiwa utama untuk kontrol tertentu (seperti GridView) untuk menyediakan navigasi fokus yang konsisten untuk berbagai perangkat input, termasuk keyboard dan gamepad.

Dalam contoh berikut, kami subkelas kontrol dan mengambil alih perilaku KeyDown untuk memindahkan fokus ke konten GridView saat tombol panah ditekan.

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

Catatan

Jika hanya menggunakan GridView untuk tata letak, pertimbangkan untuk menggunakan kontrol lain seperti ItemsControl dengan ItemsWrapGrid.

Komandan

Sejumlah kecil elemen UI menyediakan dukungan bawaan untuk perintah. Perintah menggunakan peristiwa rute terkait input dalam implementasi yang mendasarnya. Ini memungkinkan pemrosesan input UI terkait, seperti tindakan pointer tertentu atau kunci akselerator tertentu, dengan memanggil satu handler perintah.

Jika perintah tersedia untuk elemen UI, pertimbangkan untuk menggunakan API perintahnya alih-alih peristiwa input diskrit apa pun. Untuk informasi selengkapnya, lihat ButtonBase.Command.

Anda juga dapat menerapkan ICommand untuk merangkum fungsionalitas perintah yang Anda panggil dari penanganan aktivitas biasa. Ini memungkinkan Anda untuk menggunakan perintah bahkan ketika tidak ada properti Perintah yang tersedia.

Input dan kontrol teks

Kontrol tertentu bereaksi terhadap peristiwa keyboard dengan penanganannya sendiri. Misalnya, TextBox adalah kontrol yang dirancang untuk mengambil lalu secara visual mewakili teks yang dimasukkan dengan menggunakan keyboard. Ini menggunakan KeyUp dan KeyDown dalam logikanya sendiri untuk mengambil penekanan tombol, lalu juga menaikkan peristiwa TextChanged sendiri jika teks benar-benar berubah.

Anda umumnya masih dapat menambahkan handler untuk KeyUp dan KeyDown ke TextBox, atau kontrol terkait apa pun yang dimaksudkan untuk memproses input teks. Namun, sebagai bagian dari desain yang dimaksudkan, kontrol mungkin tidak merespons semua nilai kunci yang diarahkannya melalui peristiwa utama. Perilaku khusus untuk setiap kontrol.

Sebagai contoh, ButtonBase (kelas dasar untuk Tombol) memproses KeyUp sehingga dapat memeriksa tombol Spacebar atau Enter. ButtonBase menganggap KeyUp setara dengan tombol kiri mouse ke bawah untuk tujuan menaikkan peristiwa Klik . Pemrosesan peristiwa ini dilakukan ketika ButtonBase mengambil alih metode virtual OnKeyUp. Dalam implementasinya, ia mengatur Ditangani ke true. Hasilnya adalah bahwa setiap induk tombol yang mendengarkan peristiwa kunci, dalam kasus Bilah Spasi, tidak akan menerima peristiwa yang sudah ditangani untuk handler-nya sendiri.

Contoh lain adalah TextBox. Beberapa tombol, seperti tombol panah, tidak dianggap sebagai teks oleh TextBox dan sebaliknya dianggap khusus untuk perilaku antarmuka pengguna kontrol. Kotak Teks menandai kasus peristiwa ini sebagai ditangani.

Kontrol kustom dapat menerapkan perilaku penimpaan serupa mereka sendiri untuk peristiwa utama dengan menimpa OnKeyDown / OnKeyUp. Jika kontrol kustom Anda memproses kunci akselerator tertentu, atau memiliki perilaku kontrol atau fokus yang mirip dengan skenario yang dijelaskan untuk TextBox, Anda harus menempatkan logika ini di penimpaan OnKeyDown / OnKeyUp Anda sendiri.

Keyboard sentuh

Kontrol input teks menyediakan dukungan otomatis untuk keyboard sentuh. Saat pengguna mengatur fokus input ke kontrol teks dengan menggunakan input sentuh, keyboard sentuh muncul secara otomatis. Saat fokus input tidak berada pada kontrol teks, keyboard sentuh disembunyikan.

Saat keyboard sentuh muncul, papan ketik secara otomatis memposisikan ulang UI Anda untuk memastikan bahwa elemen yang difokuskan tetap terlihat. Ini dapat menyebabkan area penting lainnya dari UI Anda untuk berpindah dari layar. Namun, Anda dapat menonaktifkan perilaku default dan membuat penyesuaian UI Anda sendiri saat keyboard sentuh muncul. Untuk informasi selengkapnya, lihat sampel Keyboard sentuh.

Jika Anda membuat kontrol kustom yang memerlukan input teks, tetapi tidak berasal dari kontrol input teks standar, Anda dapat menambahkan dukungan keyboard sentuh dengan menerapkan pola kontrol Automation UI yang benar. Untuk informasi selengkapnya, lihat sampel Keyboard sentuh.

Tombol menekan pada papan ketik sentuh menaikkan peristiwa KeyDown dan KeyUp seperti penekanan tombol pada keyboard perangkat keras. Namun, keyboard sentuh tidak akan menaikkan peristiwa input untuk Ctrl+A, Ctrl+Z, Ctrl+X, Ctrl+C, dan Ctrl+V, yang disediakan untuk manipulasi teks dalam kontrol input.

Anda dapat membuatnya jauh lebih cepat dan lebih mudah bagi pengguna untuk memasukkan data di aplikasi Anda dengan mengatur cakupan input kontrol teks agar sesuai dengan jenis data yang Anda harapkan untuk dimasukkan pengguna. Cakupan input memberikan petunjuk pada jenis input teks yang diharapkan oleh kontrol sehingga sistem dapat menyediakan tata letak keyboard sentuh khusus untuk jenis input. Misalnya, jika kotak teks hanya digunakan untuk memasukkan PIN 4 digit, atur properti InputScope ke Angka. Ini memberi tahu sistem untuk menampilkan tata letak keypad numerik, yang memudahkan pengguna untuk memasukkan PIN. Untuk detail selengkapnya, lihat Menggunakan cakupan input untuk mengubah keyboard sentuh.

Pengembang

Desainer

Sampel

Sampel Arsip