<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="hr">
<translation id="1503959756075098984">ID-jevi proširenja i URL-ovi ažuriranja koja će biti instalirana u pozadini</translation>
<translation id="2463365186486772703">Oznaka zemlje/jezika aplikacije</translation>
<translation id="1397855852561539316">Predloženi URL zadanog davatelja usluge pretraživanja</translation>
<translation id="3347897589415241400">Zadano ponašanje za web-lokacije koje nisu ni u jednom paketu sadržaja.

          To je pravilo za Chromeovu internu upotrebu.</translation>
<translation id="7040229947030068419">Primjer vrijednosti:</translation>
<translation id="1213523811751486361">Određuje URL tražilice koja se upotrebljava za davanje prijedloga pretraživanja. URL treba sadržavati niz &quot;<ph name="SEARCH_TERM_MARKER"/>&quot; koji će u trenutku upita biti zamijenjen tekstom koji je korisnik dotad unio. Ovo je pravilo izborno. Ako nije postavljeno, neće se upotrijebiti nijedan URL prijedloga. Ovo se pravilo poštuje samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="6106630674659980926">Omogući upravitelja zaporki</translation>
<translation id="7109916642577279530">Dopusti ili odbij snimanje zvuka.

      Ako je to pravilo omogućeno ili nije konfigurirano (zadano), korisniku će se nuditi
      pristup snimanju zvuka, osim za URL-ove konfigurirane na popisu
      AudioCaptureAllowedUrls koji će dobiti pristup bez postavljanja upita.

      Kada je to pravilo onemogućeno, korisniku se nikad neće postaviti upit i snimanje
      će biti dostupno samo URL-ovima konfiguriranima na AudioCaptureAllowedUrls.

      To pravilo utječe na sve vrste audioulaza, a ne samo na ugrađeni mikrofon.</translation>
<translation id="9150416707757015439">Ovo je pravilo zastarjelo. Umjesto njega upotrijebite &quot;IncognitoModeAvailability&quot;. Omogućuje anonimni način u proizvodu <ph name="PRODUCT_NAME"/>. Ako je ova postavka omogućena ili nije konfigurirana, korisnici mogu otvarati web-stranice u anonimnom načinu. Ako je postavka onemogućena, korisnici ne mogu otvarati stranice u anonimnom načinu. Ako ovo pravilo nije postavljeno, to će biti omogućeno i korisnik će moći upotrebljavati anonimni način.</translation>
<translation id="4203389617541558220">Ograniči aktivno vrijeme uređaja određivanjem vremena za automatska ponovna pokretanja.

      Kada se to pravilo postavi, određuje duljinu aktivnog vremena uređaja nakon kojeg je određeno automatsko ponovno pokretanje.

      Kada se to pravilo ne postavi, aktivno vrijeme uređaja nije ograničeno.

      Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

      Automatsko ponovno pokretanje određeno je za odabrano vrijeme, ali može se odgoditi na uređaju do 24 sata ako korisnik trenutačno upotrebljava uređaj.

      Napomena: trenutačno su automatska ponovna pokretanja omogućena samo dok se prikazuje zaslon za prijavu ili dok traje sesija aplikacije kioska. To će se u budućnosti promijeniti i pravilo će se primjenjivati uvijek, bez obzira na to je li neka određena vrsta sesije u tijeku ili nije.

      Vrijednost pravila treba navesti u sekundama. Zadana je najmanja vrijednost 3600 (jedan sat).</translation>
<translation id="5304269353650269372">Određuje koliko vremena treba proći od zadnjeg korisničkog unosa nakon kojeg se prikazuje dijaloški okvir upozorenja kada uređaj nije priključen na struju.

          Kada je postavljeno, ovo pravilo određuje koliko dugo korisnik treba biti neaktivan prije nego što <ph name="PRODUCT_OS_NAME"/> prikaže dijaloški okvir upozorenja koji obavještava korisnika da će biti poduzeta radnja u vezi s neaktivnošću.

          Kada pravilo nije postavljeno, dijaloški se okvir ne prikazuje.

          Vrijednost pravila treba se postaviti u milisekundama. Vrijednosti se prilagođavaju kako bi bile manje ili jednake odgodi neaktivnosti.</translation>
<translation id="7818131573217430250">Postavljanje zadanog stanja načina visokog kontrasta na zaslonu za prijavu</translation>
<translation id="7614663184588396421">Popis onemogućenih shema protokola</translation>
<translation id="2309390639296060546">Zadana postavka zemljopisnog položaja</translation>
<translation id="1313457536529613143">Određuje postotak odgode skaliranja zatamnjivanja zaslona kada se uoči aktivnosti korisnika dok se zaslon zatamnjuje ili ubrzo nakon što se zaslon isključi.

          Ako se to pravilo postavi, ono određuje postotak odgode skaliranja zatamnjivanja zaslona kada se uoči aktivnosti korisnika dok se zaslon zatamnjuje ili ubrzo nakon što se zaslon isključi. Kada se odgoda zatamnjivanja skalira, odgode isključivanja zaslona, zaključavanja zaslona i mirovanja podešavaju se kako bi se zadržali isti vremenski odmaci za odgodu zatamnjivanja zaslona koji su izvorno konfigurirani.

          Ako se to pravilo ne postavi, upotrebljava se zadani faktor skaliranja.

          Faktor skaliranja mora biti 100% ili više.</translation>
<translation id="7443616896860707393">Zahtjevi za Cross-origin HTTP Basic Auth</translation>
<translation id="2337466621458842053">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje smiju prikazivati slike. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultImagesSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="4680961954980851756">Omogući Automatsko popunjavanje</translation>
<translation id="5183383917553127163">Omogućuje određivanje proširenja koja ne podliježu crnoj listi.

          Vrijednost * na crnoj listi znači da su sva proširenja na crnoj listi i da korisnici mogu instalirati samo proširenja koja su na bijeloj listi.

          Prema zadanim postavkama sva su proširenja na bijeloj listi, no ako su sva proširenja prema pravilu na crnoj listi, bijela lista može se upotrebljavati za poništavanje tog pravila.</translation>
<translation id="5921888683953999946">Postavi zadano stanje značajke pristupačnosti velikog pokazivača na zaslonu za prijavu.

          Ako se to pravilo postavi na točno, veliki će pokazivač biti omogućen dok se prikazuje zaslon za prijavu.

          Ako se to pravilo postavi na netočno, veliki će pokazivač biti onemogućen dok se prikazuje zaslon za prijavu.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući veliki pokazivač. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, veliki je pokazivač onemogućen pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti veliki pokazivač u bilo kojem trenutku, a njegov status na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="3185009703220253572">od verzije <ph name="SINCE_VERSION"/></translation>
<translation id="2204753382813641270">Kontroliraj automatsko skrivanje police</translation>
<translation id="3816312845600780067">Omogući tipkovni prečac za izbjegavanje automatske prijave</translation>
<translation id="3214164532079860003">Ako je omogućeno, ovo pravilo prisilno uvozi početnu stranicu iz trenutačno zadanog preglednika. Ako je onemogućeno, početna se stranica ne uvozi. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti stranicu ili do uvoza može doći automatski.</translation>
<translation id="5330684698007383292">Dopusti proizvodu <ph name="PRODUCT_FRAME_NAME"/> rukovanje sljedećim vrstama sadržaja</translation>
<translation id="6647965994887675196">Ako je postavljeno na točno, mogu se izrađivati i upotrebljavati nadzirani korisnici.

          Ako je postavljeno na netočno ili nije konfigurirano, izrada i prijava nadziranih korisnika bit će onemogućena. Svi postojeći nadzirani korisnici bit će skriveni.

          NAPOMENA: zadano se ponašanje za potrošačke i poslovne uređaje razlikuje: na potrošačkim su uređajima nadzirani korisnici omogućeni prema zadanim postavkama, a na poslovnim su uređajima onemogućeni prema zadanim postavkama.</translation>
<translation id="69525503251220566">Značajka pretraživanja po slici koja pruža parametre za zadanog davatelja usluge pretraživanja</translation>
<translation id="5469825884154817306">Blokiraj slike na ovim web-lokacijama</translation>
<translation id="8412312801707973447">Izvršavaju li se mrežne provjere OCSP/CRL</translation>
<translation id="6649397154027560979">Pravilo je obustavljeno, upotrijebite URLBlacklist.

      Onemogućuje navedene sheme protokola na usluzi <ph name="PRODUCT_NAME"/>.

      URL-ovi koji upotrebljavaju shemu s tog popisa neće se učitati i nisu dostupni navigacijom.

      Ako se to pravilo ne postavi ili ako je popis prazan, sve će sheme biti dostupne na usluzi <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3213821784736959823">Kontrolira primjenjuje li se ugrađeni DNS klijent u proizvodu <ph name="PRODUCT_NAME"/>.

      Ako je to pravilo postavljeno na točno, primijenit će se ugrađeni DNS klijent ako je dostupan.

      Ako je to pravilo postavljeno na netočno, ugrađeni DNS klijent nikad neće biti upotrijebljen.

      Ako pravilo nije postavljeno, korisnici će moći mijenjati hoće li ugrađeni DNS klijent biti upotrijebljen uređivanjem oznaka chrome:// ili navođenjem oznaka naredbenog retka.</translation>
<translation id="2908277604670530363">Maksimalan broj istodobnih veza na proxy poslužitelju</translation>
<translation id="556941986578702361">Kontroliraj automatsko skrivanje police proizvoda <ph name="PRODUCT_OS_NAME"/>.

      Ako je ta polica postavljena na &quot;AlwaysAutoHideShelf&quot;, polica će uvijek biti automatski skrivena.

      Ako je ta polica postavljena na &quot;NeverAutoHideShelf&quot;, polica se nikada automatski ne skriva.

      Ako postavite to pravilo, korisnici ga ne mogu promijeniti niti prebrisati.

      Ako pravilo nije postavljeno, korisnici mogu birati treba li se polica automatski skrivati.</translation>
<translation id="4838572175671839397">Sadrži regularni izraz koji se upotrebljava za utvrđivanje korisnika koji se mogu prijaviti na uslugu <ph name="PRODUCT_NAME"/>.

      Prikazuje se odgovarajuća pogreška ako se korisnik pokuša prijaviti korisničkim imenom koje se ne podudara s uzorkom.

      Ako se ovo pravilo ne postavi ili ostavi prazno, korisnik se može prijaviti na uslugu <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2892225385726009373">Kada je ta postavka omogućena, <ph name="PRODUCT_NAME"/> će uvijek izvršiti provjeru opoziva za certifikate poslužitelja koji uspješno potvrđuju lokalno instalirane CA certifikate kojima su potpisani.

      Ako <ph name="PRODUCT_NAME"/> ne može dobiti informaciju o statusu opoziva, s takvim će se certifikatima postupati kao da su opozvani (tzv. &quot;hard-fail&quot;).

      Ako to pravilo nije postavljeno ili je postavljeno kao neistinito, tada će Chrome upotrijebiti postojeće mrežne postavke provjere opoziva.</translation>
<translation id="1438955478865681012">Konfigurira pravila koja se odnose na proširenja. Korisniku nije dopušteno instaliranje proširenja na crnoj listi, osim ako su na bijeloj listi. Također možete navesti <ph name="PRODUCT_NAME"/> na automatsko instaliranje proširenja tako da ih navedete u značajci <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Crna lista ima prednost u odnosu na popis nametnutih proširenja.</translation>
<translation id="3516856976222674451">Ograniči maksimalnu duljinu sesije korisnika.

      Kada je postavljeno to pravilo, određeno je vremensko razdoblje nakon kojeg se korisnik automatski odjavljuje, a sesija se prekida. Korisnik je informiran o preostalom vremenu odbrojavanjem koje se prikazuje na programskoj traci.

      Kada to pravilo nije postavljeno, duljina sesije nije ograničena.

      Ako postavite to pravilo, korisnici ga ne mogu promijeniti niti prebrisati.

      Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene u rasponu od 30 sekundi do 24 sata.</translation>
<translation id="9200828125069750521">Parametri za URL slike koji upotrebljava POST</translation>
<translation id="2769952903507981510">Konfiguriraj traženi naziv domene za hostove daljinskog pristupa</translation>
<translation id="3478024346823118645">Izbriši korisničke podatke nakon odjave</translation>
<translation id="8668394701842594241">Određuje popis dodataka koji su omogućeni u proizvodu <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene ovu postavku. Zamjenski znakovi &quot;*&quot; i &quot;?&quot; mogu se upotrijebiti za podudarne nizove proizvoljnih znakova. &quot;*&quot; odgovara proizvoljnom broju znakova, dok &quot;?&quot; određuje izborni pojedinačni znak, tj. odgovara znaku nula ili jedan. Prespojni znak je &quot;\&quot;, tako da za podudaranje sa stvarnim znakovima &quot;*&quot;, &quot;?&quot; ili &quot;\&quot; ispred njih stavite znak &quot;\&quot;. Navedeni popis dodataka uvijek se upotrebljava u proizvodu <ph name="PRODUCT_NAME"/> ako je instaliran. Dodaci su označeni kao omogućeni u stavci &quot;about:plugins&quot; i korisnici ih ne mogu onemogućiti. Uzmite u obzir da ovo pravilo nadjačava pravila &quot;DisabledPlugins&quot; i &quot;DisabledPluginsExceptions&quot;.</translation>
<translation id="653608967792832033">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zaključao tijekom rada s baterijskim napajanjem.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> zaključa zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME"/> ne zaključava zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Preporučen je način za zaključavanje zaslona tijekom neaktivnosti omogućiti zaključavanje zaslona tijekom obustavljanja i postaviti <ph name="PRODUCT_OS_NAME"/> na obustavljanje nakon razdoblja neaktivnosti. Ovo bi se pravilo trebalo upotrebljavati samo kada bi do zaključavanja zaslona trebalo doći puno prije obustavljanja ili kada obustavljanje u razdoblju neaktivnosti uopće nije poželjno.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti.</translation>
<translation id="4157003184375321727">Izvješće o verziji OS-a i opreme</translation>
<translation id="4752214355598028025">Usluga Sigurno pregledavanje prikazuje stranicu upozorenja kada korisnici dođu do web-lokacija koje su označene kao potencijalno zlonamjerne. Omogućavanje te postavke sprječava korisnike da ipak krenu dalje sa stranice upozorenja do zlonamjerne web-lokacije.

      Ako je ta postavka onemogućena ili ako nije konfigurirana, korisnici prema želji mogu nastaviti do označene web-lokacije nakon što im se prikazalo upozorenje.</translation>
<translation id="5255162913209987122">Može se preporučiti</translation>
<translation id="1861037019115362154">Određuje popis dodataka koji su onemogućeni u proizvodu <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene tu postavku.

      Zamjenski znakovi &quot;*&quot; i &quot;?&quot; mogu se upotrijebiti za podudarne nizove proizvoljnih znakova. &quot;*&quot; odgovara proizvoljnom broju znakova, dok &quot;?&quot; određuje izborni pojedinačni znak, tj. ne odgovara nijednom ili odgovara jednom znaku. Prespojni je znak &quot;\&quot;, tako da za podudaranje sa stvarnim znakovima &quot;*&quot;, &quot;?&quot; ili &quot;\&quot; ispred njih morate staviti znak &quot;\&quot;.

      Ako omogućite tu postavku, određeni popis dodataka nikada se neće upotrebljavati u proizvodu <ph name="PRODUCT_NAME"/>. Dodaci su označeni kao onemogućeni u stavci &quot;about:plugins&quot; i korisnici ih ne mogu omogućiti.

      Uzmite u obzir da ovo pravilo može biti nadjačano pravilima EnabledPlugins i DisabledPluginsExceptions.

      Ako to pravilo nije postavljeno, korisnik može upotrijebiti bilo koji dodatak koji je instaliran na sustavu, osim ukodiranih nekompatibilnih, zastarjelih ili opasnih dodataka.</translation>
<translation id="9197740283131855199">Postotak skaliranja odgode zatamnjivanja zaslona ako korisnik postane aktivan nakon zatamnjivanja</translation>
<translation id="1492145937778428165">Određuje razdoblje u milisekundama u kojem se usluzi upravljanja uređajem postavlja upit za informacije o pravilima uređaja.

      Postavljanjem tog pravila premošćuje se zadana vrijednost od 3 sata. Važeće vrijednosti za to pravilo sežu od 1800000 (30 minuta) do 86400000 (1 dan). Sve vrijednosti koje nisu u tom rasponu bit će uklopljene u odgovarajuće granice.

      Ako se to pravilo ne postavi, usluga <ph name="PRODUCT_OS_NAME"/> upotrebljavat će zadanu vrijednost od 3 sata.</translation>
<translation id="3765260570442823273">Trajanje poruke upozorenja za odjavu u stanju mirovanja</translation>
<translation id="7302043767260300182">Odgoda zaključavanja zaslona za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="7331962793961469250">Kada je postavljeno na &quot;true&quot; (točno), promocije za aplikacije Chrome web-trgovine neće se pojavljivati na stranici Nova kartica. Ako se ova opcija postavi na &quot;false&quot; (netočno) ili se ne postavi uopće, promocije za aplikacije Chrome web-trgovine prikazivat će se na stranici Nova kartica</translation>
<translation id="7271085005502526897">Uvoz početne stranice iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="6036523166753287175">Omogući prijelaz vatrozida iz hosta za daljinski pristup</translation>
<translation id="1096105751829466145">Zadani davatelj usluga pretraživanja</translation>
<translation id="7567380065339179813">Omogući dodatke na ovim web-lokacijama</translation>
<translation id="1617235075406854669">Omogući brisanje povijesti preglednika i preuzimanja</translation>
<translation id="5290940294294002042">Odredite popis dodataka koje korisnik može omogućiti ili onemogućiti</translation>
<translation id="3153348162326497318">Omogućuje da odredite koja proširenja korisnici NE mogu instalirati. Proširenja koja su već instalirana bit će uklonjena ako se nalaze na popisu zabranjenih proširenja. Vrijednost popisa zabranjenih proširenja &quot;*&quot; znači da nije dopušteno nijedno proširenje, osim ako nisu izričito navedena na popisu dopuštenih. Ako pravilo nije postavljeno, korisnik može instalirati bilo koje proširenje u <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3067188277482006117">Ako je postavljeno na točno, korisnik može upotrebljavati hardver na uređajima Chrome za daljinsko atestiranje identiteta pri agenciji za certifikat privatnosti putem API-ja Enterprise Platform Keys chrome.enterprise.platformKeysPrivate.challengeUserKey().

          Ako je postavljeno na netočno ili ako nije postavljeno, pozivi API-ju vraćat će kôd pogreške.</translation>
<translation id="5809728392451418079">Postavlja naziv za prikaz za lokalne račune uređaja</translation>
<translation id="1427655258943162134">Adresa ili URL proxy poslužitelja</translation>
<translation id="1827523283178827583">Upotrijebi fiksne proxy poslužitelje</translation>
<translation id="3021409116652377124">Onemogući alat za traženje dodataka</translation>
<translation id="7236775576470542603">Postavi zadanu vrstu povećala koje je omogućeno na zaslonu za prijavu.

          Ako se to pravilo postavi, ono upravlja vrstom povećala koje je omogućeno dok se zaslon za prijavu prikazuje. Postavljanjem tog pravila na vrijednost &quot;Ništa&quot; povećalo se onemogućuje.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući povećalo. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, povećalo je onemogućeno pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti povećalo u bilo kojem trenutku, a njegov status na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="5423001109873148185">Ako je omogućeno, ovo pravilo prisilno uvozi tražilice iz trenutačno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, zadana se tražilica ne uvozi. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti tražilicu ili do uvoza može doći automatski.</translation>
<translation id="3288595667065905535">Kanal izdanja</translation>
<translation id="2785954641789149745">Omogućuje značajku Sigurno pregledavanje usluge <ph name="PRODUCT_NAME"/> i onemogućuje korisnicima da promijene tu postavku.

      Ako omogućite tu postavku, Sigurno pregledavanje uvijek je aktivno.

      Ako je onemogućite, Sigurno pregledavanje nikada nije aktivno.

      Ako omogućite ili onemogućite tu postavku, korisnici ne mogu promijeniti ili premostiti postavku &quot;Omogući zaštitu od krađe identiteta i zlonamjernog softvera&quot; na usluzi <ph name="PRODUCT_NAME"/>.

      Ako se to pravilo ne postavi, ta će postavka biti omogućena, ali će je korisnici moći promijeniti.</translation>
