<?xml version="1.0" encoding="utf-8"?>
<!--
     Copyright (C) 2017-2021 The LineageOS 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">
    <!-- FastCharge feature -->
    <string name="fast_charging_title">Fast charging</string>
    <string name="fast_charging_summary">Disable to reduce the heat produced by the device while charging or to extend the lifespan of the battery</string>

    <!-- High touch sensitivity -->
    <string name="high_touch_sensitivity_title">High touch sensitivity</string>
    <string name="high_touch_sensitivity_summary">Increase touchscreen sensitivity so it can be used while wearing gloves</string>

    <!-- Navigation bar hint -->
    <string name="show_navbar_gesture_bar_title">Gesture bar</string>
    <string name="show_navbar_gesture_bar_summary">Show gesture bar at the bottom of the screen</string>

    <!-- Black theme for dark mode -->
    <string name="berry_black_theme_title">Pure black</string>
    <string name="berry_black_theme_summary">Pure black background for dark theme</string>

    <!-- Advanced restart options -->
    <string name="power_menu_advanced_restart_title">Advanced restart</string>
    <string name="power_menu_advanced_restart_summary">When unlocked, include options in the power menu for restarting into recovery or bootloader</string>

    <!-- Lock screen pattern size -->
    <string name="lock_pattern_size_3" translatable="false">3 \u00d7 3</string>
    <string name="lock_pattern_size_4" translatable="false">4 \u00d7 4</string>
    <string name="lock_pattern_size_5" translatable="false">5 \u00d7 5</string>
    <string name="lock_pattern_size_6" translatable="false">6 \u00d7 6</string>
    <string name="lock_settings_picker_pattern_size_message">Choose a pattern size</string>

    <!-- Whether a visible red line will be drawn after the user has drawn the unlock pattern incorrectly -->
    <string name="lockpattern_settings_enable_error_path_title">Show pattern error</string>
    <!-- Whether the dots will be drawn when using the lockscreen pattern -->
    <string name="lockpattern_settings_enable_dots_title">Show pattern dots</string>

    <!-- Max refresh rate -->
    <string name="max_refresh_rate_title">Peak refresh rate</string>

    <!-- Min refresh rate -->
    <string name="min_refresh_rate_title">Minimum refresh rate</string>

    <!-- PIN scramble -->
    <string name="unlock_scramble_pin_layout_title">Scramble layout</string>
    <string name="unlock_scramble_pin_layout_summary">Scramble PIN layout when unlocking device</string>

    <!-- Hotspot extras -->
    <string name="tethering_allow_vpn_upstreams_title">Allow clients to use VPNs</string>
    <string name="tethering_allow_vpn_upstreams_summary">Permit hotspot clients to use this device\u2019s VPN connections for upstream connectivity</string>

    <!-- Display : Rotation -->
    <string name="display_rotation_title">Rotation settings</string>
    <string name="display_rotation_enabled">Auto-rotation is enabled</string>
    <string name="display_rotation_disabled">Auto-rotation is disabled</string>
    <string name="display_rotation_unit">degrees</string>
    <string name="display_rotation_category_title">Rotation modes</string>
    <string name="display_rotation_0_title">0 degrees</string>
    <string name="display_rotation_90_title">90 degrees</string>
    <string name="display_rotation_180_title">180 degrees</string>
    <string name="display_rotation_270_title">270 degrees</string>

    <!-- Status bar -->
    <string name="status_bar_title">Status bar</string>
    <string name="status_bar_system_icons_summary">Control which status bar icons are shown</string>

    <!-- Display settings screen, peak refresh rate settings summary [CHAR LIMIT=NONE] -->
    <string name="peak_refresh_rate_summary_custom">Automatically raises the refresh rate from 60 to %1$d Hz for some content. Increases battery usage.</string>

    <!-- Location settings screen, setting check box label if Assisted GPS should be enabled -->
    <string name="assisted_gps">Use assisted GPS</string>
    <!-- Location settings screen, setting summary for Assisted GPS switch -->
    <string name="assisted_gps_summary">Download satellite assistance data from the internet which can greatly improve the GPS startup performance</string>
</resources>
