<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2019 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>
    <!-- Search hint, displayed inside the search box [CHAR LIMIT=50] -->
    <string name="car_ui_toolbar_default_search_hint">Search&#8230;</string>
    <!-- CarUxRestrictions Utility -->
    <string name="car_ui_ellipsis" translatable="false">&#8230;</string>
    <!-- Content description for paged recycler view scroll bar down arrow [CHAR LIMIT=30] -->
    <string name="car_ui_scrollbar_page_down_button">Scroll down</string>
    <!-- Content description for paged recycler view scroll bar up arrow [CHAR LIMIT=30] -->
    <string name="car_ui_scrollbar_page_up_button">Scroll up</string>
    <!-- Title of the search menu item. Will be displayed if the button is in the overflow menu. [CHAR_LIMIT=50] -->
    <string name="car_ui_toolbar_menu_item_search_title">Search</string>
    <!-- Title of the settings menu item. Will be displayed if the button is in the overflow menu. [CHAR_LIMIT=50] -->
    <string name="car_ui_toolbar_menu_item_settings_title">Settings</string>

    <!-- Positive option for a preference dialog. [CHAR_LIMIT=30] -->
    <string name="car_ui_dialog_preference_positive">Ok</string>
    <!-- Negative option for a preference dialog. [CHAR_LIMIT=30] -->
    <string name="car_ui_dialog_preference_negative">Cancel</string>
    <!-- Text to show when a preference switch is on. [CHAR_LIMIT=30] -->
    <string name="car_ui_switch_preference_on">On</string>
    <!-- Text to show when a preference switch is off. [CHAR_LIMIT=30] -->
    <string name="car_ui_switch_preference_off">Off</string>
    <!-- Font family to use for preference category titles. [CHAR_LIMIT=NONE] -->
    <string name="car_ui_preference_category_title_font_family" translatable="false">sans-serif-medium</string>

    <!-- Text to show when no button is provided and a default button is used. -->
    <string name="car_ui_alert_dialog_default_button" translatable="false">Close</string>
</resources>