<translation id="8369602308428138533">Odgoda isključivanja zaslona za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="6513756852541213407">Omogućuje određivanje proxy poslužitelja koji <ph name="PRODUCT_NAME"/> upotrebljava i sprječava korisnike da promijene postavke proxy poslužitelja. Ako odaberete da se proxy poslužitelj nikad ne upotrebljava i da se veza uvijek uspostavlja izravno, sve se ostale opcije zanemaruju. Ako odaberete upotrebu sistemskih postavki proxy poslužitelja ili automatsko otkrivanje proxy poslužitelja, sve se ostale opcije zanemaruju. Ako odaberete način fiksnog proxy poslužitelja, možete odrediti dodatne opcije pod &quot;Adresa ili URL proxy poslužitelja&quot; i &quot;Popis pravila proxy zaobilaženja odvojenih zarezima&quot;. Ako odaberete upotrebu .pac skripte proxy proslužitelja, morate navesti URL prema skripti pod &quot;URL prema .pac datoteci proxy poslužitelja&quot;. Za podrobne primjere posjetite: <ph name="PROXY_HELP_URL"/> Ako omogućite ovu postavku, <ph name="PRODUCT_NAME"/> zanemaruje sve opcije u vezi s proxy poslužiteljem određene naredbenim retkom. Ako ovo pravilo nije postavljeno, korisnici će moći sami odabrati postavke proxy poslužitelja.</translation>
<translation id="7763311235717725977">Omogućuje da postavite smiju li web-lokacije prikazivati slike. Prikazivanje slika može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije. Ako se ovo pravilo ne postavi, upotrebljavat će se pravilo &quot;AllowImages&quot;, a korisnici će to moći promijeniti.</translation>
<translation id="5630352020869108293">Vrati posljednju sesiju</translation>
<translation id="4980635395568992380">Vrste podataka:</translation>
<translation id="3096595567015595053">Popis omogućenih dodataka</translation>
<translation id="3048744057455266684">Ako je ovo pravilo postavljeno i ako URL pretraživanja predloženog u višenamjenskom okviru sadrži taj parametar u nizu upita ili identifikatoru fragmenta, prijedlog će prikazati pojmove za pretraživanje i pružatelja usluge pretraživanja umjesto neobrađenog URL-a pretraživanja.

          Pravilo nije obavezno. Ako nije postavljeno, neće se vršiti zamjena pojma za pretraživanje.

          Pravilo se primjenjuje samo ako je pravilo &quot;DefaultSearchProviderEnabled&quot; omogućeno.</translation>
<translation id="5912364507361265851">Omogući korisnicima prikazivanje zaporki u Upravitelju zaporki</translation>
<translation id="510186355068252378">Onemogućuje sinkronizaciju podataka u proizvodu <ph name="PRODUCT_NAME"/> pomoću usluga sinkronizacije s hostingom na Googleu i sprječava korisnike da promijene ovu postavku. Ako omogućite ovu postavku, korisnici ne mogu promijeniti ni poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME"/>. Ako se ovo pravilo ne postavi, korisnik će moći odabrati želi li upotrebljavati Google Sinkronizaciju.</translation>
<translation id="7953256619080733119">Hostovi ručnih iznimaka upravljanih korisnika</translation>
<translation id="7412982067535265896">Omogućuje vam da postavite popis uzoraka URL-ova koji navode web-lokacije kojima je dopušteno da postave kolačiće samo za sesije.

          Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se globalna zadana vrijednost iz pravila &quot;DefaultCookiesSetting&quot;, ako je to pravilo postavljeno, ili zadana vrijednost iz korisnikove osobne konfiguracije.

          Ako je pravilo &quot;RestoreOnStartup&quot; postavljeno na vraćanje URL-ova iz prethodnih sesija, to će pravilo biti zanemareno i kolačići za te web-lokacije pohranjivat će se trajno.</translation>
<translation id="8828766846428537606">Konfigurirajte zadanu početnu stranicu u proizvodu <ph name="PRODUCT_NAME"/> i spriječite korisnike da je promijene.

      Korisničke postavke početne stranice bit će potpuno zaključane ako odaberete početnu stranicu kao web-stranicu nove kartice ili je postavite kao URL i navedete URL početne stranice.

      Ako ne navedete URL početne stranice, korisnik će svejedno moći postaviti početnu stranicu na web-stranicu nove kartice tako da navede &quot;chrome://newtab&quot;.</translation>
<translation id="2231817271680715693">Uvoz povijesti pregledavanja iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="1353966721814789986">Početne stranice</translation>
<translation id="1841130111523795147">Omogućuje korisniku prijavu na proizvod <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene te postavku.

      Ako postavite ovo pravilo, možete konfigurirati dopuštenje za prijavu korisnika na proizvod  <ph name="PRODUCT_NAME"/>.</translation>
<translation id="5564962323737505851">Konfigurira upravitelja zaporki. Ako je upravitelj zaporki omogućen, možete omogućiti ili onemogućiti korisničku opciju prikazivanja pohranjenih lozinki čitljivim tekstom.</translation>
<translation id="4668325077104657568">Zadana postavka slika</translation>
<translation id="4492287494009043413">Onemogući izradu snimki zaslona</translation>
<translation id="6368403635025849609">Omogući JavaScript na ovim web-lokacijama</translation>
<translation id="6074963268421707432">Nemoj dopustiti nijednoj web-lokaciji da prikazuje obavijesti radne površine</translation>
<translation id="8614804915612153606">Onemogućuje automatsko ažuriranje</translation>
<translation id="382476126209906314">Konfiguriraj prefiks TalkGadget za hostove daljinskog pristupa</translation>
<translation id="6561396069801924653">Prikaži opcije pristupačnosti u izborniku palete sustava</translation>
<translation id="8104962233214241919">Automatski odabir certifikata klijenta za ove web-lokacije</translation>
<translation id="2906874737073861391">Popis proširenja AppPack</translation>
<translation id="3758249152301468420">Onemogući Razvojne alate</translation>
<translation id="8665076741187546529">Konfiguriraj popis prisilno instaliranih proširenja</translation>
<translation id="410478022164847452">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se izvršila radnja neaktivnosti tijekom napajanja izmjeničnom strujom.

          Kada je pravilo postavljeno, određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> pokrene radnju neaktivnosti, što se može konfigurirati zasebno.

          Kada pravilo nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama.</translation>
<translation id="1675391920437889033">Kontrolira koje se vrste aplikacija/proširenja smiju instalirati.

          Ova postavka sadrži popis dopuštenih vrsta proširenja/aplikacija koje se mogu instalirati u proizvodu <ph name="PRODUCT_NAME"/>. Vrijednost je popis nizova, od kojih svaki treba biti jedan od sljedećih: &quot;extension&quot;, &quot;theme&quot;, &quot;user_script&quot;, &quot;hosted_app&quot;, &quot;legacy_packaged_app&quot; ili &quot;platform_app&quot;. Više informacija o tim vrstama potražite u dokumentaciji o proširenjima sustava Chrome.

          Imajte na umu da to pravilo također utječe na proširenja i aplikacije čija se instalacija mora nametnuti popisom ExtensionInstallForcelist.

          Ako je ta postavka konfigurirana, proširenja/aplikacije vrste koja nije na popisu neće se instalirati.

          Ako ta postavka ostane nekonfigurirana, neće se primijeniti ograničenja o prihvatljivim vrstama proširenja/aplikacija.</translation>
<translation id="6378076389057087301">Odredi utječe li zvučna aktivnost na upravljanje napajanjem</translation>
<translation id="8818173863808665831">Prijavljuje geografsku lokaciju uređaja.

      Ako se to pravilo ne postavi ili ako se postavi na lažno, lokacija se neće prijavljivati.</translation>
<translation id="4899708173828500852">Omogući Sigurno pregledavanje</translation>
<translation id="4442582539341804154">Omogući zaključavanje kada uređaj prijeđe u stanje mirovanja ili se isključi</translation>
<translation id="7719251660743813569">Kontrolira hoće li se mjerni podaci upotrebe prijavljivati Googleu. Ako je to pravilo postavljeno na &quot;istinito&quot;, sustav <ph name="PRODUCT_OS_NAME"/> prijavljivat će mjerne podatke o upotrebi. Ako to pravilo nije konfigurirano ili je postavljeno na &quot;lažno&quot;, prijavljivanje mjernih podataka o upotrebi bit će onemogućeno.</translation>
<translation id="2372547058085956601">Odgoda automatske prijave u javnu sesiju.

      Ako nije postavljeno pravilo |DeviceLocalAccountAutoLoginId|, ovo se pravilo neće primjenjivati. U suprotnom:

      Ako je postavljeno, ovo pravilo određuje koliko vremena treba proći od zadnje aktivnosti korisnika prije automatske prijave u javnu sesiju koja je određena pravilom |DeviceLocalAccountAutoLoginId|.

      Ako ovo pravilo nije postavljeno, za privremeni prekid bit će upotrijebljena vrijednost od 0 milisekundi.

      To se pravilo određuje u milisekundama.</translation>
<translation id="7275334191706090484">Upravljane oznake</translation>
<translation id="3570008976476035109">Blokiraj dodatke na ovim web-lokacijama</translation>
<translation id="8749370016497832113">Omogućuje brisanje povijesti preglednika i preuzimanja u pregledniku <ph name="PRODUCT_NAME"/> te sprječava korisnike da promijene tu postavku.

      Uzmite u obzir da čak i kada je onemogućeno ovo pravilo, čuvanje povijesti pregledavanja i preuzimanja nije zajamčeno: korisnici možda mogu izravno urediti ili izbrisati datoteke baze podataka povijesti, a preglednik također može u bilo kojem trenutku arhivirati neke ili sve stavke povijesti ili im ukinuti rok trajanja.

      Ako je ova postavka omogućena ili nije postavljena, povijest pregledavanja i preuzimanja može se izbrisati.

      Ako je ova postavka onemogućena, povijest pregledavanja i preuzimanja nije moguće izbrisati.</translation>
<translation id="2884728160143956392">Omogući kolačiće na ovim web-lokacijama samo tijekom sesija</translation>
<translation id="3021272743506189340">Onemogućuje sinkronizaciju Google diska u aplikaciji Datoteke OS-a Chrome prilikom upotrebe mobilne veze kada je postavljeno na točno. U tom se slučaju podaci sinkroniziraju samo s Google diskom tijekom povezanosti putem WiFi-ja ili Etherneta.

          Ako nije postavljeno ili je postavljeno na netočno, korisnici će moći prenositi datoteke na Google disk mobilnim vezama.</translation>
<translation id="4655130238810647237">Omogućuje ili onemogućuje uređivanje knjižnih oznaka u proizvodu <ph name="PRODUCT_NAME"/>. Ako omogućite ovu postavku, knjižne oznake mogu se dodavati, uklanjati i mijenjati. To je zadana postavka čak i ako pravilo nije postavljeno. Ako onemogućite ovu postavku, knjižne oznake ne mogu se dodavati, uklanjati ni mijenjati. Postojeće knjižne oznake i dalje će biti dostupne.</translation>
<translation id="3496296378755072552">Upravitelj zaporki</translation>
<translation id="2565967352111237512">Omogućuje slanje anonimnih izvješća o upotrebi i podataka o padovima proizvoda <ph name="PRODUCT_NAME"/> Googleu te sprječava korisnike da promijene ovu postavku. Ako omogućite ovu postavku, Googleu se šalju anonimna izvješća o upotrebi i podaci o padovima. Ako onemogućite ovu postavku, Googleu se ne šalju anonimna izvješća o upotrebi i podaci o padovima. Ako omogućite ili onemogućite ovu postavku, korisnici ne mogu promijeniti ni poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME"/>. Ako pravilo nije postavljeno, postavka će biti ona koju je korisnik izabrao prilikom instalacije/prvog pokretanja.</translation>
<translation id="6256787297633808491">Oznake na razini sustava koje se primjenjuju prilikom pokretanja Chromea</translation>
<translation id="2516600974234263142">Omogućuje ispis na proizvodu <ph name="PRODUCT_NAME"/> i onemogućuje korisnicima promjenu ove postavke.

      Ako je ta postavka omogućena ili nije konfigurirana, korisnici mogu ispisivati.

      Ako je ta postavka onemogućena, korisnici ne mogu ispisivati iz proizvoda <ph name="PRODUCT_NAME"/>. Ispis je onemogućen na izborniku francuskog ključa, proširenjima, aplikacijama jezika JavaScript itd. I dalje je omogućen ispis iz dodataka koji tijekom ispisa zaobilaze proizvod <ph name="PRODUCT_NAME"/>. Primjerice, određene Flash aplikacije imaju na svojem kontekstom izborniku opciju ispisa, koja nije pokrivena ovim pravilom.</translation>
<translation id="9135033364005346124">Omogući <ph name="CLOUD_PRINT_NAME"/> proxy</translation>
<translation id="4519046672992331730">Omogućuje prijedloge pretraživanja u višenamjenskom okviru usluge <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene tu postavku.

      Ako omogućite ovu postavku, upotrebljavaju se prijedlozi pretraživanja.

      Ako onemogućite ovu postavku, prijedlozi pretraživanja nikad se ne upotrebljavaju.

      Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti niti poništiti ovu postavku na usluzi <ph name="PRODUCT_NAME"/>.

      Ako ovo pravilo nije postavljeno, bit će omogućeno, ali će ga korisnici moći promijeniti.</translation>
<translation id="6943577887654905793">Naziv Mac/Linux preferencije:</translation>
<translation id="6925212669267783763">Konfigurira direktorij koji će usluga <ph name="PRODUCT_FRAME_NAME"/> upotrebljavati za pohranjivanje korisničkih podataka.

      Ako postavite to pravilo, proizvod <ph name="PRODUCT_FRAME_NAME"/> upotrijebit će navedeni direktorij.

      Popis varijabli koje je moguće upotrijebiti potražite na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Ako ova postavka nije postavljena, upotrebljava se zadani direktorij profila.</translation>
<translation id="8906768759089290519">Omogući način gosta</translation>
<translation id="2168397434410358693">Odgoda neaktivnosti za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="838870586332499308">Omogući roaming podataka</translation>
<translation id="3234167886857176179">To je popis pravila kojih se <ph name="PRODUCT_NAME"/> pridržava.

      Te postavke ne morate mijenjati ručno! Možete preuzeti praktične obrasce s adrese
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>.

      Popis podržanih pravila isti je za Chromium i Google Chrome.

      Ta su pravila isključivo namijenjena za konfiguriranje Chromeovih instalacija unutar vaše organizacije. Upotreba tih pravila izvan vaše organizacije (primjerice, u javno distribuiranom programu) smatra se zlonamjernom i takvu će upotrebu Google i dobavljači antivirusnih programa vjerojatno označiti kao zlonamjeran softver.

      Napomena: počevši od verzije Chromea 28 pravila se učitavaju izravno iz API-ja Pravila grupe u sustavu Windows. Ručno zapisana pravila u registru bit će zanemarena. Pojedinosti potražite na http://crbug.com/259236.</translation>
<translation id="2292084646366244343">Proizvod <ph name="PRODUCT_NAME"/> može upotrebljavati Googleovu web-uslugu za ispravljanje pravopisnih pogrešaka. Ako je ta postavka omogućena, ta se usluga uvijek upotrebljava. Ako je ta postavka onemogućena, ta se usluga nikad ne upotrebljava.

      Provjera pravopisa još se uvijek može vršiti pomoću preuzetog rječnika; to pravilo upravlja samo upotrebom mrežne usluge.

      Ako ta postavka nije konfigurirana, korisnici mogu sami odlučiti hoće li se usluga provjere pravopisa upotrebljavati ili neće.</translation>
<translation id="8782750230688364867">Određuje postotak skaliranja odgode zatamnjivanja zaslona kada je uređaj u načinu prezentacije.

          Ako se postavi, pravilo određuje postotak skaliranja odgode zatamnjivanja zaslona kada je uređaj u načinu prezentacije. Kada se odgoda zatamnjivanja skalira, odgode isključivanja zaslona, zaključavanja zaslona i mirovanja podešavaju se kako bi se zadržali isti vremenski odmaci za odgodu zatamnjivanja zaslona koji su izvorno konfigurirani.

          Ako se to pravilo ne postavi, upotrebljava se zadani faktor skaliranja.

          Faktor skaliranja mora biti 100% ili više. Vrijednosti koje bi učinile odgodu zatamnjivanja zaslona u načinu prezentacije kraćom od uobičajene odgode zatamnjivanja zaslona nisu dopuštene.</translation>
<translation id="254524874071906077">Postavi Chrome kao zadani preglednik</translation>
<translation id="8764119899999036911">Određuje temelji li se generirani Kerberos SPN na kanonskom DNS imenu ili unesenom izvornom imenu. Ako omogućite ovu postavku, CNAME pretraživanje bit će preskočeno, a upotrijebit će se uneseni naziv poslužitelja. Ako onemogućite ovu postavku ili ju ne postavite, kanonski naziv poslužitelja bit će utvrđen putem CNAME pretraživanja.</translation>
<translation id="5056708224511062314">Povećalo je onemogućeno</translation>
<translation id="4377599627073874279">Dopusti svim web-lokacijama prikazivanje svih slika</translation>
<translation id="7195064223823777550">Određuje radnju koja će se izvršiti kada korisnik spusti poklopac.

          Kada je ovo pravilo postavljeno, određuje radnju koju će <ph name="PRODUCT_OS_NAME"/> izvršiti kada korisnik spusti poklopac uređaja.

          Kada pravilo nije postavljeno, izvršava se zadana radnja, koja je obustavljena.

          Ako je radnja obustavljena, moguće je zasebno konfigurirati <ph name="PRODUCT_OS_NAME"/> da zaključa ili ne zaključa zaslon prije obustavljanja.</translation>
<translation id="3915395663995367577">URL prema proxy .pac datoteci</translation>
<translation id="1022361784792428773">ID-jevi proširenja u čijem bi instaliranju korisnik trebao biti spriječen (ili * za sve)</translation>
<translation id="5499375345075963939">To je pravilo aktivno samo u prodajnom načinu.

      Kada je vrijednost tog pravila postavljena i nije 0, trenutačno prijavljeni korisnik demo verzije automatski će biti odjavljen nakon isteka razdoblja neaktivnosti određenog trajanja.

      Vrijednost pravila treba odrediti u milisekundama.</translation>
<translation id="7683777542468165012">Dinamičko osvježavanje pravila</translation>
<translation id="1160939557934457296">Onemogući nastavljanje sa stranice upozorenja Sigurno pregledavanje</translation>
<translation id="8987262643142408725">Onemogućavanje dijeljenja zapisa SSL-a</translation>
<translation id="4529945827292143461">Prilagođava popis uzoraka URL-ova koje bi preglednik hosta trebao uvijek prikazivati. Ako to pravilo nije postavljeno, za sve web-lokacije upotrebljavat će se zadani prikazivač kako je određeno pravilom &quot;ChromeFrameRendererSettings&quot;. Primjere uzoraka pogledajte na http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Izvješće načina pokretanja uređaja</translation>
<translation id="2746016768603629042">Ovo je pravilo obustavljeno, umjesto njega upotrijebite DefaultJavaScriptSetting.

      Može se upotrijebiti za onemogućavanje JavaScripta na usluzi <ph name="PRODUCT_NAME"/>.

      Ako je ova postavka onemogućena, web-stranice ne mogu upotrebljavati JavaScript i korisnik ne može promijeniti tu postavku.

      Ako je ova postavka omogućena ili nije postavljena, web-stranice mogu upotrebljavati JavaScript, no korisnik može promijeniti tu postavku.</translation>
