<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="it">
<translation id="1503959756075098984">ID estensioni e URL di aggiornamento da installare automaticamente</translation>
<translation id="793134539373873765">Consente di specificare se p2p deve essere utilizzato per i payload di aggiornamento del sistema operativo. Se questa norma viene impostata su True, i dispositivi condivideranno e proveranno a consumare i payload di aggiornamento sulla LAN, riducendo potenzialmente l'utilizzo e la congestione della larghezza di banda Internet. Se il payload di aggiornamento non è disponibile sulla LAN, il dispositivo ripiegherà sul download da un server di aggiornamento. Se la norma viene impostata su False o non viene configurata, non verrà utilizzato p2p.</translation>
<translation id="2463365186486772703">Lingua dell'applicazione</translation>
<translation id="1397855852561539316">URL di suggerimento del provider di ricerca predefinito</translation>
<translation id="3347897589415241400">Il comportamento predefinito per i siti non presenti in alcun pacchetto di contenuti.

          Questa norma è per uso interno di Chrome.</translation>
<translation id="7040229947030068419">Valore di esempio:</translation>
<translation id="1213523811751486361">Consente di specificare l'URL del motore di ricerca utilizzato per fornire suggerimenti di ricerca. L'URL deve contenere la stringa &quot;<ph name="SEARCH_TERM_MARKER"/>&quot;, che verrà sostituita in fase di query dal testo inserito fino a quel momento dall'utente. Questa norma è facoltativa. Se non viene impostata, non verranno utilizzati URL di suggerimento. Questa norma viene rispettata soltanto se la norma &quot;DefaultSearchProviderEnabled&quot; è attiva.</translation>
<translation id="6106630674659980926">Abilita Gestione password</translation>
<translation id="7109916642577279530">Consente di permettere o negare l'acquisizione audio.

Se la norma viene attivata o non viene configurata (impostazione predefinita), all'utente verrà richiesto l'accesso all'acquisizione audio, ad eccezione degli URL configurati nell'elenco AudioCaptureAllowedUrls per cui verrà concesso l'accesso senza richieste.

Se questa norma viene disattivata, all'utente non verrà mai chiesto nulla e l'acquisizione audio sarà disponibile soltanto per gli URL configurati in AudioCaptureAllowedUrls.

Questa norma viene applicata per tutti i tipi di ingressi audio e non soltanto per il microfono integrato.</translation>
<translation id="7267809745244694722">Per impostazione predefinita, i tasti multimediali si comportano come tasti funzione.</translation>
<translation id="9150416707757015439">Questa norma è obsoleta. Utilizza IncognitoModeAvailability. Consente di attivare la modalità di navigazione in incognito in <ph name="PRODUCT_NAME"/>. Se questa impostazione viene attivata o non viene configurata, gli utenti potranno aprire le pagine web in modalità di navigazione in incognito. Se l'impostazione viene disattivata, gli utenti non potranno aprire le pagine web in modalità di navigazione in incognito. Se questa norma non viene impostata, l'impostazione verrà attivata e gli utenti potranno utilizzare la modalità di navigazione in incognito.</translation>
<translation id="4203389617541558220">Consente di limitare il tempo di attività del dispositivo programmando riavvii automatici.

Se questa norma viene impostata consente di specificare il periodo di tempo di attività del dispositivo trascorso il quale è programmato un riavvio automatico.

Se la norma non viene impostata il tempo di attività del dispositivo non è limitato.

Se la norma viene impostata gli utenti non potranno modificarla o ignorarla.

Il riavvio automatico è programmato all'ora selezionata ma potrebbe essere ritardato sul dispositivo di massimo 24 ore se un utente sta utilizzando il dispositivo.

Nota. Attualmente i riavvii automatici vengono attivati soltanto durante la visualizzazione della schermata di accesso o durante una sessione di un'app kiosk. Questo comportamento cambierà in futuro e la norma sarà sempre valida, a prescindere dal fatto che sia in corso o meno una sessione di tipo specifico.

