<!--
     Copyright (C) 2018 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">
    <!-- The name of this application, a theme picker. [CHAR LIMIT=50] -->
    <string name="app_name">Wallpaper &amp; style</string>

    <!-- Title of a section of the customization picker where the user can select a Theme for the
        device. [CHAR LIMIT=15] -->
    <string name="theme_title">Style</string>

    <!-- Title of a section of the customization picker where the user can select a Clock face.
        [CHAR LIMIT=15] -->
    <string name="clock_title">Custom Clock</string>

    <!-- Description of a section of the customization picker where the user can select a Clock
        face. [CHAR LIMIT=15] -->
    <string name="clock_description">Pick a custom clock</string>

    <!-- The content description of clock entry. [CHAR LIMIT=NONE] -->
    <string name="clock_picker_entry_content_description">Change a custom clock</string>

    <!-- Title of a section of the customization picker where the user can configure Clock face. [CHAR LIMIT=15] -->
    <string name="clock_settings_title">Clock Settings</string>

    <!-- Title of a tab to change the clock color. [CHAR LIMIT=15] -->
    <string name="clock_color">Color</string>

    <!-- Title of a tab to change the clock size. [CHAR LIMIT=15] -->
    <string name="clock_size">Size</string>

    <!-- Title of a radio button to apply clock size dynamic. [CHAR LIMIT=15] -->
    <string name="clock_size_dynamic">Dynamic</string>

    <!-- Description of a radio button to apply clock size dynamic. [CHAR LIMIT=NONE] -->
    <string name="clock_size_dynamic_description">Clock size changes according to lock screen content</string>

    <!-- Title of a radio button to apply clock size large. [CHAR LIMIT=15] -->
    <string name="clock_size_large">Large</string>

    <!-- Title of a section of the customization picker where the user can select a Grid size for
        the home screen. [CHAR LIMIT=15] -->
    <string name="grid_title">App grid</string>

    <!-- Label for a button that allows the user to apply the currently selected Theme.
        [CHAR LIMIT=20] -->
    <string name="apply_theme_btn">Apply</string>

    <!-- Label telling the user they can tap the card to edit the currently selected custom Theme.
        [CHAR LIMIT=50] -->
    <string name="edit_custom_theme_lbl">Tap to edit</string>

    <!-- Label for a checkbox to allow the user to use their currently set wallpaper instead of
        the one bundled with selected Theme [CHAR LIMIT=35]-->
    <string name="keep_my_wallpaper">Keep current wallpaper</string>

    <!-- Content description of theme preview card. [CHAR_LIMIT=30]-->
    <string name="theme_preview_card_content_description">Style preview</string>

    <!-- Content description of grid preview card. [CHAR_LIMIT=30]-->
    <string name="grid_preview_card_content_description">Grid preview</string>

    <!-- Content description of font preview. [CHAR_LIMIT=30]-->
    <string name="font_preview_content_description">Font preview</string>

    <!-- Content description of icon preview. [CHAR_LIMIT=30]-->
    <string name="icon_preview_content_description">Icon preview</string>

    <!-- Content description of color preview. [CHAR_LIMIT=30]-->
    <string name="color_preview_content_description">Color preview</string>

    <!-- Content description of shape preview. [CHAR_LIMIT=30]-->
    <string name="shape_preview_content_description">Shape preview</string>

    <!-- Content description indicating that the selected option is currently applied to the device. [CHAR_LIMIT=NONE] -->
    <string name="option_applied_description"><xliff:g name="style_name">%1$s</xliff:g>, currently applied</string>

    <!-- Content description indicating that the selected option is currently applied and previewed. [CHAR_LIMIT=NONE] -->
    <string name="option_applied_previewed_description"><xliff:g name="style_name">%1$s</xliff:g>, currently applied and previewed</string>

    <!-- Content description indicating that the selected option is currently being previewed. [CHAR_LIMIT=NONE] -->
    <string name="option_previewed_description"><xliff:g name="style_name">%1$s</xliff:g>, currently previewed</string>

    <!-- Content description indicating that the focused option can be selected and previewed if clicked. [CHAR_LIMIT=NONE] -->
    <string name="option_change_applied_previewed_description"><xliff:g name="style_name">%1$s</xliff:g>, change selected and previewed</string>

    <!-- Sample text used to show a preview of a selected font [CHAR LIMIT=3] -->
    <string name="theme_font_example" translatable="false">ABC</string>

    <!-- Content description for previewing a style, describing each of their components. [CHAR_LIMIT=NONE] -->
    <string name="theme_description">Font: <xliff:g name="font_name">%1$s</xliff:g>, icons: <xliff:g name="icon_name">%2$s</xliff:g>, shape: <xliff:g name="shape_name">%3$s</xliff:g>, color: <xliff:g name="color_name">%4$s</xliff:g> </string>

    <!-- Plus sign used to indicate that the user can add a custom theme -->

    <!-- Name for the Android Theme (Style/Wallpaper/Grid/Clock...) that comes preset with the device [CHAR LIMIT=10]-->
    <string name="default_theme_title">Default</string>

    <!-- Title of a page that shows the user the preview of a font selection [CHAR_LIMIT=20] -->
    <string name="preview_name_font">Font</string>

    <!-- Title of a page that shows the user the preview of a set of icons [CHAR_LIMIT=20] -->
    <string name="preview_name_icon">Icon</string>

    <!-- Title of a page that shows the user the preview of a color [CHAR_LIMIT=20] -->
    <string name="preview_name_color">Color</string>

    <!-- Title of a page that shows the user the preview of a set of icons' shape [CHAR_LIMIT=20] -->
    <string name="preview_name_shape">Shape</string>

    <!-- Title of a page that shows the user the preview of a wallpaper associated with a theme [CHAR_LIMIT=20] -->
    <string name="preview_name_wallpaper">Wallpaper</string>

    <!-- Header sample text used to preview the look of a particular font, we show samples of
        uppercase and lowercase characters and numbers. [CHAR LIMIT=30] -->
    <string name="font_card_title">ABC • abc • 123</string>

    <!-- Body text for previewing a font [CHAR LIMIT=160] -->
    <string name="font_card_body">Add your favorite fonts to every screen</string>

    <!--Title for grid options [CHAR LIMIT=NONE] -->
    <string name="grid_options_title">Choose a grid size</string>

    <!--Title for a grid option, describing the number of columns and rows, eg: 4x4 [CHAR LIMIT=10] -->
    <string name="grid_title_pattern"><xliff:g name="num_cols" example="1">%1$d</xliff:g>x<xliff:g name="num_rows" example="1">%2$d</xliff:g></string>

    <!-- Message shown when a theme has been applied successfully in the system [CHAR LIMIT=NONE] -->
    <string name="applied_theme_msg">Style set successfully</string>

    <!-- Message shown when a clock has been applied successfully in the system [CHAR LIMIT=NONE] -->
    <string name="applied_clock_msg">Clock set successfully</string>

    <!-- Message shown when a grid has been applied successfully in the system [CHAR LIMIT=NONE] -->
    <string name="applied_grid_msg">Grid set successfully</string>

    <!-- Message shown when a theme couldn't be applied in the system because of an error
        [CHAR LIMIT=NONE] -->
    <string name="apply_theme_error_msg">There was a problem applying the style</string>

    <!-- Label for a button that takes the user to the next step when configuring a custom theme.
        [CHAR LIMIT=20] -->
    <string name="custom_theme_next">Next</string>

    <!-- Label for a button that takes the user back to the previous step when configuring a custom theme.
        [CHAR LIMIT=20] -->
    <string name="custom_theme_previous">Previous</string>

    <!-- Title for "Custom theme" option. [CHAR LIMIT=20] -->
    <string name="custom_theme">Custom</string>

    <!-- Generic label for one system Style/Theme (combination of fonts/colors/icons) that is
        defined and customized by the user (note there could be more than one so the label includes
        a number, eg "Custom 1, Custom 2, etc") [CHAR LIMIT=15] -->
    <string name="custom_theme_title">Custom <xliff:g name="custom_num" example="1">%1$d</xliff:g></string>

    <!-- Title for a screen that lets the user define their custom system Style/Theme
        [CHAR LIMIT=30] -->
    <string name="custom_theme_fragment_title">Custom Style</string>

    <!-- Title of a menu option that removes the custom theme being currently edited
        [CHAR LIMIT=30] -->
    <string name="custom_theme_delete">Delete</string>

    <!-- Title of a page allowing the user to choose a font for a custom theme [CHAR LIMIT=40]-->
    <string name="font_component_title">Choose font</string>

    <!-- Title of a page allowing the user to choose an icon set for a custom theme [CHAR LIMIT=40]-->
    <string name="icon_component_title">Choose icons</string>

    <!-- Title of a page allowing the user to choose a color for a custom theme [CHAR LIMIT=40]-->
    <string name="color_component_title">Choose color</string>

    <!-- Title of a page allowing the user to choose an icon shape for a custom theme [CHAR LIMIT=40]-->
    <string name="shape_component_title">Choose shape</string>

    <!-- Title of a page allowing the user to set a name for a custom theme [CHAR LIMIT=40]-->
    <string name="name_component_title">Name your style</string>

    <!-- Title of a set of icons that the user can chose for their custom style (eg, "Icons 2") -->
    <string name="icon_component_label">Icons <xliff:g name="component_number" example="1">%1$d</xliff:g></string>

    <string name="font_component_option_thumbnail" translatable="false">Aa</string>

    <!-- Dialog box asking the user to confirm if they want to delete the current custom style
        [CHAR_LIMIT=NONE] -->
    <string name="delete_custom_theme_confirmation">Delete Custom style?</string>

    <!-- Button in a dialog box confirming that the current style will be deleted [CHAR_LIMIT=20] -->
    <string name="delete_custom_theme_button">Delete</string>

    <!-- Generic label for canceling the current action [CHAR_LIMIT=20] -->
    <string name="cancel">Cancel</string>

    <!-- Label for a dialog which asks the user the destination (home screen, lock screen, both)
        where to set the theme's bundled image as wallpaper. [CHAR LIMIT=50] -->
    <string name="set_theme_wallpaper_dialog_message">Set style wallpaper</string>

    <!-- Title for a dialog box asking the user to use an existing, equivalent theme (style) instead
        of their customly defined one. [CHAR_LIMIT=30] -->
    <string name="use_style_instead_title">Use <xliff:g name="style_name">%1$s</xliff:g> instead?</string>

    <!-- Body for a dialog box asking the user to use an existing, equivalent theme (style) instead
        of their customly defined one. [CHAR_LIMIT=NONE] -->
    <string name="use_style_instead_body">The components you chose match the <xliff:g name="style_name">%1$s</xliff:g> style. Do you want to use <xliff:g name="style_name">%1$s</xliff:g> instead?</string>

    <!-- Label for a button in the dialog box that asks the user to use an existing, theme (style)
        instead of their customly defined one. The button let's the user use the suggested theme
        [CHAR_LIMIT=16] -->
    <string name="use_style_button">Use <xliff:g name="style_name">%1$s</xliff:g></string>

    <!-- Label for a button in the dialog box that asks the user to use an existing, theme (style)
        instead of their customly defined one. The button dismisses the dialog and goes back to the
        previous screen. [CHAR_LIMIT=16]  -->
    <string name="no_thanks">No, thanks</string>

    <!-- Content description for a screen showing the preview of a clock face. [CHAR_LIMIT=NONE] -->
    <string name="clock_preview_content_description"><xliff:g name="clock_name">%1$s</xliff:g> clock preview</string>

    <!-- Generic error message [CHAR_LIMIT=NONE] -->
    <string name="something_went_wrong">Oops! Something went wrong.</string>

    <!-- Title for a section of a style preview screen that shows a preview of the style color and icons. [CHAR_LIMIT=30]-->
    <string name="theme_preview_icons_section_title">Color / Icons</string>

    <!-- Bottom sheet dialog which displaying different theme's info. [CHAR_LIMIT=80] -->
    <string name="style_info_description">Preview of font, icons, app shape, and color</string>

    <!-- Accessibility for custom style font page [CHAR_LIMIT=50] -->
    <string name="accessibility_custom_font_title">Custom font</string>

    <!-- Accessibility for custom style icon page [CHAR_LIMIT=50] -->
    <string name="accessibility_custom_icon_title">Custom icon</string>

    <!-- Accessibility for custom style color page [CHAR_LIMIT=50] -->
    <string name="accessibility_custom_color_title">Custom color</string>

    <!-- Accessibility for custom style shape page [CHAR_LIMIT=50] -->
    <string name="accessibility_custom_shape_title">Custom shape</string>

    <!-- Accessibility for custom style name page [CHAR_LIMIT=50] -->
    <string name="accessibility_custom_name_title">Custom style name</string>

    <!--Name of metadata in the main launcher Activity which values contains the authority
    corresponding to a ContentProvider in launcher to query or change themed icon option  -->
    <string name="themed_icon_metadata_key" translatable="false">com.android.launcher3.themedicon.option</string>

    <!--  Strings for new customization UI.  -->

    <!-- The title of mode section view. [CHAR_LIMIT=20] -->
    <string name="mode_title" msgid="1000319159005403986">Dark theme</string>
    <string name="mode_disabled_msg" msgid="1926077857799715086">Temporarily disabled due to Battery Saver</string>
    <!-- The text for A11y announcement when theme changes. -->
    <string name="mode_changed">Theme changed</string>

    <!-- Title of a section of the customization where the user can select color override for icon. [CHAR LIMIT=30] -->
    <string name="themed_icon_title" msgid="4305612684940220645">Themed icons</string>

    <!-- Title of the tag to indicate beta version. [CHAR LIMIT=6] -->
    <string name="beta_title">Beta</string>

    <!-- The content description of grid picker entry. [CHAR LIMIT=NONE] -->
    <string name="gird_picker_entry_content_description" msgid="7538418512525897691">Change app grid</string>

    <!-- The title for the tab with colors from wallpaper. [CHAR_LIMIT=20]-->
    <string name="wallpaper_color_tab">Wallpaper colors</string>
    <!-- The description on an item that shows a color obtained from the wallpaper
        (used mainly for accessibility). [CHAR_LIMIT=NONE] -->
    <string name="wallpaper_color_title">Wallpaper color</string>
    <!-- The title for the tab with a default set of color options. [CHAR_LIMIT=20]-->
    <string name="preset_color_tab">Basic colors</string>
    <!-- The text for A11y announcement when color changes. -->
    <string name="color_changed">Color changed</string>
    <!-- Title of a section of color selection option that obtains colors automatically from the
        wallpaper instead of a set color [CHAR LIMIT=15] -->
    <string name="adaptive_color_title">Dynamic</string>
    <!--
    Title for a screen where the user can configure the system colors by selecting from a list of
    color options.
    [CHAR LIMIT=32].
    -->
    <string name="color_picker_title">System Colors</string>

    <!--
    Name of the slot on the "start" side of the bottom of the lock screen, where lock screen
    shortcuts can be added to the lock screen. In left-to-right languages, this is the left-hand
    side button. In right-to-left languages, this is the right-hand side button. [CHAR LIMIT=16].
    -->
    <string name="keyguard_slot_name_bottom_start">Left shortcut</string>

    <!--
    Name of the slot on the "end" side of the bottom of the lock screen, where lock screen shortcuts
    can be added to the lock screen. In left-to-right languages, this is the right-hand side button.
    In right-to-left languages, this is the left-hand side button. [CHAR LIMIT=16].
    -->
    <string name="keyguard_slot_name_bottom_end">Right shortcut</string>

    <!--
    Name for an option to have no quick affordance selected for one of the sides of the lock
    screen. We show this as an option in a settings experience, where users get to choose which
    quick affordances (or buttons) are available on their device's lock screen. [CHAR LIMIT=10].
    -->
    <string name="keyguard_affordance_none">None</string>

    <!--
    Title for a popup dialog shown when the user attempts to select an option that is not currently
    enabled. The dialog contains a list of instructions that the user needs to take in order to
    enable the option before it can be selected again. [CHAR LIMIT=NONE].
    -->
    <string name="keyguard_affordance_enablement_dialog_title">To select `<xliff:g id="appName" example="Wallet">%1$s</xliff:g>` check the following</string>

    <!--
    Template for an action that opens a specific app. [CHAR LIMIT=16]
    -->
    <string name="keyguard_affordance_enablement_dialog_action_template">Open <xliff:g id="appName" example="Wallet">%1$s</xliff:g></string>

    <!--
    Template for a message shown right before a list of instructions that tell the user what to do
    in order to enable a shortcut to a specific app. [CHAR LIMIT=NONE]
    -->
    <string name="keyguard_affordance_enablement_dialog_message">To add the <xliff:g id="appName" example="Wallet">%1$s</xliff:g> app as a shortcut, make sure</string>

    <!--
    Label for button in a dialog shown to the user with a list of instructions that the user should
    follow in order to make a piece of functionality available as a lock screen quick affordance.
    [CHAR LIMIT=10].
    -->
    <string name="keyguard_affordance_enablement_dialog_dismiss_button">Done</string>

    <!--
    Title for a screen where the user can configure the lock screen shortcut buttons that appear on
    the device without unlocking.
    [CHAR LIMIT=32].
    -->
    <string name="keyguard_quick_affordance_title">Shortcuts</string>

    <!--
    Label for a menu item on a settings screen that helps the user open a new screen where they can
    configure the lock screen shortcut buttons that appear on the device without unlocking.
    [CHAR LIMIT=16].
    -->
    <string name="keyguard_quick_affordance_section_title">Shortcuts</string>

    <!--
    Template for text that shows the names of two currently-selected lock screen shortcuts on the
    lock screen. For example, it may say "Camera, Wallet", if the first selected shortcut opens the
    camera app and the second one opens the tap-to-pay wallet experience.
    [CHAR LIMIT=60].
    -->
    <string name="keyguard_quick_affordance_two_selected_template"><xliff:g id="first">%1$s</xliff:g>, <xliff:g id="second">%2$s</xliff:g></string>

    <!--
    Placeholder text that shows when no lock screen shortcuts are currently selected on the lock
    screen. When selected, "None" is replaced by another string that shows what is currently
    selected. For example, it may say "Camera, Wallet", if the first selected shortcut opens the
    camera app and the second one opens the tap-to-pay wallet experience.
    [CHAR LIMIT=60].
    -->
    <string name="keyguard_quick_affordance_none_selected">None</string>

    <!--
    Title for a section in a list of sections in the settings app that allows the user to modify
    how notifications behave whilst the device is locked.

    [CHAR LIMIT=32].
    -->
    <string name="notifications_section_title">Notifications</string>

    <!--
    Summary for a setting that lets the user toggle between showing or hiding notifications on their
    device's lock screen. This one is shown when the user is allowing notifications to show on their
    device's lock screen.

    [CHAR LIMIT=64].
    -->
    <string name="show_notifications_on_lock_screen">Show notifications on the lock screen</string>

    <!--
    Summary for a setting that lets the user toggle between showing or hiding notifications on their
    device's lock screen. This one is shown when the user is not allowing notifications to show on
    their device's lock screen.

    [CHAR LIMIT=64].
    -->
    <string name="hide_notifications_on_lock_screen">Hide notifications on the lock screen</string>

    <!--
    Title for a section in a list of sections in the settings app that allows the user to access
    additional settings related to lock screen behaviour.

    [CHAR LIMIT=32].
    -->
    <string name="more_settings_section_title">More options</string>

    <!--
    Summary for a setting that lets the user access additional settings related to lock screen
    behaviour. Please note that "Now Playing" is an entity; it's a name of an existing feature
    that allows users to see the song that the device is picking up through its microphone on
    the lock screen; therefore, it should not be translated literally.

    [CHAR LIMIT=64].
    -->
    <string name="more_settings_section_description">Text on lock screen, Now Playing, and more</string>

    <!--
    Label for button that lets the user navigate to a full-screen experience of selecting
    system colors.

    [CHAR LIMIT=128].
    -->
    <string name="more_colors">More Colors</string>
</resources>