<translation id="4047207703890139433">Određuje format sata koji će se upotrebljavati za uređaj. Korisnici mogu poništiti format sata za trenutačnu sesiju, ali će prilikom odjave format ponovo biti postavljen na navedenu vrijednost. Ako se navede prazan niz, upotrebljavat će se postavka vlasnika uređaja.</translation>
<translation id="1942957375738056236">Ovdje možete odrediti URL proxy poslužitelja. Ovo se pravilo primjenjuje samo ako ste odabrali ručno postavljanje proxy poslužitelja u stavci &quot;Odabir načina određivanja postavki proxy poslužitelja&quot;. Ne postavljajte ovo pravilo ako ste odabrali neki drugi način za postavljanje pravila proxy poslužitelja. Za više mogućnosti i podrobne primjere posjetite: <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Onemogući priključivanje vanjske pohrane.

      Kada je to pravilo postavljeno na True, vanjska pohrana neće biti dostupna u pregledniku datoteka.

      To pravilo utječe na sve vrste medija za pohranu, na primjer, USB flash pogone, vanjske tvrde diskove, SD i ostale memorijske kartice, optičku pohranu itd. Ne utječe na unutarnju pohranu pa se i dalje može pristupati datotekama spremljenima u mapu Preuzimanja. To pravilo ne utječe ni na Google disk.

      Ako je ta postavka onemogućena ili ako nije konfigurirana, korisnici na svojem uređaju mogu upotrebljavati sve podržane vrste vanjske pohrane.</translation>
<translation id="6936894225179401731">Određuje maksimalni broj simultanih veza proxy poslužitelja.

      Neki proxy poslužitelji ne mogu imati velik broj istodobnih veza po klijentu, a to se može riješiti postavljanjem ovog pravila na nižu vrijednost.

      Vrijednost ovog pravila treba biti niža od 100 i viša od 6, a zadana je vrijednost 32.

      Poznato je da neke web-aplikacije zauzimaju brojne veze uz GET-ove na čekanju pa snižavanje vrijednosti ispod 32 može dovesti do mrežnog čekanja za preglednik ako je otvoreno previše takvih web-aplikacija. Smanjivanje ispod zadane vrijednosti činite na vlastiti rizik.

      Ako to pravilo nije postavljeno, upotrebljavat će se zadana vrijednost, a to je 32.</translation>
<translation id="5395271912574071439">Omogućuje skrivanje hostova za daljinski pristup dok traje povezivanje.

          Ako je ova postavka omogućena, tada se onemogućuju fizički ulazni i izlazni uređaji hosta dok je daljinsko povezivanje u tijeku.

          Ako je ta postavka onemogućena ili nije postavljena, tada u interakciju s hostom mogu stupati lokalni i udaljeni korisnici kada se on dijeli.</translation>
<translation id="1426410128494586442">Da</translation>
<translation id="4897928009230106190">Određuje parametre koji se upotrebljavaju prilikom pretraživanja prijedloga pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {searchTerms} u gornjem primjeru, zamijenit će se podacima stvarnih pojmova za pretraživanje.

          To je pravilo izborno. Ako nije postavljeno, zahtjev za predloženo pretraživanje poslat će se pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="4962195944157514011">Određuje URL tražilice koja se upotrebljava prilikom zadanog pretraživanja. URL treba sadržavati niz &quot;<ph name="SEARCH_TERM_MARKER"/>&quot; koji će u trenutku upita biti zamijenjen pojmovima koje korisnik traži. Ova opcija mora biti postavljena kada je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot; i poštovat će se samo u tom slučaju.</translation>
<translation id="6009903244351574348">Dopustite proizvodu <ph name="PRODUCT_FRAME_NAME"/> rukovanje navedenim vrstama sadržaja. Ako ovo pravilo nije postavljeno, upotrebljavat će se zadani prikazivač za sve web-lokacije kao što je navedeno u pravilu &quot;ChromeFrameRendererSettings&quot;.</translation>
<translation id="3381968327636295719">Upotrijebi preglednik hosta prema zadanim postavkama</translation>
<translation id="3627678165642179114">Omogući ili onemogući web-uslugu provjere pravopisa</translation>
<translation id="6520802717075138474">Uvoz tražilica iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="4039085364173654945">Nadzire smije li podsadržaj treće strane na stranici prikazivati skočni dijaloški okvir HTTP Basic Auth. Obično je to onemogućeno radi obrane od krađe identiteta. Ako ovo pravilo nije postavljeno, to je onemogućeno i podsadržajima treće strane neće biti dopušteno prikazivanje skočnog dijaloškog okvira HTTP Basic Auth.</translation>
<translation id="4946368175977216944">Određuje oznake koje se trebaju primijeniti na Chrome prilikom njegova pokretanja. Navedene oznake primjenjuju se prije pokretanja Chromea čak i za zaslon za prijavu.</translation>
<translation id="7447786363267535722">Omogućuje spremanje zaporki i upotrebu spremljenih zaporki u proizvodu <ph name="PRODUCT_NAME"/>. Ako omogućite ovu postavku, <ph name="PRODUCT_NAME"/> može korisnicima zapamtiti zaporke i automatski ih pružiti prilikom sljedeće prijave na web-lokaciju. Ako onemogućite ovu postavku, korisnici neće moći spremati zaporke niti upotrebljavati već spremljene zaporke. Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti ni poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME"/>. Ako ovo pravilo nije postavljeno, to će biti omogućeno, ali će korisnik to moći promijeniti.</translation>
<translation id="1138294736309071213">To je pravilo aktivno samo u prodajnom načinu.

      Određuje koliko će potrajati prije nego što se čuvar zaslona prikaže na zaslonu prijave za uređaje u prodajnom načinu.

      Vrijednost pravila trebala bi biti navedena u milisekundama.</translation>