Il valore della norma dovrebbe essere specificato in secondi. Il valore minimo deve essere 3600 (un'ora).</translation>
<translation id="5304269353650269372">Consente di specificare il periodo di tempo senza immissioni da parte dell'utente dopo il quale viene mostrata una finestra di dialogo di avviso quando il computer è alimentato a batteria.

          Quando è impostata, questa norma specifica per quanto tempo l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> mostri una finestra di dialogo di avviso in cui comunica all'utente che sta per essere intrapresa l'azione richiesta in caso di inattività.

          Quando questa norma non è impostata, non viene visualizzata alcuna finestra di dialogo di avviso.

          Il valore della norma deve essere specificato in millisecondi. I valori sono fissati in modo da essere minori o uguali al ritardo di inattività.</translation>
<translation id="7818131573217430250">Impostazione stato predefinito modalità ad alto contrasto nella schermata di accesso</translation>
<translation id="7614663184588396421">Elenco degli schemi di protocollo disabilitati</translation>
<translation id="2309390639296060546">Impostazione di geolocalizzazione predefinita</translation>
<translation id="1313457536529613143">Consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando viene osservata l'attività dell'utente mentre lo schermo è oscurato o subito dopo lo spegnimento dello schermo.

Se questa norma viene impostata, consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando viene osservata l'attività dell'utente mentre lo schermo è oscurato o subito dopo lo spegnimento dello schermo. Quando il ritardo di oscuramento viene regolato, i ritardi di spegnimento, blocco e inattività dello schermo vengono regolati per mantenere gli stessi distacchi dal ritardo di oscuramento dello schermo configurato in origine.

Se la norma non viene impostata viene utilizzato un fattore di regolazione predefinito.

Il fattore di regolazione minimo deve essere 100%.</translation>
<translation id="7443616896860707393">Richieste di autenticazione di base HTTP tra origini</translation>
<translation id="2337466621458842053">Consente di impostare un elenco di pattern URL che specificano i siti in cui è consentita la visualizzazione di immagini. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultImagesSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="4680961954980851756">Abilita Compilazione automatica</translation>
<translation id="5183383917553127163">Consente di specificare le estensioni da non includere nella blacklist. Un valore di * riportato nella blacklist indica che tutte le estensioni sono state inserite nella blacklist e che gli utenti possono installare solo quelle elencate nella whitelist. Per impostazione predefinita, tutte le estensioni si trovano nella whitelist, ma se in base alla norma applicata tutte le estensioni sono state inserite nella blacklist, la whitelist può essere utilizzata per annullare tale norma.</translation>
<translation id="5921888683953999946">Consente di impostare lo stato predefinito della funzione di accessibilità del puntatore grande nella schermata di accesso.

Se questa norma viene impostata su true, il puntatore grande viene attivato quando viene visualizzata la schermata di accesso.

Se la norma viene impostata su false, il puntatore grande viene disattivato quando viene visualizzata la schermata di accesso.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando il puntatore grande. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, il puntatore grande viene disattivato alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare il puntatore grande in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="3185009703220253572">a partire dalla versione <ph name="SINCE_VERSION"/></translation>
<translation id="5298412045697677971">Configurazione dell'immagine avatar dell'utente.

      Questo criterio ti consente di configurare l'immagine avatar che rappresenta l'utente nella schermata di accesso. Per impostare il criterio, è necessario specificare l'URL dal quale scaricare l'immagine avatar in <ph name="PRODUCT_OS_NAME"/> e un hash crittografico la cui funzione è quella di verificare l'integrità del download. L'immagine deve essere in formato JPEG e non deve superare le dimensioni di 512 kB. L'URL specificato deve essere accessibile senza bisogno di autenticazione.

      L'immagine avatar viene scaricata e memorizzata nella cache. Questo si verifica anche ogniqualvolta venga modificato l'URL o l'hash.

      Il criterio deve essere specificato sotto forma di una stringa contenente l'URL e l'hash in formato JSON, conforme al seguente schema:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;URL da cui scaricare l'immagine avatar.&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;Hash SHA-256 dell'immagine avatar.&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Una volta impostato il criterio, l'immagine avatar viene scaricata e utilizzata in <ph name="PRODUCT_OS_NAME"/>.

      Se imposti questo criterio, gli utenti non potranno modificarlo né sostituirlo.

      Se invece il criterio non viene impostato, l'utente può scegliere l'immagine avatar da cui farsi rappresentare nella schermata di accesso.</translation>
<translation id="2204753382813641270">Controlla la visualizzazione automatica dello shelf</translation>
<translation id="3816312845600780067">Attivazione scorciatoia da tastiera bailout per accesso automatico</translation>
<translation id="3214164532079860003">Se è attiva, questa norma impone l'importazione della pagina iniziale dal browser predefinito corrente. Se non è attiva, la pagina iniziale non viene importata. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="5330684698007383292">Consenti a <ph name="PRODUCT_FRAME_NAME"/> di gestire i seguenti tipi di contenuti</translation>
<translation id="6647965994887675196">Se questa norma è impostata su true, è possibile creare e utilizzare utenti supervisionati.

          Se questa norma è impostata su false o non è configurata, la creazione di utenti supervisionati e il relativo accesso saranno disattivati. Tutti gli utenti supervisionati esistenti saranno nascosti.

          NOTA. Il comportamento predefinito per dispositivi consumer ed enterprise è diverso: sui dispositivi consumer, gli utenti supervisionati sono abilitati per impostazione predefinita, mentre sui dispositivi enterprise sono disabilitati per impostazione predefinita.</translation>
<translation id="69525503251220566">Parametro che fornisce la funzione di ricerca tramite immagine per il provider di ricerca predefinito</translation>
<translation id="5469825884154817306">Blocca immagini su questi siti</translation>
<translation id="8412312801707973447">Esecuzione dei controlli OCSP/CRL online</translation>
<translation id="2482676533225429905">Messaggi nativi</translation>
<translation id="6649397154027560979">Questa norma non è più supportata; utilizza la norma URLBlacklist.

Consente di disattivare gli schemi dei protocolli elencati in <ph name="PRODUCT_NAME"/>.

Gli URL che utilizzano uno schema di questo elenco non verranno caricati e non potranno essere visitati.

Se questa norma non viene impostata o se l'elenco è vuoto, sarà possibile accedere a tutti gli schemi in <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3213821784736959823">Controlla se il client DNS integrato è in uso in <ph name="PRODUCT_NAME"/>.

      Se il criterio è impostato su True, verrà utilizzato il client DNS integrato, se disponibile.

      Se il criterio è impostato su False, il client DNS integrato non verrà mai utilizzato.

      Se il criterio non viene impostato, gli utenti saranno in grado di scegliere se il client DNS integrato è utilizzato modificando chrome://flags o specificando un flag della riga di comando.</translation>
<translation id="2908277604670530363">Numero massimo di connessioni simultanee al server proxy</translation>
<translation id="556941986578702361">Controlla la visualizzazione automatica dello shelf in <ph name="PRODUCT_OS_NAME"/>.

      Se il criterio è impostato su &quot;AlwaysAutoHideShelf&quot;, lo scaffale non sarà mai visualizzato.

      Se il criterio è impostato su &quot;NeverAutoHideShelf&quot;, lo scaffale sarà sempre visualizzato.

      Se imposti questo criterio, gli utenti non potranno modificarlo o ignorarlo.

      Se il criterio non viene impostato, gli utenti possono scegliere la visualizzazione dello shelf.</translation>
<translation id="4838572175671839397">Contiene un'espressione regolare che è possibile utilizzare per stabilire gli utenti che possono accedere a <ph name="PRODUCT_NAME"/>.

Viene visualizzato un errore appropriato se un utente tenta di accedere con un nome utente non corrispondente allo schema indicato.

Se questa norma non viene impostata o viene lasciata vuota, qualsiasi utente potrà accedere a <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2892225385726009373">Se questa impostazione viene attivata, <ph name="PRODUCT_NAME"/> eseguirà sempre il controllo delle revoche per i certificati server che vengono convalidati e vengono firmati tramite certificati CA installati localmente.

Se <ph name="PRODUCT_NAME"/> non riesce a ottenere informazioni sullo stato delle revoche, tali certificati vengono considerati revocati (&quot;hard-fail&quot;).

Se questa norma non viene impostata o se viene impostata su false, Chrome utilizzerà le impostazioni di controllo delle revoche online esistenti.</translation>
<translation id="3516856976222674451">Limita la durata massima di una sessione utente.

      Quando è impostato, questo criterio specifica il tempo dopo il quale un utente viene automaticamente disconnesso, terminando la sessione. Un conto alla rovescia nell'area di notifica informa l'utente del tempo rimanente.

      Quando il criterio non è impostato, la durata della sessione non è limitata.

      Se imposti questo criterio, gli utenti non potranno modificarlo o ignorarlo.

      Il valore del criterio deve essere specificato in millisecondi. I valori sono limitati a un intervallo compreso tra 30 secondi e 24 ore.</translation>
<translation id="9200828125069750521">Parametri per l'URL dell'immagine che utilizza POST</translation>
<translation id="2769952903507981510">Configura il nome di dominio richiesto per gli host di accesso remoto</translation>
<translation id="8294750666104911727">In genere le pagine con X-UA-Compatible impostato su chrome=1 saranno visualizzate in <ph name="PRODUCT_FRAME_NAME"/> nonostante la norma &quot;£ChromeFrameRendererSettings&quot;.

Se attivi questa impostazione, le pagine non saranno sottoposte a scansione per i metatag.

Se disattivi questa impostazione, le pagine saranno sottoposte a scansione per i metatag.

Se questa norma non viene impostata, le pagine saranno sottoposte a scansione per i metatag.</translation>
<translation id="3478024346823118645">Cancella dati utente all'uscita</translation>
<translation id="8668394701842594241">Consente di specificare un elenco di plug-in attivi in <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare questa impostazione. È possibile utilizzare i caratteri jolly &quot;*&quot; e &quot;?&quot; in corrispondenza delle sequenze di caratteri arbitrari. Il carattere &quot;*&quot; corrisponde a un numero arbitrario di caratteri, mentre &quot;?&quot; indica un singolo carattere facoltativo, cioè corrisponde a zero caratteri o a uno solo. Il carattere di escape è &quot;\&quot; quindi, per indicare i caratteri &quot;*&quot;, &quot;?&quot; e &quot;\&quot; effettivi, puoi inserire prima di tali caratteri un simbolo &quot;\&quot;. L'elenco di plug-in specificato verrà utilizzato sempre in <ph name="PRODUCT_NAME"/> se i plug-in sono installati. I plug-in verranno contrassegnati come attivi in &quot;about:plugins&quot; e gli utenti non potranno disattivarli. Tieni presente che questa norma ha la precedenza sulle norme DisabledPlugins e DisabledPluginsExceptions. Se questa norma non viene impostata, gli utenti potranno disattivare qualsiasi plug-in installato sul sistema.</translation>
<translation id="653608967792832033">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene bloccato quando viene utilizzata la batteria.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> blocchi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME"/> non blocca lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il metodo consigliato per bloccare lo schermo in caso di inattività consiste nell'attivare il blocco dello schermo in caso di sospensione e fare in modo che <ph name="PRODUCT_OS_NAME"/> venga sospeso dopo il ritardo di inattività. Questa norma dovrebbe essere utilizzata soltanto quando il blocco dello schermo dovrebbe avvenire molto tempo prima della sospensione o quando non si desidera affatto la sospensione in caso di inattività.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori al ritardo di inattività.</translation>
<translation id="979541737284082440">(questo documento potrebbe includere norme destinate alle versioni successive di <ph name="PRODUCT_NAME"/>, soggette a modifiche senza preavviso. L'elenco di norme supportate è lo stesso di Chromium e Google Chrome.) Non apportare modifiche manuali a queste impostazioni. Puoi scaricare modelli facili da utilizzare da <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>. Queste norme sono strettamente riservate all'utilizzo per la configurazione delle istanze di Chrome all'interno dell'organizzazione. L'utilizzo di tali norme al di fuori dell'organizzazione (ad esempio, in un programma distribuito pubblicamente) è considerato malware e con ogni probabilità verrà considerato malware da Google e dai fornitori di programmi anti-virus. Nota. A partire da <ph name="PRODUCT_NAME"/> 28, le norme vengono caricate direttamente dalle API delle norme del gruppo su Windows. Le norme scritte manualmente sul registro verranno ignorate. Per conoscere i dettagli, fai riferimento a http://crbug.com/259236. A partire da <ph name="PRODUCT_NAME"/> 35, le norme vengono lette direttamente dal registro se la workstation appartiene a un dominio Active Directory; in caso contrario, le norme vengono lette da GPO.</translation>
<translation id="4157003184375321727">Indica versione sistema operativo e firmware</translation>
<translation id="5255162913209987122">Può essere consigliata</translation>
<translation id="1861037019115362154">Consente di specificare un elenco di plug-in non attivi in <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare questa impostazione.

      È possibile utilizzare i caratteri jolly &quot;*&quot; e &quot;?&quot; in corrispondenza delle sequenze di caratteri arbitrari. Il carattere &quot;*&quot; corrisponde a un numero arbitrario di caratteri, mentre &quot;?&quot; indica un singolo carattere facoltativo, cioè corrisponde a zero caratteri o a uno solo. Il carattere di escape è &quot;\&quot; e quindi, per indicare i caratteri &quot;*&quot;, &quot;?&quot; e &quot;\&quot; effettivi, puoi inserire prima di tali caratteri un simbolo &quot;\&quot;.

      Se attivi questa impostazione, l'elenco di plug-in specificato non verrà mai utilizzato in <ph name="PRODUCT_NAME"/>. I plug-in vengono contrassegnati come non attivi in &quot;about:plugins&quot; e gli utenti non possono attivarli.

      Tieni presente che questa norma può essere sostituita dalle norme EnabledPlugins e DisabledPluginsExceptions.

      Se questa norma non viene impostata, gli utenti potranno utilizzare qualsiasi plug-in installato sul sistema, tranne i plug-in hard-coded, non compatibili, obsoleti o pericolosi.</translation>
<translation id="9197740283131855199">Percentuale di regolazione del ritardo di oscuramento dello schermo se l'utente diventa attivo dopo l'oscuramento</translation>
<translation id="1492145937778428165">Consente di specificare il periodo in millisecondi per cui il servizio di gestione del dispositivo viene interrogato sulle informazioni relative alle norme del dispositivo.

      Se viene impostata questa norma, il valore predefinito di tre ore viene ignorato. L'intervallo dei valori validi per la norma va da 1800000 (30 minuti) a 86400000 (un giorno). I valori non compresi in questo intervallo verranno bloccati sul corrispettivo limite.

      Se questa norma non viene impostata, per <ph name="PRODUCT_OS_NAME"/> verrà utilizzato il valore predefinito di tre ore.</translation>
<translation id="3765260570442823273">Durata del messaggio di avviso di uscita per inattività</translation>
<translation id="7302043767260300182">Ritardo blocco schermo in caso di utilizzo di CA</translation>
<translation id="7331962793961469250">Quando la norma è impostata su True, le promozioni relative alle applicazioni del Chrome Web Store non vengono visualizzate nella pagina Nuova scheda. Se questa opzione viene impostata su False o non viene impostata, le promozioni relative alle applicazioni del Chrome Web Store vengono visualizzate nella pagina Nuova scheda.</translation>
<translation id="7271085005502526897">Importazione della home page dal browser predefinito alla prima esecuzione</translation>
<translation id="6036523166753287175">Abilita attraversamento firewall da host di accesso remoto</translation>
<translation id="1096105751829466145">Provider di ricerca predefinito</translation>
<translation id="7567380065339179813">Consenti plug-in su questi siti</translation>
<translation id="4555850956567117258">Attivazione dell'attestazione da remoto per l'utente</translation>
<translation id="5966615072639944554">Estensioni autorizzate a utilizzare l'API di attestazione da remoto</translation>
<translation id="1617235075406854669">Attiva eliminazione cronologia del browser e dei download</translation>
<translation id="5290940294294002042">Specifica un elenco di plug-in che l'utente può attivare o disattivare</translation>
<translation id="3153348162326497318">Consente di specificare le estensioni che gli utenti NON possono installare. Se presenti nella blacklist, le estensioni precedentemente installate verranno rimosse. Un valore &quot;*&quot; riportato nella blacklist indica che tutte le estensioni sono state inserite nella blacklist a meno che non siano espressamente elencate nella whitelist. Se questa norma non viene impostata, gli utenti potranno installare qualsiasi estensione in <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3067188277482006117">Se la norma è impostata su True, l'utente può utilizzare l'hardware su dispositivi Chrome per attestare da remoto la propria identità presso l'Autorità di certificazione della privacy tramite chrome.enterprise.platformKeysPrivate.challengeUserKey() dell'API Enterprise Platform Keys.

          Se la norma è impostata su False o non è impostata, le chiamate all'API non riusciranno e genereranno un codice di errore.</translation>
<translation id="5809728392451418079">Imposta il nome visualizzato per gli account del dispositivo</translation>
<translation id="1427655258943162134">Indirizzo o URL del server proxy</translation>
<translation id="1827523283178827583">Utilizza server proxy definiti</translation>
<translation id="3021409116652377124">Disabilita ricerca plug-in</translation>
<translation id="7236775576470542603">Consente di impostare il tipo di ingrandimento dello schermo predefinito che viene attivato nella schermata di accesso.

Se questa norma viene impostata consente di controllare il tipo di ingrandimento dello schermo che viene attivato quando viene visualizzata la schermata di accesso. L'impostazione della norma su &quot;None&quot; consente di disattivare l'ingrandimento dello schermo.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando l'ingrandimento dello schermo. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, l'ingrandimento dello schermo viene disattivato alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare l'ingrandimento dello schermo in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="5423001109873148185">Se è attiva, questa norma impone l'importazione dei motori di ricerca dal browser predefinito corrente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, il motore di ricerca predefinito non viene importato. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="3288595667065905535">Canale di rilascio</translation>
<translation id="2785954641789149745">Consente di attivare la funzione Navigazione sicura di <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare l'impostazione.

Se l'impostazione viene attivata, la funzione Navigazione sicura è sempre attiva.

Se l'impostazione viene disattivata, la funzione Navigazione sicura non è mai attiva.

Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificare o ignorare l'impostazione &quot;Attiva protezione contro phishing e malware&quot; di <ph name="PRODUCT_NAME"/>.

Se la norma non viene impostata l'impostazione verrà attivata ma gli utenti potranno modificarla.</translation>
<translation id="268577405881275241">Attiva la funzione proxy di compressione dei dati</translation>
<translation id="3820526221169548563">Attiva la funzione di accessibilità della tastiera sullo schermo.

          Se questa norma viene impostata su true, la tastiera sullo schermo sarà sempre attivata.

          Se questa norma viene impostata su false, la tastiera sullo schermo sarà sempre disattivata.

          Se questa norma viene viene impostata, gli utenti non potranno modificarla o sostituirla.

          Se questa norma non viene impostata, inizialmente la tastiera sullo schermo è disattivata, ma l'utente la può attivare in qualsiasi momento.</translation>
<translation id="8369602308428138533">Ritardo disattivazione schermo in caso di utilizzo di CA</translation>
<translation id="6513756852541213407">Consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare le impostazioni del proxy. Se decidi di non utilizzare mai un server proxy e di eseguire sempre un collegamento diretto, tutte le altre opzioni vengono ignorate. Se scegli di utilizzare le impostazioni proxy di sistema o di rilevare automaticamente il server proxy, tutte le altre opzioni vengono ignorate. Se scegli di utilizzare un server proxy fisso, puoi specificare ulteriori opzioni in &quot;Indirizzo o URL del server proxy&quot; e in &quot;Elenco separato da virgole delle regole di bypass proxy&quot;. Se scegli di utilizzare uno script proxy .pac, devi specificare l'URL per lo script in &quot;URL di un file proxy .pac&quot;. Per esempi dettagliati, visita il sito: <ph name="PROXY_HELP_URL"/>. Se attivi questa impostazione, <ph name="PRODUCT_NAME"/> ignora tutte le opzioni correlate al proxy specificate dalla riga di comando. Se questa norma non viene impostata, gli utenti potranno scegliere autonomamente le impostazioni del proxy.</translation>
<translation id="7763311235717725977">Permette di stabilire se consentire o meno la visualizzazione delle immagini nei siti web. La visualizzazione delle immagini può essere consentita o negata per tutti i siti web. Se questa norma non viene impostata, verrà utilizzato il valore &quot;AllowImages&quot;, che potrà essere modificato dagli utenti.</translation>
<translation id="5630352020869108293">Ripristina l'ultima sessione</translation>
<translation id="2067011586099792101">Blocca l'accesso ai siti non presenti nei pacchetti di contenuti</translation>
<translation id="4980635395568992380">Tipo di dati:</translation>
<translation id="3096595567015595053">Elenco dei plug-in attivati</translation>
<translation id="3048744057455266684">Se questa norma viene impostata e un URL di ricerca suggerito dalla omnibox contiene questo parametro nella stringa di ricerca o nell'identificatore del frammento, il suggerimento visualizzerà i termini di ricerca e il fornitore del servizio di ricerca anziché l'URL di ricerca non elaborato.

Questa norma è facoltativa. Se non viene impostata, non verrà effettuata alcuna sostituzione dei termini di ricerca.

Questa norma viene rispettata soltanto se viene attivata la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="5912364507361265851">Consenti agli utenti di mostrare le password in Gestione password</translation>
<translation id="5318185076587284965">Attiva l'utilizzo dei server relay per l'host di accesso remoto</translation>
<translation id="510186355068252378">Consente di disattivare la sincronizzazione dei dati in <ph name="PRODUCT_NAME"/> tramite servizi di sincronizzazione in hosting su Google e di impedire agli utenti di modificare questa impostazione. Se questa impostazione viene attivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se questa norma non viene impostata, gli utenti potranno scegliere se utilizzare o meno Google Sync.</translation>
<translation id="7953256619080733119">Host delle eccezioni manuali per gli utenti gestiti</translation>
<translation id="4807950475297505572">Gli utenti utilizzati meno di recente vengono rimossi fino alla disponibilità di spazio libero sufficiente</translation>
<translation id="8789506358653607371">Consenti modalità a schermo intero.

      Questa norma consente di controllare la disponibilità della modalità a schermo intero, in cui l'intera interfaccia utente di <ph name="PRODUCT_NAME"/> è nascosta e sono visibili soltanto i contenuti web.

      Se questa norma viene impostata su true oppure non viene configurata, l'utente, le app e le estensioni con le autorizzazioni appropriate possono attivare la modalità a schermo intero.

      Se questa norma viene impostata su false, l'utente, le app e le estensioni non possono attivare la modalità a schermo intero.

      Su tutte le piattaforme, a eccezione di <ph name="PRODUCT_OS_NAME"/>, la modalità kiosk non è disponibile quando la modalità a schermo intero è disattivata.</translation>
<translation id="8828766846428537606">Configura la Pagina inziale predefinita in <ph name="PRODUCT_NAME"/> e impedisce agli utenti di modificarla. Le impostazioni relative alla Pagina iniziale dell'utente sono completamente bloccate solo se imposti come pagina inziale la pagina Nuova scheda, o se scegli URL e lo specifichi nella sezione Pagina inziale. Se non specifichi l'URL della pagina inziale, l'utente può impostare la pagina Nuova scheda come pagina inziale specificando &quot;chrome://newtab&quot;.</translation>
<translation id="2231817271680715693">Importa cronologia di navigazione dal browser predefinito alla prima esecuzione</translation>
<translation id="1353966721814789986">Pagine di avvio</translation>
<translation id="7173856672248996428">Profilo temporaneo</translation>
<translation id="1841130111523795147">Consente all'utente di accedere a <ph name="PRODUCT_NAME"/> e impedisce agli utenti di modificare questa impostazione.

      Se imposti questa norma, puoi scegliere se un utente è autorizzato o meno ad accedere a <ph name="PRODUCT_NAME"/>.</translation>
<translation id="5564962323737505851">Configura Gestione password. Se Gestione password è abilitata, puoi scegliere di consentire o meno all'utente di visualizzare le password memorizzate in testo non crittografato.</translation>
<translation id="4668325077104657568">Impostazione immagini predefinite</translation>
<translation id="4492287494009043413">Disabilita l'acquisizione di screenshot</translation>
<translation id="6368403635025849609">Consenti JavaScript su questi siti</translation>
<translation id="6074963268421707432">Non consentire la visualizzazione di notifiche desktop da parte dei siti</translation>
<translation id="8614804915612153606">Disattiva l'aggiornamento automatico</translation>
<translation id="4834526953114077364">Gli utenti utilizzati meno di recente che non hanno eseguito l'accesso negli ultimi tre mesi vengono rimossi fino alla disponibilità di spazio libero sufficiente</translation>
<translation id="382476126209906314">Configura il prefisso TalkGadget per gli host di accesso remoto</translation>
<translation id="6561396069801924653">Mostra le opzioni di accessibilità nel menu della barra delle applicazioni di sistema</translation>
<translation id="8104962233214241919">Seleziona automaticamente i certificati client per questi siti</translation>
<translation id="2906874737073861391">Elenco di estensioni AppPack</translation>
<translation id="4386578721025870401">Consente di limitare il tempo per cui un utente autenticato tramite SAML può eseguire l'accesso offline.

      Durante l'accesso, Chrome OS può eseguire l'autenticazione con un server (online) o utilizzando una password memorizzata nella cache (offline).

      Se questa norma viene impostata sul valore -1, l'utente può eseguire l'autenticazione offline in qualsiasi momento. Se viene impostata su un altro valore, tale valore specifica il periodo di tempo dall'ultima autenticazione online trascorso il quale l'utente deve eseguire di nuovo l'autenticazione online.

      Se questa norma non viene impostata, <ph name="PRODUCT_OS_NAME"/> utilizza un limite di tempo predefinito di 14 giorni trascorsi i quali l'utente deve eseguire di nuovo l'autenticazione online.

      Questa norma viene applicata soltanto per gli utenti che si sono autenticati tramite SAML.

      Il valore della norma deve essere specificato in secondi.</translation>
<translation id="3758249152301468420">Disabilita Strumenti per sviluppatori</translation>
<translation id="8665076741187546529">Configura l'elenco delle estensioni con installazione imposta</translation>
<translation id="2386768843390156671">Abilita l'installazione di host di messaggistica nativi a livello di utente.

          Se l'impostazione è abilitata, in <ph name="PRODUCT_NAME"/> è consentito
          utilizzare host di messaggistica nativi installati a livello di utente.

          Se l'impostazione è disabilitata, in <ph name="PRODUCT_NAME"/> vengono
          utilizzati solo gli host di messaggistica nativi installati a livello del sistema.

          Se l'impostazione non viene specificata, in <ph name="PRODUCT_NAME"/>
          è consentito utilizzare host di messaggistica nativi a livello di utente.</translation>
<translation id="410478022164847452">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale viene compiuta l'azione stabilita per l'inattività quando viene utilizzata la corrente alternata.

Se questa norma viene impostata, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> compia l'azione di inattività, che può essere configurata separatamente.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="6598235178374410284">Immagine avatar utente</translation>
<translation id="1675391920437889033">Controlla quali tipi di app/estensioni possono essere installati.

          Questa impostazione autorizza i tipi consentiti di estensioni/app che possono essere installate in <ph name="PRODUCT_NAME"/>. Il valore è un elenco di stringhe, ognuna delle quali deve corrispondere a una delle seguenti stringhe: &quot;extension&quot;, &quot;theme&quot;, &quot;user_script&quot;, &quot;hosted_app&quot;, &quot;legacy_packaged_app&quot;, &quot;platform_app&quot;. Per ulteriori informazioni su questi tipi, consulta la documentazione sulle estensioni di Chrome .

          Tieni presente che questo criterio riguarda anche le estensioni e le app con installazione forzata tramite ExtensionInstallForcelist.

          Se l'impostazione è configurata, le estensioni/app con un tipo che non è in elenco non verranno installate.

          Se l'impostazione non è configurata, non vengono imposte restrizioni sui tipi di estensioni/app accettabili.</translation>
<translation id="6378076389057087301">Specifica se l'attività audio incide sulla gestione dell'alimentazione</translation>
<translation id="8818173863808665831">Consente di segnalare la posizione geografica del dispositivo.

Se la norma non viene impostata o viene impostata su false, la posizione non viene segnalata.</translation>
<translation id="4899708173828500852">Consenti Navigazione sicura</translation>
<translation id="4442582539341804154">Attiva il blocco quando lo stato del dispositivo diventa inattivo o sospeso</translation>
<translation id="7719251660743813569">Consente di stabilire se riferire o meno le metriche sull'utilizzo a Google. Se la norma viene impostata su true, <ph name="PRODUCT_OS_NAME"/> riferirà le metriche sull'utilizzo. Se non viene configurata o viene impostata su false, i rapporti sulle metriche verranno disattivati.</translation>
<translation id="2372547058085956601">Il ritardo prima dell'accesso automatico alla sessione pubblica.

      Se non è impostata, la norma |DeviceLocalAccountAutoLoginId| non ha effetto. In caso contrario:

      Se è impostata, questa norma determina quanto tempo deve trascorrere senza attività dell'utente prima che venga eseguito l'accesso automatico alla sessione pubblica specificata dalla norma |DeviceLocalAccountAutoLoginId|.

      Se questa norma non è impostata, verrà utilizzato un timeout di 0 millisecondi.

      Questa norma è specificata in millisecondi.</translation>
<translation id="7275334191706090484">Preferiti gestiti</translation>
<translation id="3570008976476035109">Blocca plug-in su questi siti</translation>
<translation id="8749370016497832113">Consente di eliminare la cronologia del browser e la cronologia dei download in <ph name="PRODUCT_NAME"/> e impedisce agli utenti di modificare questa impostazione.

      Tieni presente che anche quando questa norma è disattivata, non è garantita la memorizzazione della cronologia di navigazione e della cronologia dei download: gli utenti potrebbero essere in grado di modificare o eliminare direttamente i file dei database delle cronologie e il browser stesso potrebbe far scadere o archiviare alcuni o tutti gli elementi della cronologia in qualsiasi momento.

      Se questa impostazione è attivata o non è impostata, la cronologia di navigazione e la cronologia dei download possono essere eliminate.

      Se questa impostazione è disattivata, la cronologia di navigazione e la cronologia dei download non possono essere eliminate.</translation>
<translation id="2884728160143956392">Consenti solo i cookie per la sessione su questi siti</translation>
<translation id="3021272743506189340">Consente di disattivare la sincronizzazione di Google Drive nell'app File di Chrome OS quando è in uso una connessione cellulare e quando la norma è impostata su True. In tal caso, i dati vengono sincronizzati con Google Drive solo quando l'utente è connesso tramite Wi-Fi o Ethernet.

          Se la norma non è impostata o è impostata su False, gli utenti possono trasferire i file su Google Drive tramite connessioni cellulari.</translation>
<translation id="4655130238810647237">Consente di attivare o disattivare la modifica dei Preferiti in <ph name="PRODUCT_NAME"/>. Se attivi questa impostazione sarà possibile aggiungere, rimuovere o modificare Preferiti. Si tratta dell'impostazione predefinita anche quando la norma non è impostata. Se disattivi questa impostazione, non sarà possibile aggiungere, rimuovere o modificare Preferiti. I Preferiti esistenti rimangono disponibili.</translation>
<translation id="3496296378755072552">Gestione password</translation>
<translation id="4372704773119750918">Non permettere all'utente aziendale di far parte del profilo multiplo (principale o secondario)</translation>
<translation id="7027785306666625591">Configura la gestione dell'alimentazione in <ph name="PRODUCT_OS_NAME"/>.

      Queste norme consentono di configurare il comportamento di <ph name="PRODUCT_OS_NAME"/> quando l'utente rimane inattivo per un determinato periodo di tempo.</translation>
<translation id="2565967352111237512">Consente di attivare la comunicazione anonima a Google dei dati sull'utilizzo e sugli arresti anomali di <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare questa impostazione. Se questa impostazione viene attivata, a Google verranno inviati rapporti anonimi di dati sull'utilizzo e sugli arresti anomali. Se l'impostazione viene disattivata, i rapporti anonimi di dati sull'utilizzo e sugli arresti anomali non verranno mai inviati a Google. Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se questa norma non viene impostata, verrà utilizzata l'impostazione scelta dall'utente in fase di installazione/prima esecuzione.</translation>
<translation id="6256787297633808491">Contrassegni a livello di sistema da applicare all'avvio di Chrome</translation>
<translation id="2516600974234263142">Consente di attivare la stampa in <ph name="PRODUCT_NAME"/> e impedisce agli utenti di modificare questa impostazione.

      Se l'impostazione è attivata o non è configurata, gli utenti possono stampare.

      Se l'impostazione è disattivata, gli utenti non possono stampare da <ph name="PRODUCT_NAME"/>. La stampa è disattivata nel menu Strumenti, nelle estensioni, nelle app JavaScript e così via. È possibile stampare da plug-in che ignorano <ph name="PRODUCT_NAME"/> durante la stampa. Ad esempio, alcune app Flash presentano l'opzione di stampa nel loro menu di scelta rapida, che non è analizzato in questo criterio.</translation>
<translation id="9135033364005346124">Attiva proxy <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="4519046672992331730">Consente di attivare i suggerimenti di ricerca nella omnibox di <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare l'impostazione.

Se questa impostazione viene attivata, i suggerimenti di ricerca verranno utilizzati, in caso contrario non verranno mai utilizzati.

Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>.

Se questa norma non viene impostata, l'impostazione verrà attivata ma gli utenti potranno modificarla.</translation>
<translation id="6943577887654905793">Nome di preferenza per Mac/Linux:</translation>
<translation id="8176035528522326671">Consenti all'utente aziendale di essere solo l'utente multiprofilo principale (comportamento predefinito per gli utenti gestiti dall'azienda)</translation>
<translation id="6925212669267783763">Configura la directory che <ph name="PRODUCT_FRAME_NAME"/> utilizzerà per la memorizzazione dei dati dell'utente.

      Se imposti questa norma, <ph name="PRODUCT_FRAME_NAME"/> utilizzerà la directory fornita.

      Visita http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per un elenco di variabili utilizzabili.

      Se questa norma non viene impostata, verrà utilizzata la directory del profilo predefinita.</translation>
<translation id="8906768759089290519">Attiva modalità ospite</translation>
<translation id="348495353354674884">Attiva tastiera virtuale</translation>
<translation id="2168397434410358693">Ritardo inattività in caso di utilizzo di CA</translation>
<translation id="838870586332499308">Attiva roaming dati</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME"/> può utilizzare un servizio web Google per correggere gli errori di ortografia. Se questa impostazione è abilitata, il servizio viene sempre utilizzato. Se questa impostazione è disabilitata, il servizio non viene mai utilizzato.

      Il controllo ortografico può essere comunque effettuato utilizzando un dizionario scaricato; questa norma controlla soltanto l'utilizzo del servizio online.

      Se questa impostazione non è configurata, gli utenti possono scegliere se utilizzare o meno il servizio di controllo ortografico.</translation>
<translation id="8782750230688364867">Consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando il dispositivo è in modalità di presentazione.

Se questa norma viene impostata, consente di specificare la percentuale di regolazione del ritardo di oscuramento dello schermo quando il dispositivo è in modalità di presentazione. Quando viene regolato il ritardo di oscuramento, i ritardi di spegnimento, blocco e inattività dello schermo vengono regolati per mantenere gli stessi distacchi dal ritardo di oscuramento dello schermo configurato in origine.

Se la norma non viene impostata viene utilizzato un fattore di regolazione predefinito.

Il fattore di regolazione minimo deve essere 100%. Valori che renderebbero il ritardo di oscuramento dello schermo in modalità di presentazione inferiore al ritardo di oscuramento normale non sono consentiti.</translation>
<translation id="254524874071906077">Imposta Chrome come browser predefinito</translation>
<translation id="8112122435099806139">Consente di specificare il formato dell'orologio da utilizzare per il dispositivo.

      Questa norma consente di configurare il formato dell'orologio da utilizzare nella schermata di accesso e come predefinito per le sessioni utente. Gli utenti possono comunque sostituire il formato dell'orologio per il loro account.

      Se la norma viene impostata su true, sul dispositivo viene utilizzato il formato di 24 ore, se viene impostata su false viene utilizzato il formato di 12 ore.

      Se questa norma non viene impostata, sul dispositivo viene utilizzato il formato predefinito di 24 ore.</translation>
<translation id="8764119899999036911">Consente di specificare se il Kerberos SPN generato si basa sul nome canonico DNS o sul nome originale inserito. Se attivi questa impostazione, la ricerca CNAME verrà saltata e verrà utilizzato il nome del server inserito. Se disattivi l'impostazione o non la imposti, il nome canonico del server sarà determinato tramite ricerca CNAME.</translation>
<translation id="5056708224511062314">Ingrandimento dello schermo disattivato</translation>
<translation id="4377599627073874279">Consenti la visualizzazione di tutte le immagini in tutti i siti</translation>
<translation id="7195064223823777550">Consente di specificare l'azione da compiere quando l'utente chiude il coperchio.

Se questa norma viene impostata, consente di specificare l'azione compiuta da <ph name="PRODUCT_OS_NAME"/> quando l'utente chiude il coperchio del dispositivo.

Se questa norma non viene impostata, viene eseguita l'azione predefinita, vale a dire la sospensione.

Se l'azione è la sospensione, è possibile configurare separatamente il blocco o meno dello schermo prima della sospensione in <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="3915395663995367577">URL di un file proxy .pac</translation>
<translation id="1022361784792428773">ID delle estensioni (oppure * per tutte le estensioni) per cui non è consentita l'installazione</translation>
<translation id="6064943054844745819">Consente di specificare un elenco di funzioni della piattaforma web obsolete da riattivare.

      Questa norma consente agli amministratori di riattivare le funzioni della piattaforma web obsolete per un periodo di tempo limitato. Le funzioni sono identificate da un tag string e le funzioni corrispondenti ai tag inclusi in questo elenco specificato tramite questa norma verranno riattivate.

      Sono attualmente definiti i seguenti tag:
      - ShowModalDialog_EffectiveUntil20150430

      Se questa norma non viene impostata o se l'elenco è vuoto, tutte le funzioni della piattaforma web obsolete rimarranno disattivate.</translation>
<translation id="3805659594028420438">Attiva estensione di certificati associati al dominio TLS (obsoleta)</translation>
<translation id="5499375345075963939">Questa norma è attiva soltanto in modalità retail.

      Quando il valore di questa norma è impostato e non è 0, l'utente Demo correntemente connesso verrà disconnesso automaticamente dopo che sarà trascorso il tempo di inattività della durata specificata.

      Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="7683777542468165012">Aggiornamento dinamico delle norme</translation>
<translation id="1160939557934457296">Disattiva procedendo dalla pagina di avviso Navigazione sicura</translation>
<translation id="8987262643142408725">Disattiva suddivisione record SSL</translation>
<translation id="4529945827292143461">Consente di personalizzare l'elenco di pattern URL per i quali il rendering deve sempre essere eseguito dal browser host. Se questa norma non viene impostata, verrà utilizzato per tutti i siti il renderer predefinito specificato dalla norma &quot;ChromeFrameRendererSettings&quot;. Per avere dei pattern di esempio, visita il sito all'indirizzo http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Indicazione modalità di avvio dispositivo</translation>
<translation id="2746016768603629042">Questa norma è obsoleta; utilizza invece DefaultJavaScriptSetting.

      Può essere utilizzata per disattivare JavaScript in <ph name="PRODUCT_NAME"/>.

      Se questa impostazione viene disattivata, le pagine web non potranno utilizzare JavaScript e l'utente non potrà modificare tale impostazione.

      Se questa impostazione viene attivata o non è impostata, le pagine web potranno utilizzare JavaScript ma l'utente potrà modificare tale impostazione.</translation>
<translation id="1942957375738056236">Qui puoi specificare l'URL del server proxy. Questa norma viene applicata soltanto se sono state selezionate le impostazioni proxy manuali in &quot;Scegli come specificare le impostazioni del server proxy&quot;. Se hai selezionato un'altra modalità per l'impostazione delle norme relative al proxy, non dovresti impostare questa norma. Per ulteriori opzioni ed esempi dettagliati, visita il sito all'indirizzo: <ph name="PROXY_HELP_URL"/>.</translation>
<translation id="6076008833763548615">Disabilita il montaggio di una memoria esterna.

      Quando questa norma è impostata su True, la memoria esterna non sarà disponibile nei file che è possibile sfogliare.

      Questa norma riguarda tutti i tipi di supporti di memorizzazione. Ad esempio: unità flash USB, dischi rigidi esterni, schede di memoria SD e di altro tipo, memorie ottiche e così via. La memoria interna non è interessata, quindi i file salvati nella cartella Download rimangono accessibili. Anche Google Drive non è interessato da questa norma.

      Se questa impostazione è disattivata o non è configurata, gli utenti possono utilizzare tutti i tipi supportati di memorie esterne sul proprio dispositivo.</translation>
<translation id="6936894225179401731">Consente di specificare il numero massimo di connessioni simultanee al server proxy.

      Alcuni server proxy non sono in grado di gestire un numero elevato di connessioni simultanee per client e questo problema può essere risolto impostando un valore inferiore per questa norma.

      Il valore di questa norma dovrebbe essere inferiore a 100 e superiore a 6, mentre il valore predefinito è 32.

      Alcune applicazioni web utilizzano notoriamente molte connessioni con Hanging-GET, pertanto utilizzare un valore minore di 32 potrebbe comportare interruzioni di rete del browser se sono aperte troppe applicazioni web di questo tipo. Se imposti un valore inferiore al valore predefinito, lo fai a tuo rischio.

      Se questa norma non viene impostata viene utilizzato il valore predefinito 32.</translation>
<translation id="5395271912574071439">Consente di attivare la separazione degli host di accesso remoto durante una connessione.

Se questa impostazione viene attivata, i dispositivi di input e output fisici degli host verranno disattivati durante una connessione remota.

Se questa impostazione viene disattivata o non viene impostata, sia gli utenti locali che remoti potranno interagire con l'host quando viene condiviso.</translation>
<translation id="2488010520405124654">Consente di attivare la richiesta di configurazione della rete in modalità offline.

      Se questa norma non viene impostata o viene impostata su True, se un account locale sul dispositivo è configurato per l'accesso automatico senza ritardo e il dispositivo non ha accesso a Internet, in <ph name="PRODUCT_OS_NAME"/> viene visualizzata una richiesta di configurazione della rete.

      Se questa norma viene impostata su False, verrà visualizzato un messaggio di errore anziché la richiesta di configurazione della rete.</translation>
<translation id="1426410128494586442">Sì</translation>
<translation id="4897928009230106190">Consente di specificare i parametri utilizzati durante la ricerca di suggerimenti con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {searchTerms} nell'esempio precedente, verrà sostituito con i dati dei termini di ricerca reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca di suggerimenti verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma &quot;DefaultSearchProviderEnabled&quot; è attiva.</translation>
<translation id="8140204717286305802">Consente di comunicare al server l'elenco di interfacce di rete con i relativi tipi e indirizzi hardware. Se la norma viene impostata su False, l'elenco di interfacce non viene comunicato.</translation>
<translation id="4962195944157514011">Consente di specificare l'URL del motore di ricerca utilizzato per eseguire una ricerca per impostazione predefinita. L'URL deve contenere la stringa &quot;<ph name="SEARCH_TERM_MARKER"/>&quot;, che verrà sostituita in fase di query dai termini di ricerca inseriti dall'utente. Questa opzione deve essere impostata quando la norma &quot;DefaultSearchProviderEnabled&quot; è attiva e verrà rispettata soltanto in questo caso.</translation>
<translation id="6009903244351574348">Consente di permettere a <ph name="PRODUCT_FRAME_NAME"/> di gestire i tipi di contenuti elencati. Se questa norma non viene impostata, verrà utilizzato per tutti i siti il renderer predefinito specificato dalla norma &quot;ChromeFrameRendererSettings&quot;.</translation>
<translation id="3381968327636295719">Utilizza il browser host per impostazione predefinita</translation>
<translation id="3627678165642179114">Attiva o disattiva il servizio web di controllo ortografico</translation>
<translation id="6520802717075138474">Importa motori di ricerca dal browser predefinito alla prima esecuzione</translation>
<translation id="4039085364173654945">Consente di stabilire se per i contenuti secondari di terze parti presenti in una pagina è consentita la visualizzazione di una finestra di dialogo Autorizzazione di base HTTP. Generalmente questa norma non è attiva per tutela dal phishing. Se questa norma non viene impostata, l'impostazione verrà disattivata e per i contenuti secondari di terze parti non potrà essere visualizzata una finestra di dialogo Autorizzazione di base HTTP.</translation>
<translation id="4946368175977216944">Consente di specificare i contrassegni che devono essere applicati a Chrome all'avvio. I contrassegni specificati vengono applicati prima che Chrome si avvii, anche per la schermata di accesso.</translation>
<translation id="7447786363267535722">Consente di attivare il salvataggio delle password e l'utilizzo delle password salvate in <ph name="PRODUCT_NAME"/>. Se attivi questa impostazione gli utenti potranno fare in modo che <ph name="PRODUCT_NAME"/> memorizzi le password e le riporti automaticamente al successivo accesso a un sito. Se disattivi questa impostazione gli utenti non potranno salvare le password o utilizzare password già salvate. Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se questa norma non viene impostata, l'impostazione verrà attivata ma gli utenti potranno modificarla.</translation>
<translation id="1138294736309071213">Questa norma è attiva soltanto in modalità retail.

      Consente di stabilire il periodo di tempo che deve trascorrere prima della visualizzazione dello screensaver nella schermata di accesso dei dispositivi in modalità retail.

      Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="6368011194414932347">Configura l'URL della pagina iniziale</translation>
<translation id="2877225735001246144">Disabilita ricerca CNAME durante la negoziazione con Kerberos</translation>
<translation id="9120299024216374976">Consente di specificare il fuso orario da utilizzare per il dispositivo. Gli utenti possono sostituire il fuso orario specificato per la sessione corrente. Dopo la disconnessione viene ripristinato il fuso orario specificato. Se viene specificato un valore non valido, la norma viene attivata comunque utilizzando il valore &quot;GMT&quot;. Se viene specificata una stringa vuota, la norma viene ignorata.

Se questa norma non viene utilizzata, rimarrà in uso il fuso orario attivo, ma gli utenti potranno modificarlo e tale modifica sarà costante. La modifica di un utente incide sulla schermata di accesso e su tutti gli altri utenti.

Sui nuovi dispositivi è impostato il fuso orario &quot;US/Pacific&quot;.

Il formato del valore segue quello dei nomi dei fusi orari del &quot;IANA Time Zone Database&quot; (consultare la pagina &quot;http://en.wikipedia.org/wiki/Tz_database&quot;). In particolare, quasi tutti i fusi orari possono essere indicati come &quot;continente/grande_città&quot; o &quot;oceano/grande_città&quot;.</translation>
<translation id="3646859102161347133">Impostazione tipo di ingrandimento dello schermo</translation>
<translation id="3528000905991875314">Attiva pagine di errore sostitutive</translation>
<translation id="1283072268083088623">Consente di specificare gli schemi di autenticazione HTTP supportati da <ph name="PRODUCT_NAME"/>. I valori possibili sono &quot;basic&quot;, &quot;digest&quot;, &quot;ntlm&quot; e &quot;negotiate&quot;. Separa i valori con la virgola. Se questa norma non viene impostata, vengono utilizzati tutti i quattro schemi.</translation>
<translation id="1017967144265860778">Gestione dell'alimentazione nella schermata di accesso</translation>
<translation id="4914647484900375533">Consente di attivare la funzione Instant di <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare l'impostazione.

Se questa impostazione viene attivata, la funzione Instant di <ph name="PRODUCT_NAME"/> viene attivata.

Se l'impostazione viene disattivata, la funzione Instant di <ph name="PRODUCT_NAME"/> viene disattivata.

Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificarla o ignorarla.

Se l'impostazione non viene impostata, gli utenti potranno decidere se utilizzare o meno la funzione.

L'impostazione è stata rimossa da Chrome 29 e versioni successive.</translation>
<translation id="6114416803310251055">obsoleto</translation>
<translation id="8493645415242333585">Disabilita salvataggio della cronologia del browser</translation>
<translation id="2747783890942882652">Consente di configurare il nome di dominio dell'host richiesto che verrà imposto sugli host di accesso remoto e impedisce agli utenti di modificarlo.

          Se questa impostazione è abilitata, gli host possono essere condivisi solo tramite account registrati sul nome di dominio specificato.

          Se questa impostazione è disabilitata o non è impostata, gli host possono essere condivisi tramite qualsiasi account.</translation>
<translation id="6417861582779909667">Consente di impostare un elenco di pattern URL che specificano i siti non autorizzati a impostare cookie. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultCookiesSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="5776485039795852974">Chiedi ogni volta che un sito desidera mostrare le notifiche desktop</translation>
<translation id="5047604665028708335">Consenti l'accesso ai siti non presenti nei pacchetti di contenuti</translation>
<translation id="5052081091120171147">Se è attiva, questa norma impone l'importazione della cronologia di navigazione dal browser predefinito corrente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, la cronologia di navigazione non viene importata. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="6786747875388722282">Estensioni</translation>
<translation id="7132877481099023201">URL a cui verrà concesso l'accesso ai dispositivi di acquisizione video senza richieste</translation>
<translation id="8947415621777543415">Segnala posizione del dispositivo</translation>
<translation id="1655229863189977773">Imposta le dimensioni della cache su disco in byte</translation>
<translation id="3358275192586364144">Consente di attivare l'ottimizzazione WPAD in <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare questa impostazione.

      L'attivazione di questa norma riduce il tempo di attesa da parte di Chrome dei server WPAD basati su DNS.

      Se questa norma non viene impostata, la norma viene attivata e l'utente non potrà modificarla.</translation>
<translation id="6376842084200599664">Consente di specificare un elenco di estensioni che verranno installate in background, senza l'interazione dell'utente.

          Ogni elemento dell'elenco è una stringa contenente un ID estensione e un URL di aggiornamento delimitati da un punto e virgola (<ph name="SEMICOLON"/>). L'ID estensione è la stringa di 32 lettere reperibile ad esempio su <ph name="CHROME_EXTENSIONS_LINK"/> in modalità sviluppatore. L'URL di aggiornamento dovrebbe rimandare a un documento Update Manifest XML, come descritto all'indirizzo <ph name="LINK_TO_EXTENSION_DOC1"/>. Tieni presente che l'URL di aggiornamento impostato in questa norma viene utilizzato solo per l'installazione iniziale; gli aggiornamenti successivi dell'estensione utilizzeranno l'URL di aggiornamento indicato nel file manifest dell'estensione.

          Per ogni elemento, <ph name="PRODUCT_NAME"/> recupererà l'estensione specificata dall'ID estensione del servizio di aggiornamento all'URL di aggiornamento specificato e lo installerà in background.

          Ad esempio, <ph name="EXTENSION_POLICY_EXAMPLE"/> installa l'estensione <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> dall'URL di aggiornamento standard del Chrome Web Store. Per ulteriori informazioni sulle estensioni in hosting, visita questo indirizzo: <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Gli utenti non saranno in grado di disinstallare le estensioni specificate da questa norma. Se rimuovi un'estensione da questo elenco, essa verrà disinstallata automaticamente da <ph name="PRODUCT_NAME"/>. Le estensioni specificate in questo elenco vengono inoltre autorizzate automaticamente per l'installazione; ExtensionsInstallBlacklist non incide su di esse.

          Se questa norma non viene impostata, l'utente potrà disinstallare qualsiasi estensione in <ph name="PRODUCT_NAME"/>.</translation>
<translation id="6899705656741990703">Rileva automaticamente impostazioni proxy</translation>
<translation id="4639407427807680016">Nomi degli host di messaggi nativi da escludere dalla lista nera.</translation>
<translation id="8382184662529825177">Attiva l'utilizzo dell'attestazione remota per la protezione dei contenuti per il dispositivo</translation>
<translation id="7003334574344702284">Se è attiva, questa norma impone l'importazione delle password salvate dal browser predefinito precedente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, le password salvate non vengono importate. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="6258193603492867656">Consente di specificare se il Kerberos SPN generato deve includere una porta non standard. Se attivi questa impostazione e specifichi una porta non standard (cioè una porta diversa da 80 o 443), la porta verrà inclusa nel Kerberos SPN generato. Se disattivi l'impostazione o non la imposti, il Kerberos SPN generato non includerà in nessun caso una porta.</translation>
<translation id="3236046242843493070">Pattern URL per consentire installazioni di estensioni, applicazioni e script utente da</translation>
<translation id="2498238926436517902">Nascondi sempre automaticamente lo shelf</translation>
<translation id="253135976343875019">Ritardo avviso inattività in caso di utilizzo di CA</translation>
<translation id="480987484799365700">Se viene attivata, questa norma forza l'attivazione della modalità provvisoria per il profilo. Se viene specificata come norma del sistema operativo (ad esempio GPO su Windows) viene applicata a ogni profilo nel sistema; se la norma viene impostata come norma Cloud, viene applicata soltanto a un profilo a cui viene eseguito l'accesso con un account gestito.

      In questa modalità, i dati del profilo rimangono memorizzati su disco soltanto per la durata della sessione utente. Funzionalità quali cronologia del browser, estensioni e relativi dati, dati web quali cookie e database web, non rimangono memorizzate alla chiusura del browser. L'utente può comunque scaricare i dati su disco manualmente, salvare pagine o stamparle.

      Se l'utente ha attivato la sincronizzazione, tutti i dati rimangono memorizzati nel suo profilo sincronizzato così come avviene per i profili normali. È disponibile anche la modalità di navigazione in incognito se non è disattivata esplicitamente dalla norma.

      Se la norma viene disattivata o non viene impostata, l'accesso rimanda a profili normali.</translation>
<translation id="6997592395211691850">Se i controlli OCSP/CRL online sono obbligatori o meno per i trust anchor locali</translation>
<translation id="152657506688053119">Elenco di URL alternativi per il fornitore del servizio di ricerca predefinito</translation>
<translation id="8992176907758534924">Non consentire la visualizzazione di immagini nei siti</translation>
<translation id="262740370354162807">Attiva l'invio di documenti a <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="7717938661004793600">Configura le funzioni di accessibilità di <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Configura Google Drive in <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="8704831857353097849">Elenco dei plug-in disattivati</translation>
<translation id="467449052039111439">Apri un elenco di URL</translation>
<translation id="1988371335297483117">I payload di aggiornamento automatico su <ph name="PRODUCT_OS_NAME"/> possono essere scaricati tramite HTTP anziché tramite HTTPS. Ciò consente la memorizzazione nella cache HTTP trasparente dei download HTTP.

      Se questa norma viene impostata su true, <ph name="PRODUCT_OS_NAME"/> tenterà di scaricare payload di aggiornamento automatico tramite HTTP. Se la norma viene impostata su false o non viene impostata, per il download di payload di aggiornamento automatico verrà utilizzato HTTPS.</translation>
<translation id="5883015257301027298">Impostazione cookie predefiniti</translation>
<translation id="5017500084427291117">Consente di bloccare l'accesso agli URL elencati.

      Questa norma impedisce agli utenti di caricare pagine web degli URL vietati.

      Un URL ha il formato &quot;schema://host:porta/percorso&quot;.
      Lo schema facoltativo può essere http, https o ftp. Verrà bloccato soltanto questo schema; se non vengono specificati schemi, vengono bloccati tutti gli schemi.
      L'host può essere un nome host o un indirizzo IP. Vengono bloccati anche i sottodomini di un nome host. Per impedire il blocco dei sottodomini, inserisci &quot;.&quot; prima del nome host. Il nome host speciale &quot;*&quot; blocca tutti i domini.
      La porta facoltativa è un numero di porta valido compreso tra 1 e 65535. Se non vengono specificate porte, vengono bloccate tutte le porte.
      Se viene specificato il percorso facoltativo, vengono bloccati soltanto i percorsi con il prefisso indicato.

      È possibile definire delle eccezioni nella norma della whitelist di URL. Per queste norme è possibile definire massimo 1000 voci; le voci in più vengono ignorate.

      Se questa norma non viene impostata, tutti gli URL nel browser non saranno autorizzati.</translation>
<translation id="2762164719979766599">Specifica l'elenco di account del dispositivo da visualizzare nella schermata di accesso.

      Ogni voce in elenco specifica un identificatore che viene utilizzato internamente per distinguere i vari account del dispositivo.</translation>
<translation id="8955719471735800169">Torna all'inizio</translation>
<translation id="4557134566541205630">URL pagina Nuova scheda provider di ricerca predefinito</translation>
<translation id="546726650689747237">Ritardo oscuramento schermo in caso di utilizzo di CA</translation>
<translation id="4988291787868618635">Azione da compiere a raggiungimento ritardo inattività</translation>
<translation id="7260277299188117560">Aggiornamento automatico p2p attivato</translation>
<translation id="5316405756476735914">Permette di stabilire se consentire o meno l'impostazione dei dati locali da parte dei siti web. L'impostazione dei dati locali può essere consentita o negata per tutti i siti web. Se questa norma non viene impostata, verrà utilizzato il valore &quot;AllowImages&quot;, che potrà essere modificato dagli utenti.</translation>
<translation id="4250680216510889253">No</translation>
<translation id="1522425503138261032">Consenti ai siti di monitorare la posizione fisica degli utenti</translation>
<translation id="6467433935902485842">Consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentita l'esecuzione dei plug-in. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultPluginsSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="4423597592074154136">Specifica manualmente le impostazioni proxy</translation>
<translation id="209586405398070749">Canale stabile</translation>
<translation id="8170878842291747619">Consente di attivare il servizio Google Traduttore integrato su <ph name="PRODUCT_NAME"/>. Se attivi questa impostazione, in <ph name="PRODUCT_NAME"/> verrà visualizzata una barra degli strumenti integrata che si offrirà di tradurre la pagina, se opportuno. Se disattivi questa impostazione, gli utenti non troveranno mai la barra di traduzione. Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se questa impostazione non viene configurata, gli utenti potranno decidere se utilizzare o meno questa funzione.</translation>
<translation id="9035964157729712237">ID delle estensioni da escludere dalla blacklist</translation>
<translation id="8244525275280476362">Ritardo di recupero massimo dopo l'invalidazione di una norma</translation>
<translation id="8587229956764455752">Consenti la creazione di nuovi account utente</translation>
<translation id="7417972229667085380">Percentuale di regolazione del ritardo di inattività in modalità di presentazione (obsoleta)</translation>
<translation id="6211428344788340116">Consente di indicare i tempi di attività del dispositivo. Se questa impostazione viene impostata su True, i dispositivi registrati indicheranno i periodi di tempo di attività di un utente sul dispositivo. Se l'impostazione viene impostata su False, i tempi di attività del dispositivo non verranno registrati o indicati.</translation>
<translation id="3964909636571393861">Consente l'accesso a un elenco di URL</translation>
<translation id="1811270320106005269">Consente di attivare il blocco quando lo stato dei dispositivi <ph name="PRODUCT_OS_NAME"/> diventa inattivo o sospeso.

      Se questa impostazione viene attivata, agli utenti verrà chiesto di inserire una password per sbloccare il dispositivo dalla sospensione.

      Se questa impostazione viene disattivata, agli utenti non verrà chiesta una password per la riattivazione del dispositivo dopo la sospensione.

      Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla.

      Se la norma non viene impostata, gli utenti potranno scegliere se impostare o meno la richiesta della password per lo sblocco del dispositivo.</translation>
<translation id="383466854578875212">Consente di specificare gli host di messaggi nativi da escludere dalla lista nera.

Il valore della lista nera * indica che tutti gli host di messaggi nativi non sono autorizzati e che verranno caricati soltanto gli host di messaggi nativi elencati nella whitelist.

Per impostazione predefinita sono autorizzati tutti gli host di messaggi nativi ma, se tutti gli host sono stati aggiunti alla lista nera secondo la norma, è possibile utilizzare la whitelist per ignorare la norma.</translation>
<translation id="6022948604095165524">Azione all'avvio</translation>
<translation id="9042911395677044526">Consente di forzare l'applicazione della configurazione di rete per utente su un dispositivo <ph name="PRODUCT_OS_NAME"/>. La configurazione di rete è una stringa in formato JSON definita secondo il formato Open Network Configuration descritto all'indirizzo <ph name="ONC_SPEC_URL"/>.</translation>
<translation id="7128918109610518786">Consente di elencare gli ID delle applicazioni da visualizzare in <ph name="PRODUCT_OS_NAME"/> sotto forma di applicazioni bloccate nella barra Avvio applicazioni.

Se questa norma viene configurata, il gruppo di applicazioni è fisso e non può essere modificato dagli utenti.

Se questa norma non viene impostata gli utenti possono modificare l'elenco di applicazioni bloccate in Avvio applicazioni.</translation>
<translation id="1679420586049708690">Sessione pubblica a cui accedere automaticamente</translation>
<translation id="5836064773277134605">Limita l'intervallo di porte UDP utilizzate dall'host di accesso remoto</translation>
<translation id="7625444193696794922">Consente di specificare il canale di rilascio su cui deve essere bloccato questo dispositivo.</translation>
<translation id="2552966063069741410">Fuso orario</translation>
<translation id="3788662722837364290">Impostazioni di gestione dell'alimentazione quando l'utente diventa inattivo</translation>
<translation id="2240879329269430151">Permette di stabilire se consentire o meno la visualizzazione dei popup nei siti web. La visualizzazione dei popup può essere consentita o negata per tutti i siti web. Se questa norma non viene impostata, verrà utilizzato il valore &quot;BlockPopups&quot;, che potrà essere modificato dagli utenti.</translation>
<translation id="2529700525201305165">Limita gli utenti autorizzati ad accedere a <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Timer accesso automatico a sessione pubblica</translation>
<translation id="8285435910062771358">Ingrandimento a schermo intero attivo</translation>
<translation id="5141670636904227950">Impostazione tipo di ingrandimento dello schermo predefinito attivato nella schermata di accesso</translation>
<translation id="3864818549971490907">Impostazione plug-in predefiniti</translation>
<translation id="7151201297958662315">Consente di stabilire se avviare o meno un processo <ph name="PRODUCT_NAME"/> all'accesso al sistema operativo e se tenerlo in esecuzione dopo la chiusura dell'ultima finestra del browser per tenere attive le applicazioni in background. Nella barra delle applicazioni viene visualizzata un'icona per il processo in background che consente di chiudere il processo in qualsiasi momento.

      Se questa norma viene impostata su True, la modalità in background viene attivata e non può essere controllata dall'utente tramite le impostazioni del browser.

      Se la norma viene impostata su False, la modalità in background viene disattivata e non può essere controllata dall'utente tramite le impostazioni del browser.

      Se la norma non viene impostata, la modalità in background viene inzialmente disattivata e può essere controllata dall'utente tramite le impostazioni del browser.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 o versione successiva</translation>
<translation id="5148753489738115745">Consente di specificare dei parametri aggiuntivi da utilizzare quando <ph name="PRODUCT_FRAME_NAME"/> avvia <ph name="PRODUCT_NAME"/>.

Se questa norma non viene impostata viene utilizzata la riga di comando predefinita.</translation>
<translation id="2646290749315461919">Permette di stabilire se consentire o meno il monitoraggio della posizione fisica degli utenti da parte dei siti web. Il monitoraggio della posizione fisica degli utenti può essere consentito o negato per impostazione predefinita oppure l'utente può ricevere una richiesta ogni volta che un sito web desidera conoscere la posizione fisica. Se questa norma non viene impostata, verrà utilizzato il valore &quot;AskGeolocation&quot;, che potrà essere modificato dagli utenti.</translation>
<translation id="6394350458541421998">La norma non è più supportata a partire dalla versione 29 di <ph name="PRODUCT_OS_NAME"/>. Utilizza la norma PresentationScreenDimDelayScale.</translation>
<translation id="2956777931324644324">Questa norma è stata ritirata a partire dalla versione 36 di <ph name="PRODUCT_NAME"/>.

      Consente di specificare se attivare o meno l'estensione di certificati associati al dominio TLS.

      Questa impostazione viene utilizzata per attivare l'estensione di certificati associati al dominio TLS per l'esecuzione di test. Questa impostazione sperimentale verrà rimossa in futuro.</translation>
<translation id="5770738360657678870">Canale Dev (potrebbe essere instabile)</translation>
<translation id="2959898425599642200">Regole di bypass proxy</translation>
<translation id="228659285074633994">Consente di specificare il periodo di tempo senza immissioni da parte dell'utente dopo il quale viene mostrata una finestra di dialogo di avviso quando il computer è collegato a una presa di corrente.

          Quando è impostata, questa norma specifica per quanto tempo l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> mostri una finestra di dialogo di avviso in cui comunica all'utente che sta per essere intrapresa l'azione richiesta in caso di inattività.

          Quando questa norma non è impostata, non viene visualizzata alcuna finestra di dialogo di avviso.

          Il valore della norma deve essere specificato in millisecondi. I valori sono fissati in modo da essere minori o uguali al ritardo di inattività.</translation>
<translation id="1327466551276625742">Attivazione richiesta di configurazione della rete offline</translation>
<translation id="7937766917976512374">Consenti o nega acquisizione video</translation>
<translation id="427632463972968153">Consente di specificare i parametri utilizzati durante la ricerca di immagini con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {imageThumbnail} nell'esempio precedente, verrà sostituito con i dati delle miniature di immagini reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca di immagini verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma &quot;DefaultSearchProviderEnabled&quot; è attiva.</translation>
<translation id="8818646462962777576">I pattern di questo elenco verranno confrontati con l'origine di sicurezza dell'URL richiedente. Se viene trovata una corrispondenza, l'accesso ai dispositivi di acquisizione audio viene concesso senza richieste.

NOTA. Al momento questa norma è supportata soltanto in modalità kiosk.</translation>
<translation id="489803897780524242">Parametro di controllo sostituzione termini di ricerca per fornitore ricerca predefinito</translation>
<translation id="316778957754360075">Questa impostazione non è più supportata a partire dalla versione 29 di <ph name="PRODUCT_NAME"/>. Il metodo consigliato per la configurazione di raccolte di estensioni/app ospitate dall'organizzazione consiste nell'includere il sito che ospita i pacchetti CRX in ExtensionInstallSources e inserire link di download diretti per i pacchetti in una pagina web. È possibile creare una funzione Avvio applicazioni per la pagina web utilizzando la norma ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">Disconnetti l'utente</translation>
<translation id="4826326557828204741">Azione da compiere quando il ritardo di inattività viene raggiunto durante l'utilizzo della batteria</translation>
<translation id="7912255076272890813">Configura tipi di app/estensioni consentiti</translation>
<translation id="817455428376641507">Consente l'accesso agli URL elencati, sotto forma di eccezioni alla blacklist di URL.

      Consulta la descrizione della norma sulle blacklist di URL per il formato delle voci di questo elenco.

      Questa norma può essere utilizzata per aprire eccezioni alle blacklist restrittive. Ad esempio &quot;*&quot; può essere incluso nella blacklist per bloccare tutte le richieste e questa norma può essere utilizzata per consentire l'accesso a un elenco limitato di URL. Può essere utilizzata per aprire eccezioni rispetto a determinati schemi, sottodomini di altri domini, porte o percorsi specifici.

      Il filtro più specifico consente di determinare se un URL è bloccato o consentito. La whitelist ha la precedenza sulla blacklist.

       Per questa norma è possibile definire massimo 1000 voci; le voci in più vengono ignorate.

      Se questa norma non viene impostata, non ci saranno eccezioni alla blacklist dalla norma &quot;URLBlacklist&quot;.</translation>
<translation id="8148901634826284024">Consente di attivare la funzione di accessibilità della modalità ad alto contrasto.

Se la norma viene impostata su true, la modalità ad alto contrasto sarà sempre attiva.

Se la norma viene impostata su false, la modalità ad alto contrasto sarà sempre disattivata.

Se la norma viene impostata, gli utenti non potranno modificarla o ignorarla.

Se la norma non viene configurata, la modalità ad alto contrasto viene inizialmente disattivata ma potrà essere attivata dagli utenti in qualsiasi momento.</translation>
<translation id="2201555246697292490">Configura whitelist messaggi nativi</translation>
<translation id="6177482277304066047">Consente di impostare una versione di destinazione per gli aggiornamenti automatici.

      Consente di specificare il prefisso di una versione di destinazione a cui <ph name="PRODUCT_OS_NAME"/> dovrebbe aggiornarsi. Se sul dispositivo è in esecuzione una versione precedente al prefisso specificato, verrà eseguito l'aggiornamento alla versione più recente con il prefisso specificato. Se sul dispositivo è già presente una versione successiva, non c'è effetto (cioè non vengono eseguiti downgrade) e il dispositivo continuerà a utilizzare la versione corrente. Il formato del prefisso funziona in base ai componenti, come illustrato nel seguente esempio:

      &quot;&quot; (o non configurata): si aggiorna alla versione più recente disponibile.
      &quot;1412.&quot;: si aggiorna a qualsiasi versione minore di 1412 (ad es. 1412.24.34 o 1412.60.2)
      &quot;1412.2.&quot;: si aggiorna a qualsiasi versione minore di 1412.2 (ad es. 1412.2.34 o 1412.2.2)
      &quot;1412.24.34&quot;: si aggiorna soltanto a questa versione specifica</translation>
<translation id="8102913158860568230">Impostazione stream multimediale predefinito</translation>
<translation id="6641981670621198190">Disattiva supporto per le API grafiche 3D</translation>
<translation id="5196805177499964601">Blocca la modalità sviluppatore.

      Se questa norma viene impostata su True, <ph name="PRODUCT_OS_NAME"/> impedirà l'avvio del dispositivo in modalità sviluppatore. Il sistema non verrà avviato e verrà visualizzata una schermata di errore quando viene attivata la modalità sviluppatore.

      Se questa norma non è impostata o è impostata su False, la modalità sviluppatore continuerà a essere disponibile per il dispositivo.</translation>
<translation id="1265053460044691532">Limita il tempo per cui un utente autenticato tramite SAML può eseguire l'accesso offline</translation>
<translation id="5703863730741917647">Consente di specificare l'azione da compiere quando viene raggiunto il ritardo di inattività.

Tieni presente che questa norma è obsoleta e verrà rimossa in futuro.

Questa norma fornisce un valore di riserva per le norme più specifiche <ph name="IDLEACTIONAC_POLICY_NAME"/> e <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Se questa norma viene impostata, il suo valore viene utilizzato se non viene impostata la rispettiva norma più specifica.

Se questa norma non viene impostata, il comportamento delle norme più specifiche rimane invariato.</translation>
<translation id="5997543603646547632">Utilizza orologio di 24 ore per impostazione predefinita</translation>
<translation id="7003746348783715221">Preferenze di <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Abilita attraversamento firewall da client di accesso remoto</translation>
<translation id="2744751866269053547">Registra gestori protocolli</translation>
<translation id="6367755442345892511">Eventuale configurazione del canale della versione da parte dell'utente</translation>
<translation id="3868347814555911633">Questa norma è attiva soltanto in modalità retail.

      Consente di elencare le estensioni che vengono installate automaticamente per gli utenti Demo di dispositivi in modalità retail. Queste estensioni vengono salvate sul dispositivo e possono essere installate offline, dopo l'installazione.

      Ogni voce dell'elenco contiene un dizionario che deve includere l'ID dell'estensione nel campo &quot;extension-id&quot; e il relativo URL di aggiornamento nel campo &quot;update-url&quot;.</translation>
<translation id="9096086085182305205">Whitelist server di autenticazione</translation>
<translation id="4980301635509504364">Consente di permettere o negare l'acquisizione video.

Se la norma viene attivata o non viene configurata (impostazione predefinita), all'utente verrà richiesto l'accesso all'acquisizione video, ad eccezione degli URL configurati nell'elenco VideoCaptureAllowedUrls per cui verrà concesso l'accesso senza richieste.

Se questa norma viene disattivata, all'utente non verrà mai chiesto nulla e l'acquisizione video sarà disponibile soltanto per gli URL configurati in VideoCaptureAllowedUrls.

Questa norma viene applicata per tutti i tipi di ingressi video e non soltanto per la webcam integrata.</translation>
<translation id="7063895219334505671">Consenti popup su questi siti</translation>
<translation id="3756011779061588474">Blocca modalità sviluppatore</translation>
<translation id="4052765007567912447">Consente di stabilire se l'utente può visualizzare le password in testo non crittografato in Gestione password. Se disattivi questa impostazione, Gestione password impedisce la visualizzazione delle password memorizzate in testo non crittografato nella finestra Gestione password. Se attivi questa norma o non la imposti, gli utenti potranno visualizzare le loro password in testo non crittografato in Gestione password.</translation>
<translation id="5936622343001856595">Forza l'esecuzione delle query in Ricerca Google con l'opzione SafeSearch attiva e impedisce agli utenti di modificare questa impostazione.

      Se attivi l'impostazione, SafeSearch in Ricerca Google è sempre attiva.

      Se disattivi l'impostazione o non imposti un valore, l'utilizzo di SafeSearch non viene forzato in Ricerca Google.</translation>
<translation id="6017568866726630990">Mostra la finestra di dialogo di stampa del sistema invece dell'anteprima di stampa.

      Se l'impostazione è attivata, <ph name="PRODUCT_NAME"/> aprirà la finestra di dialogo di stampa del sistema invece dell'anteprima di stampa integrata quando un utente richiede la stampa di una pagina.

      Se il criterio non è impostato o è impostato su False, i comandi di stampa attivano la schermata dell'anteprima di stampa.</translation>
<translation id="7933141401888114454">Attivazione della creazione di utenti controllati</translation>
<translation id="2824715612115726353">Attiva modalità di navigazione in incognito</translation>
<translation id="1057535219415338480">Consente la previsione della rete in <ph name="PRODUCT_NAME"/> e impedisce agli utenti di modificare questa impostazione.

      Controlla non solo il precaricamento DNS, ma anche la preconnessione TCP ed SSL e il prerendering delle pagine web. Il nome della norma si riferisce al precaricamento DNS per motivi storici.

      Se attivi o disattivi questa impostazione, gli utenti non potranno modificare o ignorare questa impostazione in <ph name="PRODUCT_NAME"/>.

      Se questa norma non viene definita, l'impostazione verrà attivata ma l'utente sarà in grado di modificarla.</translation>
<translation id="4541530620466526913">Account del dispositivo</translation>
<translation id="5815129011704381141">Riavvia automaticamente dopo l'aggiornamento</translation>
<translation id="1757688868319862958">Consente a <ph name="PRODUCT_NAME"/> di eseguire plug-in che richiedono l'autorizzazione. Se attivi questa impostazione, i plug-in che non sono obsoleti vengono sempre eseguiti. Se questa impostazione viene disattivata o non viene impostata, agli utenti verrà chiesta l'autorizzazione di eseguire i plug-in che richiedono l'autorizzazione. Si tratta di plug-in che possono compromettere la sicurezza.</translation>
<translation id="6392973646875039351">Consente di attivare la funzione Compilazione automatica di <ph name="PRODUCT_NAME"/> e di permettere agli utenti di eseguire il completamento automatico dei moduli web utilizzando informazioni memorizzate in precedenza, come l'indirizzo o i dati della carta di credito. Se disattivi questa impostazione, gli utenti non potranno utilizzare la funzione Compilazione automatica. Se attivi questa impostazione o non imposti un valore, la funzione Compilazione automatica potrà essere gestita dagli utenti. Gli utenti potranno quindi configurare i profili di Compilazione automatica e attivare o disattivare a propria scelta la funzione Compilazione automatica.</translation>
<translation id="6157537876488211233">Elenco separato da virgole delle regole di bypass proxy</translation>
<translation id="7788511847830146438">Per profilo</translation>
<translation id="2516525961735516234">Consente di specificare se l'attività video incide o meno sulla gestione dell'alimentazione.

          Se questa norma viene impostata su True o non viene impostata, l'utente non viene considerato inattivo durante la riproduzione del video. In questo modo non viene raggiunto il ritardo di inattività, l'oscuramento dello schermo, la disattivazione dello schermo e il blocco dello schermo e non vengono compiute le azioni corrispondenti.

          Se questa norma viene impostata su False, l'attività video non impedisce di considerare inattivo l'utente.</translation>
<translation id="3965339130942650562">Timeout fino a esecuzione uscita utente non attivo</translation>
<translation id="5814301096961727113">Impostazione stato predefinito dei feedback vocali nella schermata di accesso</translation>
<translation id="1950814444940346204">Attiva funzioni piattaforma web obsolete</translation>
<translation id="9084985621503260744">Specifica se l'attività video incide sulla gestione dell'alimentazione</translation>
<translation id="7091198954851103976">Esegue sempre i plug-in che richiedono l'autorizzazione</translation>
<translation id="1708496595873025510">Imposta la limitazione sul recupero del numero di inizializzazione delle varianti</translation>
<translation id="8870318296973696995">Pagina iniziale</translation>
<translation id="1240643596769627465">Consente di specificare l'URL del motore di ricerca utilizzato per fornire risultati immediati. L'URL deve contenere la stringa &quot;<ph name="SEARCH_TERM_MARKER"/>&quot;, che sarà sostituita in fase di query dal testo inserito dall'utente fino a quel momento. Questa norma è facoltativa. Se non viene impostata, non verranno restituiti risultati di ricerca immediati. Questa norma viene rispettata soltanto se è attiva la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="6693751878507293182">Se attivi questa impostazione, la ricerca automatica e l'installazione dei plug-in mancanti verranno disattivate in <ph name="PRODUCT_NAME"/>. Se disattivi questa opzione o non la imposti, la funzione di ricerca dei plug-in sarà attiva.</translation>
<translation id="2650049181907741121">Azione da compiere quando l'utente chiude il coperchio</translation>
<translation id="7880891067740158163">Consente di specificare un elenco di pattern URL che indicano i siti per cui <ph name="PRODUCT_NAME"/> deve selezionare automaticamente un certificato client, se i siti in questione richiedono un certificato. Se questa norma non viene impostata, non verranno effettuate selezioni automatiche per i siti.</translation>
<translation id="3866249974567520381">Descrizione</translation>
<translation id="5192837635164433517">Consente di attivare l'utilizzo di pagine di errore alternative integrate in <ph name="PRODUCT_NAME"/> (come &quot;pagina non trovata&quot;) e di impedire agli utenti di modificare questa impostazione. Se attivi questa impostazione, vengono utilizzate le pagine di errore alternative. Se la disattivi, le pagine di errore alternative non vengono mai utilizzate. Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se questa norma non viene impostata, l'impostazione verrà attivata ma gli utenti potranno modificarla.</translation>
<translation id="2236488539271255289">Non consentire ai siti di impostare i dati locali</translation>
<translation id="4467952432486360968">Blocca cookie di terze parti</translation>
<translation id="1305864769064309495">Un dizionario che mappa gli URL su un flag booleano che specifica se l'accesso all'host deve essere consentito (true) oppure bloccato (false).

          Questa norma è per uso interno di Chrome.</translation>
<translation id="5586942249556966598">Non fare niente</translation>
<translation id="131353325527891113">Mostra nomi utente nella schermata di accesso</translation>
<translation id="5365946944967967336">Mostra il pulsante Pagina iniziale nella barra degli strumenti</translation>
<translation id="3709266154059827597">Configura blacklist per l'installazione delle estensioni</translation>
<translation id="1933378685401357864">Immagine di sfondo</translation>
<translation id="8451988835943702790">Usa la pagina Nuova scheda come Pagina iniziale</translation>
<translation id="4617338332148204752">Salta il controllo dei metatag in <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="8469342921412620373">Consente di attivare l'utilizzo di un provider di ricerca predefinito. Se attivi questa impostazione, quando l'utente digiterà nella omnibox del testo che non sia un URL verrà eseguita una ricerca predefinita. Puoi specificare il provider di ricerca predefinito da utilizzare impostando tutte le altre norme di ricerca predefinita. Se queste norme non vengono impostate, l'utente potrà selezionare il provider predefinito. Se disattivi questa impostazione, quando l'utente inserirà nella omnibox del testo che non sia un URL non verrà eseguita alcuna ricerca. Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se questa norma non viene impostata, verrà attivato il provider di ricerca predefinito e gli utenti potranno impostare l'elenco di provider di ricerca.</translation>
<translation id="4791031774429044540">Consente di attivare la funzione di accessibilità del puntatore grande.

Se la norma viene impostata su true, il puntatore grande sarà sempre attivo.

Se la norma viene impostata su false, il puntatore grande sarà sempre disattivato.

Se la norma viene impostata, gli utenti non potranno modificarla o ignorarla.

Se la norma non viene impostata, il puntatore grande sarà inizialmente disattivato ma gli utenti potranno attivarlo in qualsiasi momento.</translation>
<translation id="2633084400146331575">Attiva feedback vocali</translation>
<translation id="687046793986382807">Questa norma è stata ritirata a partire dalla versione 35 di <ph name="PRODUCT_NAME"/>.

      Le informazioni sulla memoria sono comunque riportate sulla pagina, indipendentemente dal valore opzione, ma le dimensioni segnalate presentano
      restrizioni e la frequenza di aggiornamento è stata limitata per motivi di sicurezza. Per acquisire dati precisi in tempo reale,
      utilizza strumenti come Telemetry.</translation>
<translation id="8731693562790917685">Le Impostazioni contenuti consentono di specificare la modalità di gestione di determinati tipi di contenuto (ad esempio Cookie, Immagini o JavaScript).</translation>
<translation id="2411919772666155530">Blocca le notifiche su questi siti</translation>
<translation id="7332963785317884918">Questa norma è obsoleta. <ph name="PRODUCT_OS_NAME"/> utilizzerà sempre la strategia di pulizia &quot;RemoveLRU&quot;.

      Consente di stabilire il comportamento di pulizia automatica sui dispositivi <ph name="PRODUCT_OS_NAME"/>. La pulizia automatica viene attivata per recuperare spazio quando la quantità di spazio libero su disco raggiunge un livello critico.

      Se questa norma viene impostata su &quot;RemoveLRU&quot;, la pulizia automatica continua a rimuovere utenti dal dispositivo in ordine di accesso meno recente fino a liberare spazio a sufficienza.

      Se questa norma viene impostata su &quot;RemoveLRUIfDormant&quot;, la pulizia automatica continua a rimuovere gli utenti che non hanno eseguito l'accesso negli ultimi tre mesi in ordine di accesso meno recente fino a liberare spazio a sufficienza.

      Se questa norma non viene impostata, la pulizia automatica utilizza la strategia incorporata predefinita, che al momento è &quot;RemoveLRUIfDormant&quot;.</translation>
<translation id="6923366716660828830">Consente di specificare il nome del provider di ricerca predefinito. Se il nome non viene impostato verrà utilizzato il nome host specificato nell'URL di ricerca. Questa norma viene considerata soltanto se è attiva la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="4869787217450099946">Specifica se sono consentiti i Wakelock dello schermo. I Wakelock dello schermo possono essere richiesti dalle estensioni tramite l'API dell'estensione di gestione dell'alimentazione.

          Se questa norma è impostata su True o non è impostata, verranno rispettati i Wakelock dello schermo nella gestione dell'alimentazione.

          Se questa norma è impostata su False, le richieste di Wakelock dello schermo verranno ignorate.</translation>
<translation id="467236746355332046">Funzionalità supportate:</translation>
<translation id="5447306928176905178">Attiva le informazioni relative ai rapporti sulla memoria (dimensioni heap JS) per la pagina (obsoleto)</translation>
<translation id="7632724434767231364">Nome della libreria GSSAPI</translation>
<translation id="3038323923255997294">Continua a eseguire applicazioni in background dopo la chiusura di <ph name="PRODUCT_NAME"/></translation>
<translation id="8909280293285028130">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene bloccato quando viene utilizzata la corrente alternata.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> blocchi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME"/> non blocca lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il metodo consigliato per bloccare lo schermo in caso di inattività consiste nell'attivare il blocco dello schermo in caso di sospensione e fare in modo che <ph name="PRODUCT_OS_NAME"/> sospenda dopo il ritardo di inattività. Questa norma dovrebbe essere utilizzata soltanto quando il blocco dello schermo dovrebbe avvenire molto tempo prima della sospensione o quando non si desidera affatto la sospensione in caso di inattività.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori al ritardo di inattività.</translation>
<translation id="7651739109954974365">È possibile stabilire se attivare o meno il roaming dei dati per il dispositivo. Se la norma viene impostata su true, il roaming dei dati sarà consentito. Se non viene configurata o viene impostata su false, il roaming dei dati non sarà disponibile.</translation>
<translation id="6244210204546589761">Pagine da aprire all'avvio</translation>
<translation id="7468416082528382842">Posizione del Registro di sistema di Windows:</translation>
<translation id="1808715480127969042">Blocca cookie su questi siti</translation>
<translation id="1908884158811109790">Consente di disattivare Google Drive su connessioni cellulari nell'app File di Chrome OS</translation>
<translation id="7340034977315324840">Indicazione tempi di attività del dispositivo</translation>
<translation id="4928632305180102854">È possibile stabilire se consentire o meno la creazione di nuovi account utente in <ph name="PRODUCT_OS_NAME"/>.

      Se questa norma viene impostata su true o non viene configurata, sarà possibile creare nuovi account utente se la norma <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/> non impedisce l'accesso agli utenti.</translation>
<translation id="4389091865841123886">Configura l'attestazione da remoto con meccanismo TPM.</translation>
<translation id="9175109938712007705">Alla luce del fatto che i controlli della revoca online soft-fail non offrono un effettivo vantaggio per la sicurezza, sono disattivati per impostazione predefinita nella versione 19 e nelle versioni successive di <ph name="PRODUCT_NAME"/>. Se questa norma viene impostata su true, viene ripristinato il comportamento precedente e vengono effettuati controlli OCSP/CRL.

      Se la norma non viene impostata o viene impostata su false, Chrome non effettuerà i controlli della revoca online in Chrome 19 e nelle versioni successive.</translation>
<translation id="8256688113167012935">Controlla il nome account visualizzato da <ph name="PRODUCT_OS_NAME"/> nella schermata di accesso per il corrispondente account del dispositivo.

      Se il criterio è impostato, la schermata di accesso utilizzerà la stringa specificata nel selettore di accesso basato su immagine per il corrispondente account del dispositivo.

      Se il criterio non viene impostato, <ph name="PRODUCT_OS_NAME"/> utilizzerà l'ID account email dell'account dispositivo come nome visualizzato nella schermata di accesso.

      Questo criterio viene ignorato per gli account utente standard.</translation>
<translation id="267596348720209223">Consente di specificare le codifiche dei caratteri supportate dal provider di ricerca. Le codifiche sono nomi di pagine codificati come UTF-8, GB2312 e ISO-8859-1. Vengono provate nell'ordine indicato. Questa norma è facoltativa. Se non viene impostata viene utilizzato il valore predefinito UTF-8. Questa norma viene rispettata soltanto se è attiva la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="1349276916170108723">Consente di disattivare la sincronizzazione di Google Drive nell'app File di Chrome OS quando la norma è impostata su True. In tal caso, nessun dato viene caricato su Google Drive.

          Se la norma non è impostata o è impostata su False, gli utenti possono trasferire i file su Google Drive.</translation>
<translation id="1964634611280150550">Modalità di navigazione in incognito non attiva</translation>
<translation id="5971128524642832825">Consente di disattivare Drive nell'app File di Chrome OS</translation>
<translation id="1847960418907100918">Consente di specificare i parametri utilizzati durante la ricerca istantanea con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {searchTerms} nell'esempio precedente, verrà sostituito con i dati dei termini di ricerca reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca istantanea verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma &quot;DefaultSearchProviderEnabled&quot; è attiva.</translation>
<translation id="6095999036251797924">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene bloccato durante l'utilizzo di alimentazione CA o batteria.

Se il periodo di tempo viene impostato su un valore maggiore di zero, questo valore rappresenta il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> blocchi lo schermo.

Se il periodo di tempo viene impostato su zero, <ph name="PRODUCT_OS_NAME"/> non blocca lo schermo quando l'utente diventa inattivo.

Se il periodo di tempo non viene impostato, viene utilizzato un periodo di tempo predefinito.

La modalità di blocco dello schermo per inattività consigliata è l'attivazione del blocco schermo in caso di sospensione e la sospensione di <ph name="PRODUCT_OS_NAME"/> una volta trascorso il ritardo di inattività. Questa norma dovrebbe essere utilizzata soltanto quando il blocco dello schermo deve avvenire molto prima della sospensione o quando non si desidera attivare la sospensione in caso di inattività.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere minori del ritardo di inattività.</translation>
<translation id="1454846751303307294">Consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentita l'esecuzione di JavaScript. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultJavaScriptSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="538108065117008131">Consenti a <ph name="PRODUCT_FRAME_NAME"/> di gestire i seguenti tipi di contenuto.</translation>
<translation id="2312134445771258233">Consente di configurare le pagine che vengono caricate all'avvio. I contenuti dell'elenco &quot;Pagine da aprire all'avvio&quot; vengono ignorati a meno che non selezioni &quot;Apri un elenco di URL&quot; in &quot;Azione all'avvio&quot;.</translation>
<translation id="1464848559468748897">Consente di controllare il comportamento degli utenti in una sessione multiprofilo su dispositivi <ph name="PRODUCT_OS_NAME"/>.

      Se questa norma viene impostata su &quot;MultiProfileUserBehaviorUnrestricted&quot;, l'utente può essere l'utente principale o secondario di una sessione multiprofilo.

      Se questa norma viene impostata su &quot;MultiProfileUserBehaviorMustBePrimary&quot;, l'utente può essere soltanto l'utente principale di una sessione multiprofilo.

      Se questa norma viene impostata su &quot;MultiProfileUserBehaviorNotAllowed&quot;, l'utente non può fare parte di una sessione multiprofilo.

      Se questa norma viene impostata, gli utenti non possono cambiarla o sostituirla.

      Se l'impostazione viene cambiata e l'utente ha eseguito l'accesso in una sessione multiprofilo, tutti gli utenti della sessione verranno confrontati con le relative impostazioni corrispondenti. La sessione viene chiusa se uno degli utenti non può più fare parte della sessione.

      Se la norma non viene impostata, per gli utenti gestiti dall'azienda viene applicato il valore predefinito &quot;MultiProfileUserBehaviorMustBePrimary&quot;, mentre per gli utenti non gestiti viene applicato il valore &quot;MultiProfileUserBehaviorUnrestricted&quot;.</translation>
<translation id="243972079416668391">Consente di specificare l'azione da compiere quando viene raggiunto il ritardo di inattività durante l'utilizzo della corrente CA.

Se questa norma viene impostata, consente di specificare l'azione compiuta da <ph name="PRODUCT_OS_NAME"/> quando l'utente rimane inattivo per il periodo di tempo indicato dal ritardo di inattività, che può essere configurato separatamente.

Se questa norma non viene impostata, viene compiuta l'azione predefinita, vale a dire la sospensione.

Se l'azione viene sospesa, <ph name="PRODUCT_OS_NAME"/> può essere configurato separatamente per bloccare o non bloccare lo schermo prima della sospensione.</translation>
<translation id="7750991880413385988">Apri pagina Nuova scheda</translation>
<translation id="5761030451068906335">Consente di configurare le impostazioni proxy per <ph name="PRODUCT_NAME"/>. Questa norma non è ancora pronta per essere utilizzata, pertanto invitiamo a non utilizzarla.</translation>
<translation id="8344454543174932833">Importa Preferiti dal browser predefinito alla prima esecuzione</translation>
<translation id="1019101089073227242">Imposta directory dati utente</translation>
<translation id="5826047473100157858">Consente di specificare se l'utente può aprire o meno le pagine in modalità di navigazione in incognito in <ph name="PRODUCT_NAME"/>. Se viene selezionata l'opzione &quot;Attiva&quot; o la norma non viene impostata, le pagine possono essere aperte in modalità di navigazione in incognito. Se viene selezionata l'opzione &quot;Non attiva&quot;, le pagine non possono essere aperte in modalità di navigazione in incognito. Se viene selezionata l'opzione &quot;Forzata&quot;, le pagine possono essere aperte SOLTANTO in modalità di navigazione in incognito.</translation>
<translation id="2988031052053447965">Nascondi l'app Chrome Web Store e il link nel piè di pagina nella pagina Nuova scheda e in Avvio applicazioni di Chrome OS.

      Quando questa norma è impostata su true, le icone sono nascoste.

      Quando questa norma è impostata su false o non è configurata, le icone sono visibili.</translation>
<translation id="5085647276663819155">Disattiva anteprima di stampa</translation>
<translation id="8672321184841719703">Scegli versione target dell'aggiornamento automatico</translation>
<translation id="553658564206262718">Consente di configurare le impostazioni di gestione dell'alimentazione quando l'utente diventa inattivo.

Questa norma consente di controllare diverse impostazioni relative alla strategia di gestione dell'alimentazione quando l'utente diventa inattivo.

Esistono quattro tipi di azioni:
* Lo schermo viene oscurato se l'utente rimane inattivo per il tempo specificato da |ScreenDim|.
* Lo schermo viene spento se l'utente rimane inattivo per il tempo specificato da |ScreenOff|.
* Se l'utente rimane inattivo per il tempo specificato da |IdleWarning|, viene visualizzata una finestra di dialogo di avviso per indicare all'utente che sta per essere compiuta l'azione per inattività.
* Se l'utente rimane inattivo per il tempo specificato da |Idle|, viene compiuta l'azione specificata da |IdleAction|.

Per ognuna delle azioni precedenti, il ritardo deve essere specificato in millisecondi e deve essere impostato un valore maggiore di zero per poter attivare l'azione corrispondente. Se il ritardo viene impostato su zero, <ph name="PRODUCT_OS_NAME"/> non compie l'azione corrispondente.

Per ogni ritardo sopra indicato, se non viene impostato il periodo di tempo viene utilizzato il valore predefinito.

I valori |ScreenDim| devono essere inferiori o uguali al valore di |ScreenOff|, mentre i valori di |ScreenOff| e |IdleWarning| devono essere inferiori o uguali al valore di |Idle|.

Il valore di |IdleAction| può essere una delle seguenti quattro azioni possibili:
* |Suspend|
* |Logout|
* |Shutdown|
* |DoNothing|

Se il valore |IdleAction| non viene impostato, viene compiuta l'azione predefinita, vale a dire la sospensione.

Esistono inoltre impostazioni separate per l'alimentazione CA e la batteria.
          </translation>
<translation id="1689963000958717134">Consente di forzare l'applicazione della configurazione di rete per tutti gli utenti di un dispositivo <ph name="PRODUCT_OS_NAME"/>. La configurazione di rete è una stringa in formato JSON definita secondo il formato Open Network Configuration descritto all'indirizzo <ph name="ONC_SPEC_URL"/>.</translation>
<translation id="6699880231565102694">Abilita autenticazione a due fattori per gli host di accesso remoto</translation>
<translation id="2030905906517501646">Parola chiave del provider di ricerca predefinito</translation>
<translation id="3072045631333522102">Screensaver da utilizzare nella schermata di accesso in modalità retail</translation>
<translation id="4550478922814283243">Attiva o disattiva l'autenticazione senza PIN</translation>
<translation id="7712109699186360774">Chiedi ogni volta che un sito vuole accedere alla fotocamera e/o al microfono</translation>
<translation id="350797926066071931">Abilita traduzione</translation>
<translation id="3711895659073496551">Sospensione</translation>
<translation id="4010738624545340900">Consenti richiamo di finestre di dialogo di selezione file</translation>
<translation id="4518251772179446575">Chiedi ogni volta che un sito desidera monitorare la posizione fisica degli utenti</translation>
<translation id="402759845255257575">Non consentire ad alcun sito di eseguire JavaScript</translation>
<translation id="5457924070961220141">Consente di configurare il renderer HTML predefinito se <ph name="PRODUCT_FRAME_NAME"/> è installato. Se questa norma non viene impostata, per impostazione predefinita il rendering viene eseguito dal browser host; tuttavia, in alternativa, puoi sostituire tale impostazione e consentire che l'esecuzione del rendering delle pagine HTML venga eseguita, per impostazione predefinita, da <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="706669471845501145">Consenti la visualizzazione di notifiche desktop da parte dei siti</translation>
<translation id="7529144158022474049">Fattore di dispersione aggiornamento automatico</translation>
<translation id="2188979373208322108">Consente di attivare la barra dei Preferiti in <ph name="PRODUCT_NAME"/>. Se attivi questa impostazione verrà visualizzata una barra dei Preferiti in <ph name="PRODUCT_NAME"/>. Se disattivi questa impostazione, gli utenti non potranno mai visualizzare la barra dei Preferiti. Se l'impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se questa impostazione non viene impostata, gli utenti potranno decidere se utilizzare o meno questa funzione.</translation>
<translation id="7593523670408385997">Consente di configurare le dimensioni della cache che verranno utilizzate da <ph name="PRODUCT_NAME"/> per archiviare sul disco i file memorizzati nella cache.

Se questa norma viene impostata, <ph name="PRODUCT_NAME"/> utilizzerà le dimensioni della cache indicate a prescindere dalla specifica o meno da parte dell'utente del flag &quot;--disk-cache-size&quot;. Il valore specificato in questa norma non è un limite rigido ma un suggerimento per il sistema di memorizzazione nella cache. I valori inferiori ad alcuni megabyte sono troppo piccoli e verranno arrotondati a un valore minimo ragionevole.

Se il valore di questa norma è 0, verranno utilizzate le dimensioni della cache predefinite, che l'utente non potrà modificare.

Se questa norma non viene impostata, verranno utilizzate le dimensioni predefinite, che l'utente potrà sostituire con il flag --disk-cache-size.</translation>
<translation id="5475361623548884387">Attiva la stampa</translation>
<translation id="7287359148642300270">Consente di specificare quali server devono essere autorizzati per l'autenticazione integrata. L'autenticazione integrata è attivata solo quando <ph name="PRODUCT_NAME"/> riceve una richiesta di autenticazione da un proxy o da un server che si trova in questo elenco di autorizzazione.

          Separa più nomi di server con delle virgole. Sono ammessi i caratteri jolly (*).

          Se questa norma non viene impostata, Chrome tenterà di rilevare se sulla Intranet è presente un server e solo allora risponderà alle richieste IWA. Se viene rilevato un server su Internet, le sue richieste IWA verranno ignorate da Chrome.</translation>
<translation id="3653237928288822292">Icona del provider di ricerca predefinito</translation>
<translation id="4721232045439708965">Consente di specificare il comportamento all'avvio.

          Se viene selezionata l'opzione &quot;Apri pagina Nuova scheda&quot;, all'avvio di <ph name="PRODUCT_NAME"/> verrà sempre aperta la pagina Nuova scheda.

          Se viene selezionata l'opzione &quot;Ripristina l'ultima sessione&quot;, verranno riaperti gli URL che erano aperti l'ultima volta che è stato chiuso <ph name="PRODUCT_NAME"/> e la sessione di navigazione verrà ripristinata così com'era.
          La selezione di questa opzione comporta la disattivazione di alcune impostazioni basate sulle sessioni o che compiono azioni all'uscita (ad esempio la cancellazione dei dati di navigazione alla chiusura o dei cookie della sessione).

          Se viene selezionata l'opzione &quot;Apri un elenco di URL&quot;, quando un utente avvia <ph name="PRODUCT_NAME"/>, viene aperto l'elenco di &quot;URL da aprire all'avvio&quot;.

          Se questa impostazione viene attivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>.

          Disattivare questa impostazione equivale a non configurarla. Gli utenti potranno modificarla in <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2872961005593481000">Spegni</translation>
<translation id="4445684791305970001">Consente di disattivare gli Strumenti per sviluppatori e la Console JavaScript. Se attivi questa impostazione, gli Strumenti per sviluppatori non saranno accessibili e non sarà più possibile eseguire un'ispezione degli elementi del sito web. Le scorciatoie da tastiera e le voci dei menu contestuali e di altri menu che consentono di aprire gli Strumenti per sviluppatori o la Console JavaScript verranno disattivate. Se disattivi questa opzione o non la imposti sarà possibile utilizzare gli Strumenti per sviluppatori e la Console JavaScript.</translation>
<translation id="9203071022800375458">Disabilita l'acquisizione di screenshot.

      Se questa norma è abilitata, non è possibile acquisire screenshot utilizzando scorciatoie da tastiera o API di estensioni.

      Se questa norma è disabilitata o non specificata, l'acquisizione di screenshot è consentita.</translation>
<translation id="5697306356229823047">Segnala utenti dispositivo</translation>
<translation id="8649763579836720255">I dispositivi Chrome OS possono utilizzare un'attestazione remota (Accesso verificato) per ottenere un certificato emesso dalla CA di Chrome OS in cui si afferma che il dispositivo è idoneo a riprodurre contenuti protetti. Questo processo comporta l'invio alla CA di Chrome OS di informazioni di approvazione dell'hardware che identificano in modo univoco il dispositivo.

Se questa impostazione viene impostata su false, il dispositivo non utilizzerà l'attestazione remota per la protezione dei contenuti e il dispositivo potrebbe non essere in grado di riprodurre i contenuti protetti.

Se l'impostazione viene impostata su true, o se non viene impostata, l'attestazione remota potrebbe essere utilizzata per la protezione dei contenuti.</translation>
<translation id="4632343302005518762">Consenti a <ph name="PRODUCT_FRAME_NAME"/> di gestire i tipi di contenuti elencati</translation>
<translation id="13356285923490863">Nome norma</translation>
<translation id="557658534286111200">Abilita o disabilita la modifica dei Preferiti</translation>
<translation id="5378985487213287085">Permette di stabilire se consentire o meno la visualizzazione di notifiche desktop nei siti web. La visualizzazione di notifiche desktop può essere consentita o negata per impostazione predefinita oppure l'utente può ricevere una richiesta ogni volta che un sito web desidera visualizzare le notifiche desktop. Se questa norma non viene impostata, verrà utilizzato il valore &quot;AskNotifications&quot;, che potrà essere modificato dagli utenti.</translation>
<translation id="2386362615870139244">Consenti Wakelock dello schermo</translation>
<translation id="6908640907898649429">Configura il provider di ricerca predefinito. Puoi specificare il provider di ricerca predefinito che l'utente utilizzerà oppure scegliere di disattivare la ricerca predefinita.</translation>
<translation id="6544897973797372144">Se questa norma è impostata su True e non è specificata la norma ChromeOsReleaseChannel, gli utenti del dominio di registrazione avranno la facoltà di modificare il canale della versione del dispositivo. Se questa norma è impostata su False, il dispositivo risulterà bloccato in qualunque canale in cui è stato impostato per ultimo.

      Il canale selezionato dall'utente verrà sostituito dalla norma ChromeOsReleaseChannel, ma se il canale della norma è più stabile di quello che è stato installato sul dispositivo, il canale cambierà solo quando la versione del canale più stabile raggiungerà un numero di versione superiore rispetto a quello installato sul dispositivo.</translation>
<translation id="389421284571827139">Consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare le impostazioni del proxy. Se decidi di non utilizzare mai un server proxy e di eseguire sempre un collegamento diretto, tutte le altre opzioni vengono ignorate. Se scegli di rilevare automaticamente il server proxy, tutte le altre opzioni vengono ignorate. Per esempi dettagliati, visita il sito: <ph name="PROXY_HELP_URL"/>. Se attivi questa impostazione, <ph name="PRODUCT_NAME"/> ignora tutte le opzioni correlate al proxy specificate dalla riga di comando. Se queste norme non vengono impostate, gli utenti potranno scegliere autonomamente le impostazioni del proxy.</translation>
<translation id="681446116407619279">Schemi di autenticazione supportati</translation>
<translation id="4027608872760987929">Attiva il provider di ricerca predefinito</translation>
<translation id="2223598546285729819">Impostazione di notifica predefinita</translation>
<translation id="6158324314836466367">Nome del web store dell'azienda (obsoleta)</translation>
<translation id="3984028218719007910">Consente di stabilire se tenere o meno memorizzati in <ph name="PRODUCT_OS_NAME"/> i dati degli account locali dopo l'uscita. Se la norma viene impostata su true, in <ph name="PRODUCT_OS_NAME"/> non verranno conservati gli account persistenti e tutti i dati della sessione utente verranno eliminati dopo l'uscita. Se la norma viene impostata su false o non viene configurata, il dispositivo potrebbe conservare i dati utente locali (crittografati).</translation>
<translation id="3793095274466276777">Configura i controlli del browser predefinito in <ph name="PRODUCT_NAME"/> e impedisce agli utenti di modificarli. Se attivi questa impostazione, all'avvio <ph name="PRODUCT_NAME"/> verifica sempre di essere il browser predefinito e, se possibile, si registra automaticamente. Se l'impostazione è disattivata, <ph name="PRODUCT_NAME"/> non potrà mai verificare di essere il browser predefinitoe disattiva i controlli utente per rendere attiva l'opzione. Se l'impostazione non è configurata, <ph name="PRODUCT_NAME"/> consente all'utente di controllare se il browser predefinito è impostato e, in caso contrario, se devono essere visualizzate le notifiche per gli utenti.</translation>
<translation id="3504791027627803580">Consente di specificare l'URL del motore di ricerca utilizzato per la ricerca di immagini. Le richieste di ricerca verranno inviate con il metodo GET. Se viene impostata la norma DefaultSearchProviderImageURLPostParams, per le richieste di ricerca di immagini viene utilizzato il metodo POST.

Questa norma è facoltativa. Se non viene impostata, non verrà utilizzata la ricerca di immagini.

Questa norma viene rispettata soltanto se viene attivata la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="7529100000224450960">Consente di impostare un elenco di pattern URL che specificano i siti in cui è consentita l'apertura dei popup. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultPopupsSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="6155936611791017817">Impostazione stato predefinito del puntatore grande nella schermata di accesso</translation>
<translation id="1530812829012954197">Visualizza sempre i seguenti schemi URL nel browser host</translation>
<translation id="9026000212339701596">Un dizionario che mappa i nomi host su un flag booleano che specifica se l'accesso all'host deve essere consentito (true) oppure bloccato (false).

          Questa norma è per uso interno di Chrome.</translation>
<translation id="913195841488580904">Blocca l'accesso a un elenco di URL</translation>
<translation id="5461308170340925511">Consente di configurare le norme relative alle estensioni. L'utente non può installare estensioni non autorizzate a meno che facciano parte della whitelist. Puoi anche forzare l'installazione automatica di estensioni in <ph name="PRODUCT_NAME"/> specificandole in <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Le estensioni a installazione forzata vengono installate indipendentemente dal fatto che facciano parte o meno della lista nera.</translation>
<translation id="3292147213643666827">Consente a <ph name="PRODUCT_NAME"/> di fungere da proxy tra <ph name="CLOUD_PRINT_NAME"/> e le stampanti preesistenti collegate al computer.

      Se l'impostazione è attivata o non è configurata, gli utenti possono attivare il proxy Cloud Print attraverso l'autenticazione con il proprio account Google.

      Se l'impostazione è disattivata, gli utenti non possono attivare il proxy e il computer non può condividere le stampanti con <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="6373222873250380826">Se questa norma viene impostata su True, gli aggiornamenti automatici vengono disattivati.

      Se questa impostazione non viene configurata o viene impostata su False, i dispositivi <ph name="PRODUCT_OS_NAME"/> controllano automaticamente la disponibilità di aggiornamenti.</translation>
<translation id="6190022522129724693">Impostazione popup predefiniti</translation>
<translation id="847472800012384958">Non consentire la visualizzazione di popup nei siti</translation>
<translation id="4733471537137819387">Norme relative all'autenticazione HTTP integrata.</translation>
<translation id="8501011084242226370">Specifica un elenco di plug-in che l'utente può attivare o disattivare in <ph name="PRODUCT_NAME"/>.

      I caratteri jolly &quot;*&quot; e &quot;?&quot; corrispondono a sequenze di caratteri arbitrari. &quot;*&quot; corrisponde a un numero di caratteri arbitrario, mentre &quot;?&quot; specifica un carattere singolo opzionale, ad esempio, caratteri zero o uno. Il carattere di escape è &quot;\&quot; e viene anteposto ai caratteri &quot;*&quot; e &quot;?&quot; per ricercarli come valori letterali.

      Se questa impostazione viene attivata, l'elenco di plug-in specificato può essere utilizzato in <ph name="PRODUCT_NAME"/>. Gli utenti possono attivarli o disattivarli in &quot;about:plugins&quot;, anche se il plug-in corrisponde a un pattern in DisabledPlugins. Gli utenti possono anche attivare e disattivare i plug-in che non corrispondono ad alcun pattern in DisabledPlugins, DisabledPluginsExceptions e EnabledPlugins.

      Questa norma consente di creare una lista nera rigida dei plug-in, in cui l'elenco &quot;DisabledPlugins&quot; contiene voci con caratteri jolly come disattiva tutti i plug-in &quot;*&quot; o disattiva tutti i plug-in Java &quot;*Java*&quot;, ma l'amministratore desidera attivare alcune versioni specifiche come &quot;IcedTea Java 2.3&quot;. Queste versioni specifiche possono essere definite in questa norma.

      Nota che devono essere esclusi sia il nome del plug-in sia il nome del gruppo del plug-in. Ogni gruppo di plug-in viene visualizzato in una sezione distinta in about:plugins. Ogni sezione può contenere uno o più plug-in. Ad esempio, il plug-in &quot;Shockwave Flash&quot; fa parte del gruppo &quot;Adobe Flash Player&quot; ed entrambi i nomi devono avere una corrispondenza nell'elenco delle eccezioni, se quel determinato plug-in deve essere escluso dalla lista nera.

      Se questa norma non viene impostata, i plug-in che corrispondono a pattern in &quot;DisabledPlugins&quot; vengono bloccati e l'utente non può attivarli.</translation>
<translation id="8951350807133946005">Impostazione directory della cache su disco</translation>
<translation id="603410445099326293">Parametri per l'URL del suggerimento che utilizza POST</translation>
<translation id="2592091433672667839">Durata inattività prima della visualizzazione dello screensaver nella schermata di accesso in modalità retail</translation>
<translation id="166427968280387991">Server proxy</translation>
<translation id="2805707493867224476">Consenti la visualizzazione di popup in tutti i siti</translation>
<translation id="1727394138581151779">Consente di bloccare tutti i plug-in</translation>
<translation id="8118665053362250806">Imposta le dimensioni della cache su disco di supporto</translation>
<translation id="6565312346072273043">Imposta lo stato predefinito della funzione di accessibilità della tastiera sullo schermo nella schermata di accesso.

          Se questa norma viene impostata su true, la tastiera sullo schermo viene attivata quando viene visualizzata la schermata di accesso.

          Se questa norma viene impostata su false, la tastiera sullo schermo viene disattivata quando viene visualizzata la schermata di accesso.

          Se questa norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando la tastiera sullo schermo. Tuttavia, la scelta dell'utente non è permanente e l'impostazione predefinita viene ripristinata ogni volta che viene visualizzata la schermata di accesso o se l'utente rimane inattivo sulla schermata di acceso per un minuto.

          Se questa norma non viene impostata, la tastiera sullo schermo è disattivata alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare la tastiera sullo schermo in qualsiasi momento e il relativo stato sulla schermata di accesso viene mantenuto tra utenti differenti.</translation>
<translation id="7079519252486108041">Blocca popup su questi siti</translation>
<translation id="1859633270756049523">Limita la durata della sessione</translation>
<translation id="7433714841194914373">Abilita Instant</translation>
<translation id="4983201894483989687">Consenti esecuzione dei plug-in obsoleti</translation>
<translation id="443665821428652897">Cancella i dati del sito alla chiusura del browser (obsoleta)</translation>
<translation id="3823029528410252878">Consente di disattivare il salvataggio della cronologia del browser in <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare questa impostazione. Se questa impostazione viene attivata, la cronologia di navigazione non viene salvata. Se viene disattivata o non viene impostata, la cronologia di navigazione viene salvata.</translation>
<translation id="7295019613773647480">Attiva utenti supervisionati</translation>
<translation id="2759224876420453487">Controlla il comportamento dell'utente in una sessione profilo multiplo</translation>
<translation id="3844092002200215574">Configura la directory che <ph name="PRODUCT_NAME"/> utilizzerà per la memorizzazione dei file della cache su disco.

      Se imposti questa norma, <ph name="PRODUCT_NAME"/> utilizzerà la directory fornita, indipendentemente dal fatto che l'utente abbia specificato o meno il flag &quot;--disk-cache-dir&quot;.

      Visita http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per un elenco di variabili utilizzabili.

      Se questa norma non viene impostata, verrà utilizzata la directory della cache predefinita e l'utente sarà in grado di ignorarla con il flag della riga di comando &quot;--disk-cache-dir&quot;.</translation>
<translation id="3034580675120919256">Permette di stabilire se consentire o meno l'esecuzione di JavaScript nei siti web. L'esecuzione di JavaScript può essere consentita o negata per tutti i siti web. Se questa norma non viene impostata, verrà utilizzato il valore &quot;AllowJavaScript&quot;, che potrà essere modificato dagli utenti.</translation>
<translation id="193900697589383153">Consente di aggiungere un pulsante di uscita all'area di notifica.

      Se il criterio è attivato, nell'area di notifica viene visualizzato un grosso pulsante di uscita rosso quando è attiva una sessione e lo schermo non è bloccato.

      Se il criterio è disattivato o non specificato, non viene visualizzato il grosso pulsante di uscita rosso nell'area di notifica.</translation>
<translation id="5111573778467334951">Consente di specificare l'azione da compiere quando viene raggiunto il ritardo di inattività durante l'utilizzo della batteria.

Se questa norma viene impostata, consente di specificare l'azione compiuta da <ph name="PRODUCT_OS_NAME"/> quando l'utente rimane inattivo per il periodo di tempo indicato dal ritardo di inattività, che può essere configurato separatamente.

Se questa norma non viene impostata, viene compiuta l'azione predefinita, vale a dire la sospensione.

Se l'azione viene sospesa, <ph name="PRODUCT_OS_NAME"/> può essere configurato separatamente per bloccare o non bloccare lo schermo prima della sospensione.</translation>
<translation id="3195451902035818945">Consente di specificare se disattivare o meno la suddivisione dei record SSL. La suddivisione dei record è una soluzione a una debolezza di SSL 3.0 e TLS 1.0 ma potrebbe causare problemi di compatibilità con alcuni proxy e server HTTPS. Se la norma non viene impostata o viene impostata su false, la suddivisione dei record verrà utilizzata per le connessioni SSL/TLS che utilizzano ciphersuite CBC.</translation>
<translation id="6903814433019432303">Questa norma è attiva soltanto in modalità retail.

      Consente di stabilire l'insieme di URL da caricare all'avvio della sessione demo. Questa norma sostituirà qualsiasi altro meccanismo di impostazione dell'URL iniziale ed è quindi possibile applicarla soltanto a una sessione non associata a un determinato utente.</translation>
<translation id="5868414965372171132">Configurazione di rete a livello di utente</translation>
<translation id="8519264904050090490">URL delle eccezioni manuali per gli utenti gestiti</translation>
<translation id="4480694116501920047">Forza SafeSearch</translation>
<translation id="465099050592230505">URL del web store dell'azienda (obsoleta)</translation>
<translation id="2006530844219044261">Gestione dell'alimentazione</translation>
<translation id="1221359380862872747">Carica gli URL specificati all'accesso demo</translation>
<translation id="8711086062295757690">Consente di specificare la parola chiave, che è la scorciatoia utilizzata nella omnibox per attivare la ricerca con il provider. Questa norma è facoltativa. Se non viene impostata, nessuna parola chiave attiverà il provider di ricerca. Questa norma viene considerata soltanto se è attiva la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="1152117524387175066">Consente di indicare lo stato dello switch dev del dispositivo all'avvio. Se la norma viene impostata su False, lo stato dello switch dev non viene indicato.</translation>
<translation id="5774856474228476867">URL di ricerca del provider di ricerca predefinito</translation>
<translation id="4650759511838826572">Disabilita schemi di protocollo dell'URL</translation>
<translation id="7831595031698917016">Consente di specificare il ritardo massimo in millisecondi tra il ricevimento dell'invalidamento di una norma e il recupero della nuova norma dal servizio di gestione del dispositivo.

Se questa norma viene impostata, il suo valore sostituisce il valore predefinito di 5000 millisecondi. I valori validi di questa norma sono compresi tra 1000 (1 secondo) e 300000 (5 minuti). I valori non compresi in questo intervallo verranno fissati al rispettivo limite.

Se questa norma non viene impostata, <ph name="PRODUCT_NAME"/> utilizzerà il valore predefinito di 5000 millisecondi.</translation>
<translation id="8099880303030573137">Ritardo inattività in caso di utilizzo della batteria</translation>
<translation id="1709037111685927635">Configurazione dell'immagine di sfondo.

      Questa norma ti consente di configurare l'immagine di sfondo che viene visualizzata dall'utente sul desktop e sullo sfondo della schermata di accesso. La norma viene impostata specificando l'URL da cui <ph name="PRODUCT_OS_NAME"/> può scaricare l'immagine di sfondo e un hash di crittografia utilizzato per verificare l'integrità del download. L'immagine deve essere in formato JPEG e avere dimensioni non superiori a 16 MB. L'URL deve essere accessibile senza nessuna autenticazione.

      L'immagine di sfondo viene scaricata e memorizzata nella cache. Verrà scaricata nuovamente ogni volta che l'URL o l'hash vengono modificati.

      La norma deve essere specificata sotto forma di stringa, in cui l'URL e l'hash vengono espressi in formato JSON, conformemente allo schema riportato di seguito:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;L'URL da cui può essere scaricata l'immagine di sfondo.&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;L'hash SHA-256 dell'immagine di sfondo.&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Se questa norma viene impostata, <ph name="PRODUCT_OS_NAME"/> scaricherà e utilizzerà l'immagine di sfondo.

      Se imposti questa norma, gli utenti non potranno modificarla o sostituirla.

      Se la norma non viene impostata, l'utente può scegliere un'immagine da visualizzare sul desktop e sullo sfondo della schermata di accesso.</translation>
<translation id="2761483219396643566">Ritardo avviso inattività in caso di utilizzo della batteria</translation>
<translation id="6281043242780654992">Consente di configurare le norme per i messaggi nativi. Gli host di messaggi nativi non autorizzati non saranno consentiti se non vengono aggiunti alla whitelist.</translation>
<translation id="1468307069016535757">Consente di impostare lo stato predefinito della funzione di accessibilità della modalità ad alto contrasto nella schermata di accesso.

Se la norma viene impostata su true, la modalità ad alto contrasto verrà attivata quando viene visualizzata la schermata di accesso.

Se la norma viene impostata su false, la modalità ad alto contrasto verrà disattivata quando viene visualizzata la schermata di accesso.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando la modalità ad alto contrasto. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, la modalità ad alto contrasto viene disattivata alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare la modalità ad alto contrasto in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="602728333950205286">URL di ricerca istantanea del provider di ricerca predefinito</translation>
<translation id="3030000825273123558">Attiva rapporti sulle metriche</translation>
<translation id="8465065632133292531">Parametri per l'URL istantaneo che utilizza POST</translation>
<translation id="6559057113164934677">Non consentire ad alcun sito di accedere alla fotocamera e al microfono</translation>
<translation id="7273823081800296768">Se questa impostazione viene attivata o non viene configurata, gli utenti possono decidere di accoppiare client e host in fase di connessione, evitando di dover inserire un codice PIN ogni volta.

Se l'impostazione viene disattivata, questa funzione non sarà disponibile.</translation>
<translation id="1675002386741412210">Supportato su:</translation>
<translation id="1608755754295374538">URL a cui verrà concesso l'accesso ai dispositivi di acquisizione audio senza richieste</translation>
<translation id="3547954654003013442">Impostazioni proxy</translation>
<translation id="5921713479449475707">Permetti download di aggiornamento automatico tramite HTTP</translation>
<translation id="4482640907922304445">Consente di visualizzare il pulsante Pagina iniziale sulla barra degli strumenti di <ph name="PRODUCT_NAME"/>. Se attivi questa impostazione il pulsante Pagina iniziale verrà sempre visualizzato, in caso contrario non verrà mai visualizzato. Se questa impostazione viene attivata o disattivata, gli utenti non potranno modificarla o sostituirla in <ph name="PRODUCT_NAME"/>. Se non imposti questa norma gli utenti potranno scegliere se visualizzare o meno il pulsante Pagina iniziale.</translation>
<translation id="2518231489509538392">Consenti riproduzione audio</translation>
<translation id="8146727383888924340">Consenti agli utenti di utilizzare le offerte tramite la registrazione a Chrome OS</translation>
<translation id="7301543427086558500">Specifica un elenco di URL alternativi che possono essere utilizzati per estrarre termini di ricerca dal motore di ricerca. Gli URL devono contenere la stringa <ph name="SEARCH_TERM_MARKER"/>, che verrà utilizzata per estrarre i termini di ricerca.

          Questa norma è facoltativa. Se non è impostata, non verrà utilizzato alcun URL alternativo per estrarre i termini di ricerca.

          Questa norma viene rispettata solo se è attiva la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="436581050240847513">Riporta interfacce di rete del dispositivo</translation>
<translation id="6282799760374509080">Consenti o nega acquisizione audio</translation>
<translation id="8864975621965365890">Consente di eliminare il messaggio di richiesta di turndown che compare quando un sito viene visualizzato da <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Codifiche del provider di ricerca predefinito</translation>
<translation id="285480231336205327">Attiva modalità ad alto contrasto</translation>
<translation id="5366977351895725771">Se questa norma è impostata su false, la creazione di utenti supervisionati da parte di questo utente sarà disabilitata. Gli eventuali utenti supervisionati esistenti saranno comunque disponibili.

          Se questa norma è impostata su true o non è configurata, questo utente può creare e gestire utenti supervisionati.</translation>
<translation id="5469484020713359236">Consente di impostare un elenco di pattern URL che specificano i siti autorizzati a impostare cookie. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultCookiesSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="1504431521196476721">Attestazione da remoto</translation>
<translation id="1881299719020653447">Nascondi lo store web nella pagina Nuova scheda e in Avvio applicazioni</translation>
<translation id="930930237275114205">Imposta la directory dei dati utente di <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="244317009688098048">Attiva scorciatoia da tastiera bailout per accesso automatico.

      Se questa norma non è impostata o è impostata su True e un account dispositivo locale è configurato per l'accesso automatico senza ritardo, <ph name="PRODUCT_OS_NAME"/> rispetterà la scorciatoia da tastiera Ctrl+Alt+S per bypassare l'accesso automatico e la visualizzazione della schermata di accesso.

      Se questa norma è impostata su False, l'accesso automatico senza ritardo (se configurato) non può essere bypassato.</translation>
<translation id="5208240613060747912">Consente di impostare un elenco di pattern URL che specificano i siti non autorizzati a visualizzare notifiche. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultNotificationsSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="346731943813722404">Consente di specificare se i ritardi di gestione dell'alimentazione e il limite di durata delle sessioni devono iniziare soltanto dopo il rilevamento dell'attività del primo utente in una sessione.

Se questa norma viene impostata su True, i ritardi di gestione dell'alimentazione e il limite di durata delle sessioni non iniziano fino al termine del rilevamento dell'attività del primo utente in una sessione.

Se questa norma viene impostata su False o non viene impostata, i ritardi di gestione dell'alimentazione e il limite di durata delle sessioni iniziano immediatamente all'avvio della sessione.</translation>
<translation id="4600786265870346112">Attivazione del puntatore grande</translation>
<translation id="5887414688706570295">Consente di configurare il prefisso TalkGadget che verrà utilizzato dagli host di accesso remoto e impedisce agli utenti di modificarlo.

          Se specificato, questo prefisso viene anteposto al nome TalkGadget di base per creare un nome di dominio completo per TalkGadget. Il nome TalkGadget di base del dominio è &quot;Talkgadget.google.com&quot;.

          Se questa impostazione è abilitata, gli host utilizzeranno il nome di dominio personalizzato per l'accesso a TalkGadget invece del nome del dominio predefinito.

          Se questa impostazione è disabilitata o non è impostata, verrà utilizzato il nome di dominio predefinito di TalkGadget (&quot;chromoting-host.talkgadget.google.com&quot;) per tutti gli host.

          I client di accesso remoto non sono interessati da questa impostazione e utilizzeranno sempre &quot;chromoting-client.talkgadget.google.com&quot; per accedere a TalkGadget.</translation>
<translation id="1103860406762205913">Attiva il vecchio accesso basato sul Web</translation>
<translation id="5765780083710877561">Descrizione:</translation>
<translation id="6915442654606973733">Consente di attivare la funzione di accessibilità del feedback vocale.

Se questa norma viene impostata su true, il feedback vocale sarà sempre attivo.

Se la norma viene impostata su false, il feedback vocale sarà sempre disattivato.

Se la norma viene impostata gli utenti non potranno modificarla o ignorarla.

Se la norma non viene configurata, il feedback vocale viene inizialmente disattivato ma potrà essere attivato dagli utenti in qualsiasi momento.</translation>
<translation id="7796141075993499320">Consente di impostare un elenco di pattern URL che specificano i siti in cui è consentita l'esecuzione dei plug-in. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultPluginsSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="3809527282695568696">Se come azione all'avvio è stata impostata &quot;Apri un elenco di URL&quot;, puoi specificare l'elenco di URL da aprire. Se questa norma non viene impostata, all'avvio non verrà aperto alcun URL. Questa norma funziona soltanto se la norma &quot;RestoreOnStartup&quot; viene impostata su &quot;RestoreOnStartupIsURLs&quot;.</translation>
<translation id="649418342108050703">Consente di disattivare il supporto delle API grafiche 3D. L'attivazione di questa impostazione impedisce alle pagine web di accedere all'unità di elaborazione grafica (GPU). Nello specifico, le pagine web non possono accedere all'API di WebGL e i plug-in non possono utilizzare l'API 3D di Pepper. Se l'impostazione viene disattivata o non viene impostata, le pagine web potrebbero utilizzare l'API di WebGL e i plug-in l'API 3D di Pepper. Per poter utilizzare tali API, le impostazioni predefinite del browser potrebbero richiedere la convalida degli argomenti della riga di comando.</translation>
<translation id="2077273864382355561">Ritardo disattivazione schermo in caso di utilizzo della batteria</translation>
<translation id="9112897538922695510">Ti consente di registrare un elenco di gestori di protocolli. Questa può essere soltanto una norma consigliata. Per la proprietà |protocol| dovrebbe essere impostato lo schema, ad esempio &quot;mailto&quot;, e per la proprietà |url| dovrebbe essere impostato il pattern URL dell'applicazione che gestisce lo schema. Il pattern può includere &quot;%s&quot; che, se presente, verrà sostituito dall'URL gestito.

          I gestori di protocolli registrati tramite la norma vengono uniti a quelli registrati dall'utente e possono essere utilizzati entrambi i tipi. L'utente può sostituire i gestori di protocolli installati tramite la norma installando un nuovo gestore predefinito, ma non può rimuovere un gestore di protocollo registrato tramite la norma.</translation>
<translation id="3417418267404583991">Se questa norma viene impostata su true o non viene configurata, in <ph name="PRODUCT_OS_NAME"/> verranno attivati gli accessi come ospite. Gli accessi come ospite sono sessioni utente anonime che non richiedono password.

      Se questa norma viene impostata su false, in <ph name="PRODUCT_OS_NAME"/> non sarà possibile avviare sessioni Ospite.</translation>
<translation id="8329984337216493753">Questa norma è attiva soltanto in modalità retail.

      Se viene specificata la norma DeviceIdleLogoutTimeout, questa norma consente di definire la durata della casella di avviso con un timer per il conto alla rovescia che viene mostrato all'utente prima dell'esecuzione dell'uscita.

      Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="237494535617297575">Consente di impostare un elenco di pattern URL che specificano i siti autorizzati a visualizzare notifiche. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultNotificationsSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="527237119693897329">Consente di specificare gli host di messaggi nativi che non devono essere caricati.

Il valore della lista nera &quot;*&quot; indica che tutti gli host di messaggi nativi non sono autorizzati, a meno che vengano elencati espressamente nella whitelist.

Se la norma non viene impostata, <ph name="PRODUCT_NAME"/> caricherà tutti gli host di messaggi nativi installati.</translation>
<translation id="749556411189861380">Consente di indicare la versione del sistema operativo e del firmware dei dispositivi registrati. Se questa impostazione non è impostata o viene impostata su True, i dispositivi registrati indicheranno periodicamente la versione del sitema operativo e del firmware. Se l'impostazione viene impostata su False, le informazioni sulla versione non verranno indicate.</translation>
<translation id="7258823566580374486">Attiva separazione degli host di accesso remoto</translation>
<translation id="5560039246134246593">Aggiungi un parametro al recupero del numero di inizializzazione delle varianti in <ph name="PRODUCT_NAME"/>.

      Se specificata, questa norma aggiunge un parametro di query chiamato &quot;restrict&quot; all'URL utilizzato per recuperare il numero di inizializzazione delle varianti. Il valore del parametro sarà il valore specificato in questa norma.

      Se non è specificata, questa norma non modifica l'URL del numero di inizializzazione delle varianti.</translation>
<translation id="944817693306670849">Imposta dimensioni cache su disco</translation>
<translation id="8544375438507658205">Renderer HTML predefinito per <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Consente di specificare il periodo in millisecondi per cui il servizio di gestione del dispositivo viene interrogato sulle informazioni relative alle norme utente.

      Se viene impostata questa norma, il valore predefinito di tre ore viene ignorato. L'intervallo dei valori validi per la norma va da 1800000 (30 minuti) a 86400000 (un giorno). I valori non compresi in questo intervallo verranno bloccati sul corrispettivo limite.

      Se questa norma non viene impostata, per <ph name="PRODUCT_NAME"/> verrà utilizzato il valore predefinito di tre ore.</translation>
<translation id="2571066091915960923">Consente di attivare o disattivare il proxy di compressione dei dati e di impedire agli utenti di cambiare questa impostazione.

Se attivi o disattivi questa impostazione, gli utenti non potranno cambiarla o ignorarla.

Se questa norma non viene impostata, l'utente potrà scegliere se utilizzare o meno la funzione proxy di compressione dei dati.</translation>
<translation id="2170233653554726857">Attiva ottimizzazione WPAD</translation>
<translation id="7424751532654212117">Elenco delle eccezioni all'elenco dei plug-in disattivati</translation>
<translation id="6233173491898450179">Imposta directory di download</translation>
<translation id="8908294717014659003">Consente di stabilire se i siti web possono accedere ai dispositivi di acquisizione dei contenuti multimediali. L'accesso ai dispositivi di acquisizione dei contenuti multimediali può essere consentito per impostazione predefinita oppure l'utente può visualizzare una richiesta ogni volta che un sito web vuole accedere ai dispositivi di acquisizione dei contenuti multimediali.

          Se questa norma non viene impostata, verrà utilizzata la norma &quot;PromptOnAccess&quot; e l'utente sarà in grado di modificarla.</translation>
<translation id="4429220551923452215">Attiva o disattiva la scorciatoia per le app nella barra dei Preferiti. Se questa norma non è impostata, l'utente può scegliere di mostrare o nascondere la scorciatoia per le app dal menu contestuale della barra dei Preferiti. Se la norma è configurata, l'utente non può modificarla e la scorciatoia per le app viene mostrata sempre oppure non viene mostrata mai.</translation>
<translation id="2299220924812062390">Consente di specificare un elenco dei plug-in attivati</translation>
<translation id="4325690621216251241">Aggiungi un pulsante di uscita all'area di notifica</translation>
<translation id="924557436754151212">Importa password salvate dal browser predefinito alla prima esecuzione</translation>
<translation id="1465619815762735808">Click to play</translation>
<translation id="7227967227357489766">Consente di definire l'elenco di utenti che possono eseguire l'accesso sul dispositivo. Le voci sono nel formato <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, ad esempio <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Per consentire utenti arbitrari su un dominio, le voci devono essere nel formato <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Se questa norma non viene configurata non esistono limitazioni relative al tipo di utenti a cui è consentito l'accesso. Tieni presente che per creare nuovi utenti è necessario configurare in modo adeguato la norma <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>.</translation>
<translation id="2521581787935130926">Mostra la scorciatoia per le app nella barra dei Preferiti</translation>
<translation id="8135937294926049787">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene disattivato quando viene utilizzata la corrente alternata.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> disattivi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME"/> non disattiva lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di inattività.</translation>
<translation id="1897365952389968758">Consenti l'esecuzione di JavaScript in tutti i siti</translation>
<translation id="922540222991413931">Configura fonti di installazione di estensioni, applicazioni e script utente</translation>
<translation id="7323896582714668701">Parametri aggiuntivi della riga di comando per <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Disattiva la sincronizzazione dei dati con Google</translation>
<translation id="1330145147221172764">Attiva tastiera sullo schermo</translation>
<translation id="7006788746334555276">Impostazioni contenuti</translation>
<translation id="450537894712826981">Consente di configurare le dimensioni della cache che verranno utilizzate da <ph name="PRODUCT_NAME"/> per archiviare sul disco i file multimediali memorizzati nella cache.

Se questa norma viene impostata, <ph name="PRODUCT_NAME"/> utilizzerà le dimensioni della cache indicate a prescindere dalla specifica o meno da parte dell'utente del flag &quot;--media-cache-size&quot;. Il valore specificato in questa norma non è un limite rigido ma un suggerimento per il sistema di memorizzazione nella cache. I valori inferiori ad alcuni megabyte sono troppo piccoli e verranno arrotondati a un valore minimo ragionevole.

Se il valore di questa norma è 0, verranno utilizzate le dimensioni della cache predefinite, che l'utente non potrà modificare.

Se questa norma non viene impostata, verranno utilizzate le dimensioni predefinite, che l'utente potrà sostituire con il flag --media-cache-size.</translation>
<translation id="5142301680741828703">Visualizza sempre i seguenti schemi di URL in <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="4625915093043961294">Configura la whitelist per l'installazione delle estensioni</translation>
<translation id="5893553533827140852">Se questa impostazione è attivata, le richieste di autenticazione Gnubby verranno trasferite al proxy attraverso una connessione host remota.

          Se questa impostazione è disattivata o non configurata, le richieste di autenticazione Gnubby non verranno trasferite al proxy.</translation>
<translation id="187819629719252111">Consente di accedere ai file locali presenti sul computer, permettendo a <ph name="PRODUCT_NAME"/> di visualizzare le finestre di dialogo di selezione dei file. Se attivi questa impostazione, gli utenti potranno aprire le finestre di dialogo di selezione dei file come di consueto. Se disattivi questa impostazione, ogni volta che l'utente eseguirà un'azione che apre una finestra di dialogo di selezione file (ad esempio importazione di Preferiti, caricamento di file, salvataggio di link e così via), verrà visualizzato un messaggio e il sistema presupporrà che l'utente abbia fatto clic sul pulsante Annulla della finestra di dialogo stessa. Se questa impostazione non viene impostata, gli utenti potranno aprire le finestre di dialogo di selezione file come di consueto.</translation>
<translation id="4507081891926866240">Consente di personalizzare l'elenco di pattern URL per i quali il rendering deve sempre essere eseguito da <ph name="PRODUCT_FRAME_NAME"/>. Se questa norma non viene impostata, verrà utilizzato per tutti i siti il renderer predefinito specificato dalla norma &quot;ChromeFrameRendererSettings&quot;. Per avere dei pattern di esempio, visita il sito all'indirizzo http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Scegli come specificare le impostazioni del server proxy</translation>
<translation id="1803646570632580723">Elenco di applicazioni bloccate da visualizzare in Avvio applicazioni</translation>
<translation id="1062011392452772310">Attivazione dell'attestazione da remoto per il dispositivo</translation>
<translation id="7774768074957326919">Utilizza le impostazioni proxy di sistema</translation>
<translation id="3891357445869647828">Abilita JavaScript</translation>
<translation id="2274864612594831715">Questa norma consente di configurare l'attivazione della tastiera virtuale come dispositivo di immissione su Chrome OS. Gli utenti non possono sostituire questa norma.

      Se la norma viene impostata su true, la tastiera virtuale sullo schermo sarà sempre attiva.

      Se viene impostata su false, la tastiera virtuale sullo schermo sarà sempre disattivata.

      Se imposti questa norma, gli utenti non possono cambiarla o sostituirla. Potranno, però, attivare/disattivare una tastiera sullo schermo di accessibilità che ha la precedenza sulla tastiera virtuale controllata da questa norma. Leggi la norma |VirtualKeyboardEnabled| per il controllo della tastiera sullo schermo di accessibilità.

      Se questa norma non viene impostata, la tastiera sullo schermo viene inizialmente disattivata ma può essere attivata dall'utente in qualsiasi momento. Potrebbero anche essere utilizzate regole euristiche per stabilire quando visualizzare la tastiera.</translation>
<translation id="6774533686631353488">Consenti host di messaggistica nativi a livello di utente (installati senza privilegi di amministratore).</translation>
<translation id="868187325500643455">Consenti l'esecuzione automatica dei plug-in in tutti i siti</translation>
<translation id="7421483919690710988">Imposta le dimensioni della cache su disco multimediale in byte</translation>
<translation id="5226033722357981948">Specifica se la ricerca plug-in deve essere disattivata</translation>
<translation id="7234280155140786597">Nomi degli host di messaggi nativi vietati (o * per indicarli tutti)</translation>
<translation id="4890209226533226410">Consente di impostare il tipo di ingrandimento dello schermo da attivare.

Se questa norma viene impostata, consente di stabilire il tipo di ingrandimento dello schermo da attivare. Se la norma viene impostata su &quot;None&quot; l'ingrandimento dello schermo viene disattivato.

Se la norma viene impostata gli utenti non potranno modificarla o ignorarla.

Se la norma non viene configurata, l'ingrandimento dello schermo viene inizialmente disattivato ma potrà essere attivato dagli utenti in qualsiasi momento.</translation>
<translation id="3428247105888806363">Attiva previsione di rete</translation>
<translation id="3460784402832014830">Consente di specificare l'URL utilizzato da un motore di ricerca per fornire una pagina Nuova scheda.

Questa norma è facoltativa. Se non viene impostata non verrà fornita una pagina Nuova scheda.

Questa norma viene rispettata soltanto se viene attivata la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="6145799962557135888">Consente di impostare un elenco di pattern URL che specificano i siti in cui è consentita l'esecuzione di JavaScript. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultJavaScriptSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="2757054304033424106">Tipi di estensioni/app che possono essere installati</translation>
<translation id="7053678646221257043">Se è attiva, questa norma impone l'importazione dei Preferiti dal browser predefinito corrente. Se la norma è attiva incide anche sulla finestra di dialogo di importazione. Se non è attiva, i Preferiti non vengono importati. Se non viene impostata, all'utente potrebbe essere chiesto se desidera effettuare l'importazione, oppure l'importazione potrebbe avvenire automaticamente.</translation>
<translation id="5757829681942414015">Configura la directory che <ph name="PRODUCT_NAME"/> utilizzerà per la memorizzazione dei dati dell'utente.

      Se imposti questa norma, <ph name="PRODUCT_NAME"/> utilizzerà la directory fornita, indipendentemente dal fatto che l'utente abbia specificato o meno il flag &quot;--user-data-dir&quot;.

      Visita http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per un elenco di variabili utilizzabili.

      Se questa norma non viene impostata, verrà utilizzato il percorso del profilo predefinito e l'utente sarà in grado di ignorarlo con il flag della riga di comando &quot;--user-data-dir&quot;.</translation>
<translation id="5067143124345820993">Whitelist di utenti con accesso</translation>
<translation id="2514328368635166290">Consente di specificare l'URL dell'icona preferita del provider di ricerca predefinito. Questa norma è facoltativa. Se non viene impostata, per il provider di ricerca non verrà visualizzata alcuna icona. Questa norma viene rispettata soltanto se è attiva la norma &quot;DefaultSearchProviderEnabled&quot;.</translation>
<translation id="7194407337890404814">Nome del provider di ricerca predefinito</translation>
<translation id="1843117931376765605">Frequenza di aggiornamento per norma utente</translation>
<translation id="5535973522252703021">Whitelist server di delega Kerberos</translation>
<translation id="9187743794267626640">Disabilita il montaggio di una memoria esterna</translation>
<translation id="6353901068939575220">Consente di specificare i parametri utilizzati durante la ricerca di un URL con POST. Si tratta di coppie di nome/valore separate da virgole. Se un valore è il parametro di un modello, come {searchTerms} nell'esempio precedente, verrà sostituito con i dati dei termini di ricerca reali.

Questa norma è facoltativa. Se non viene impostata, la richiesta di ricerca verrà inviata utilizzando il metodo GET.

Questa norma viene rispettata soltanto se la norma &quot;DefaultSearchProviderEnabled&quot; è attiva.</translation>
<translation id="5307432759655324440">Disponibilità della modalità di navigazione in incognito</translation>
<translation id="4056910949759281379">Disabilita protocollo SPDY</translation>
<translation id="3808945828600697669">Specifica un elenco dei plug-in disattivati</translation>
<translation id="4525521128313814366">Consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentita la visualizzazione di immagini. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultImagesSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="8499172469244085141">Impostazioni predefinite (gli utenti possono ignorarle)</translation>
<translation id="4816674326202173458">Consenti all'utente aziendale di essere l'utente principale e secondario (comportamento predefinito per gli utenti non gestiti)</translation>
<translation id="8693243869659262736">Utilizza client DNS integrato</translation>
<translation id="3072847235228302527">Imposta i Termini di servizio di un account locale del dispositivo</translation>
<translation id="5523812257194833591">Una sessione pubblica a cui accedere automaticamente dopo un ritardo.

      Se questa norma è impostata, verrà eseguito l'accesso automatico alla sessione specificata dopo che è trascorso un periodo di tempo senza interazioni dell'utente nella schermata di accesso. La sessione pubblica deve essere già configurata (vedi |DeviceLocalAccounts|).

      Se questa norma non è impostata, non avverrà l'accesso automatico.</translation>
<translation id="5983708779415553259">Comportamento predefinito per i siti non presenti in pacchetti di contenuti</translation>
<translation id="3866530186104388232">Se questa norma viene impostata su true o non viene configurata, nella schermata di accesso di <ph name="PRODUCT_OS_NAME"/> verranno visualizzati gli utenti esistenti tra cui sarà possibile selezionare un utente. Se la norma viene impostata su false, per accedere a <ph name="PRODUCT_OS_NAME"/> verranno richiesti nome utente e password.</translation>
<translation id="7384902298286534237">Consente di impostare un elenco di pattern URL che specificano i siti che possono impostare cookie solo per la sessione.

          Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultCookiesSetting&quot;, se è impostata, oppure la configurazione personale dell'utente.

          Se la norma &quot;RestoreOnStartup&quot; viene impostata in modo da ripristinare gli URL delle sessioni precedenti, questa norma non verrà rispettata e i cookie verranno memorizzati in modo permanente per i siti.</translation>
<translation id="2098658257603918882">Attiva rapporti sull'utilizzo e sui dati relativi agli arresti anomali</translation>
<translation id="4633786464238689684">Consente di modificare il comportamento predefinito dei tasti della fila superiore in tasti funzione.

          Se questa norma è impostata su &quot;true&quot;, i tasti della fila superiore della tastiera riprodurranno i comandi dei tasti funzione per impostazione predefinita. Per ripristinare il comportamento dei tasti multimediali, è necessario premere il tasto per la ricerca.

          Se questa norma è impostata su &quot;false&quot; o non viene impostata, la tastiera riprodurrà i comandi dei tasti multimediali per impostazione predefinita e i comandi dei tasti funzione quando viene premuto il tasto per la ricerca.</translation>
<translation id="2324547593752594014">Consente di accedere a Chrome</translation>
<translation id="172374442286684480">Consenti a tutti i siti di impostare i dati locali</translation>
<translation id="1151353063931113432">Consenti immagini su questi siti</translation>
<translation id="1297182715641689552">Utilizza uno script proxy .pac</translation>
<translation id="2976002782221275500">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene oscurato quando viene utilizzata la batteria.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> oscuri lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME"/> non oscura lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di disattivazione dello schermo (se impostato) e al ritardo di inattività.</translation>
<translation id="8631434304112909927">fino alla versione <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Attiva suggerimenti di ricerca</translation>
<translation id="4906194810004762807">Frequenza di aggiornamento per norma dispositivo</translation>
<translation id="8922668182412426494">Server a cui <ph name="PRODUCT_NAME"/> potrebbe delegare le credenziali utente.

          Separa più nomi di server con delle virgole. Sono ammessi i caratteri jolly (*).

          Se questa norma non è impostata, Chrome non delegherà le credenziali utente, anche se viene rilevato un server sulla Intranet.</translation>
<translation id="1398889361882383850">Consente di stabilire se consentire o meno ai siti web di eseguire automaticamente i plug-in. L'esecuzione automatica dei plug-in può essere consentita o negata per tutti i siti web.

Click-to-play consente di eseguire i plug-in ma l'utente deve fare clic sopra per avviarne l'esecuzione.

Se questa norma non viene impostata, verrà utilizzata la norma &quot;AllowPlugins&quot; e l'utente potrà modificarla.</translation>
<translation id="7974114691960514888">Questa norma non è più supportata. Consente di attivare l'utilizzo di server relay e STUN durante la connessione a un client remoto. Se questa impostazione viene attivata, questo computer potrà rilevare i computer host remoti e collegarsi a essi anche se sono separati da un firewall. Se questa impostazione viene disattivata e le connessioni UDP in uscita vengono filtrate dal firewall, questo computer potrà collegarsi ai computer host soltanto all'interno della rete locale.</translation>
<translation id="7694807474048279351">Consente di pianificare un riavvio automatico in seguito all'applicazione di un aggiornamento di <ph name="PRODUCT_OS_NAME"/>.

Se questa norma viene impostata su true, viene pianificato un riavvio automatico in seguito all'applicazione di un aggiornamento di <ph name="PRODUCT_OS_NAME"/> e quando è necessario un riavvio per completare la procedura di aggiornamento. Il riavvio viene programmato subito ma potrebbe essere ritardato sul dispositivo di massimo 24 ore se un utente sta utilizzando il dispositivo.


Se la norma viene impostata su false, non vengono programmati riavvii automatici in seguito all'applicazione di un aggiornamento di <ph name="PRODUCT_OS_NAME"/>. La procedura di aggiornamento viene completata al successivo riavvio del dispositivo.

Se la norma viene impostata gli utenti non potranno modificarla o ignorarla.

Nota. Attualmente i riavvii automatici vengono attivati soltanto durante la visualizzazione della schermata di accesso o durante una sessione di un'app kiosk. Questo comportamento cambierà in futuro e la norma sarà sempre valida, a prescindere dal fatto che sia in corso o meno una sessione di tipo specifico.</translation>
<translation id="5511702823008968136">Attiva barra dei Preferiti</translation>
<translation id="5105313908130842249">Ritardo blocco schermo in caso di utilizzo della batteria</translation>
<translation id="7882585827992171421">Questa norma è attiva soltanto in modalità retail.

      Consente di stabilire l'ID dell'estensione da utilizzare come screensaver nella schermata di accesso. L'estensione deve far parte dell'AppPack configurato per il dominio tramite la norma DeviceAppPack.</translation>
<translation id="1796466452925192872">Consente di specificare gli URL che possono installare estensioni, applicazioni e temi.

A partire da Chrome 21 è più complicato installare estensioni, applicazioni e script utente dall'esterno del Chrome Web Store. In precedenza gli utenti potevano fare clic su un link che rimandava a un file *.crx e Chrome si offriva di installare il file dopo alcuni avvisi. Dopo Chrome 21 tali file devono essere scaricati e trascinati nella pagina di impostazioni di Chrome. Questa impostazione consente a URL specifici di avere il precedente flusso di installazione più semplice.

Ogni voce presente in questo elenco è uno schema di corrispondenza in stile di estensione (vedi l'indirizzo http://code.google.com/chrome/extensions/match_patterns.html). Gli utenti potranno installare facilmente degli elementi dagli URL corrispondenti a una voce nell'elenco. Questi schemi devono consentire sia la posizione del file *.crx sia la pagina da cui viene avviato il download (il referrer).

La norma ExtensionInstallBlacklist ha la precedenza su questa norma. Ciò significa che un'estensione presente nella blacklist non verrà installata, anche se è di un sito presente in questo elenco.</translation>
<translation id="2113068765175018713">Limita il tempo di attività del dispositivo riavviandolo automaticamente</translation>
<translation id="4224610387358583899">Ritardi del blocco schermo</translation>
<translation id="5388730678841939057">Consente di selezionare la strategia da utilizzare per liberare spazio su disco durante la pulizia automatica (obsoleta)</translation>
<translation id="7848840259379156480">Consente di configurare il renderer HTML predefinito quando <ph name="PRODUCT_FRAME_NAME"/> è installato. Per impostazione predefinita, il rendering viene eseguito dal browser host; tuttavia, in alternativa, puoi sostituire tale impostazione e consentire che l'esecuzione del rendering delle pagine HTML venga eseguita, per impostazione predefinita, da <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="186719019195685253">Azione da compiere quando il ritardo di inattività viene raggiunto durante l'utilizzo della corrente CA</translation>
<translation id="197143349065136573">Consente di attivare il vecchio flusso di accesso basato sul Web.

      Questa impostazione è utile per i clienti aziendali che utilizzano soluzioni SSO non ancora compatibili con il nuovo flusso di accesso incorporato.
      Se attivi questa impostazione, viene utilizzato il vecchio flusso di accesso basato sul Web.
     Se disattivi questa impostazione o se la lasci non impostata, per impostazione predefinita viene utilizzato il nuovo flusso di accesso incorporato. Gli utenti potrebbero attivare il vecchio flusso di accesso basato sul Web tramite il flag della riga di comando --enable-web-based-signin.

      In futuro, quando l'accesso incorporato supporterà completamente tutti i flussi di accesso SSO, questa impostazione sperimentale verrà rimossa.</translation>
<translation id="4121350739760194865">Impedisci la visualizzazione delle promozioni di applicazioni nella pagina Nuova scheda</translation>
<translation id="2127599828444728326">Consenti notifiche su questi siti</translation>
<translation id="3973371701361892765">Non nascondere mai automaticamente lo shelf</translation>
<translation id="7635471475589566552">Consente di configurare in <ph name="PRODUCT_NAME"/> le impostazioni della lingua e di impedirne la modifica agli utenti. Se attivi questa impostazione, <ph name="PRODUCT_NAME"/> utilizzerà le impostazioni della lingua specificate. Se la lingua configurata non è supportata, verrà utilizzata la lingua &quot;en-US&quot;. Se questa impostazione viene disattivata o non viene impostata, <ph name="PRODUCT_NAME"/> utilizzerà la lingua preferita specificata dall'utente (se configurata), quella del sistema o la lingua di fallback &quot;en-US&quot;.</translation>
<translation id="2948087343485265211">Consente di specificare se l'attività audio incide o meno sulla gestione dell'alimentazione.

Se questa norma viene impostata su True o non viene impostata, l'utente non viene considerato inattivo durante la riproduzione dell'audio. In questo modo non viene raggiunto il timeout di inattività e l'azione per l'inattività non viene compiuta. Tuttavia, dopo i timeout configurati lo schermo viene oscurato, disattivato e bloccato, a prescindere dall'attività audio.

Se questa norma viene impostata su False, l'attività audio non impedisce di considerare inattivo l'utente.</translation>
<translation id="7842869978353666042">Configura opzioni di Google Drive</translation>
<translation id="718956142899066210">Tipi di connessioni consentiti per gli aggiornamenti</translation>
<translation id="1734716591049455502">Configura le opzioni di accesso remoto</translation>
<translation id="7336878834592315572">Conserva cookie per tutta la durata della sessione</translation>
<translation id="7715711044277116530">Percentuale di regolazione del ritardo di oscuramento dello schermo in modalità di presentazione</translation>
<translation id="8777120694819070607">Consente a <ph name="PRODUCT_NAME"/> di eseguire i plug-in obsoleti. Se attivi questa impostazione, i plug-in obsoleti vengono utilizzati come normali plug-in. Se disattivi questa impostazione, i plug-in obsoleti non vengono utilizzati e agli utenti non viene richiesta l'autorizzazione per eseguirli. Se l'impostazione non è configurata, agli utenti viene richiesta l'autorizzazione per eseguire i plug-in obsoleti.</translation>
<translation id="2629448496147630947">Configura le opzioni di accesso remoto in <ph name="PRODUCT_NAME"/>. Se l'applicazione web Accesso remoto non è installata, queste funzioni vengono ignorate.</translation>
<translation id="4001275826058808087">Gli amministratori IT di dispositivi aziendali possono utilizzare questo flag per stabilire se consentire agli utenti di utilizzare le offerte tramite la registrazione a Chrome OS.

      Se questa norma viene impostata su true o non viene impostata, gli utenti potranno utilizzare le offerte tramite la registrazione a Chrome OS.

      Se questa norma viene impostata su false, gli utenti non potranno utilizzare le offerte.</translation>
<translation id="1310699457130669094">Qui puoi specificare un URL che rimanda a un file proxy .pac. Questa norma viene applicata soltanto se sono state selezionate le impostazioni proxy manuali in &quot;Scegli come specificare le impostazioni del server proxy&quot;. Se hai selezionato un'altra modalità per l'impostazione delle norme relative al proxy, non dovresti impostare questa norma. Per esempi dettagliati, visita il sito all'indirizzo: <ph name="PROXY_HELP_URL"/>.</translation>
<translation id="1509692106376861764">Questa norma non è più supportata a partire dalla versione 29 di <ph name="PRODUCT_NAME"/>.</translation>
<translation id="5464816904705580310">Configurazione delle impostazioni per gli utenti gestiti.</translation>
<translation id="3219421230122020860">Modalità di navigazione in incognito disponibile</translation>
<translation id="7690740696284155549">Configura la directory che <ph name="PRODUCT_NAME"/> utilizzerà per il download dei file.

      Se imposti questa norma, <ph name="PRODUCT_NAME"/> utilizzerà la directory fornita, indipendentemente dal fatto che l'utente ne abbia specificata una o abbia attivato il flag da attivare ogni volta per il percorso di download.

      Visita http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables per un elenco di variabili utilizzabili.

      Se questa norma non viene impostata, verrà utilizzata la directory di download predefinita e l'utente sarà in grado di modificarla.</translation>
<translation id="7381326101471547614">Consente di disattivare l'utilizzo del protocollo SPDY in <ph name="PRODUCT_NAME"/>. Se questa norma viene attivata, il protocollo SPDY non sarà disponibile in <ph name="PRODUCT_NAME"/>. Se la norma viene disattivata sarà possibile utilizzare il protocollo. Se la norma non viene impostata, il protocollo SPDY sarà disponibile.</translation>
<translation id="2208976000652006649">Parametri per l'URL di ricerca che utilizza POST</translation>
<translation id="1583248206450240930">Utilizza <ph name="PRODUCT_FRAME_NAME"/> per impostazione predefinita</translation>
<translation id="1047128214168693844">Non consentire ad alcun sito di monitorare la posizione fisica degli utenti</translation>
<translation id="4101778963403261403">Consente di configurare il tipo di pagina iniziale predefinita in <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare le preferenze della pagina iniziale. È possibile impostare come pagina iniziale un URL specificato oppure la pagina Nuova scheda. Se attivi questa impostazione, come pagina iniziale verrà sempre utilizzata la pagina Nuova scheda e la posizione dell'URL della pagina iniziale verrà ignorata. Se disattivi l'impostazione, la pagina iniziale degli utenti non sarà mai la pagina Nuova scheda, a meno che il relativo URL sia &quot;chrome://newtab&quot;. Se l'impostazione viene attivata o disattivata, gli utenti non potranno cambiare il tipo di pagina iniziale in <ph name="PRODUCT_NAME"/>. Se questa norma non viene impostata, gli utenti potranno scegliere se utilizzare o meno come pagina iniziale la pagina Nuova scheda.</translation>
<translation id="8970205333161758602">Eliminazione del messaggio di richiesta di turndown di <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="3273221114520206906">Impostazione JavaScript predefinita</translation>
<translation id="4025586928523884733">Consente di bloccare i cookie di terze parti. L'attivazione di questa impostazione impedisce l'impostazione dei cookie da parte degli elementi delle pagine web non provenienti dal dominio indicato nella barra degli indirizzi del browser. La disattivazione di questa impostazione consente l'impostazione dei cookie da parte degli elementi delle pagine web non provenienti dal dominio indicato nella barra degli indirizzi del browser e impedisce agli utenti di modificare l'impostazione stessa. Se questa norma non viene impostata, i cookie di terze parti saranno attivati ma gli utenti potranno modificare l'impostazione.</translation>
<translation id="4604931264910482931">Configura lista nera di messaggi nativi</translation>
<translation id="6810445994095397827">Blocca Javascript in questi siti</translation>
<translation id="6672934768721876104">Questa norma è obsoleta, quindi utilizza ProxyMode. Consente di specificare il server proxy utilizzato da <ph name="PRODUCT_NAME"/> e di impedire agli utenti di modificare le impostazioni proxy. Se decidi di non utilizzare mai un server proxy e di eseguire sempre un collegamento diretto, tutte le altre opzioni vengono ignorate. Se scegli di utilizzare le impostazioni proxy del sistema o di rilevare automaticamente il server proxy, tutte le altre opzioni vengono ignorate. Se scegli le impostazioni proxy manuali, puoi specificare ulteriori opzioni in &quot;Indirizzo o URL del server proxy&quot;, &quot;URL per file proxy .pac&quot; ed &quot;Elenco separato da virgole delle regole bypass proxy&quot;. Per esempi dettagliati, visita il sito: <ph name="PROXY_HELP_URL"/>. Se attivi questa impostazione, <ph name="PRODUCT_NAME"/> ignorerà tutte le opzioni correlate al proxy specificate dalla riga di comando. Se questa norma non viene impostata, gli utenti potranno scegliere autonomamente le impostazioni del proxy.</translation>
<translation id="3780152581321609624">Includi porta non standard in Kerberos SPN</translation>
<translation id="1749815929501097806">Consente di impostare i Termini di servizio che l'utente deve accettare per poter avviare una sessione con l'account locale del dispositivo.

Se questa norma viene impostata, <ph name="PRODUCT_OS_NAME"/> scaricherà i Termini di servizio e li presenterà all'utente all'avvio di una sessione con l'account locale del dispositivo. L'utente potrà avviare la sessione soltanto dopo avere accettato i Termini di servizio.

Se questa norma non viene impostata, i Termini di servizio non verranno visualizzati.

Per la norma dovrebbe essere impostato un URL da cui <ph name="PRODUCT_OS_NAME"/> possa scaricare i Termini di servizio. I Termini di servizio devono essere in testo normale e pubblicati come testo di tipo MIME/semplice. Il markup non è consentito.</translation>
<translation id="2623014935069176671">Attesa dell'attività iniziale dell'utente</translation>
<translation id="2660846099862559570">Non utilizzare mai un proxy</translation>
<translation id="637934607141010488">Consente di indicare un elenco di utenti del dispositivo che hanno eseguito l'accesso di recente. Se la norma è impostata su False, gli utenti non vengono indicati.</translation>
<translation id="1956493342242507974">Questa norma consente di configurare la gestione dell'alimentazione in relazione alla schermata di accesso di <ph name="PRODUCT_OS_NAME"/>.

      Questa norma consente di configurare il comportamento di <ph name="PRODUCT_OS_NAME"/> quando non c'è attività dell'utente per un periodo di tempo mentre è visualizzata la schermata di accesso. La norma consente di controllare diverse impostazioni. Per conoscere la semantica e gli intervalli di valori di ogni impostazione, leggi le norme corrispondenti che consentono di controllare la gestione dell'alimentazione all'interno di una sessione. Le uniche differenze rispetto a queste norme sono:
      * Le azioni da compiere in caso di inattività o chiusura del coperchio non possono essere l'interruzione della sessione.
      * L'azione predefinita compiuta in caso di inattività durante l'alimentazione con corrente alternata è lo spegnimento.

      Se un'impostazione non viene specificata, viene utilizzato un valore predefinito.

      Se questa norma non viene impostata, vengono utilizzati i valori predefiniti per tutte le impostazioni.</translation>
<translation id="1435659902881071157">Configurazione di rete a livello di dispositivo</translation>
<translation id="8071636581296916773">Consente l'utilizzo dei server relay quando i client remoti cercano di stabilire una connessione con il computer.

          Se questa impostazione viene attivata, i client remoti possono utilizzare server relay per collegarsi al computer quando non è disponibile una connessione diretta (ad esempio a causa di limitazioni del firewall).

          Tieni presente che, se viene disattivata la norma <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/>, questa norma viene ignorata.

          Se questa norma non viene impostata, l'impostazione viene attivata.</translation>
<translation id="2131902621292742709">Ritardo oscuramento schermo in caso di utilizzo della batteria</translation>
<translation id="5781806558783210276">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale viene compiuta l'azione stabilita per l'inattività quando viene utilizzata la batteria.

Se questa norma viene impostata, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> compia l'azione di inattività, che può essere configurata separatamente.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi.</translation>
<translation id="5512418063782665071">URL pagina iniziale</translation>
<translation id="2948381198510798695"><ph name="PRODUCT_NAME"/> ignorerà i proxy relativi all'elenco di host specificato qui. Questa norma verrà applicata soltanto se sono state selezionate manualmente le impostazioni proxy manuali in &quot;Scegli come specificare le impostazioni del server proxy&quot;. Se hai selezionato un'altra modalità per l'impostazione delle norme relative al proxy, non dovresti impostare questa norma. Per esempi più dettagliati, visita il sito all'indirizzo <ph name="PROXY_HELP_URL"/>.</translation>
<translation id="6658245400435704251">Consente di specificare il numero di secondi massimo per cui un dispositivo può ritardare in modo casuale il download di un suo aggiornamento dal momento della pubblicazione dell'aggiornamento sul server. Il dispositivo può attendere una parte di questo tempo in termini di tempo reale e la parte rimanente in termini di numero di controlli della disponibilità di aggiornamenti. In ogni caso, la dispersione ha un limite massimo pari a un periodo di tempo costante in modo che un dispositivo non si blocchi mai in attesa di scaricare un aggiornamento.</translation>
<translation id="102492767056134033">Impostazione stato predefinito della tastiera sullo schermo nella schermata di accesso</translation>
<translation id="523505283826916779">Impostazioni di accessibilità</translation>
<translation id="1948757837129151165">Norme relative all'autenticazione HTTP</translation>
<translation id="5946082169633555022">Canale Beta</translation>
<translation id="7187256234726597551">Se la norma viene impostata su true, l'attestazione da remoto viene consentita per il dispositivo e viene generato automaticamente un certificato che viene caricato sul Server di gestione del dispositivo.

Se la norma viene impostata su false o non viene impostata, non verrà generato alcun certificato e le chiamate all'API di estensione enterprise.platformKeysPrivate non andranno a buon fine.</translation>
<translation id="5242696907817524533">Consente di configurare un elenco di Preferiti gestiti.

Questa norma è un elenco di Preferiti e ogni preferito è un dizionario contenente il &quot;nome&quot; del preferito e &quot;l'URL&quot; del target.

Questi Preferiti vengono inseriti in una cartella Preferiti gestiti all'interno dei Preferiti per cellulari. Questi Preferiti non possono essere modificati dall'utente.

Se questa norma viene impostata, Preferiti gestiti è la cartella predefinita aperta quando viene aperta la visualizzazione Preferiti in Chrome.

I Preferiti gestiti non vengono sincronizzati con l'account utente.</translation>
<translation id="6757375960964186754">Visualizza opzioni di accesso di <ph name="PRODUCT_OS_NAME"/> nel menu di sistema.

          Se questa norma viene impostata su true, le opzioni di accesso vengono sempre visualizzate nel menu della barra delle applicazioni.

          Se questa norma viene impostata su false, le opzioni di accesso non vengono mai visualizzate nel menu della barra delle applicazioni.

          Se imposti questa norma, gli utenti non possono modificarla o ignorarla.

          Se questa norma non viene impostata, le opzioni di accesso non vengono visualizzate nel menu della barra delle applicazioni, tuttavia l'utente può impostarne la visualizzazione tramite la pagina Impostazioni.</translation>
<translation id="8303314579975657113">Consente di specificare la libreria GSSAPI da utilizzare per l'autenticazione HTTP. Puoi impostare semplicemente un nome di libreria oppure un percorso completo. Se non viene fornita alcuna impostazione, <ph name="PRODUCT_NAME"/> dovrà ricorrere a un nome di libreria predefinito.</translation>
<translation id="8549772397068118889">Avvisa quando vengono visitati siti non presenti nei pacchetti di contenuti</translation>
<translation id="7749402620209366169">Consente di abilitare l'autenticazione a due fattori per gli host di accesso remoto invece di un PIN specificato dall'utente.

          Se questa impostazione è abilitata, gli utenti devono fornire un codice valido a due fattori quando accedono a un host.

          Se questa impostazione è disabilitata o non è impostata, l'autenticazione a due fattori non sarà attiva e verrà utilizzato il comportamento predefinito che prevede l'uso di un PIN definito dall'utente.</translation>
<translation id="6698424063018171973">Consente di limitare l'intervallo di porte UDP utilizzate dall'host di accesso remoto in questo computer.

          Se questa norma non viene impostata, o se viene impostata una stringa vuota, l'host di accesso remoto potrà utilizzare qualsiasi porta disponibile, a meno che la norma <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/> sia disattivata; in questo caso l'host di accesso remoto utilizzerà l'intervallo di porte UDP 12400-12409.</translation>
<translation id="7329842439428490522">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene disattivato quando viene utilizzata la batteria.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> disattivi lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME"/> non disattiva lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di inattività.</translation>
<translation id="384743459174066962">Consente di impostare un elenco di pattern URL che specificano i siti in cui non è consentita l'apertura dei popup. Se questa norma non viene impostata, per tutti i siti verrà utilizzato il valore predefinito globale della norma &quot;DefaultPopupsSetting&quot;, se è impostata, oppure verrà utilizzata la configurazione personale dell'utente.</translation>
<translation id="5645779841392247734">Consenti i cookie in questi siti</translation>
<translation id="4043912146394966243"> I tipi di connessioni utilizzabili per aggiornamenti del sistema operativo. Gli aggiornamenti del sistema operativo possono mettere a dura prova la connessione a causa delle loro dimensioni e potrebbero generare costi aggiuntivi. Pertanto, per impostazione predefinita non sono abilitati per i tipi di connessione che sono considerati costosi, fra cui WiMax, Bluetooth e cellulare, al momento.

      Gli identificatori dei tipi di connessione riconosciuti sono &quot;ethernet&quot;, &quot;wifi&quot;, &quot;wimax&quot;, &quot;bluetooth&quot; e &quot;cellulare&quot;.</translation>
<translation id="6652197835259177259">Impostazioni degli utenti gestiti localmente</translation>
<translation id="2808013382476173118">Consente di attivare l'utilizzo di server STUN quando i client remoti tentano di stabilire una connessione con questo computer.

          Se questa impostazione viene attivata, i client remoti possono rilevare questo computer e collegarsi a esso anche se sono separati da un firewall.

          Se questa impostazione viene disattivata e le connessioni UDP in uscita vengono filtrate dal firewall, questo computer consentirà soltanto connessioni da computer client all'interno della rete locale.

          Se questa norma non viene impostata l'impostazione verrà attivata.</translation>
<translation id="3243309373265599239">Consente di specificare il periodo di tempo senza input dell'utente trascorso il quale lo schermo viene oscurato quando viene utilizzata la corrente alternata.

Se questa norma viene impostata su un valore maggiore di zero, consente di specificare il periodo di tempo per cui l'utente deve rimanere inattivo prima che <ph name="PRODUCT_OS_NAME"/> oscuri lo schermo.

Se questa norma viene impostata su zero, <ph name="PRODUCT_OS_NAME"/> non oscura lo schermo quando l'utente diventa inattivo.

Se questa norma non viene impostata, viene utilizzato un periodo di tempo predefinito.

Il valore della norma deve essere specificato in millisecondi. I valori devono essere inferiori o uguali al ritardo di disattivazione dello schermo (se impostato) e al ritardo di inattività.</translation>
<translation id="3859780406608282662">Consente di aggiungere un parametro al recupero del numero di inizializzazione delle varianti in <ph name="PRODUCT_OS_NAME"/>.

      Se la norma è specificata, verrà aggiunto un parametro query chiamato &quot;restrict&quot; all'URL utilizzato per recuperare il numero di inizializzazione delle varianti. Il valore del parametro sarà il valore specificato in questa norma.

      Se la norma non è specificata, l'URL di recupero del numero di inizializzazione delle varianti non verrà modificato.</translation>
<translation id="7049373494483449255">Permette di consentire a <ph name="PRODUCT_NAME"/> di inviare documenti da stampare a <ph name="CLOUD_PRINT_NAME"/>. NOTA. Questo riguarda soltanto il supporto di <ph name="CLOUD_PRINT_NAME"/> in <ph name="PRODUCT_NAME"/>. Non impedisce agli utenti di inviare processi di stampa su siti web. Se questa impostazione viene attivata o non viene configurata, gli utenti potranno stampare con <ph name="CLOUD_PRINT_NAME"/> utilizzando la finestra di dialogo di stampa di <ph name="PRODUCT_NAME"/>. Se questa impostazione viene disattivata, gli utenti non potranno stampare con <ph name="CLOUD_PRINT_NAME"/> utilizzando la finestra di dialogo di stampa di <ph name="PRODUCT_NAME"/>.</translation>
<translation id="4088589230932595924">Modalità di navigazione in incognito forzata</translation>
<translation id="5862253018042179045">Consente di impostare lo stato predefinito della funzione di accessibilità del feedback vocale nella schermata di accesso.

Se questa norma viene impostata su true, il feedback vocale viene attivato quando viene visualizzata la schermata di accesso.

Se la norma viene impostata su false, il feedback vocale viene disattivato quando viene visualizzata la schermata di accesso.

Se la norma viene impostata, gli utenti possono ignorarla temporaneamente attivando o disattivando il feedback vocale. La scelta dell'utente non è però permanente e viene ripristinato il valore predefinito quando viene visualizzata di nuovo la schermata di accesso o quando l'utente rimane inattivo nella schermata di accesso per un minuto.

Se la norma non viene impostata, il feedback vocale viene disattivato alla prima visualizzazione della schermata di accesso. Gli utenti possono attivare o disattivare il feedback vocale in qualsiasi momento e il relativo stato nella schermata di accesso persiste per tutti gli utenti.</translation>
<translation id="8197918588508433925">Questa norma specifica le estensioni autorizzate a utilizzare chrome.enterprise.platformKeysPrivate.challengeUserKey() dell'API Enterprise Platform Keys per l'attestazione da remoto. Le estensioni devono essere aggiunte a questo elenco per utilizzare l'API.

          Se un'estensione non è presente nell'elenco o l'elenco non è impostato, la chiamata all'API non riuscirà e verrà generato un codice di errore.</translation>
<translation id="2811293057593285123">Il servizio Navigazione sicura mostra una pagina di avviso quando gli utenti visitano siti che sono segnalati come potenzialmente dannosi. L'attivazione di questa impostazione impedisce agli utenti di proseguire dalla pagina di avviso al sito dannoso.

      Se questa impostazione è disattivata o non è configurata, gli utenti possono scegliere di proseguire al sito segnalato dopo che è stato mostrato l'avviso.</translation>
<translation id="7649638372654023172">Consente di configurare l'URL della pagina iniziale predefinita in <ph name="PRODUCT_NAME"/> e impedire agli utenti di modificarlo.

La pagina iniziale è la pagina aperta tramite il pulsante Home. Le pagine che si aprono all'avvio sono stabilite dalle norme RestoreOnStartup.

Il tipo di pagina iniziale può essere impostato su un URL specificato qui oppure sulla pagina Nuova scheda. Se viene selezionata la pagina Nuova scheda, questa norma viene ignorata.

Se questa impostazione viene attivata, gli utenti non potranno modificare l'URL della pagina iniziale in <ph name="PRODUCT_NAME"/>, ma potranno comunque scegliere la pagina Nuova scheda come loro pagina iniziale.

Se questa norma non viene impostata, gli utenti potranno scegliere la loro pagina iniziale se non è impostata neanche la norma HomepageIsNewTabPage.</translation>
<translation id="3806576699227917885">Consente la riproduzione dell'audio.

      Se questa norma viene impostata su false, l'uscita audio non sarà disponibile sul dispositivo dopo avere eseguito l'accesso.

      Questa norma influisce su tutti i tipi di uscite audio e non soltanto sugli altoparlanti integrati. Anche le funzioni di accessibilità audio vengono bloccate da questa norma. Non attivare questa norma se all'utente occorre uno screen reader.

      Se questa impostazione viene impostata su true o non viene configurata, gli utenti potranno utilizzare tutte le uscite audio supportate sui loro dispositivi.</translation>
<translation id="6517678361166251908">Consenti autenticazione Gnubby</translation>
<translation id="4858735034935305895">Consenti modalità a schermo intero</translation>
</translationbundle>