<?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="switch_bar_on">Uključeno</string>
    <string name="switch_bar_off">Isključeno</string>
    <string name="device_settings_app_name">Napredne postavke</string>
    <string name="screen_gestures_panel_title">Geste</string>
    <string name="touchscreen_gesture_extras">Dodatno</string>
    <string name="touchscreen_gesture_haptic_feedback">Dodirna povratna informacija</string>
    <string name="touchscreen_gesture_haptic_feedback_summary">Vibriraj kada se otkrije gesta na dodirnom zaslonu</string>
    <string name="touchscreen_gesture_settings_title">Geste dodirnog zaslona</string>
    <string name="touchscreen_gesture_settings_summary">Izvrši razne geste dodirnog zaslona za brze radnje</string>
    <string name="gesture_display_title">Geste isključenog zaslona</string>
    <string name="touchscreen_c_gesture_title">Fotoaparat</string>
    <string name="touchscreen_c_gesture_summary">Nacrtajte \"C\" da biste aktivirali Fotoaparat</string>
    <string name="touchscreen_e_gesture_title">E-pošta</string>
    <string name="touchscreen_e_gesture_summary">Nacrtajte \"e\" da biste otvorili aplikaciju e-pošte</string>
    <string name="touchscreen_m_gesture_title">Poruke</string>
    <string name="touchscreen_m_gesture_summary">Nacrtajte \"M\" za otvaranje aplikacije Poruke</string>
    <string name="touchscreen_s_gesture_title">Poruke</string>
    <string name="touchscreen_s_gesture_summary">Nacrtajte \"S\" za otvaranje aplikacije Poruke</string>
    <string name="touchscreen_v_gesture_title">Brojčana tipkovnica</string>
    <string name="touchscreen_v_gesture_summary">Nacrtajte \"V\" da biste otvorili aplikaciju Brojčana tipkovnica</string>
    <string name="touchscreen_w_gesture_title">Preglednik</string>
    <string name="touchscreen_w_gesture_summary">Nacrtajte \"W\" za otvaranje aplikacije Preglednik</string>
    <string name="touchscreen_z_gesture_title">Bljeskalica</string>
    <string name="touchscreen_z_gesture_summary">Nacrtajte \"Z\" za upravljanje svjetiljkom</string>
    <string name="touchscreen_flashlight_gesture_title">Bljeskalica</string>
    <string name="touchscreen_flashlight_gesture_summary">Nacrtajte krug za upravljanje svjetiljkom</string>
    <string name="touchscreen_music_gesture_title">Glazba</string>
    <string name="touchscreen_music_gesture_summary">Koristi geste za kontrolu glazbe \n
    • Kliznite dolje za sviranje/pauzu\n
    • Kliznite lijevo za prethodnu pjesmu\n
    • Kliznite desno za sljedeću pjesmu</string>
    <string name="touchscreen_swipe_up_title">Povuci gore</string>
    <string name="touchscreen_swipe_right_title">Povuci desno</string>
    <string name="touchscreen_swipe_down_title">Povuci dolje</string>
    <string name="touchscreen_swipe_left_title">Povuci lijevo</string>
    <string name="user_aware_display_title">Korisniku prilagođen prikaz</string>
    <string name="user_aware_display_summary">Drži zaslon uključen dok je korisnik ispred zaslona</string>
    <string name="ambient_display_title">Ambijentni zaslon</string>
    <string name="ambient_display_enable_title">Ambijentni zaslon</string>
    <string name="ambient_display_enable_summary">Probudi zaslon kada primite obavijesti</string>
    <string name="ambient_display_gestures_title">Geste ambijentalnog prikaza</string>
    <string name="ambient_display_gestures_summary">Dodatne geste za buđenje zaslona</string>
    <string name="ambient_display_summary">Probudi zaslon kada primite obavijesti</string>
    <string name="ambient_display_summary_on">Zaslon će se probuditi kad primite obavijesti</string>
    <string name="ambient_display_summary_off">Zaslon se neće probuditi kad primite obavijesti</string>
    <string name="tilt_sensor_title">Senzor nagiba</string>
    <string name="pickup_sensor_title">Senzor podizanja</string>
    <string name="proximity_sensor_title">Senzor blizine</string>
    <string name="hand_wave_gesture_title">Zamah rukom</string>
    <string name="hand_wave_gesture_summary">Prikaz obavijesti na zamah rukom</string>
    <string name="hand_wave_gesture_flat_title">Otkrivanje orijentacije</string>
    <string name="hand_wave_gesture_flat_summary">Pulsiraj samo ako telefon leži licem prema gore na ravnoj površini</string>
    <string name="pick_up_gesture_title">Podizanje</string>
    <string name="pick_up_gesture_summary">Prikaz obavijesti kod podizanja</string>
    <string name="pocket_gesture_title">Džep</string>
    <string name="pocket_gesture_summary">Prikaz obavijesti kada izvadite uređaj iz džepa</string>
    <string name="proximity_wake_title">Probudi zaslon na blizinu</string>
    <string name="proximity_wake_enable_title">Probudi zaslon na blizinu</string>
    <string name="proximity_wake_enable_summary">Probudi uređaj na zamah rukom</string>
    <string name="actions_title">Radnje</string>
    <string name="camera_gesture_title">Dvostruki zaokret</string>
    <string name="camera_gesture_summary">Otvori fotoaparat gestom dvostruki zaokret</string>
    <string name="chop_chop_gesture_title">Chop-chop</string>
    <string name="chop_chop_gesture_summary">Uključi/isključi svjetiljku koristeći chop-chop gestu</string>
    <string name="hand_wave_silencer_title">Mahni za tišinu</string>
    <string name="hand_wave_silencer_summary">Utišaj dolazne pozive mahanjem preko zaslona</string>
    <string name="flip_to_mute_title">Preokreni za Ne ometaj</string>
    <string name="flip_to_mute_summary">Okrenite telefon prema dolje za utišavanje obavijesti i poziva</string>
    <string name="dnd_access">Molimo vas, dajte \"Ne ometaj\" pristup CMActions da biste mogli koristiti ovu opciju.</string>
    <string name="lift_to_silence_title">Javi se da prestane zvoniti</string>
    <string name="lift_to_silence_summary">Podignite uređaj da utišate dolazne pozive. Radi samo kada vaš telefon počinje iz ravnog položaja</string>
    <string name="action_none">Onemogući</string>
    <string name="action_launch_camera">Pokreni kameru</string>
    <string name="action_torch">Prekidač svjetiljke</string>
    <string name="feedback_intensity_title">Intenzitet odgovora dodira</string>
    <string name="feedback_intensity_summary">Jakost povratne informacije za duplu rotaciju i požuri akciju</string>
    <string name="feedback_intensity_none">Onemogućeno</string>
    <string name="feedback_intensity_low">Niska</string>
    <string name="feedback_intensity_medium">Srednje</string>
    <string name="feedback_intensity_high">Visoka</string>
    <string name="dialog_ok">OK</string>
    <string name="doze_settings_help_title">Pomoć</string>
    <string name="doze_settings_help_text">Te značajke koriste događaje senzora za pokretanje pulsiranja obavijesti. Odabrani senzor je omogućen jedino kada uređaj primi obavijest, to pomaže smanjenju potrošnje baterije. Tu je i opcija omogućenja odabranog senzora čim se zaslon isključi, to će uzrokovati veću potrošnju baterije.</string>
    <string name="button_panel_title">Dodatne tipke</string>
    <string name="button_swap_title">Zamijeni tipke</string>
    <string name="button_swap_summary">Zamijeni redoslijed tipke za prikaz nedavnih aplikacije i tipke za povratak natrag</string>
    <string name="fingerprint_title">Otisak prsta</string>
    <string name="fingerprint_as_home_title">Otisak prsta kao početni gumb</string>
    <string name="fingerprint_as_home_summary">Upotrebljavajte senzor za otisak prsta kao gumb za početni zaslon</string>
    <string name="fingerprint_wakeup_title">Buđenje otiskom</string>
    <string name="fingerprint_wakeup_summary">Omogućite senzoru otiska prsta da probudi uređaj kad je zaslon isključen.</string>
    <string name="fingerprint_pocketmode_title">Spriječi slučajna buđenja</string>
    <string name="fingerprint_pocketmode_summary">Provjeri senzor blizine prije buđenja aktivirano otiskom prsta</string>
    <string name="fingerprint_sleep_title">Mirovanje otiska prsta</string>
    <string name="fingerprint_sleep_summary">Pritisnite senzor otiska prsta za isključivanje zaslona</string>
    <string name="high_touch_sensitivity_title">Visoka osjetljivost na dodir</string>
    <string name="high_touch_sensitivity_summary">Povećajte osjetljivost na dodir tako da možete koristiti rukavice.</string>
</resources>