<translation id="6368011194414932347">Konfiguriraj URL početne stranice</translation>
<translation id="2877225735001246144">Onemogući CNAME pretraživanje prilikom provjere Kerberos autentičnosti</translation>
<translation id="9120299024216374976">Određuje vremensku zonu koja će se upotrebljavati za uređaj. Korisnici mogu poništiti navedenu vremensku zonu za trenutačnu sesiju. Međutim, nakon odjave uređaj se ponovo postavlja na navedenu vremensku zonu. Ako se pruži nevažeća vrijednost, pravilo je još uvijek aktivirano i umjesto nje upotrebljava se &quot;GMT&quot;.

      Ako se ovo pravilo ne upotrebljava, trenutačno aktivna vremenska zona ostat će u upotrebi, ali korisnici će je moći promijeniti i ta će promjena biti trajna. Stoga će promjena koju napravi jedan korisnik utjecati na zaslon za prijavu i sve ostale korisnike.

      Na novim uređajima početna vremenska zona postavljena je na &quot;SAD/Pacifik&quot;.

      Format vrijednosti slijedi nazive vremenskih zona u &quot;Bazi podataka vremenskih zona IANA&quot; (pogledajte &quot;http://en.wikipedia.org/wiki/List_of_tz_database_time&quot;). Većina vremenskih zona naročito može biti označena kao &quot;kontinent/veliki_grad&quot; ili &quot;ocean/veliki_grad&quot;.</translation>
<translation id="3646859102161347133">Postavljanje vrste povećala</translation>
<translation id="3528000905991875314">Omogući alternativne stranice pogrešaka</translation>
<translation id="1283072268083088623">Određuje koje sheme HTTP autentifikacije <ph name="PRODUCT_NAME"/> podržava. Moguće su vrijednosti &quot;basic&quot; (osnovno), &quot;digest&quot; (sažeto), &quot;NTLM&quot; i &quot;negotiate&quot; (pregovaranje). Više vrijednosti odvojite zarezima. Ako ovo pravilo nije postavljeno, upotrebljavat će se sve četiri sheme.</translation>
<translation id="4914647484900375533">Omogućuje značajku Instant usluge <ph name="PRODUCT_NAME"/> i onemogućuje korisnicima da mijenjaju tu postavku.

      Ako omogućite tu postavku, <ph name="PRODUCT_NAME"/> Instant omogućen je.

      Ako onemogućite tu postavku, <ph name="PRODUCT_NAME"/> Instant onemogućen je.

      Ako omogućite ili onemogućite tu postavku, korisnici je ne mogu promijeniti ili premostiti.

      Ako se ta postavka ne postavi, korisnici mogu upotrebljavati tu funkciju prema želji.

      Ta je postavka uklonjena iz verzije Chrome 29 i novijih verzija.</translation>
<translation id="6114416803310251055">neodobreno</translation>
<translation id="8493645415242333585">Onemogući pohranjivanje povijesti preglednika</translation>
<translation id="5319306267766543020">Konfiguriraj upravljanje napajanjem za <ph name="PRODUCT_OS_NAME"/>.

      Ova vam pravila omogućuju da konfigurirate kako će se <ph name="PRODUCT_OS_NAME"/> ponašati kada korisnik ne bude aktivan određeno vrijeme.</translation>
<translation id="2747783890942882652">Konfigurira traženi naziv domene hosta koji će biti nametnut hostovima daljinskog pristupa i sprječava korisnike da ga promijene.

          Ako je ta postavka omogućena, hostovi se mogu dijeliti samo putem računa koji su registrirani na domeni navedenog naziva.

          Ako je ta postavka onemogućena ili nije postavljena, hostovi se mogu dijeliti putem bilo kojeg računa.</translation>
<translation id="6417861582779909667">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju postavljati kolačiće. Ako se ovo pravilo ne postavi, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultCookiesSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="5457296720557564923">Stranicama omogućuje pristup statistici o iskorištenosti memorije JavaScripta. Te postavke statistiku memorije s ploče Profila alata razvojnih programera čine dostupnom samoj web-stranici.</translation>
<translation id="5776485039795852974">Pitaj kad god web-lokacija želi prikazati obavijesti radne površine</translation>
<translation id="5052081091120171147">Ako je omogućeno, ovo pravilo prisilno uvozi povijest pregledavanja iz trenutačno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, povijest pregledavanja se ne uvozi. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti povijest pregledavanja ili do uvoza može doći automatski.</translation>
<translation id="6786747875388722282">Proširenja</translation>
<translation id="8947415621777543415">Prijava lokacije uređaja</translation>
<translation id="1655229863189977773">Postavite veličinu predmemorije diska u bajtovima</translation>
<translation id="6376842084200599664">Omogućuje vam da odredite popis proširenja koja će biti instalirana u pozadini, bez interakcije korisnika.

          Svaka stavka na popisu niz je koji sadrži ID proširenja i URL za ažuriranje razgraničen točkom-zarezom (<ph name="SEMICOLON"/>). ID proširenja niz je koji sadrži 32 slova i nalazi se u npr. vezi <ph name="CHROME_EXTENSIONS_LINK"/> dok je u načinu razvojnih programera. URL treba otvarati XML dokument manifesta za ažuriranje kao što je opisano u dokumentu <ph name="LINK_TO_EXTENSION_DOC1"/>. Imajte na umu da se URL za ažuriranje postavljen u ovom pravilu upotrebljava samo za početnu instalaciju. Za naknadna ažuriranja proširenja upotrijebit će se URL za ažuriranje naveden u manifestu proširenja.

          Usluga <ph name="PRODUCT_NAME"/> za svaku će stavku dohvatiti proširenje navedeno u ID-u proširenja sa servisa za ažuriranje na navedenom URL-u za ažuriranje i instalirati ga u pozadini.

          Primjerice, pravilo <ph name="EXTENSION_POLICY_EXAMPLE"/> instalira proširenje <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> sa standardnog URL-a za ažuriranje web-trgovine Chrome. Više informacija o hostiranju proširenja potražite u dokumentu: <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Korisnici neće moći deinstalirati proširenja koja su navedena u ovom pravilu. Ako uklonite proširenje s ovog popisa, usluga <ph name="PRODUCT_NAME"/> automatski će ga deinstalirati. Proširenja navedena na ovom popisu ujedno se automatski stavljaju na popis dopuštenih za instalaciju; na njih ne utječe ExtensionsInstallBlacklist.

          Ako ovo pravilo nije postavljeno, korisnik može deinstalirati svaku ekstenziju na usluzi <ph name="PRODUCT_NAME"/>.</translation>
<translation id="6899705656741990703">Automatski detektiraj proxy postavke</translation>
<translation id="7003334574344702284">Ako je omogućeno, ovo pravilo prisilno uvozi spremljene zaporke iz prethodno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, spremljene se zaporke ne uvoze. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti zaporke ili do uvoza može doći automatski.</translation>
<translation id="6258193603492867656">Određuje treba li generirani Kerberos SPN uključivati nestandardni priključak. Ako omogućite ovu postavku, a bude unesen nestandardni priključak (tj. priključak koji nije 80 ili 443), on će biti uključen u generirani Kerberos SPN. Ako onemogućite ovu postavku ili ju ne postavite, generirani Kerberos SPN neće uključivati priključak ni u kojem slučaju.</translation>
<translation id="3236046242843493070">Obrasci URL-ova za dopuštanje instalacija proširenja, aplikacija i korisničkih skripti iz izvora</translation>
<translation id="2498238926436517902">Uvijek automatski sakrij policu</translation>
<translation id="253135976343875019">Odgoda upozorenja o neaktivnosti dok je uređaj priključen na struju</translation>
<translation id="6997592395211691850">Jesu li potrebne mrežne OCSP/CRL provjere za lokalna pouzdana sidra</translation>
<translation id="152657506688053119">Popis zamjenskih URL-ova za zadanog davatelja usluge pretraživanja</translation>
<translation id="8992176907758534924">Ne dopuštaj web-lokacijama prikazivanje slika</translation>
<translation id="262740370354162807">Omogući slanje dokumenata na uslugu <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="7717938661004793600">Konfiguriranje značajki pristupačnosti proizvoda <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Konfiguracija Google diska u proizvodu <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="8704831857353097849">Popis onemogućenih dodataka</translation>
<translation id="8391419598427733574">Izvješće o verziji OS-a i opreme upisanog uređaja. Ako je ova postavka postavljena na True, upisani uređaji povremeno će izvijestiti o verziji OS-u i opreme. Ako ova postavka nije postavljena ili je postavljena na False, informacije o verziji neće se prijaviti u izvješću.</translation>
<translation id="467449052039111439">Otvori popis URL-ova</translation>
<translation id="5883015257301027298">Zadana postavka kolačića</translation>
<translation id="5017500084427291117">Blokira pristup navedenim URL-ovima.

      To pravilo sprječava korisnika da učitava web-stranice s popisa zabranjenih URL-ova.

      Format URL-a je &quot;scheme://host:port/path&quot;.
      Opcijska shema može biti http, https ili ftp. Blokirana će biti samo ta shema, a ako ništa nije navedeno, blokirane će biti sve sheme.
      Host može biti naziv hosta ili IP adresa. Poddomene naziva hosta također će biti blokirane. Da biste spriječili blokiranje poddomena, unesite &quot;.&quot; ispred naziva hosta. Posebni naziv hosta &quot;*&quot; blokirat će sve domene.
      Opcijski priključak važeći je broj priključka od 1 do 65535. Ako ništa nije navedeno, blokirani će biti svi priključci.
      Ako je navedena opcijska putanja, blokirane će biti samo putanje s tim prefiksom.

      Iznimke se mogu definirati putem pravila za dopuštene URL-ove. Ta su pravila ograničena na 1000 unosa, a svi se daljnji unosi zanemaruju.

      Ako to pravilo nije postavljeno, u pregledniku neće biti zabranjen nijedan URL.</translation>
<translation id="2762164719979766599">Navodi popis lokalnih računa na uređaju koji se prikazuje na zaslonu prijave.

      Svaki unos na popisu navodi identifikator, koji se upotrebljava interno da bi se razlikovali lokalni računi na uređaju.</translation>
<translation id="8955719471735800169">Natrag na vrh</translation>
<translation id="2534584045044686957">Konfigurira veličinu predmemorije koju će proizvod <ph name="PRODUCT_NAME"/> upotrebljavati za pohranjivanje predmemoriranih medijskih datoteka na disk.

      Ako postavite to pravilo, proizvod <ph name="PRODUCT_NAME"/> upotrebljavat će navedenu veličinu predmemorije bez obzira na to je li korisnik odredio znaku &quot;--media-cache-size&quot; ili nije.

      Ako je vrijednost tog pravila 0, upotrebljavat će se zadana veličina predmemorije, ali korisnik ju neće moći promijeniti.

      Ako se to pravilo ne postavi, upotrebljavat će se zadana veličina, a korisnik će ju moći premostiti oznakom &quot;--media-cache-size&quot;.</translation>
<translation id="3723474915949495925">Određuje popis dodataka koji korisnik može omogućiti ili onemogućiti u proizvodu <ph name="PRODUCT_NAME"/>.

      Zamjenski znakovi &quot;*&quot; i &quot;?&quot; mogu se upotrijebiti za podudarne nizove proizvoljnih znakova. &quot;*&quot; odgovara proizvoljnom broju znakova, dok &quot;?&quot; određuje izborni pojedinačni znak, tj. ne odgovara nijednom ili odgovara jednom znaku. Prespojni je znak &quot;\&quot;, tako da za podudaranje sa stvarnim znakovima &quot;*&quot;, &quot;?&quot; ili &quot;\&quot; ispred njih morate staviti znak &quot;\&quot;.

      Ako omogućite tu postavku, određeni popis dodataka može se upotrebljavati u proizvodu <ph name="PRODUCT_NAME"/>. Korisnici ih mogu omogućiti ili onemogućiti pod stavkom &quot;about:plugins&quot;, čak i ako dodatak također odgovara uzorku u pravilu DisabledPlugins. Korisnici također mogu omogućiti i onemogućiti dodatke koji ne odgovaraju nijednom uzorku u pravilima DisabledPlugins, DisabledPluginsExceptions i EnabledPlugins.

      To je pravilo namijenjeno omogućavanju strogih popisa za zabranjene dodatke, u kojima popis &quot;DisabledPlugins&quot; sadrži zamjenske znakove poput znaka za onemogućavanje svih dodataka &quot;*&quot; ili znaka za onemogućavanje svih Java dodataka &quot;*Java*&quot;, ali administrator želi omogućiti neke određene verzije kao što je &quot;IcedTea Java 2.3&quot;. Ta se verzija može odrediti u ovom pravilu.

      Ako se to pravilo ne postavi, svi dodaci koji odgovaraju uzorku u pravilu &quot;DisabledPlugins&quot; bit će zaključani kao onemogućeni i korisnik ih neće moći omogućiti.</translation>
<translation id="546726650689747237">Odgoda zatamnjenja zaslona za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="4988291787868618635">Radnja koja će se izvršiti kada nastupi odgoda neaktivnosti</translation>
<translation id="5316405756476735914">Omogućuje da postavite smiju li web-lokacije postavljati lokalne podatke. Postavljanje lokalnih podataka može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije. Ako to pravilo nije postavljeno, upotrebljavat će se pravilo &quot;AllowCookies&quot;, a korisnik će moći to promijeniti.</translation>
<translation id="4250680216510889253">Ne</translation>
<translation id="1522425503138261032">Dopusti web-lokacijama praćenje fizičke lokacije korisnika</translation>
<translation id="6467433935902485842">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju stranice koje ne smiju pokretati dodatke. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultPluginsSetting&quot; ako je ono postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="4423597592074154136">Ručno određivanje proxy postavki</translation>
<translation id="209586405398070749">Stabilan kanal</translation>
<translation id="8170878842291747619">Omogućuje integriranu uslugu Google Prevoditelj u proizvodu <ph name="PRODUCT_NAME"/>. Ako omogućite ovu postavku, usluga <ph name="PRODUCT_NAME"/> prikazivat će integriranu alatnu traku koja u odgovarajućem slučaju korisniku nudi prijevod stranice. Ako onemogućite ovu postavku, korisnicima se nikad neće prikazivati traka prevođenja. Ako omogućite ili onemogućite ovu postavku, korisnici ne mogu mijenjati niti poništiti tu postavku u proizvodu <ph name="PRODUCT_NAME"/>. Ako ova postavka nije postavljena, korisnik može odlučiti hoće li upotrebljavati tu funkciju.</translation>
<translation id="9035964157729712237">ID-jevi proširenja za izuzimanje s crne liste</translation>
<translation id="8244525275280476362">Maksimalna odgoda dohvaćanja nakon poništavanja valjanosti pravila</translation>
<translation id="8587229956764455752">Dopusti stvaranje novih korisničkih računa</translation>
<translation id="7417972229667085380">Postotak za skaliranje odgode u stanju mirovanja u načinu prezentacije (obustavljeno)</translation>
<translation id="3964909636571393861">Omogućuje pristup popisu URL-ova</translation>
<translation id="3450318623141983471">Izvješćivanje o stanju dev prekidača uređaja kod pokretanja.

      Ako pravilo nije postavljeno ili je postavljeno na &quot;false&quot;, stanje prekidača dev neće se prijaviti u izvješću.</translation>
<translation id="1811270320106005269">Omogući zaključavanje kada uređaji <ph name="PRODUCT_OS_NAME"/> prijeđu u stanje mirovanja ili se isključe.

      Ako omogućite tu postavku, korisnici će morati unijeti zaporku za otključavanje uređaja u stanju mirovanja.

      Ako onemogućite tu postavku, korisnici neće morati unijeti zaporku za otključavanje uređaja u stanju mirovanja.

      Ako omogućite ili onemogućite tu postavku, korisnici je ne mogu promijeniti ni premostiti.

      Ako je ostavite nepostavljenu, korisnici mogu odabrati žele li unositi zaporku za otključavanje uređaja.</translation>
<translation id="6022948604095165524">Radnja prilikom pokretanja</translation>
<translation id="9042911395677044526">Omogućuje nametanje mrežne konfiguracije za primjenu po korisniku na uređaju <ph name="PRODUCT_OS_NAME"/>. Mrežna je konfiguracija niz u formatu JSON, kao što je definirano formatom &quot;Open Network Configuration&quot; koji je opisan na adresi <ph name="ONC_SPEC_URL"/></translation>
<translation id="7128918109610518786">Navodi identifikatore aplikacija koje sustav <ph name="PRODUCT_OS_NAME"/> prikazuje kao prikvačene aplikacije u traci pokretača.

      Ako se to pravilo konfigurira, utvrđuje se skupina aplikacija i korisnik ih ne može mijenjati.

      Ako se to pravilo ne postavi, korisnik može mijenjati popis prikvačenih aplikacija u pokretaču.</translation>
<translation id="1679420586049708690">Javna sesija za automatsku prijavu</translation>
<translation id="7625444193696794922">Određuje kanal za izdavanje na koji bi ovaj uređaj trebao biti priključen.</translation>
<translation id="2552966063069741410">Vremenska zona</translation>
<translation id="2240879329269430151">Omogućuje da postavite smiju li web-lokacije prikazivati skočne prozore. Prikazivanje skočnih prozora može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije. Ako to pravilo nije postavljeno, upotrebljavat će se pravilo &quot;BlockPopups&quot;, a korisnik će to moći promijeniti.</translation>
<translation id="2529700525201305165">Ograničavanje korisnika koji se mogu prijaviti na uslugu <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Odbrojavanje za automatsku prijavu u javnu sesiju</translation>
<translation id="8285435910062771358">Omogućeno je povećalo cijelog zaslona</translation>
<translation id="5141670636904227950">Postavljanje zadane vrste povećala na &quot;omogućeno&quot; na zaslonu za prijavu</translation>
<translation id="3864818549971490907">Zadana postavka dodataka</translation>
<translation id="7151201297958662315">Određuje hoće li se proces usluge <ph name="PRODUCT_NAME"/> pokrenuti kada se OS prijavi i nastaviti se izvršavati kada se posljednji prozor preglednika zatvori, omogućujući time pozadinskim aplikacijama da ostanu aktivne. Pozadinski proces prikazuje ikonu ladice sustava i uvijek se može zatvoriti s tog mjesta.

      Ako je to pravilo postavljeno na &quot;istinito&quot;, način rada u pozadini omogućen je i korisnik ga ne može kontrolirati u postavkama preglednika.

      Ako je to pravilo postavljeno na &quot;lažno&quot;, način rada u pozadini onemogućen je i korisnik ga ne može kontrolirati u postavkama preglednika.

      Ako se to pravilo ne postavi, način rada u pozadini u početku je onemogućen i korisnik ga može kontrolirati u postavkama preglednika.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 ili noviji</translation>
<translation id="5148753489738115745">Omogućuje vam da odredite dodatne parametre koji se upotrebljavaju kada <ph name="PRODUCT_FRAME_NAME"/> pokreće uslugu <ph name="PRODUCT_NAME"/>.

          Ako se to pravilo ne postavi, upotrebljavat će se zadani naredbeni redak.</translation>
<translation id="2646290749315461919">Omogućuje da postavite smiju li web-lokacije pratiti fizičku lokaciju korisnika. Praćenje fizičke lokacije korisnika može biti dopušteno prema zadanim postavkama, odbijeno prema zadanim postavkama ili se korisniku može postaviti upit svaki puta kada web-lokacija zahtijeva fizičku lokaciju. Ako ovo pravilo nije postavljeno, upotrebljavat će se pravilo &quot;AskGeolocation&quot;, a korisnik će to moći promijeniti.</translation>
<translation id="6394350458541421998">To se pravilo ne upotrebljava od verzije 29 sustava <ph name="PRODUCT_OS_NAME"/>. Umjesto toga upotrijebite pravilo PresentationScreenDimDelayScale.</translation>
<translation id="5770738360657678870">Razvojni kanal (možda je nestabilan)</translation>
<translation id="2959898425599642200">Pravila zaobilaženja proxyja</translation>
<translation id="228659285074633994">Određuje koliko vremena treba proći od zadnjeg korisničkog unosa nakon kojeg se prikazuje dijaloški okvir s upozorenjem dok je uređaj priključen na struju.

          Kada je postavljeno, ovo pravilo određuje koliko dugo korisnik treba biti neaktivan prije nego što proizvod <ph name="PRODUCT_OS_NAME"/> prikaže dijaloški okvir upozorenja koji obavještava korisnika da će biti poduzeta radnja u vezi s neaktivnošću.

          Kada ovo pravilo nije postavljeno, ne prikazuje se dijaloški okvir upozorenja.

          Vrijednost pravila treba biti navedena u milisekundama. Vrijednosti se prilagođavaju kako bi bile manje ili jednake odgodi neaktivnosti.</translation>
<translation id="1098794473340446990">Izvješće o vremenima aktivnosti uređaja. Ako je ova postavka postavljena na True, upisani uređaji izvijestit će o razdobljima kad je korisnik aktivan na uređaju. Ako ova postavka nije postavljena ili je postavljena na False, aktivnost uređaja neće biti zabilježena niti će se o njoj izvijestiti.</translation>
<translation id="7937766917976512374">Omogući ili onemogući snimanje videozapisa</translation>
<translation id="427632463972968153">Određuje parametre koji se upotrebljavaju prilikom pretraživanja slika pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {imageThumbnail} u gornjem primjeru, zamijenit će se podacima stvarne minijature slike.

          To je pravilo izborno. Ako nije postavljeno, zahtjev za pretraživanje slika poslat će se pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="8818646462962777576">Uzorci na tom popisu usporedit će se sa sigurnosnim
      izvorištem URL-a koji šalje zahtjev. Ako se podudaranje pronađe, pristup
      uređajima za snimanje zvuka dodijelit će se bez upita.

      NAPOMENA: to je pravilo trenutačno podržano samo u načinu kioska.</translation>
<translation id="489803897780524242">Parametar koji kontrolira položaj pojma za pretraživanje za zadanog pružatelja usluge pretraživanja</translation>
<translation id="316778957754360075">To se pravilo ne upotrebljava od verzije 29 sustava <ph name="PRODUCT_NAME"/>. Preporučuje se da se pri postavljanju zbirki proširenja ili aplikacija koje hostira određena organizacija web-lokacija koja hostira CRX pakete uključi u pravilo ExtensionInstallSources te da se u pakete na web-stanici postave izravne veze za preuzimanje. Pokretač za tu web-stranicu može se izraditi pomoću pravila ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">Odjavi korisnika</translation>
<translation id="4826326557828204741">Radnja koja se poduzima kada se dosegne odgoda zbog neaktivnosti dok računalo pokreće baterija</translation>
<translation id="7912255076272890813">Konfiguriraj dopuštene vrste aplikacija/proširenja</translation>
<translation id="817455428376641507">Omogućuje pristup navedenim URL-ovima kao iznimkama s popisa zabranjenih URL-ova.

      Pogledajte opis pravila o popisu zabranjenih URL-ova za opis formata unosa na tom popisu.

      Ovo se pravilo može upotrijebiti za otvaranje iznimaka s ograničavajućih popisa nedopuštenih stavki. Primjerice, &quot;*&quot; može biti zabranjen kako bi se blokirali svi zahtjevi i to se pravilo može upotrebljavati za omogućavanje pristupa ograničenom popisu URL-ova. Može se upotrijebiti za otvaranje iznimaka za određene sheme, poddomene drugih domena, priključke ili specifične putanje.

      Najodređeniji filtar odredit će je li URL blokiran ili dopušten. Popis dopuštenih stavki ima prednost pred popisom nedopuštenih.

      Pravilo je ograničeno na 1000 unosa; svi se daljnji unosi zanemaruju.

      Ako to pravilo nije postavljeno, na popisu nedopuštenih stavki u pravilu 'URLBlacklist' neće biti iznimaka.</translation>
<translation id="4163644371169597382">IT administratori za poslovne uređaje pomoću te oznake mogu kontrolirati hoće li korisnici moći iskoristiti ponude registracijom OS-a Chrome.

      Ako je ovo pravilo postavljeno na istinito ili ako nije postavljeno, korisnici će moći iskoristiti ponude registracijom OS-a Chrome.

      Ako je pravilo postavljeno na lažno, korisnici neće moći iskoristiti ponude.</translation>
<translation id="8148901634826284024">Omogući značajku pristupačnosti načina visokog kontrasta.

          Ako se to pravilo postavi na točno, način visokog kontrasta uvijek će biti omogućen.

          Ako se to pravilo postavi na netočno, način visokog kontrasta uvijek će biti onemogućen.

          Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

          Ako se to pravilo ne postavi, način visokog kontrasta u početku će biti onemogućen, ali korisnik ga može omogućiti u bilo kojem trenutku.</translation>
<translation id="6177482277304066047">Postavlja ciljnu verziju za Automatska ažuriranja.

      Određuje prefiks ciljne verzije na koju bi se proizvod <ph name="PRODUCT_OS_NAME"/> trebao ažurirati. Ako uređaj izvodi verziju koja prethodi navedenom prefiksu, ažurirat će se u najnoviju verziju s navedenim prefiksom. Ako uređaj već ima noviju verziju, ništa se neće promijeniti (tj. neće biti vraćanja na stariju verziju) i uređaj će ostati na trenutačnoj verziji. Format prefiksa funkcionira prema komponentama kao što je prikazano u sljedećem primjeru:

      &quot;&quot; (ili nije konfigurirano): ažuriranje u najnoviju dostupnu verziju.
      &quot;1412.&quot;: ažuriranje u bilo koju verziju podređenu verziji 1412 (npr., 1412.24.34 ili 1412.60.2)
      &quot;1412.2.&quot;: ažuriranje u bilo koju verziju podređenu verziji 1412.2 (npr., 1412.2.34 ili 1412.2.2)
      &quot;1412.24.34&quot;: ažuriranje samo u tu konkretnu verziju</translation>
<translation id="8102913158860568230">Zadana postavka za medijski stream</translation>
<translation id="6641981670621198190">Onemogući podršku za API-je 3D grafike</translation>
<translation id="7929480864713075819">Omogućite izvješćivanje o informacijama memorije (ukupna veličina JS-a) na stranici</translation>
<translation id="5703863730741917647">Određuje radnju koja se poduzima kada se dosegne odgoda zbog neaktivnosti.

          Uzmite u obzir da se to pravilo obustavlja te će ubuduće biti uklonjeno.

          To pravilo navodi zamjensku vrijednost za detaljnija pravila <ph name="IDLEACTIONAC_POLICY_NAME"/> i <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Ako je to pravilo postavljeno, njegova će se vrijednost upotrebljavati ako nije postavljeno odgovarajuće detaljnije pravilo.

          Kada to pravilo nije postavljeno, neće biti utjecaja na ponašanje detaljnijih pravila.</translation>
<translation id="5997543603646547632">Upotrijebi sat s 24-satnim prikazom prema zadanim postavkama</translation>
<translation id="7003746348783715221">Postavke za <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Omogući prijelaz vatrozida iz klijenta za daljinski pristup</translation>
<translation id="6367755442345892511">Treba li korisnik imati mogućnost za konfiguriranje kanala izdanja</translation>
<translation id="4035570660718398959">Dopusti korisnicima da iskoriste ponude registracijom OS-a Chrome.</translation>
<translation id="3868347814555911633">To je pravilo aktivno samo u prodajnom načinu.

      Navodi proširenja koja se automatski instaliraju za korisnike demo verzije, za uređaje u prodajnom načinu. Ta se proširenja spremaju na uređaj i mogu se instalirati izvanmrežno, nakon instalacije.

      Svaki unos popisa sadrži rječnik koji mora uključivati ID proširenja u polju &quot;extension-id&quot; i njegov URL za ažuriranje u polju &quot;update-url&quot;.</translation>
<translation id="9096086085182305205">Bijela lista poslužitelja za autentifikaciju</translation>
<translation id="4980301635509504364">Dopusti ili odbij videosnimanje.

      Ako je to pravilo omogućeno ili nije konfigurirano (zadano), korisniku će se nuditi
      pristup videosnimanju, osim za URL-ove konfigurirane na popisu
      VideoCaptureAllowedUrls koji će dobiti pristup bez postavljanja upita.

      Kada je to pravilo onemogućeno, korisniku se nikad neće postaviti upit i snimanje
      će biti dostupno samo URL-ovima konfiguriranima na VideoCaptureAllowedUrls.

      To pravilo utječe na sve vrste videoulaza, a ne samo na ugrađenu kameru.</translation>
<translation id="7063895219334505671">Dopusti skočne prozore na ovim web-lokacijama</translation>
<translation id="4052765007567912447">Nadzire može li korisnik vidjeti zaporke u nešifriranom tekstu u upravitelju zaporki. Ako onemogućite ovu postavku, upravitelj zaporki ne dopušta prikaz pohranjenih zaporki u nešifriranom tekstu u prozoru upravitelja zaporki. Ako omogućite ili ne postavite ovo pravilo, korisnici mogu vidjeti svoje zaporke u nešifriranom tekstu u upravitelju zaporki.</translation>
<translation id="5213629107215526747">URL-ovi koji će dobiti pristup uređajima za videosnimanje bez postavljanja upita.</translation>
<translation id="5936622343001856595">Nameće da se upiti u Google web-pretraživanju provode s aktiviranom funkcijom Sigurno pretraživanje te sprječava korisnike da promijene tu postavku.

      Ako omogućite tu postavku, Sigurno pretraživanje uvijek će biti aktivno u Google pretraživanju.

      Ako onemogućite tu postavku ili ne odredite njenu vrijednost, Sigurno pretraživanje u Google pretraživanju neće biti primijenjeno.</translation>
<translation id="6017568866726630990">Prikaži dijalog ispisa iz sustava umjesto pretpregleda ispisa.

      Kada je omogućena ta postavka, proizvod <ph name="PRODUCT_NAME"/> otvorit će dijalog ispisa iz sustava umjesto ugrađenog pretpregleda ispisa kada korisnik zatraži ispis stranice.

      Ako to pravilo nije postavljeno ili je postavljeno na netočno, naredbe ispisa pokreću zaslon pretpregleda ispisa.</translation>
<translation id="2824715612115726353">Omogući anonimni način</translation>
<translation id="1057535219415338480">Omogućuje predviđanje mreže na usluzi <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene ovu postavku.

      Ovime se ne nadzire samo pretpreuzimanje DNS-a, već i TCP i SSL pretpovezivanje i pretprikaz web-stranica. Naziv pravila odnosi se na pretpreuzimanje DNS-a iz povijesnih razloga.

      Ako omogućite ili onemogućite ovu postavku, korisnici je ne mogu na usluzi <ph name="PRODUCT_NAME"/> promijeniti niti nadjačati.

      Ako ovo pravilo nije postavljeno, bit će omogućeno, no korisnik će ga moći promijeniti.</translation>
<translation id="4541530620466526913">Lokalni računi na uređaju</translation>
<translation id="5815129011704381141">Automatsko ponovno pokretanje nakon ažuriranja</translation>
<translation id="1757688868319862958">Omogućuje proizvodu <ph name="PRODUCT_NAME"/> pokretanje dodataka koji zahtijevaju autorizaciju. Ako omogućite ovu postavku, dodaci koji nisu zastarjeli uvijek će se pokretati. Ako je postavka isključena ili nije postavljena, od korisnika će se tražiti dopuštenje za pokretanje dodataka koji zahtijevaju autorizaciju. Ti dodaci mogu ugroziti sigurnost.</translation>
<translation id="6392973646875039351">Omogućuje značajku Automatsko popunjavanje proizvoda <ph name="PRODUCT_NAME"/> i omogućuje korisnicima automatsko ispunjavanje web-obrazaca pomoću ranije pohranjenih informacija, kao što su adresa ili podaci o kreditnoj kartici. Ako onemogućite ovu postavku, Automatsko popunjavanje neće biti dostupno korisnicima. Ako omogućite ovu postavku i ne konfigurirate vrijednost, Automatsko popunjavanje ostat će pod nadzorom korisnika. To će im omogućiti konfiguriranje profila Automatskog popunjavanja te uključivanje ili isključivanje Automatskog popunjavanja po vlastitom nahođenju.</translation>
<translation id="6157537876488211233">Popis pravila zaobilaženja proxyja odvojenih zarezima</translation>
<translation id="7788511847830146438">Po profilu</translation>
<translation id="2516525961735516234">Određuje hoće li aktivnost videozapisa utjecati na upravljanje napajanjem.

          Ako je ovo pravilo postavljeno na istinito ili ako nije postavljeno, korisnik se ne smatra neaktivnim tijekom reprodukcije videozapisa. Time se sprječava odgoda neaktivnosti te zatamnjivanja, isključivanja i zaključavanja zaslona, kao i izvršavanje odgovarajućih radnji.

          Ako je pravilo postavljeno na lažno, korisnik se može smatrati neaktivnim bez obzira na aktivnost videozapisa.</translation>
<translation id="3965339130942650562">Privremeni prekid do izvršavanja odjave korisnika u stanju mirovanja</translation>
<translation id="5814301096961727113">Postavljanje zadanog stanja izgovaranja povratnih informacija na zaslonu za prijavu</translation>
<translation id="9084985621503260744">Odredi utječe li aktivnost videozapisa na upravljanje napajanjem</translation>
<translation id="7091198954851103976">Uvijek pokreni dodatke koji zahtijevaju autorizaciju</translation>
<translation id="1708496595873025510">Postavljanje ograničenja za dohvaćanje vrijednosti varijacija</translation>
<translation id="8870318296973696995">Početna stranica</translation>
<translation id="1240643596769627465">Određuje URL tražilice koja se upotrebljava za pružanje rezultata usluge Instant. URL treba sadržavati niz <ph name="SEARCH_TERM_MARKER"/> koji će biti zamijenjen u trenutku postavljanja upita tekstom koji je korisnik dotad unio. Ovo je pravilo izborno. Ako ga ne postavite, neće se pružati rezultati pretraživanja uz uslugu Instant. Ovo pravilo poštovat će se samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="6693751878507293182">Ako omogućite ovu postavku, automatsko pretraživanje i instalacija dodataka koji nedostaju bit će onemogućeni u proizvodu <ph name="PRODUCT_NAME"/>. Ako onemogućite ovu opciju ili ju ne postavite, alat za traženje dodataka bit će aktivan.</translation>
<translation id="2650049181907741121">Radnja koja će se izvršiti kada korisnik spusti poklopac</translation>
<translation id="7880891067740158163">Omogućuje da navedete popis uzoraka URL-ova koji određuju web-lokacije za koje proizvod <ph name="PRODUCT_NAME"/> treba automatski odabrati certifikat klijenta, u slučaju da web-lokacija zahtijeva certifikat. Ako ovo pravilo nije postavljeno, ni za jednu web-lokaciju neće se provoditi automatski odabir.</translation>
<translation id="3866249974567520381">Opis</translation>
<translation id="5192837635164433517">Omogućuje upotrebu zamjenskih stranica pogrešaka koje su ugrađene u proizvod <ph name="PRODUCT_NAME"/> (poput &quot;Stranica nije pronađena&quot;) te sprječava korisnike da promijene tu postavku. Ako omogućite ovu postavku, upotrebljavat će se zamjenske stranice pogrešaka. Ako onemogućite ovu postavku, zamjenske stranice pogrešaka neće se nikada upotrebljavati. Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti niti poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME"/>. Ako pravilo nije postavljeno, to će biti omogućeno, ali korisnik će to moći promijeniti.</translation>
<translation id="2236488539271255289">Ne dopusti nijednoj web-lokaciji postavljanje lokalnih podataka</translation>
<translation id="4467952432486360968">Blokiraj kolačiće trećih strana</translation>
<translation id="2041396837791669429">Blokiraj pristup web-lokacijama izvan paketa sadržaja.</translation>
<translation id="1305864769064309495">Rječnik koji mapira URL-ove na Booleovu oznaku koja određuje hoće li pristup hostu biti dopušten (točno) ili blokiran (netočno).

          To je pravilo za Chromeovu internu upotrebu.</translation>
<translation id="5586942249556966598">Ne radi ništa</translation>
<translation id="131353325527891113">Prikaži korisnička imena na zaslonu prijave</translation>
<translation id="5317965872570843334">Omogućuje upotrebu STUN i relejnih poslužitelja kada udaljeni klijenti pokušavaju uspostaviti vezu s ovim računalom. Ako je ova postavka omogućena, onda udaljeni klijenti mogu otkriti ovo računalo i povezati se s njime, čak i ako je odvojeno vatrozidom. Ako je ova postavka je onemogućena, a odlazne UDP veze filtrirane su vatrozidom, onda će ovo računalo dopustiti samo veze s klijentskih računala unutar lokalne mreže. Ako ovo pravilo nije postavljeno, postavka će biti omogućena.</translation>
<translation id="5365946944967967336">Prikaži gumb Početna na alatnoj traci</translation>
<translation id="3709266154059827597">Konfiguriraj crnu listu instalacije proširenja</translation>
<translation id="8451988835943702790">Upotrijebi web-stranicu nove kartice kao početnu stranicu</translation>
<translation id="8469342921412620373">Omogućuje upotrebu zadanog davatelja usluga pretraživanja. Ako omogućite ovu postavku, zadano pretraživanje obavlja se kad korisnik u višenamjenski okvir upiše tekst koji nije URL. Zadanog davatelja usluga pretraživanja koji će se upotrebljavati možete odrediti postavljanjem ostalih pravila zadanog pretraživanja. Ako se ova pravila ostave prazna, korisnik može odabrati zadanog davatelja usluga pretraživanja. Ako onemogućite ovu postavku, pretraživanje neće biti provedeno kad korisnik u višenamjenski okvir unese tekst koji nije URL. Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti ni poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME"/>. Ako ovo pravilo nije postavljeno, bit će omogućen zadani davatelj usluga pretraživanja, a korisnici će moći postaviti popis davatelja usluga pretraživanja.</translation>
<translation id="4791031774429044540">Omogući značajku pristupačnosti velikog pokazivača.

          Ako se to pravilo postavi na točno, veliki će pokazivač uvijek biti omogućen.

          Ako se to pravilo postavi na netočno, veliki će pokazivač uvijek biti onemogućen.

          Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

          Ako se to pravilo ne postavi, veliki će pokazivač u početku biti onemogućen, ali korisnici ga mogu omogućiti u bilo kojem trenutku.</translation>
<translation id="2633084400146331575">Omogućavanje govornih povratnih informacija</translation>
<translation id="7712008868843631413">Omogućivanje nadziranih korisnika.</translation>
<translation id="8731693562790917685">Postavke sadržaja omogućuju određivanje načina postupanja s određenim vrstama sadržaja (kao što su Kolačići, Slike i JavaScript).</translation>
<translation id="2411919772666155530">Blokiranje obavijesti na ovim web-lokacijama</translation>
<translation id="6923366716660828830">Određuje naziv zadanog davatelja usluga pretraživanja. Ako naziv ostane prazan ili nije postavljen, upotrebljavat će se naziv hosta određen URL-om pretraživanja. Ovo će pravilo biti uzeto u obzir samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="4869787217450099946">Određuje jesu li dopuštena blokiranja aktivacije zaslona. Ta blokiranja mogu tražiti proširenja putem API-ja proširenja za upravljanje napajanjem.

          Ako je to pravilo postavljeno na točno ili ako nije postavljeno, blokiranja aktivacije zaslona primjenjivat će se radi upravljanja napajanjem.

          Ako je to pravilo postavljeno na netočno, ti će se zahtjevi zanemarivati.</translation>
<translation id="467236746355332046">Podržane značajke:</translation>
<translation id="7632724434767231364">Naziv GSSAPI biblioteke</translation>
<translation id="3038323923255997294">Nastavi izvršavati ​​pozadinske aplikacije po zatvaranju usluge <ph name="PRODUCT_NAME"/></translation>
<translation id="4652284479838524692">Omogućivanje daljinskog atestiranja za uređaj.</translation>
<translation id="8909280293285028130">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zaključao tijekom napajanja izmjeničnom strujom.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> zaključa zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME"/> ne zaključava zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Preporučen je način za zaključavanje zaslona tijekom neaktivnosti omogućiti zaključavanje zaslona tijekom obustavljanja i postaviti <ph name="PRODUCT_OS_NAME"/> na obustavljanje nakon razdoblja neaktivnosti. Ovo bi se pravilo trebalo upotrebljavati samo kada bi do zaključavanja zaslona trebalo doći puno prije obustavljanja ili kada obustavljanje u razdoblju neaktivnosti uopće nije poželjno.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti.</translation>
<translation id="7651739109954974365">Utvrđuje treba li roaming podataka biti omogućen za uređaj. Ako je to pravilo postavljeno na &quot;istinito&quot;, roaming podataka bit će dopušten. Ako to pravilo nije konfigurirano ili je postavljeno na &quot;lažno&quot;, roaming podataka neće biti dostupan.</translation>
<translation id="6244210204546589761">URL-ovi koji se otvaraju prilikom pokretanja</translation>
<translation id="7468416082528382842">Lokacija Windows registra:</translation>
<translation id="1808715480127969042">Blokiraj kolačiće na ovim web-lokacijama</translation>
<translation id="1908884158811109790">Onemogućuje Google disk putem mobilnih veza u aplikaciji Datoteke OS-a Chrome</translation>
<translation id="7340034977315324840">Izvješće o vremenima aktivnosti uređaja</translation>
<translation id="4928632305180102854">Kontrolira dopušta li sustav <ph name="PRODUCT_OS_NAME"/> stvaranje novih korisničkih računa. Ako je to pravilo postavljeno na &quot;lažno&quot;, korisnici koji još nemaju račun neće se moći prijaviti.

      Ako je to pravilo postavljeno na &quot;istinito&quot; ili ako nije konfigurirano, izrada novih korisničkih računa bit će dopuštena pod uvjetom da pravilo <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/> ne sprječava prijavu korisnika.</translation>
<translation id="4389091865841123886">Konfiguriranje daljinskog atestiranja TPM mehanizmom.</translation>
<translation id="8256688113167012935">Kontrolira naziv računa koji prikazuje proizvod <ph name="PRODUCT_OS_NAME"/> na zaslonu prijave za odgovarajući lokalni račun na uređaju.

      Ako je to pravilo postavljeno, zaslon prijave upotrijebit će navedeni niz u alatu za odabir prijave prema slici s odgovarajućeg lokalnog računa uređaja.

      Ako pravilo nije postavljeno, proizvod <ph name="PRODUCT_OS_NAME"/> upotrijebit će ID računa e-pošte lokalnog računa uređaja kao naziv za prikaz na zaslonu prijave.

      Ovo se pravilo zanemaruje za redovite korisničke račune.</translation>
<translation id="267596348720209223">Određuje kodiranje znakova koje podržava davatelj usluga pretraživanja. Kodiranja su nazivi kodnih stranica poput UTF-8, GB2312 i ISO-8859-1. Isprobavaju se navedenim redoslijedom. Ovo je pravilo izborno. Ako nije postavljeno, upotrebljavat će se zadana stranica UTF-8. Ovo će se pravilo poštovati samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="1349276916170108723">Onemogućuje sinkronizaciju Google diska u aplikaciji Datoteke OS-a Chrome kada je postavljeno na točno. U tom se slučaju nikakvi podaci ne prenose na Google disk.

          Ako nije postavljeno ili je postavljeno na netočno, korisnici će moći prenositi datoteke na Google disk.</translation>
<translation id="1964634611280150550">Onemogućen je anoniman način rada</translation>
<translation id="5971128524642832825">Onemogućuje Disk u aplikaciji Datoteke OS-a Chrome</translation>
<translation id="1847960418907100918">Određuje parametre koji se upotrebljavaju prilikom pretraživanja uz značajku Instant pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {searchTerms} u gornjem primjeru, zamijenit će se podacima stvarnih pojmova za pretraživanje.

          To je pravilo izborno. Ako nije postavljeno, zahtjev za pretraživanje uz značajku Instant poslat će se pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="1454846751303307294">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije kojima nije dopušteno pokretanje JavaScripta. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultJavaScriptSetting&quot;, ako je postavljeno, odnosno iz osobne konfiguracije korisnika, ako nije.</translation>
<translation id="538108065117008131">Dopusti da <ph name="PRODUCT_FRAME_NAME"/> rukuje sljedećim vrstama sadržaja.</translation>
<translation id="2312134445771258233">Omogućuje konfiguriranje stranica koje se učitavaju prilikom pokretanja. Sadržaj popisa &quot;URL-ovi za otvaranje prilikom pokretanja&quot; zanemaruje se, osim ako odaberete &quot;Otvori popis URL-ova&quot; pod &quot;Radnje prilikom pokretanja&quot;.</translation>
<translation id="243972079416668391">Određuje radnju koja se poduzima kada se dosegne odgoda zbog neaktivnosti dok je računalo priključeno na struju.

          Kada je to pravilo postavljeno, ono navodi radnju koju <ph name="PRODUCT_OS_NAME"/> poduzima kada je korisnik neaktivan onoliko vremena koliko je određeno u odgodi zbog neaktivnosti koja se može zasebno konfigurirati.

          Kada to pravilo nije postavljeno, poduzima se zadana radnja, a to je obustava.

          Ako je radnja obustava, <ph name="PRODUCT_OS_NAME"/> je moguće zasebno konfigurirati tako da zaključava ili ne zaključava zaslon prije obustavljanja.</translation>
<translation id="7750991880413385988">Otvori stranicu Nova kartica</translation>
<translation id="741903087521737762">Omogućuje vam da odredite ponašanje pri pokretanju.

          Ako odaberete &quot;Otvori stranicu Nova kartica&quot;, ta će se stranica otvarati svaki put kada pokrenete uslugu <ph name="PRODUCT_NAME"/>.

          Ako odaberete &quot;Vrati posljednju sesiju&quot;, URL-ovi koji su bili otvoreni kada je usluga <ph name="PRODUCT_NAME"/> posljednji put zatvorena otvorit će se ponovo i sesija pregledavanja vratit će se na isto mjesto.
          Biranjem te opcije onemogućit će se neke postavke koje se oslanjaju na sesije ili koje izvršavaju radnje pri izlasku (na primjer, brisanje podataka o pregledavanju pri izlasku ili kolačići koji se odnose samo na sesije).

          Ako odaberete &quot;Otvori popis URL-ova&quot;, popis &quot;URL-ova koji će se otvoriti pri pokretanju&quot; otvorit će se kada korisnik pokrene uslugu <ph name="PRODUCT_NAME"/>.

          Ako omogućite tu postavku, korisnici ju ne mogu promijeniti ili premostiti na usluzi <ph name="PRODUCT_NAME"/>.

          Onemogućavanje te postavke ima jednak učinak kao da ju niste konfigurirali. Korisnik će ju i dalje moći promijeniti na usluzi <ph name="PRODUCT_NAME"/>.</translation>
<translation id="8161570238552664224">Dopušta se reprodukcija zvuka.

      Kad je ovo pravilo postavljeno na neistinito, zvučni izlaz neće biti dostupan na uređaju dok je korisnik prijavljen.

      Ovo pravilo utječe na sve vrste zvučnih izlaza, a ne samo na ugrađene zvučnike. Značajke zvučne pristupačnosti također su zabranjene ovim pravilom. Ne omogućujte ovo pravilo ako je korisniku potreban čitač zaslona.

      Ako je ovo pravilo postavljeno na istinito ili nije konfigurirano, tada korisnici mogu upotrebljavati sve podržane zvučne izlaze na svojem uređaju.</translation>
<translation id="5761030451068906335">Konfigurira proxy postavke za uslugu <ph name="PRODUCT_NAME"/>. To pravilo nije još spremno za upotrebu, nemojte ga upotrebljavati.</translation>
<translation id="3006443857675504368">Prikaz opcija pristupačnosti za proizvod <ph name="PRODUCT_OS_NAME"/> u izborniku sustava.

          Ako je ovo pravilo postavljeno na istinito, opcije pristupačnosti uvijek će se prikazivati u izborniku palete sustava.

          Ako je pravilo postavljena na lažno, opcije pristupačnosti nikad se neće prikazivati u izborniku palete sustava.

          Ako postavite ovo pravilo, korisnici ga neće moći promijeniti ni poništiti.

          Ako se ovo pravilo ne postavi, opcije pristupačnosti neće se prikazivati u izborniku palete sustava, ali će korisnici moći prikazati opcije pristupačnosti putem stranice Postavke.</translation>
<translation id="8344454543174932833">Uvoz oznaka iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="1019101089073227242">Postavi imenik korisničkih podataka</translation>
<translation id="5826047473100157858">Određuje može li korisnik otvarati stranice u anonimnom načinu u proizvodu <ph name="PRODUCT_NAME"/>. Ako je odabrano &quot;Enabled&quot; (omogućeno) ili pravilo nije postavljeno, stranice se mogu otvarati u anonimnom načinu. Ako je odabrano &quot;Disabled&quot; (onemogućeno), stranice se ne mogu otvarati u anonimnom načinu. Ako je odabrano &quot;Forced&quot; (prisilno), stranice se mogu otvarati SAMO u anonimnom načinu.</translation>
<translation id="2988031052053447965">Skrivanje aplikacije Chrome web-trgovine i veze u podnožju s web-stranice nove kartice i pokretača aplikacija OS-a Chrome.

      Kada je ovo pravilo postavljeno na istinito, ikone su skrivene.

      Kada je ovo pravilo postavljeno na lažno ili nije konfigurirano, ikone su vidljive.</translation>
<translation id="8401282319420373133">Proširenja koja smiju upotrebljavati API za daljinsko atestiranje.</translation>
<translation id="5085647276663819155">Onemogući pregled ispisa</translation>
<translation id="8672321184841719703">Ciljna verzija automatskog ažuriranja</translation>
<translation id="1689963000958717134">Omogućuje nametanje primjene mrežne konfiguracije za sve korisnike uređaja <ph name="PRODUCT_OS_NAME"/>. Mrežna je konfiguracija niz u formatu JSON, kao što je definirano formatom &quot;Open Network Configuration&quot;, koji je opisan na stranici <ph name="ONC_SPEC_URL"/></translation>
<translation id="6699880231565102694">Omogući autentifikaciju s dva čimbenika za hostove daljinskog pristupa</translation>
<translation id="2030905906517501646">Zadani davatelj usluga pretraživanja</translation>
<translation id="3072045631333522102">Čuvar zaslona koji će se upotrebljavati na zaslonu prijave u prodajnom načinu</translation>
<translation id="4550478922814283243">Omogući ili onemogući autentifikaciju bez PIN-a</translation>
<translation id="7712109699186360774">Pitaj svaki put kada web-lokacija želi pristupiti kameri i/ili mikrofonu</translation>
<translation id="350797926066071931">Omogući Prevoditelj</translation>
<translation id="3711895659073496551">Obustavi</translation>
<translation id="4010738624545340900">Omogućavanje pozivanja dijaloga za odabir datoteka</translation>
<translation id="4518251772179446575">Pitaj kad web-lokacija želi pratiti fizičku lokaciju korisnika</translation>
<translation id="402759845255257575">Nemoj dopustiti nijednoj web-lokaciji da pokreće JavaScript</translation>
<translation id="5457924070961220141">Omogućuje konfiguriranje zadanog HTML prikazivača kada je instaliran okvir <ph name="PRODUCT_FRAME_NAME"/>. Ako ovo pravilo nije postavljeno, zadana je postavka da prikazivanje obavlja preglednik hosta, ali to po izboru možete poništiti i postaviti da okvir <ph name="PRODUCT_FRAME_NAME"/> prikazuje HTML stranice prema zadanim postavkama.</translation>
<translation id="706669471845501145">Dopusti web-lokaciji prikazivanje obavijesti radne površine</translation>
<translation id="7529144158022474049">Čimbenik raspršivanja automatskog ažuriranja</translation>
<translation id="2188979373208322108">Omogućuje traku oznaka u proizvodu <ph name="PRODUCT_NAME"/>. Ako omogućite ovu postavku, usluga <ph name="PRODUCT_NAME"/> prikazivat će traku oznaka. Ako onemogućite ovu postavku, korisnicima nikad neće biti prikazana traka oznaka. Ako omogućite ili onemogućite ovu postavku, korisnici ju neće moći promijeniti niti poništiti u proizvodu <ph name="PRODUCT_NAME"/>. Ako ova postavka nije postavljena, korisnici mogu odlučiti žele li upotrebljavati tu funkciju.</translation>
<translation id="5475361623548884387">Omogući ispis</translation>
<translation id="7287359148642300270">Određuje koji poslužitelji trebaju biti stavljeni na popis dopuštenih za integriranu autentifikaciju. Integrirana autentifikacija omogućena je samo kada proizvod <ph name="PRODUCT_NAME"/> primi zahtjev za autentifikaciju od proxyja ili poslužitelja koji se nalazi na tom popisu.

          Razdvojite više poslužitelja zarezima. Zamjenski su znakovi (*) dopušteni.

          Ako ne postavite ovo pravilo, Chrome će pokušati otkriti je li poslužitelj na intranetu te će jedino tada odgovoriti na IWA zahtjeve. Ako otkrije da se radi o poslužitelju na internetu, Chrome će zanemariti IWA zahtjeve koji s njega dolaze.</translation>
<translation id="3653237928288822292">Ikona zadanog davatelja usluga pretraživanja</translation>
<translation id="2872961005593481000">Isključi</translation>
<translation id="4445684791305970001">Onemogućuje Alate za razvojne programere i konzolu JavaScriptu. Ako omogućite ovu postavku, više neće biti moguće pristupiti Alatima za razvojne programere i više se neće moći provjeravati elementi web-lokacija. Bit će onemogućeni svi tipkovnički prečaci i stavke izbornika ili kontekstnih izbornika za otvaranje Alata za razvojne programere ili konzole JavaScriptu. Ako se ova opcija onemogući ili ne postavi, bit će dopuštena upotreba Alata za razvojne programere i konzole JavaScripta.</translation>
<translation id="9203071022800375458">Onemogućuje izradu snimki zaslona.

      Ako je omogućeno, snimke zaslona ne mogu se izrađivati upotrebom tipkovničkih prečaca ni API-ja proširenja.

      Ako je onemogućeno ili nije određeno, izrada snimki zaslona dopuštena je.</translation>
<translation id="4632343302005518762">Dopusti proizvodu <ph name="PRODUCT_FRAME_NAME"/> rukovanje navedenim vrstama sadržaja</translation>
<translation id="13356285923490863">Naziv pravila</translation>
<translation id="557658534286111200">Omogućuje ili onemogućuje uređivanje knjižnih oznaka</translation>
<translation id="5378985487213287085">Omogućuje da postavite smiju li web-lokacije prikazivati obavijesti radne površine. Prikazivanje obavijesti radne površine može biti dopušteno prema zadanim postavkama, odbijeno prema zadanim postavkama ili korisnik može primiti upit svaki put kad web-lokacija želi prikazati obavijest radne površine. Ako to pravilo nije postavljeno, upotrebljavat će se pravilo &quot;AskNotifications&quot;, a korisnik će to moći promijeniti.</translation>
<translation id="2386362615870139244">Dopusti blokiranja aktivacije zaslona</translation>
<translation id="6908640907898649429">Konfigurira zadanog davatelja usluge pretraživanja. Možete odrediti zadanog davatelja usluge pretraživanja koji će korisnik upotrebljavati ili onemogućiti zadano pretraživanje.</translation>
<translation id="6544897973797372144">Ako je to pravilo postavljeno na True, a pravilo ChromeOsReleaseChannel nije određeno, korisnicima domene koja se prijavljuje bit će dopušteno da mijenjaju kanal izdanja na uređaju. Ako je to pravilo postavljeno na False, uređaj će biti zaključan na posljednji postavljeni kanal.

      Pravilo ChromeOsReleaseChannel premostit će kanal koji je odabrao korisnik, ali ako je kanal određen pravilom stabilniji od kanala instaliranog na uređaj, kanal će se promijeniti samo nakon što verzija stabilnijeg kanala dosegne viši broj verzije od verzije koja je instalirana na uređaj.</translation>
<translation id="389421284571827139">Omogućuje određivanje proxy poslužitelja koji <ph name="PRODUCT_NAME"/> upotrebljava i sprječava korisnike da promijene postavke proxy poslužitelja. Ako odaberete da se proxy poslužitelj nikad ne upotrebljava i da se veza uvijek uspostavlja izravno, sve se ostale opcije zanemaruju. Ako odaberete automatsko otkrivanje proxy poslužitelja, sve se ostale opcije zanemaruju. Za podrobne primjere posjetite: <ph name="PROXY_HELP_URL"/> Ako omogućite ovu postavku, <ph name="PRODUCT_NAME"/> zanemaruje sve opcije u vezi s proxy poslužiteljem određene naredbenim retkom. Ako ova pravila nisu postavljena, korisnici će moći sami odabrati postavke proxy poslužitelja.</translation>
<translation id="681446116407619279">Podržane sheme autentifikacije</translation>
<translation id="4027608872760987929">Omogući zadanog davatelja usluge pretraživanja</translation>
<translation id="2223598546285729819">Zadana postavka obavijesti</translation>
<translation id="6158324314836466367">Naziv web-trgovine tvrtke (obustavljeno)</translation>
<translation id="3984028218719007910">Određuje hoće li sustav <ph name="PRODUCT_OS_NAME"/> zadržati lokalne podatke računa nakon odjave. Ako je to pravilo postavljeno na &quot;istinito&quot;, sustav <ph name="PRODUCT_OS_NAME"/> ne zadržava trajne račune i svi podaci s korisnikove sesije bit će odbačeni nakon odjave. Ako je to pravilo postavljeno na &quot;lažno&quot; ili ako nije konfigurirano, uređaj će možda zadržavati (kriptirane) lokalne korisničke podatke.</translation>
<translation id="3793095274466276777">Konfigurira zadane provjere preglednika u proizvodu <ph name="PRODUCT_NAME"/> i sprječava korisnike da ih promijene. Ako omogućite ovu postavku, <ph name="PRODUCT_NAME"/> će prilikom svakog pokretanja provjeriti je li zadani preglednik i automatski se registrirati ako je moguće. Ako je ova postavka onemogućena, <ph name="PRODUCT_NAME"/> neće nikad provjeravati je li zadani preglednik i onemogućit će korisničke kontrole za postavljanje ove opcije. Ako ova postavka nije podešena, korisnik će moći odrediti je li <ph name="PRODUCT_NAME"/> zadani preglednik i trebaju li korisničke obavijesti biti prikazane kada to nije slučaj.</translation>
<translation id="3504791027627803580">Određuje URL tražilice koja se upotrebljava za pretraživanje slika. Zahtjevi za pretraživanje slat će se pomoću GET metode. Ako je postavljeno pravilo &quot;DefaultSearchProviderImageURLPostParams&quot;, zahtjevi za pretraživanje slika umjesto toga upotrebljavat će POST metodu.

          To je pravilo izborno. Ako nije postavljeno, neće se upotrijebiti nijedna slika.

          To se pravilo poštuje samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="7529100000224450960">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije kojima je dopušteno otvaranje skočnih prozora. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultPopupsSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="6155936611791017817">Postavljanje zadanog stanja velikog pokazivača na zaslonu za prijavu</translation>
<translation id="1530812829012954197">Uvijek prikaži sljedeće URL obrasce u pregledniku hosta</translation>
<translation id="9026000212339701596">Rječnik koji mapira nazive hostova na Booleovu oznaku koja određuje hoće li pristup hostu biti dopušten (točno) ili blokiran (netočno).

          To je pravilo za Chromeovu internu upotrebu.</translation>
<translation id="913195841488580904">Blokiranje pristupa popisu URL-ova</translation>
<translation id="3292147213643666827">Omogućuje da se proizvod <ph name="PRODUCT_NAME"/> ponaša kao proxy između pisača iz oblaka <ph name="CLOUD_PRINT_NAME"/> i pisača iz starog sustava povezanih s računalom. Ako je ova postavka onemogućena ili nije konfigurirana, korisnici mogu omogućiti proxy ispisivanja na oblaku autentifikacijom putem svojih Google računa. Ako je ova postavka onemogućena, korisnici ne mogu omogućiti proxy, a računalu neće biti dopušteno dijeljenje pisača s oblakom <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="6373222873250380826">Onemogućuje automatska ažuriranja kada je postavljeno na &quot;istinito&quot;.

      Uređaji sa sustavom <ph name="PRODUCT_OS_NAME"/> automatski traže ažuriranja kada ta postavka nije konfigurirana ili kada je postavljena na &quot;lažno&quot;.</translation>
<translation id="6190022522129724693">Zadana postavka skočnih prozora</translation>
<translation id="847472800012384958">Ne dopusti web-lokacijama prikazivanje skočnih prozora</translation>
<translation id="4733471537137819387">Pravila koja se odnose na integriranu HTTP autentifikaciju.</translation>
<translation id="8951350807133946005">Postavi direktorij predmemorije na disku</translation>
<translation id="603410445099326293">Parametri URL-a za prijedloge koji upotrebljava POST</translation>
<translation id="2592091433672667839">Trajanje neaktivnosti prije nego što se čuvar zaslona prikaže na zaslonu prijave u prodajnom načinu</translation>
<translation id="166427968280387991">Proxy poslužitelj</translation>
<translation id="2805707493867224476">Dopusti svim web-lokacijama prikazivanje skočnih prozora</translation>
<translation id="1727394138581151779">Blokiraj sve dodatke</translation>
<translation id="8118665053362250806">Postavi veličinu predmemorije medijskog diska</translation>
<translation id="7079519252486108041">Blokiraj skočne prozore na ovim web-lokacijama</translation>
<translation id="1859633270756049523">Ograničava duljinu sesije</translation>
<translation id="7433714841194914373">Omogući Instant</translation>
<translation id="4983201894483989687">Dopusti pokretanje dodataka koji su zastarjeli</translation>
<translation id="443665821428652897">Izbriši podatke o web-lokacijama prilikom isključivanja preglednika (obustavljeno)</translation>
<translation id="3823029528410252878">Onemogućuje spremanje povijesti preglednika u proizvodu <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene ovu postavku. Ako je ova postavka omogućena, povijest pregledavanja ne sprema se. Ako je ova postavka onemogućena ili nije postavljena, povijest pregledavanja sprema se.</translation>
<translation id="3844092002200215574">Konfigurira direktorij koji će usluga <ph name="PRODUCT_NAME"/> upotrebljavati za pohranjivanje datoteka iz predmemorije na disk.

      Ako postavite to pravilo, usluga <ph name="PRODUCT_NAME"/> upotrijebit će navedeni direktorij bez obzira je li korisnik naveo oznaku '--user-data-dir' ili ne.

      Popis varijabli koje je moguće upotrijebiti potražite na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Ako ovo pravilo nije postavljeno, upotrebljava se zadani direktorij predmemorije i korisnik će ga moći nadjačati oznakom naredbenog retka '--disk-cache-dir'.</translation>
<translation id="3034580675120919256">Omogućuje da postavite smiju li web-lokacije pokretati JavaScript. Pokretanje JavaScripta može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije. Ako ovo pravilo nije postavljeno, upotrebljavat će se pravilo &quot;AllowJavaScript&quot;, a korisnik će to moći promijeniti.</translation>
<translation id="193900697589383153">Dodaje gumb odjave na programskoj traci.

      Ako je omogućeno, na programskoj traci prikazuje se veliki, crveni gumb za odjavu dok je sesija aktivna, a zaslon nije zaključan.

      Ako je onemogućeno ili nije navedeno, na programskoj traci ne prikazuje se veliki crveni gumb za odjavu.</translation>
<translation id="5111573778467334951">Određuje radnju koja se treba poduzeti kada se dosegne odgoda zbog neaktivnosti dok računalo pokreće baterija.

          Kada je to pravilo postavljeno, ono određuje radnju koju <ph name="PRODUCT_OS_NAME"/> poduzima kada je korisnik neaktivan onoliko vremena koliko je navedeno u odgodi zbog neaktivnosti koja se može zasebno konfigurirati.

          Kada to pravilo nije postavljeno, poduzima se zadana radnja, a to je obustava.

          Ako je radnja obustava, <ph name="PRODUCT_OS_NAME"/> je moguće zasebno konfigurirati tako da zaključava ili ne zaključava zaslon prije obustavljanja.</translation>
<translation id="3195451902035818945">Određuje hoće li se omogućiti dijeljenje zapisa SSL-a. Dijeljenje zapisa rješavanje je slabosti za SSL 3.0 i TLS 1.0, ali može uzrokovati probleme s kompatibilnošću s nekim HTTPS poslužitelja i proxijima. Ako pravilo nije postavljeno ili je postavljeno na &quot;false&quot; (lažno), znači da će se dijeljenje zapisa upotrebljavati na vezama SSL/TLS koje upotrebljavaju CBC paket šifri.</translation>
<translation id="6903814433019432303">To je pravilo aktivno samo u prodajnom načinu.

      Određuje set URL-ova za učitavanje kada se pokrene demonstracijska sesija. To će pravilo premostiti sve druge mehanizme za postavljanje početnog URL-a, pa se može primijeniti samo na sesiju koja nije povezana s određenim korisnikom.</translation>
<translation id="5868414965372171132">Mrežna konfiguracija na razini korisnika</translation>
<translation id="8519264904050090490">URL-ovi ručnih iznimaka upravljanih korisnika</translation>
<translation id="4480694116501920047">Nametni Sigurno pretraživanje</translation>
<translation id="465099050592230505">URL web-trgovine tvrtke (obustavljeno)</translation>
<translation id="1221359380862872747">Učitaj navedene URL-ove pri demonstracijskoj prijavi</translation>
<translation id="2431811512983100641">Određuje treba li omogućiti proširenje TLS certifikata vezanih uz domenu. Ta postavka upotrebljava se za omogućivanje proširenja TLS certifikata vezanih uz domenu radi testiranja. Ta eksperimentalna postavka u budućnosti će biti uklonjena.</translation>
<translation id="8711086062295757690">Određuje ključnu riječ koja je prečac u višenamjenskom okviru za pokretanje usluge pretraživanja ovog davatelja usluga. Ovo je pravilo izborno. Ako nije postavljeno, nijedna ključna riječ neće aktivirati davatelja usluga pretraživanja. Ovo se pravilo uzima u obzir samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="5774856474228476867">URL zadanog davatelja usluge pretraživanja</translation>
<translation id="4650759511838826572">Onemogući sheme URL protokola</translation>
<translation id="7831595031698917016">Određuje maksimalnu odgodu u milisekundama od primitka poništenja valjanosti pravila do dohvaćanja novog pravila s usluge upravljanja uređajem.

      Postavljanjem tog pravila poništava se zadana vrijednost od 5000 milisekundi. Važeće vrijednosti za to pravilo u rasponu su od 1000 (1 sekunde) do 300000 (5 minuta). Sve vrijednosti koje nisu u tom rasponu bit će prilagođene odgovarajućoj granici.

      Ako se to pravilo ne postavi, <ph name="PRODUCT_NAME"/> upotrebljavat će zadanu vrijednost od 5000 milisekundi.</translation>
<translation id="8099880303030573137">Odgoda neaktivnosti za vrijeme baterijskog napajanja</translation>
<translation id="2761483219396643566">Odgoda upozorenja o neaktivnosti dok uređaj nije priključen na struju</translation>
<translation id="1468307069016535757">Postavi zadano stanje značajke pristupačnosti načina visokog kontrasta na zaslonu za prijavu.

          Ako se to pravilo postavi na točno, način visokog kontrasta bit će omogućen dok se prikazuje zaslon za prijavu.

          Ako se to pravilo postavi na netočno, način visokog kontrasta bit će onemogućen dok se prikazuje zaslon za prijavu.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući način visokog kontrasta. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, način visokog kontrasta onemogućen je pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti način visokog kontrasta u bilo kojem trenutku, a njegov status na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="8580857153747395000">Upozori kada se posjećuju web-lokacije izvan paketa sadržaja.</translation>
<translation id="350796261613621561">Omogući izradu nadziranih korisnika.</translation>
<translation id="602728333950205286">Instant URL zadanog davatelja usluge pretraživanja</translation>
<translation id="3030000825273123558">Omogući izvješće o metrici</translation>
<translation id="8465065632133292531">Parametri za URL usluge Instant koji upotrebljava POST</translation>
<translation id="6559057113164934677">Ne dopuštaj nijednoj web-lokaciji pristupanje kameri i mikrofonu</translation>
<translation id="7273823081800296768">Ako je ta postavka omogućena ili nije konfigurirana, tada korisnici mogu odabrati hoće li upariti klijente i hostove u trenutku povezivanja tako da ne moraju svaki put unositi PIN.

          Ako je ta postavka onemogućena, ta značajka neće biti dostupna.</translation>
<translation id="1675002386741412210">Podržano na:</translation>
<translation id="3547954654003013442">Proxy postavke</translation>
<translation id="4482640907922304445">Pokazuje gumb Početna na alatnoj traci proizvoda <ph name="PRODUCT_NAME"/>. Ako omogućite ovu postavku, gumb Početna prikazivat će se uvijek. Ako onemogućite ovu postavku, gumb Početna neće se nikad prikazivati. Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti ni poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME"/>. Ako ovo pravilo nije postavljeno, korisnik će moći odabrati želi li da se prikazuje gumb Početna.</translation>
<translation id="6897718480289510689">Dopusti pristup web-lokacijama izvan paketa sadržaja.</translation>
<translation id="2518231489509538392">Dopusti reprodukciju zvuka</translation>
<translation id="7301543427086558500">Navodi popis zamjenskih URL-ova koji se mogu upotrijebiti za izvlačenje pojmova pretraživanja iz tražilice. URL-ovi trebaju sadržavati niz <ph name="SEARCH_TERM_MARKER"/>, koji će se upotrijebiti za izvlačenje pojmova pretraživanja.

          Ovo pravilo nije obavezno. Ako nije postavljeno, za izvlačenje pojmova pretraživanja neće se upotrebljavati zamjenski URL-ovi.

          Ovo se pravilo primjenjuje samo ako je omogućeno pravilo 'DefaultSearchProviderEnabled'.</translation>
<translation id="436581050240847513">Izvješća o mrežnim sučeljima uređaja</translation>
<translation id="6282799760374509080">Omogući ili onemogući snimanje zvuka</translation>
<translation id="8864975621965365890">Zaustavlja upit za odbijanje koji se pojavljuje kada web-lokaciju generira <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Kodiranja zadanog davatelja usluge pretraživanja</translation>
<translation id="285480231336205327">Omogućavanje načina visokog kontrasta</translation>
<translation id="5366977351895725771">Ako je postavljeno na netočno, korisnik neće moći izrađivati nadzirane korisnike. Postojeći nadzirani korisnici i dalje će biti dostupni.

          Ako je postavljeno na točno ili nije konfigurirano, korisnik može izrađivati nadzirane korisnike i upravljati njima.</translation>
<translation id="8101760444435022591">Budući da &quot;soft-fail&quot;, mrežne provjere opoziva ne pružaju učinkovitu zaštitu sigurnosti, onemogućuju se prema zadanim postavkama na usluzi <ph name="PRODUCT_NAME"/> verzije 19 i novijih verzija. Postavljanjem tog pravila na vrijednost &quot;istinito&quot;, prethodno se ponašanje vraća i mrežne provjere OCSP/CRL bit će izvršene.

      Ako to pravilo nije postavljeno ili je postavljeno na vrijednost &quot;lažno&quot;, Chrome neće vršiti mrežne provjere opoziva u Chromeu 19 i novijim verzijama.</translation>
<translation id="5469484020713359236">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju postavljati kolačiće. Ako se ovo pravilo ne postavi, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultCookiesSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="1504431521196476721">Daljinsko atestiranje</translation>
<translation id="1881299719020653447">Skrivanje web-trgovine s web-stranice nove kartice i iz pokretača aplikacija</translation>
<translation id="930930237275114205">Postavi direktorij korisničkih podataka za pravilo <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="244317009688098048">Omogućuje tipkovni prečac za izbjegavanje automatske prijave.

      Ako to pravilo nije postavljeno ili ako je postavljeno na točno, a račun na uređaju konfiguriran je za automatsku prijavu bez odgode, proizvod <ph name="PRODUCT_OS_NAME"/> primjenjivat će tipkovni prečac Ctrl + Alt + S za izbjegavanje automatske prijave i prikazivanje zaslona za prijavu.

      Ako je to pravilo postavljeno na netočno, automatska prijava bez odgode (ako je konfigurirana) ne može se izbjeći.</translation>
<translation id="5208240613060747912">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju prikazivati obavijesti. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultNotificationsSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="7927140259706020912">URL-ovi koji će dobiti pristup uređajima za snimanje zvuka bez postavljanja upita.</translation>
<translation id="4600786265870346112">Omogućivanje velikog pokazivača</translation>
<translation id="8592105098257899882">Konfigurira veličinu predmemorije koju će <ph name="PRODUCT_NAME"/> upotrebljavati za pohranu predmemoriranih datoteka na disku. Ako postavite ovo pravilo, proizvod <ph name="PRODUCT_NAME"/> upotrebljavat će navedenu veličinu predmemorije neovisno o tome je li korisnik odredio oznaku &quot;--disk-cache-size&quot;. Ako je vrijednost pravila 0, upotrebljavat će se zadana veličina predmemorije, ali korisnik ju neće moći promijeniti. Ako ovo pravilo nije postavljeno, upotrebljavat će se zadana veličina, a korisnik će ju moći poništiti oznakom &quot;--disk-cache-size&quot;.</translation>
<translation id="5887414688706570295">Konfigurira prefiks za TalkGadget koji će upotrebljavati hostovi daljinskog pristupa i sprječava korisnike da ga mijenjaju.

          Ako je naveden, taj se prefiks stavlja ispred temeljnog naziva za TalkGadget kako bi nastao puni naziv domene za TalkGadget. Temeljni je naziv domene za TalkGadget &quot;.talkgadget.google.com&quot;.

          Ako je ta postavka omogućena, hostovi će upotrebljavati prilagođeni naziv domene kada pristupaju TalkGadgetu umjesto zadanog naziva domene.

          Ako je ta postavka onemogućena ili ako nije postavljena, zadani naziv domene TalkGadget (&quot;chromoting-host.talkgadget.google.com&quot;) upotrebljavat će se za sve hostove.

          Ta postavka pravila ne utječe na klijente daljinskog pristupa. Oni će uvijek upotrebljavati &quot;chromoting-client.talkgadget.google.com&quot; za pristup TalkGadgetu.</translation>
<translation id="5765780083710877561">Opis:</translation>
<translation id="6915442654606973733">Omogući značajku pristupačnosti izgovaranja povratnih informacija.

          Ako se to pravilo postavi na točno, izgovaranje povratnih informacija uvijek će biti omogućeno.

          Ako se to pravilo postavi na netočno, izgovaranje povratnih informacija uvijek će biti onemogućeno.

          Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

          Ako se to pravilo ne postavi, izgovaranje povratnih informacija u početku je onemogućeno, ali korisnik ga može omogućiti u bilo kojem trenutku.</translation>
<translation id="7796141075993499320">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje smiju pokretati dodatke. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultPluginsSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="3809527282695568696">Ako za radnju pri pokretanju odaberete &quot;Otvaranje popisa URL-ova&quot;, moći ćete odrediti popis URL-ova koji se otvaraju. Ako nije postavljeno, nijedan se URL neće otvarati prilikom pokretanja. To pravilo vrijedi samo ako je pravilo &quot;RestoreOnStartup&quot; postavljeno na &quot;RestoreOnStartupIsURLs&quot;.</translation>
<translation id="649418342108050703">Onemogući podršku za API-je 3D grafike. Omogućivanje ove postavke sprječava web-stranice da pristupe grafičkom procesoru (GPU). Točnije, web-stranice ne mogu pristupiti WebGL API-ju, a dodaci ne mogu upotrebljavati Pepper 3D API. Onemogućivanje ove postavke potencijalno dopušta web-stranicama upotrebu WebGL API-ja, a dodacima upotrebu Pepper 3D API-ja. Zadane postavke preglednika mogu svejedno zahtijevati prosljeđivanje argumenata naredbenog retka radi upotrebe ovih API-ja.</translation>
<translation id="2077273864382355561">Odgoda isključivanja zaslona za vrijeme baterijskog napajanja</translation>
<translation id="909184783177222836">Upravljanje napajanjem</translation>
<translation id="3417418267404583991">Ako je to pravilo postavljeno na &quot;istinito&quot; ili ako nije konfigurirano, sustav <ph name="PRODUCT_OS_NAME"/> omogućit će prijave gostiju. Prijave gostiju predstavljaju sesije anonimnih korisnika i zaporka nije potrebna.

      Ako je to pravilo postavljeno na &quot;lažno&quot;, sustav <ph name="PRODUCT_OS_NAME"/> neće dopustiti pokretanje gostujućih sesija.</translation>
<translation id="8329984337216493753">To je pravilo aktivno samo u prodajnom načinu.

      Kada je pravilo &quot;DeviceIdleLogoutTimeout&quot; navedeno, to pravilo određuje trajanje okvira za upozorenje s odbrojavanjem koji se prikazuje korisniku prije nego što se izvrši odjava.

      Vrijednost pravila trebala bi biti navedena u milisekundama.</translation>
<translation id="237494535617297575">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju prikazivati obavijesti. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultNotificationsSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="7258823566580374486">Omogući skrivanje hosta za daljinski pristup</translation>
<translation id="5560039246134246593">Dodavanje parametra dohvaćanju vrijednosti varijacija u proizvodu <ph name="PRODUCT_NAME"/>.

      Ako je naveden, parametar upita pod nazivom &quot;restrict&quot; dodat će se URL-u za dohvaćanje vrijednosti varijacija. Vrijednost parametra bit će vrijednost navedena u ovom pravilu.

      Ako nije naveden, URL vrijednosti varijacija neće se izmijeniti.</translation>
<translation id="944817693306670849">Postavi veličinu predmemorije diska</translation>
<translation id="8544375438507658205">Zadani alat za prikazivanje HTML-a za <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Određuje razdoblje u milisekundama u kojem se usluzi upravljanja uređajem postavlja upit za informacije o korisničkim pravilima.

      Postavljanjem tog pravila premošćuje se zadana vrijednost od 3 sata. Važeće vrijednosti za to pravilo sežu od 1800000 (30 minuta) do 86400000 (1 dan). Sve vrijednosti koje nisu u tom rasponu bit će uklopljene u odgovarajuće granice.

      Ako se to pravilo ne postavi, usluga <ph name="PRODUCT_NAME"/> upotrebljavat će zadanu vrijednost od 3 sata.</translation>
<translation id="7424751532654212117">Popis iznimki popisa onemogućenih dodataka</translation>
<translation id="6233173491898450179">Postavi imenik za preuzimanje</translation>
<translation id="78524144210416006">Konfigurirajte upravljanje energijom na zaslonu za prijavu u sustavu <ph name="PRODUCT_OS_NAME"/>.

      Tim pravilom možete konfigurirati kako će se <ph name="PRODUCT_OS_NAME"/> ponašati kada korisnik određeno vrijeme nije aktivan dok se prikazuje zaslon za prijavu. Pravilo upravlja višestrukim postavkama. Za njihovu pojedinačnu semantiku i raspone vrijednosti pogledajte odgovarajuća pravila koja kontroliraju upravljanje energijom u okviru sesije. Jedina odstupanja od tih pravila:
      *Radnje koje se poduzimaju za vrijeme neaktivnosti ili pri zatvaranju poklopca ne mogu biti završavanje sesije.
      *Zadana radnja koja se poduzima za vrijeme neaktivnosti dok je računalo priključeno na struju jest isključivanje.

      Pravilo se treba navesti kao niz koji izražava pojedinačnu postavku u JSON formatu u skladu sa sljedećom shemom:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;AC&quot;: {
            &quot;description&quot;: &quot;Postavke upravljanja energijom koje se primjenjuju samo kada je računalo priključeno na struju&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Duljina vremena bez korisničkog unosa nakon kojeg se zaslon zatamnjuje, u milisekundama&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Duljina vremena bez korisničkog unosa nakon kojeg se zaslon isključuje, u milisekundama&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Duljina vremena bez korisničkog unosa nakon kojeg se poduzima radnja zbog neaktivnosti, u milisekundama&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Radnja koja se poduzima kada se dosegne odgoda zbog neaktivnosti&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;Battery&quot;: {
            &quot;description&quot;: &quot;Postavke upravljanja energijom koje se primjenjuju samo dok računalo pokreće baterija&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Duljina vremena bez korisničkog unosa nakon kojeg se zaslon zatamnjuje, u milisekundama&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Duljina vremena bez korisničkog unosa nakon kojeg se zaslon isključuje, u milisekundama&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Duljina vremena bez korisničkog unosa nakon kojeg se poduzima radnja zbog neaktivnosti, u milisekundama&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Radnja koja se poduzima kada se dosegne odgoda zbog neaktivnosti&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;LidCloseAction&quot;: {
            &quot;description&quot;: &quot;Radnja koja se poduzima kada je poklopac zatvoren&quot;,
            &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
          },
          &quot;UserActivityScreenDimDelayScale&quot;: {
            &quot;description&quot;: &quot;Postotak skaliranja odgode zatamnjenja zaslona kada se promatra korisnička aktivnost dok je zaslon zatamnjen ili netom po isključivanju zaslona&quot;,
            &quot;type&quot;: &quot;integer&quot;,
            &quot;minimum&quot;: 100
          }
        }
      }

      Ako postavka nije određena, upotrebljavat će se zadana vrijednost.

      Ako to pravilo nije postavljeno, za sve će se postavke upotrebljavati zadane vrijednosti.</translation>
<translation id="8908294717014659003">Omogućuje vam da postavite hoće li web-lokacijama biti dopušten pristup medijskim uređajima za snimanje. Pristup medijskim uređajima za snimanje može biti dopušten prema zadanim postavkama ili se korisniku može postaviti pitanje svaki put kada web-lokacija želi pristupiti tim uređajima.

          Ako se to pravilo ne postavi, upotrijebit će se &quot;PromptOnAccess&quot; i korisnik će ga moći promijeniti.</translation>
<translation id="2299220924812062390">Odredi popis omogućenih dodataka</translation>
<translation id="4325690621216251241">Dodaj gumb za odjavu na programsku traku</translation>
<translation id="924557436754151212">Uvoz spremljenih zaporki iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="1465619815762735808">Kliknite za reprodukciju</translation>
<translation id="7227967227357489766">Definira popis korisnika kojima je dopuštena prijava na uređaj. Unosi su u obliku <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, na primjer, <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Da bi slučajnim korisnicima bio dopušten pristup domeni, upotrijebite unose u obliku <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Ako se to pravilo ne konfigurira, nema ograničenja za prijavu korisnika. Napominjemo da stvaranje novih korisnika još uvijek zahtijeva odgovarajuću konfiguraciju pravila <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>.</translation>
<translation id="8135937294926049787">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon isključio tijekom napajanja izmjeničnom strujom.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> isključi zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME"/> ne isključuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti ili jednako tom vremenu.</translation>
<translation id="1897365952389968758">Dopusti svim web-lokacijama izvođenje JavaScripta</translation>
<translation id="5244714491205147861">Upravljanje energijom na zaslonu za prijavu</translation>
<translation id="922540222991413931">Konfiguracija izvora instalacija proširenja, aplikacija i korisničkih skripti</translation>
<translation id="7323896582714668701">Dodatni parametri naredbenog retka za uslugu <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Onemogući sinkronizaciju podataka s Googleom</translation>
<translation id="7006788746334555276">Postavke sadržaja</translation>
<translation id="5142301680741828703">Uvijek prikaži sljedeće URL obrasce u okviru <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="4625915093043961294">Konfiguriraj bijelu listu instalacije proširenja</translation>
<translation id="187819629719252111">Omogućuje pristup lokalnim datotekama na računalu tako da dopušta proizvodu <ph name="PRODUCT_NAME"/> prikaz dijaloških okvira za odabir datoteka. Ako omogućite ovu postavku, korisnici mogu otvarati dijaloške okvire za odabir datoteka kao i obično. Ako onemogućite ovu postavku, svaki put kad korisnik napravi neku radnju koja bi dovela do otvaranja dijaloškog okvira za odabir datoteka (poput uvoza knjižnih oznaka, prijenosa datoteka, spremanja veza itd.) umjesto dijaloškog okvira prikazat će se poruka, a za korisnika će se pretpostaviti da je kliknuo &quot;Odustani&quot; u dijaloškom okviru za odabir datoteka. Ako ova postavka nije postavljena, korisnici mogu otvarati dijaloške okvire za odabir datoteka kao i obično.</translation>
<translation id="4507081891926866240">Prilagođava popis uzoraka URL-ova koje bi <ph name="PRODUCT_FRAME_NAME"/> uvijek trebao prikazivati. Ako ovo pravilo nije postavljeno, zadani prikazivač upotrebljavat će se za sve web-lokacije kako je određeno pravilom &quot;ChromeFrameRendererSettings&quot;. Primjere uzoraka pogledajte na http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Odaberi način određivanja postavki proxy poslužitelja</translation>
<translation id="1803646570632580723">Popis prikvačenih aplikacija za prikazivanje u pokretaču</translation>
<translation id="7774768074957326919">Upotrijebi proxy postavke sustava</translation>
<translation id="3891357445869647828">Omogući JavaScript</translation>
<translation id="868187325500643455">Dopusti svim web-lokacijama pokretanje dodataka</translation>
<translation id="7421483919690710988">Postavite veličinu predmemorije medijskog diska u bajtovima</translation>
<translation id="5226033722357981948">Odredi treba li onemogućiti alat za traženje dodataka</translation>
<translation id="4890209226533226410">Postavi vrstu povećala koje je omogućeno.

          Ako se to pravilo postavi, ono upravlja vrstom povećala koje je omogućeno. Postavljanjem tog pravila na opciju &quot;Ništa&quot; povećalo se onemogućuje.

          Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

          Ako se to pravilo ne postavi, povećalo je u početku onemogućeno, ali korisnik ga može omogućiti u bilo kojem trenutku.</translation>
<translation id="3428247105888806363">Omogućavanje predviđanja mreže</translation>
<translation id="6145799962557135888">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju pokretati JavaScript. Ako to pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultJavaScriptSetting&quot;, ako je postavljeno, odnosno iz osobne konfiguracije korisnika, ako nije.</translation>
<translation id="2757054304033424106">Vrste proširenja/aplikacija koje se smiju instalirati</translation>
<translation id="7053678646221257043">Ako je omogućeno, ovo pravilo prisilno uvozi knjižne oznake iz trenutačno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, nijedna knjižna oznaka neće biti uvezena. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti oznake ili do uvoza može doći automatski.</translation>
<translation id="5757829681942414015">Konfigurira direktorij koji će usluga <ph name="PRODUCT_NAME"/> upotrebljavati za pohranjivanje korisničkih podataka.

      Ako postavite to pravilo, usluga <ph name="PRODUCT_NAME"/> upotrijebit će navedeni direktorij bez obzira je korisnik naveo oznaku '--user-data-dir' ili ne.

      Popis varijabli koje je moguće upotrijebiti potražite na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Ako ovo pravilo nije postavljeno, upotrebljava se zadana putanja profila i korisnik će je morati nadjačati s oznakom naredbenog retka '--user-data-dir'.</translation>
<translation id="5067143124345820993">Popis korisnika kojima je dopuštena prijava</translation>
<translation id="2514328368635166290">Određuje URL ikone favorita zadanog davatelja usluga pretraživanja. Ovo je pravilo izborno. Ako nije postavljeno, za davatelja usluga pretraživanja neće biti prikazana nijedna ikona. Ovo se pravilo poštuje samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="7194407337890404814">Naziv zadanog davatelja usluge pretraživanja</translation>
<translation id="1843117931376765605">Brzina osvježavanja za korisničko pravilo</translation>
<translation id="5535973522252703021">Bijela lista Kerberos poslužitelja za ovlašćivanje</translation>
<translation id="4578030379102330182">Omogući daljinsko atestiranje za korisnika.</translation>
<translation id="9187743794267626640">Onemogući priključivanje vanjske pohrane</translation>
<translation id="6353901068939575220">Određuje parametre koji se upotrebljavaju prilikom pretraživanja URL-ova pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {searchTerms} u gornjem primjeru, zamijenit će se podacima stvarnih pojmova za pretraživanje.

          To je pravilo izborno. Ako nije postavljeno, poslat će se zahtjev za pretraživanje pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="5307432759655324440">Dostupnost anonimnog načina rada</translation>
<translation id="4056910949759281379">Onemogući SPDY protokol</translation>
<translation id="3808945828600697669">Odredi popis onemogućenih dodataka</translation>
<translation id="4525521128313814366">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju prikazivati slike. Ako se ovo pravilo ne postavi, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultImagesSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="8499172469244085141">Zadane postavke (korisnici ih mogu prebrisati)</translation>
<translation id="8693243869659262736">Upotreba ugrađenog DNS klijenta</translation>
<translation id="3072847235228302527">Postavi Uvjete pružanja usluge za lokalni račun na uređaju</translation>
<translation id="5523812257194833591">Automatska prijava u javnu sesiju nakon odgode.

      Ako je ovo pravilo postavljeno, automatski će se prijavljivati u navedenu sesiju nakon isteka vremenskog razdoblja bez interakcije korisnika na zaslonu za prijavu. Javna sesija mora biti već konfigurirana (pogledajte |DeviceLocalAccounts|).

      Ako ovo pravilo nije postavljeno, neće biti automatske prijave.</translation>
<translation id="5983708779415553259">Zadano ponašanje za web-lokacije koje nisu ni u jednom paketu sadržaja</translation>
<translation id="3866530186104388232">Ako je to pravilo postavljeno na &quot;istinito&quot; ili ako nije konfigurirano, sustav <ph name="PRODUCT_OS_NAME"/> prikazat će postojeće korisnike na zaslonu prijave i dopustiti biranje jednog korisnika. Ako je to pravilo postavljeno na &quot;lažno&quot;, sustav <ph name="PRODUCT_OS_NAME"/> upotrebljavat će korisničko ime i zaporku za prijavu.</translation>
<translation id="2098658257603918882">Omogući izvješćivanje o upotrebi i podatke o rušenjima programa</translation>
<translation id="2324547593752594014">Dopuštanje prijave u Chrome</translation>
<translation id="172374442286684480">Dopusti svim web-lokacijama postavljanje lokalnih podataka</translation>
<translation id="1151353063931113432">Dopusti slike na ovim web-lokacijama</translation>
<translation id="1297182715641689552">Upotrijebi .pac proxy skriptu</translation>
<translation id="2976002782221275500">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zatamnio tijekom rada s baterijskim napajanjem.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> zatamni zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME"/> ne zatamnjuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode isključivanja zaslona i odgode neaktivnosti ili jednako tom vremenu (ako je postavljeno).</translation>
<translation id="8631434304112909927">do verzije <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Omogući prijedloge pretraživanja</translation>
<translation id="4906194810004762807">Brzina osvježavanja za pravilo uređaja</translation>
<translation id="8922668182412426494">Poslužitelji koje proizvod <ph name="PRODUCT_NAME"/> može ovlastiti.

          Razdvojite više poslužitelja zarezima. Zamjenski su znakovi (*) dopušteni.

          Ako ne postavite ovo pravilo, Chrome neće dodijeliti vjerodajnice korisnika čak ni ako otkrije da je poslužitelj na intranetu.</translation>
<translation id="1398889361882383850">Omogućuje vam da postavite hoće li web-lokacijama biti dopušteno automatsko pokretanje dodataka. Automatsko pokretanje dodataka može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije.

          Klik za reprodukciju omogućuje pokretanje dodataka, ali korisnik ih mora kliknuti da bi se pokrenulo njihovo izvršenje.

          Ako ovo pravilo nije postavljeno, bit će upotrijebljeno pravilo &quot;Dopusti dodatke&quot;, a korisnik će ga moći promijeniti.</translation>
<translation id="7974114691960514888">Ovo pravilo više se ne podržava. Omogućuje upotrebu STUN i relejnih poslužitelja prilikom povezivanja s udaljenim klijentom. Ako je ova postavka omogućena, onda ovo računalo može otkriti udaljena računala hostove i povezati se s njima, čak i ako su odvojena vatrozidom. Ako je ova postavka onemogućena, a izlazne UDP veze filtrirane su vatrozidom, onda se ovo računalo može jedino povezati s računalima hostovima unutar lokalne mreže.</translation>
<translation id="7694807474048279351">Odredi vrijeme automatskog ponovnog pokretanja nakon primjene ažuriranja sustava <ph name="PRODUCT_OS_NAME"/>.

      Kada se to pravilo postavi na točno, određuje se vrijeme automatskog ponovnog pokretanja kada se primijeni ažuriranje sustava <ph name="PRODUCT_OS_NAME"/> za čije je dovršavanje potrebno ponovno pokretanje. Ponovno je pokretanje postavljeno na trenutak dovršavanja ažuriranja, ali može se odgoditi na uređaju do 24 sata ako korisnik trenutačno upotrebljava taj uređaj.

      Kada se to pravilo postavi na netočno, nakon primjene ažuriranja sustava <ph name="PRODUCT_OS_NAME"/> ne određuje se vrijeme automatskog ponovnog pokretanja. Postupak ažuriranja dovršava se kada korisnik sljedeći put ponovo pokrene uređaj.

      Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

      Napomena: trenutačno su automatska ponovna pokretanja omogućena samo dok se prikazuje zaslon za prijavu ili dok traje sesija aplikacije kioska. To će se u budućnosti promijeniti i pravilo će se primjenjivati uvijek, bez obzira na to je li neka određena vrsta sesije u tijeku ili nije.</translation>
<translation id="5511702823008968136">Omogući traku Knjižne oznake</translation>
<translation id="5105313908130842249">Odgoda zaključavanja zaslona za vrijeme baterijskog napajanja</translation>
<translation id="7882585827992171421">To je pravilo aktivno samo u prodajnom načinu.

      Određuje ID proširenja koje će se upotrebljavati kao čuvar zaslona na zaslonu prijave. To proširenje mora biti dijelom paketa AppPack koji se konfigurira za ovu domenu pravilom DeviceAppPack.</translation>
<translation id="7736666549200541892">Omogući proširenje TLS certifikata vezanih uz domenu</translation>
<translation id="1796466452925192872">Omogućuje vam da odredite URL-ove kojima je dopušteno instaliranje proširenja, aplikacija i tema.

          Počevši s preglednikom Chrome 21, instaliranje proširenja, aplikacija i korisničkih skripta iz izvora izvan okvira Chrome web-trgovine postalo je teže. Prije su korisnici mogli kliknuti vezu na *.crx datoteku i Chrome bi ponudio instaliranje datoteke nakon nekoliko upozorenja. Od Chromea 21 takve se datoteke moraju preuzeti i povući na stranicu postavki preglednika Chrome. Ta postavka određenim URL-ovima omogućuje stari, jednostavniji tijek instalacije.

          Svaka stavka na tom popisu podudarni je uzorak stila proširenja (pogledajte http://code.google.com/chrome/extensions/match_patterns.html). Korisnici će moći jednostavno instalirati stavke s bilo kojeg URL-a koji se podudara sa stavkom na tom popisu. Ti uzorci moraju dopustiti lokaciju *.crx datoteke kao i stranicu s koje se pokreće preuzimanje (tj. referalnu stranicu).

          Pravilo ExtensionInstallBlacklist ima prednost nad tim pravilom. To znači da proširenje na popisu zabranjenih proširenja neće biti instalirano čak ni ako dolazi s web-lokacije na tom popisu.</translation>
<translation id="2113068765175018713">Ograničavanje vremena rada uređaja automatskim ponovnim pokretanjem sustava</translation>
<translation id="7848840259379156480">Omogućuje konfiguriranje zadanog alata za prikazivanje HTML-a kad je <ph name="PRODUCT_FRAME_NAME"/> instaliran. Zadana postavka je dopuštanje pregledniku hosta da obavi prikazivanje, no ovu postavku možete zaobići i kao zadano postaviti <ph name="PRODUCT_FRAME_NAME"/> da prikazuje HTML stranice.</translation>
<translation id="186719019195685253">Radnja koja se poduzima kada se dosegne odgoda zbog neaktivnosti dok je računalo priključeno na struju</translation>
<translation id="7890264460280019664">Prijava popisa izvješća mrežnih sučelja s njihovim vrstama i adresama hardvera poslužitelju.

      Ako pravilo nije postavljeno ili je postavljeno kao neistinito, popis sučelja neće biti prijavljen.</translation>
<translation id="4121350739760194865">Sprječavanje prikaza promocija aplikacija na stranici Nova kartica</translation>
<translation id="2127599828444728326">Dopuštanje obavijesti na ovim web-lokacijama</translation>
<translation id="3973371701361892765">Nikada nemoj automatski sakriti policu</translation>
<translation id="7635471475589566552">Konfigurira oznaku zemlje/jezika aplikacije u proizvodu <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene oznaku zemlje/jezika. Ako omogućite ovu postavku, <ph name="PRODUCT_NAME"/> upotrebljavat će navedenu oznaku zemlje/jezika. Ako konfigurirana oznaka zemlje/jezika nije podržana, upotrebljavat će se &quot;en-US&quot;. Ako je ova postavka onemogućena ili nije postavljena, <ph name="PRODUCT_NAME"/> upotrebljavat će oznaku zemlje/jezika koju odredi korisnik (ako je konfigurirana), oznaku zemlje/jezika sustava ili standardnu oznaku zemlje/jezika &quot;en-US&quot;.</translation>
<translation id="2948087343485265211">Određuje hoće li zvučna aktivnost utjecati na upravljanje napajanjem.

          Ako je ovo pravilo postavljeno na istinito ili ako nije postavljeno, korisnik se ne smatra neaktivnim tijekom reprodukcije zvuka. Time se sprječava privremeni prekid neaktivnosti i izvršavanje radnje predviđene nakon isteka razdoblja neaktivnosti. Međutim, zatamnjivanje, isključivanje i zaključavanje zaslona izvršit će se nakon konfiguriranih privremenih prekida bez obzira na reprodukciju zvuka.

          Ako je pravilo postavljeno na lažno, korisnik se može smatrati neaktivnim bez obzira na zvučnu aktivnost.</translation>
<translation id="7842869978353666042">Konfiguracija opcije Google diska</translation>
<translation id="718956142899066210">Dopuštene vrste veza za ažuriranja</translation>
<translation id="1734716591049455502">Konfiguriraj opcije daljinskog pristupa</translation>
<translation id="7336878834592315572">Zadrži kolačiće za vrijeme trajanja sesije</translation>
<translation id="7715711044277116530">Postotak za skaliranje odgode zatamnjenja zaslona u načinu prezentacije</translation>
<translation id="8777120694819070607">Omogućuje da <ph name="PRODUCT_NAME"/> pokreće dodatke koji su zastarjeli. Ako omogućite ovu postavku, zastarjeli dodaci upotrebljavaju se kao uobičajeni dodaci. Ako onemogućite ovu postavku, zastarjeli dodaci neće se upotrebljavati i korisnici neće biti pitani za dozvolu za njihovo pokretanje. Ako ova postavka nije aktivirana, korisnici će biti pitani za dozvolu za pokretanje zastarjelih dodataka.</translation>
<translation id="2629448496147630947">Konfigurira opcije daljinskog pristupa za proizvod <ph name="PRODUCT_NAME"/>. Te se značajke zanemaruju osim u slučaju ako je instalirana web-aplikacija za daljinski pristup.</translation>
<translation id="1310699457130669094">Ovdje možete odrediti URL za .pac datoteku proxy poslužitelja. Ovo pravilo vrijedi samo ako ste odabrali ručne postavke proxy poslužitelja u stavci &quot;Odabir načina određivanja postavki proxy poslužitelja&quot;. Ne postavljajte ovo pravilo ako ste odabrali bilo koji drugi način postavljanja pravila za proxy poslužitelje. Za podrobne primjere posjetite: <ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">To se pravilo ne upotrebljava od verzije 29 sustava <ph name="PRODUCT_NAME"/>.</translation>
<translation id="5464816904705580310">Konfiguriranje postavki za upravljane korisnike.</translation>
<translation id="3219421230122020860">Dostupan je anoniman način rada</translation>
<translation id="7690740696284155549">Konfigurira direktorij koji će usluga <ph name="PRODUCT_NAME"/> upotrebljavati za preuzimanje datoteka.

      Ako postavite to pravilo, usluga <ph name="PRODUCT_NAME"/> upotrijebit će navedeni direktorij bez obzira je li ga korisnik naveo ili je potvrdio okvir za postavljanje upita o lokaciji prilikom svakog preuzimanja.

      Popis varijabli koje je moguće upotrijebiti potražite na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Ako ovo pravilo nije postavljeno, upotrebljava se zadani direktorij za preuzimanja i korisnik će ga moći promijeniti.</translation>
<translation id="7381326101471547614">Onemogućuje upotrebe protokola SPDY za uslugu <ph name="PRODUCT_NAME"/>. Ako se to pravilo omogućuje, protokol SPDY neće biti dostupan za uslugu <ph name="PRODUCT_NAME"/>. Onemogućavanjem ovog pravila dopustit će se upotreba protokola SPDY. Ako se to pravilo ne postavi, SPDY neće biti dostupan.</translation>
<translation id="2208976000652006649">Parametri za URL pretraživanja koji upotrebljava POST</translation>
<translation id="1583248206450240930">Upotrijebi <ph name="PRODUCT_FRAME_NAME"/> kao zadano</translation>
<translation id="1047128214168693844">Ne dopuštaj web-lokacijama praćenje fizičke lokacije korisnika</translation>
<translation id="4101778963403261403">Konfigurira vrstu zadane početne stranice u proizvodu <ph name="PRODUCT_NAME"/> i sprječava korisnike da promijene postavke početne stranice. Početna stranica može biti postavljena na URL koji odredite ili na stranicu Nova kartica. Ako omogućite ovu postavku, početna stranica uvijek će biti stranica Nova kartica, a lokacija URL-a početne stranice bit će zanemarena. Ako onemogućite ovu postavku, korisnička početna stranica nikad neće biti stranica Nova kartica, osim ako URL nije postavljen na &quot;chrome://newtab&quot;. Ako omogućite ili onemogućite ovu postavku, korisnici neće moći mijenjati vrstu početne stranice u proizvodu <ph name="PRODUCT_NAME"/>. Ako ovo pravilo nije postavljeno, korisnik će moći sam odabrati želi li postaviti stranicu Nova kartica za početnu stranicu.</translation>
<translation id="8970205333161758602">Zaustavljanje upita za odbijanje usluge <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="3273221114520206906">Zadana postavka JavaScripta</translation>
<translation id="4025586928523884733">Blokira kolačiće treće strane. Omogućavanjem ove postavke sprječavaju se elementi web-stranica koji ne pripadaju domeni prikazanoj u adresnoj traci preglednika da postavljaju kolačiće. Onemogućavanjem ove postavke dopušta se postavljanje kolačića elementima web-stranica koji ne pripadaju domeni prikazanoj u adresnoj traci preglednika te se sprječava da korisnici promijene tu postavku. Ako ovo pravilo nije postavljeno, kolačići treće strane bit će omogućeni, ali korisnici će to moći promijeniti.</translation>
<translation id="6810445994095397827">Blok JavaScript na ovim web-lokacijama</translation>
<translation id="6672934768721876104">Ovo je pravilo zastarjelo. Umjesto njega upotrijebite ProxyMode. Omogućuje određivanje proxy poslužitelja koji <ph name="PRODUCT_NAME"/> upotrebljava i sprječava korisnike da promijene postavke proxy poslužitelja. Ako odaberete da se proxy poslužitelj nikad ne upotrebljava i da se veza uvijek uspostavlja izravno, sve se ostale opcije zanemaruju. Ako odaberete upotrebu sistemskih postavki proxy poslužitelja ili automatsko otkrivanje proxy poslužitelja, sve se ostale opcije zanemaruju. Ako odaberete ručne postavke proxy poslužitelja, možete odrediti dodatne opcije pod &quot;Adresa ili URL proxy poslužitelja&quot;, &quot;URL prema .pac datoteci proxy poslužitelja&quot; i &quot;Popis pravila proxy zaobilaženja odvojenih zarezima&quot;. Za podrobne primjere posjetite <ph name="PROXY_HELP_URL"/>. Ako omogućite ovu postavku, <ph name="PRODUCT_NAME"/> će zanemariti sve opcije u vezi s proxy poslužiteljem određene naredbenim retkom. Ako ovo pravilo nije postavljeno, korisnici će moći sami odabrati postavke proxy poslužitelja.</translation>
<translation id="3780152581321609624">Uključi nestandardni port u Kerberos SPN-u</translation>
<translation id="1749815929501097806">Postavlja Uvjete pružanja usluge koje korisnik mora prihvatiti prije nego što započne sesiju lokalnog računa na uređaju.

      Ako je ovo pravilo postavljeno, <ph name="PRODUCT_OS_NAME"/> preuzima Uvjete pružanja usluge i prikazuje ih korisniku na početku svake sesije lokalnog računa na uređaju. Korisniku se sesija dopušta samo nakon što prihvati Uvjete pružanja usluge.

      Ako pravilo nije postavljeno, Uvjeti pružanja usluge ne prikazuju se.

      Pravilo treba biti postavljeno na URL s kojeg <ph name="PRODUCT_OS_NAME"/> može preuzeti Uvjete pružanja usluge. Uvjeti pružanja usluge moraju biti običan tekst, poslužen kao vrsta &quot;text/plain&quot; protokola MIME. Jezik za označavanje nije dopušten.</translation>
<translation id="2660846099862559570">Nikad ne upotrebljavaj proxy</translation>
<translation id="1435659902881071157">Mrežna konfiguracija na razini uređaja</translation>
<translation id="2131902621292742709">Odgoda zatamnjivanja zaslona za vrijeme baterijskog napajanja</translation>
<translation id="5781806558783210276">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se izvršila radnja neaktivnosti tijekom baterijskog napajanja.

          Kada je pravilo postavljeno, određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> pokrene radnju neaktivnosti, što se može konfigurirati zasebno.

          Kada pravilo nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama.</translation>
<translation id="5512418063782665071">URL početne stranice</translation>
<translation id="2948381198510798695"><ph name="PRODUCT_NAME"/> će zaobići sve proxy poslužitelje pomoću ovdje navedenog popisa hostova. Ovo pravilo vrijedit će samo ako ste odabrali ručne postavke proxy poslužitelja u stavci &quot;Odabir načina određivanja postavki proxy poslužitelja&quot;. Ne postavljajte ovo pravilo ako ste odabrali bilo koji drugi način postavljanja pravila za proxy poslužitelje. Za podrobne primjere posjetite: <ph name="PROXY_HELP_URL"/></translation>
<translation id="6658245400435704251">Određuje do koliko sekundi uređaj može nasumično odgađati preuzimanje ažuriranja od trenutka kad je ažuriranje prvi put poslano na poslužitelj. Uređaj može dio tog vremena čekati u smislu stvarnog proteka vremena, a preostalo vrijeme u smislu broja provjera ažuriranja. U bilo kojem slučaju, gornja granica raspršivanja konstantan je iznos vremena tako da uređaj nikad ne može zauvijek zapeti čekajući ažuriranje.</translation>
<translation id="523505283826916779">Postavke pristupačnosti</translation>
<translation id="1948757837129151165">Pravila za HTTP autentifikaciju</translation>
<translation id="5946082169633555022">Beta kanal</translation>
<translation id="7187256234726597551">Ako je točno, daljinsko atestiranje dopušteno je za uređaj i certifikat će se automatski generirati i prenijeti na poslužitelj za upravljanje uređajem.

          Ako se postavi na netočno ili se ne postavi, certifikat se neće generirati i pozivi API-ju proširenja enterprise.platformKeysPrivate neće uspjeti.</translation>
<translation id="5242696907817524533">Konfigurira popis upravljanih oznaka.

      Pravilo je popis oznaka i svaka je oznaka rječnik koji sadržava &quot;naziv&quot; oznake i ciljni &quot;URL&quot;.

      Te oznake nalaze se u mapi Upravljane oznake u Mobilnim oznakama. Te oznake ne može izmijeniti korisnik.

      Kada je to pravilo postavljeno, Upravljane oznake zadana su mapa koja se otvara kada se otvori prikaz oznaka u Chromeu.

      Upravljane oznake ne sinkroniziraju se s korisničkim računom.</translation>
<translation id="8303314579975657113">Određuje koja se GSSAPI knjižnica treba upotrebljavati za HTTP autentifikaciju. Možete postaviti samo naziv knjižnice ili cijelu putanju. Ako nijedna postavka nije navedena, <ph name="PRODUCT_NAME"/> upotrebljavat će zadani naziv knjižnice.</translation>
<translation id="7749402620209366169">Omogućuje autentifikaciju s dva čimbenika za hostove daljinskog pristupa umjesto PIN-a koji određuje korisnik.

          Ako je ta postavka omogućena, korisnici moraju unijeti važeći kôd s dva čimbenika kada pristupaju hostu.

          Ako je ta postavka onemogućena ili ako nije postavljena, autentifikacija s dva čimbenika neće biti omogućena i upotrebljavat će se zadani postupak s PIN-om koji određuje korisnik.</translation>
<translation id="7329842439428490522">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon isključio tijekom baterijskog napajanja.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> isključi zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME"/> ne isključuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti ili jednako tom vremenu.</translation>
<translation id="384743459174066962">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju otvarati skočne prozore. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila &quot;DefaultPopupsSetting&quot; ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="5645779841392247734">Dopusti kolačiće na ovim web-lokacijama</translation>
<translation id="4043912146394966243"> Vrste veza putem kojih su dopuštena ažuriranja OS-a. Ažuriranja OS-a potencijalno jako opterećuju vezu zbog svoje veličine i mogu uzrokovati dodatne troškove. Stoga prema zadanim postavkama nisu omogućena za vrste veza koje se smatraju skupima, što trenutačno uključuje WiMax, Bluetooth i mobilne veze.

      Prepoznati identifikatori vrste veze jesu &quot;ethernet&quot;, &quot;wifi&quot;, &quot;wimax&quot;, &quot;bluetooth&quot; i &quot;mobilna&quot;.</translation>
<translation id="6652197835259177259">Postavke lokalno upravljanih korisnika</translation>
<translation id="3243309373265599239">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zatamnio tijekom napajanja izmjeničnom strujom.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME"/> zatamni zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME"/> ne zatamnjuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode isključivanja zaslona i odgode neaktivnosti ili jednako tom vremenu (ako je postavljeno).</translation>
<translation id="3859780406608282662">Dodaje parametar dohvaćanju početne vrijednosti Varijacija u proizvodu <ph name="PRODUCT_OS_NAME"/>.

      Ako je navedeno, dodat će parametar upita zvan &quot;restrict&quot; URL-u koji se upotrebljava za dohvaćanje početne vrijednosti Varijacije. Vrijednost parametra bit će vrijednost navedena u tom pravilu.

      Ako nije navedeno, neće mijenjati URL početne vrijednosti Varijacija.</translation>
<translation id="7049373494483449255">Omogućuje proizvodu <ph name="PRODUCT_NAME"/> slanje dokumenata na uslugu <ph name="CLOUD_PRINT_NAME"/> za ispis. NAPOMENA: To se odnosi samo na podršku usluge <ph name="CLOUD_PRINT_NAME"/> u proizvodu <ph name="PRODUCT_NAME"/>. To ne sprječava korisnike da poslove ispisa šalju na web-lokacije. Ako je ova postavka omogućena ili nije konfigurirana, korisnici mogu ispisivati putem usluge <ph name="CLOUD_PRINT_NAME"/> iz dijaloškog okvira za ispis u proizvodu <ph name="PRODUCT_NAME"/>. Ako je ova postavka onemogućena, korisnici ne mogu ispisivati putem usluge <ph name="CLOUD_PRINT_NAME"/> iz dijaloškog okvira za ispis u proizvodu <ph name="PRODUCT_NAME"/></translation>
<translation id="4088589230932595924">Anoniman način rada prisilno je uključen</translation>
<translation id="5862253018042179045">Postavi zadano stanje značajke pristupačnosti izgovaranja povratnih informacija na zaslonu za prijavu.

          Ako se to pravilo postavi na točno, izgovaranje povratnih informacija bit će omogućeno dok se prikazuje zaslon za prijavu.

          Ako se to pravilo postavi na netočno, izgovaranje povratnih informacija bit će onemogućeno dok se prikazuje zaslon za prijavu.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući izgovaranje povratnih informacija. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, izgovaranje povratnih informacija onemogućeno je pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti izgovaranje povratnih informacija u bilo kojem trenutku, a status te značajke na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="8197918588508433925">To pravilo određuje dopuštena proširenja za upotrebu API-ja Enterprise Platform Keys API chrome.enterprise.platformKeysPrivate.challengeUserKey() za daljinsko atestiranje. Proširenja se moraju dodati na taj popis da bi upotrebljavala taj API.

          Ako proširenje nije na popisu ili ako popis nije postavljen, poziv API-ju vratit će kôd pogreške.</translation>
<translation id="7649638372654023172">Konfigurira URL zadane početne stranice na usluzi <ph name="PRODUCT_NAME"/> i sprječava korisnike da ga mijenjaju.

          Početna je stranica ona stranica koja se otvara gumbom Početna. Stranicama koje se otvaraju pri pokretanju upravljaju pravila RestoreOnStartup.

          Vrsta početne stranice može biti postavljena na URL koji navedete ovdje ili na stranicu Nova kartica. Ako odaberete stranicu Nova kartica, ovo se pravilo zanemaruje.

          Ako omogućite ovu postavku, korisnici ne mogu mijenjati URL početne stranice na usluzi <ph name="PRODUCT_NAME"/>, ali i dalje mogu odabrati stranicu Nova kartica kao početnu stranicu.

          Ako ne postavite to pravilo, korisnik će moći sam odabrati početnu stranicu ako pravilo HomepageIsNewTabPage također nije postavljeno.</translation>
</translationbundle>