<?xml version="1.0" encoding="utf-8"?>
<!--
/*
**
** Copyright 2008, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <!-- Title for Latin keyboard  -->
    <string name="english_ime_name">Android keyboard</string>
    <!-- Application name for opensource Android keyboard. AOSP(Android Open Source Project) should not be translated. -->
    <string name="aosp_android_keyboard_ime_name">Android keyboard (AOSP)</string>
    <!-- Title for Latin keyboard settings activity / dialog -->
    <string name="english_ime_settings">Android keyboard settings</string>
    <!-- Title for Latin keyboard input options dialog [CHAR LIMIT=25] -->
    <string name="english_ime_input_options">Input options</string>

    <!-- Name of Android spell checker service -->
    <string name="spell_checker_service_name">Android spell checker</string>
    <!-- Name of Android spell checker service. AOSP(Android Open Source Project) should not be translated. -->
    <string name="aosp_spell_checker_service_name">Android spell checker (AOSP)</string>

    <!-- Title for the spell checking service settings screen -->
    <string name="android_spell_checker_settings">Spell checking settings</string>

    <!-- Title for the spell checker option to turn on/off contact names lookup [CHAR LIMIT=25] -->
    <string name="use_contacts_for_spellchecking_option_title">Look up contact names</string>

    <!-- Description for the spell checker option to turn on/off contact names lookup. [CHAR LIMIT=65] -->
    <string name="use_contacts_for_spellchecking_option_summary">Spell checker uses entries from your contact list</string>

    <!-- Option to provide vibrate/haptic feedback on keypress -->
    <string name="vibrate_on_keypress">Vibrate on keypress</string>

    <!-- Option to play back sound on keypress in soft keyboard -->
    <string name="sound_on_keypress">Sound on keypress</string>

    <!-- Option to control whether or not to show a popup with a larger font on each key press. -->
    <string name="popup_on_keypress">Popup on keypress</string>

    <!-- Category title for general settings for Android keyboard -->
    <string name="general_category">General</string>

    <!-- Category title for text prediction -->
    <string name="correction_category">Text correction</string>

    <!-- Category title for misc options  -->
    <string name="misc_category">Other options</string>

    <!-- Option name for advanced settings screen [CHAR LIMIT=25] -->
    <string name="advanced_settings">Advanced settings</string>
    <!-- Option summary for advanced settings screen [CHAR LIMIT=65 (two lines) or 30 (fits on one line, preferable)] -->
    <string name="advanced_settings_summary">Options for experts</string>

    <!-- Option name for including other IMEs in the language switch list [CHAR LIMIT=30] -->
    <string name="include_other_imes_in_language_switch_list">Switch to other input methods</string>
    <!-- Option summary for including other IMEs in the language switch list [CHAR LIMIT=65] -->
    <string name="include_other_imes_in_language_switch_list_summary">Language switch key covers other input methods too</string>
    <!-- Option to suppress language switch key [CHAR LIMIT=30] -->
    <string name="suppress_language_switch_key">Suppress language switch key</string>

    <!-- Option for the dismiss delay of the key popup [CHAR LIMIT=25] -->
    <string name="key_preview_popup_dismiss_delay">Key popup dismiss delay</string>
    <!-- Description for delay for dismissing a popup on keypress: no delay [CHAR LIMIT=15] -->
    <string name="key_preview_popup_dismiss_no_delay">No delay</string>
    <!-- Description for delay for dismissing a popup on screen: default value of the delay [CHAR LIMIT=15] -->
    <string name="key_preview_popup_dismiss_default_delay">Default</string>

    <!-- Option name for enabling or disabling the use of names of people in Contacts for suggestion and correction [CHAR LIMIT=25] -->
    <string name="use_contacts_dict">Suggest Contact names</string>
    <!-- Description for option enabling or disabling the use of names of people in Contacts for suggestion and correction [CHAR LIMIT=65] -->
    <string name="use_contacts_dict_summary">Use names from Contacts for suggestions and corrections</string>

    <!-- Option name for enabling insertion of suggestion spans (advanced option) [CHAR LIMIT=25] -->
    <string name="enable_span_insert">Enable recorrections</string>
    <!-- Option summary for enabling insertion of suggestion spans (advanced option) [CHAR LIMIT=65] -->
    <string name="enable_span_insert_summary">Set suggestions for recorrections</string>

    <!-- Option to enable auto capitalization of sentences -->
    <string name="auto_cap">Auto-capitalization</string>

    <!-- Option to configure dictionaries -->
    <string name="configure_dictionaries_title">Add-on dictionaries</string>
    <!-- Name of the main dictionary, as opposed to auxiliary dictionaries (medical/entertainment/sports...) -->
    <string name="main_dictionary">Main dictionary</string>

    <!-- Option to enable showing suggestions -->
    <string name="prefs_show_suggestions">Show correction suggestions</string>
    <!-- Description for show suggestions -->
    <string name="prefs_show_suggestions_summary">Display suggested words while typing</string>
    <string name="prefs_suggestion_visibility_show_name">Always show</string>
    <string name="prefs_suggestion_visibility_show_only_portrait_name">Show on portrait mode</string>
    <string name="prefs_suggestion_visibility_hide_name">Always hide</string>

    <!-- Option to decide the auto correction threshold score -->
    <!-- Option to enable auto correction [CHAR LIMIT=20]-->
    <string name="auto_correction">Auto correction</string>
    <!-- Description for auto correction [CHAR LIMIT=65 (two lines) or 30 (fits on one line, preferable)] -->
    <string name="auto_correction_summary">Spacebar and punctuation automatically correct mistyped words</string>
    <!-- Option to disable auto correction. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_off">Off</string>
    <!-- Option to suggest auto correction suggestions modestly. Auto-corrects only to a word which has small edit distance from typed word. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_modest">Modest</string>
    <!-- Option to suggest auto correction suggestions aggressively. Auto-corrects to a word which has even large edit distance from typed word. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_aggeressive">Aggressive</string>
    <!-- Option to suggest auto correction suggestions very aggressively. Auto-corrects to a word which has even large edit distance from typed word. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_very_aggeressive">Very aggressive</string>

    <!-- Option to enable next word correction -->
    <string name="bigram_suggestion">Next word suggestions</string>
    <!-- Option to enable next word suggestion. This uses the previous word in an attempt to improve the suggestions quality -->
    <string name="bigram_suggestion_summary">Use previous word to improve suggestions</string>
    <!-- Option to enable using next word prediction -->
    <string name="bigram_prediction">Next word prediction</string>
    <!-- Description for "next word prediction" option. This displays suggestions even when there is no input, based on the previous word. -->
    <string name="bigram_prediction_summary">Use previous word also for prediction</string>

    <!-- Indicates that a word has been added to the dictionary -->
    <string name="added_word"><xliff:g id="word">%s</xliff:g> : Saved</string>

    <!-- Label for soft enter key when it performs GO action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_go_key">Go</string>
    <!-- Label for soft enter key when it performs NEXT action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_next_key">Next</string>
    <!-- Label for soft enter key when it performs PREVIOUS action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_previous_key">Prev</string>
    <!-- Label for soft enter key when it performs DONE action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_done_key">Done</string>
    <!-- Label for soft enter key when it performs SEND action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_send_key">Send</string>
    <!-- Label for "switch to alphabetic" key.  Must be short to fit on key! [CHAR LIMIT=3] -->
    <string name="label_to_alpha_key">ABC</string>
    <!-- Label for "switch to symbols" key.  Must be short to fit on key! [CHAR LIMIT=4] -->
    <string name="label_to_symbol_key">\?123</string>
    <!-- Label for "switch to symbols with microphone" key. This string shouldn't include the "mic"
         part because it'll be appended by the code. Must be short to fit on key! [CHAR LIMIT=3] -->
    <string name="label_to_symbol_with_microphone_key">123</string>
    <!-- Label for "Pause" key of phone number keyboard.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_pause_key">Pause</string>
    <!-- Label for "Wait" key of phone number keyboard.  Must be short to fit on key! [CHAR LIMIT=5]-->
    <string name="label_wait_key">Wait</string>

    <!-- Spoken description to let the user know that when typing in a password, they can plug in a headset in to hear spoken descriptions of the keys they type. [CHAR LIMIT=NONE] -->
    <string name="spoken_use_headphones">Plug in a headset to hear password keys spoken aloud.</string>

    <!-- Spoken description for the currently entered text -->
    <string name="spoken_current_text_is">Current text is "%s"</string>
    <!-- Spoken description when there is no text entered -->
    <string name="spoken_no_text_entered">No text entered</string>

    <!-- Spoken description for unknown keyboard keys. -->
    <string name="spoken_description_unknown">Key code %d</string>
    <!-- Spoken description for the "Shift" keyboard key when "Shift" is off. -->
    <string name="spoken_description_shift">Shift</string>
    <!-- Spoken description for the "Shift" keyboard key when "Shift" is on. -->
    <string name="spoken_description_shift_shifted">Shift on (tap to disable)</string>
    <!-- Spoken description for the "Shift" keyboard key when "Caps lock" is on. -->
    <string name="spoken_description_caps_lock">Caps lock on (tap to disable)</string>
    <!-- Spoken description for the "Delete" keyboard key. -->
    <string name="spoken_description_delete">Delete</string>
    <!-- Spoken description for the "To Symbol" keyboard key. -->
    <string name="spoken_description_to_symbol">Symbols</string>
    <!-- Spoken description for the "To Alpha" keyboard key. -->
    <string name="spoken_description_to_alpha">Letters</string>
    <!-- Spoken description for the "To Numbers" keyboard key. -->
    <string name="spoken_description_to_numeric">Numbers</string>
    <!-- Spoken description for the "Settings" keyboard key. -->
    <string name="spoken_description_settings">Settings</string>
    <!-- Spoken description for the "Tab" keyboard key. -->
    <string name="spoken_description_tab">Tab</string>
    <!-- Spoken description for the "Space" keyboard key. -->
    <string name="spoken_description_space">Space</string>
    <!-- Spoken description for the "Mic" keyboard key. -->
    <string name="spoken_description_mic">Voice input</string>
    <!-- Spoken description for the "Smiley" keyboard key. -->
    <string name="spoken_description_smiley">Smiley face</string>
    <!-- Spoken description for the "Return" keyboard key. -->
    <string name="spoken_description_return">Return</string>
    <!-- Spoken description for the "Search" keyboard key. -->
    <string name="spoken_description_search">Search</string>
    <!-- Spoken description for the "U+2022" (BULLET) keyboard key. -->
    <string name="spoken_description_dot">Dot</string>

    <!-- Spoken feedback after turning "Shift" mode on. -->
    <string name="spoken_description_shiftmode_on">Shift enabled</string>
    <!-- Spoken feedback after turning "Caps lock" mode on. -->
    <string name="spoken_description_shiftmode_locked">Caps lock enabled</string>
    <!-- Spoken feedback after turning "Shift" mode off. -->
    <string name="spoken_description_shiftmode_off">Shift disabled</string>

    <!-- Spoken feedback after changing to the symbols keyboard. -->
    <string name="spoken_description_mode_symbol">Symbols mode</string>
    <!-- Spoken feedback after changing to the alphanumeric keyboard. -->
    <string name="spoken_description_mode_alpha">Letters mode</string>
    <!-- Spoken feedback after changing to the phone dialer keyboard. -->
    <string name="spoken_description_mode_phone">Phone mode</string>
    <!-- Spoken feedback after changing to the shifted phone dialer (symbols) keyboard. -->
    <string name="spoken_description_mode_phone_shift">Phone symbols mode</string>

    <!-- Preferences item for enabling speech input -->
    <string name="voice_input">Voice input key</string>

    <!-- Voice Input modes -->
    <!-- On settings screen, voice input pop-up menu option to show voice key on main keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_main_keyboard">On main keyboard</string>
    <!-- On settings screen, voice input pop-up menu option to show voice key on symbols keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_symbols_keyboard">On symbols keyboard</string>
    <!-- On settings screen, voice input pop-up menu option to never show voice key [CHAR LIMIT=20] -->
    <string name="voice_input_modes_off">Off</string>
    <!-- Voice Input modes summary -->
    <!-- On settings screen, voice input pop-up menu summary text to show voice key on main keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_summary_main_keyboard">Mic on main keyboard</string>
    <!-- On settings screen, voice input pop-up menu summary text to show voice key on symbols keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_summary_symbols_keyboard">Mic on symbols keyboard</string>
    <!-- On settings screen, voice input pop-up menu summary text to never show voice key [CHAR LIMIT=20] -->
    <string name="voice_input_modes_summary_off">Voice input is disabled</string>

    <!-- Title for configuring input method settings [CHAR LIMIT=35] -->
    <string name="configure_input_method">Configure input methods</string>

    <!-- Title for input language selection screen -->
    <string name="language_selection_title">Input languages</string>

    <!-- Preference for input language selection -->
    <string name="select_language">Input languages</string>

    <!-- Add to dictionary hint -->
    <string name="hint_add_to_dictionary">Touch again to save</string>

    <!-- Inform the user that a particular language has an available dictionary -->
    <string name="has_dictionary">Dictionary available</string>

    <!-- Preferences item for enabling to send user statistics to Google -->
    <string name="prefs_enable_log">Enable user feedback</string>
    <!-- Description for enabling to send user statistics to Google -->
    <string name="prefs_description_log">Help improve this input method editor by automatically sending usage statistics and crash reports to Google.</string>

    <!-- Title of the item to change the keyboard theme [CHAR LIMIT=20]-->
    <string name="keyboard_layout">Keyboard theme</string>

    <!-- Description for English (United Kingdom) keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_en_GB">English (UK)</string>
    <!-- Description for English (United States) keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_en_US">English (US)</string>
    <!-- Description for English (United Kingdom) keyboard subtype with explicit keyboard layout [CHAR LIMIT=25]
         This should be identical to subtype_en_GB aside from the trailing (%s). -->
    <string name="subtype_with_layout_en_GB">English (UK) (<xliff:g id="layout">%s</xliff:g>)</string>
    <!-- Description for English (United States) keyboard subtype with explicit keyboard layout [CHAR LIMIT=25]
         This should be identical to subtype_en_US aside from the trailing (%s). -->
    <string name="subtype_with_layout_en_US">English (US) (<xliff:g id="layout">%s</xliff:g>)</string>
    <!-- Description for language agnostic keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language">No language</string>
    <!-- Description for language agnostic QWERTY keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_qwerty">No language (QWERTY)</string>
    <!-- Description for language agnostic QWERTZ keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_qwertz">No language (QWERTZ)</string>
    <!-- Description for language agnostic AZERTY keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_azerty">No language (AZERTY)</string>
    <!-- Description for language agnostic Dvorak keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_dvorak">No language (Dvorak)</string>
    <!-- Description for language agnostic Colemak keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_colemak">No language (Colemak)</string>
    <!-- Description for language agnostic PC QWERTY keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_pcqwerty">No language (PC)</string>

    <!-- Title of the preference settings for custom input styles (language and keyboard layout pairs) [CHAR LIMIT=35]-->
    <string name="custom_input_styles_title">Custom input styles</string>
    <!-- Title of the option menu to add a new style entry in the preference settings [CHAR LIMIT=16] -->
    <string name="add_style">Add style</string>
    <!-- Title of the button to add custom style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="add">Add</string>
    <!-- Title of the button to remove a custom style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="remove">Remove</string>
    <!-- Title of the button to save a custom style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="save">Save</string>
    <!-- Title of the spinner for choosing a language of custom style in the settings dialog [CHAR LIMIT=15] -->
    <string name="subtype_locale">Language</string>
    <!-- Title of the spinner for choosing a keyboard layout of custom style in the settings dialog [CHAR LIMIT=15] -->
    <string name="keyboard_layout_set">Layout</string>
    <!-- The message of the dialog to note that a custom input style needs to be enabled. [CHAR LIMIT=64] -->
    <string name="custom_input_style_note_message">"Your custom input style needs to be enabled before you start using it. Do you want to enable it now?"</string>
    <!-- Title of the button to enable a custom input style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="enable">Enable</string>
    <!-- Title of the button to postpone enabling a custom input style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="not_now">Not now</string>
    <!-- Toast text to describe the same input style already exists [CHAR LIMIT=64]-->
    <string name="custom_input_style_already_exists">"The same input style already exists: <xliff:g id="input_style_name">%s</xliff:g>"</string>

    <!-- Title of an option for usability study mode -->
    <string name="prefs_usability_study_mode">Usability study mode</string>
    <!-- Title of the settings for keypress vibration duration -->
    <string name="prefs_keypress_vibration_duration_settings">Keypress vibration duration settings</string>
    <!-- Title of the settings for keypress sound volume -->
    <string name="prefs_keypress_sound_volume_settings">Keypress sound volume settings</string>
</resources>
