<?xml version="1.0" encoding="utf-8"?>
<!--
     Copyright (C) 2013-2016 The CyanogenMod Project
               (C) 2017 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">
    <string name="device_settings_app_name">Erweidert Astellungen</string>
    <string name="screen_gestures_panel_title">Gesten</string>
    <string name="touchscreen_gesture_extras">Extraen</string>
    <string name="touchscreen_gesture_haptic_feedback">Haptesche Feedback</string>
    <string name="touchscreen_c_gesture_title">Fotoapparat</string>
    <string name="touchscreen_c_gesture_summary">\'C\' zeechnen, fir de Fotoapparat z\'aktivéieren</string>
    <string name="touchscreen_e_gesture_title">E-Mail</string>
    <string name="touchscreen_e_gesture_summary">\'e\' zeechnen, fir d\'Email-App z\'aktivéieren</string>
    <string name="touchscreen_s_gesture_title">Messagen</string>
    <string name="touchscreen_s_gesture_summary">\'S\' zeechnen, fir d\'SMS-App z\'aktivéieren</string>
    <string name="touchscreen_v_gesture_title">Telefon</string>
    <string name="touchscreen_v_gesture_summary">\'V\' zeechnen, fir d\'Telefons-App z\'aktivéieren</string>
    <string name="touchscreen_w_gesture_title">Browser</string>
    <string name="touchscreen_w_gesture_summary">\'W\' zeechnen, fir d\'Browser-App z\'aktivéieren</string>
    <string name="touchscreen_z_gesture_title">Täscheluucht</string>
    <string name="touchscreen_z_gesture_summary">\'Z\' zeechnen, fir d\'Täscheluucht un-/auszemaachen</string>
    <string name="user_aware_display_title">Benotzerbewosst Uweis</string>
    <string name="user_aware_display_summary">De Schierm waakreghalen, soulaang e virun engem Benutzer ass</string>
    <string name="ambient_display_title">Ambiente Schierm</string>
    <string name="ambient_display_enable_title">Ambiente Schierm</string>
    <string name="ambient_display_enable_summary">Schierm waakreg maachen, wann s du Notifikatiounen empfänks</string>
    <string name="hand_wave_gesture_title">Wénken</string>
    <string name="hand_wave_gesture_summary">Puls-Notifikatioune beim Wénken</string>
    <string name="pick_up_gesture_title">Ophiewen</string>
    <string name="pick_up_gesture_summary">Notifikatioune beim Ophiewe kuerz uweisen</string>
    <string name="pocket_gesture_title">Täsch</string>
    <string name="pocket_gesture_summary">Notifikatioune beim Eraushuelen aus der Täsch kuerz ablenden</string>
    <string name="proximity_wake_title">Waakreg ginn wéinst d\'Proximitéit</string>
    <string name="proximity_wake_enable_title">Waakreg gi bei Proximitéit</string>
    <string name="proximity_wake_enable_summary">Apparat duerch Wénke waakreg maachen</string>
    <string name="actions_title">Aktiounen</string>
    <string name="camera_gesture_title">Duebel Dréiung</string>
    <string name="camera_gesture_summary">Fotoapparat aktivéieren, wann de Gest \"Duebel Dréinung\" benotzt gëtt</string>
    <string name="hand_wave_silencer_title">Wénke fir roueg ze schalten</string>
    <string name="hand_wave_silencer_summary">Erakommend Uriff roueg schalten duerch d\'Wénken iwwer de Schierm</string>
    <string name="action_none">Desaktivéieren</string>
    <string name="action_launch_camera">Kamera starten</string>
    <string name="action_torch">Täscheluucht un/ausmaachen</string>
    <string name="feedback_intensity_title">Intensitéit vum haptesche Feedback</string>
    <string name="feedback_intensity_summary">Stäerkt vum haptesche Feedback fir d\'Duebel-Dréinung- an d\'Schwenk-Aktiounen</string>
    <string name="feedback_intensity_none">Desaktivéiert</string>
    <string name="feedback_intensity_low">Niddreg</string>
    <string name="feedback_intensity_medium">Mëttel</string>
    <string name="feedback_intensity_high">Héich</string>
</resources>
