QGIS User Guide 1.7 - en to it translation catalogue (66 entries)

en: Using SEXTANTE from the console
it: Uso di SEXTANTE dalla console

en: Introduction
it: Introduzione

en: The console allows advanced users to increase their productivity and perform complex operations that cannot be performed using any of the other elements of the SEXTANTE GUI. Models involving several algorithms can be defined using the command-line interface, and additional operations such as loops and conditional sentences can be added to create more flexible and powerful workflows.
it: La console permette ad utenti esperti di aumentare la propria produttività e di eseguire operazioni complesse che non possono essere eseguite utilizzando uno qualsiasi degli altri elementi dell'interfaccia grafica di SEXTANTE. I modelli che richiamano diversi algoritmi possono essere definiti utilizzando l'interfaccia della riga di comando, e le operazioni aggiuntive, come i loop e le frasi condizionali possono essere aggiunte per creare flussi di lavoro più flessibili e potenti.

en: There is not a SEXTANTE console in QGIS, but all SEXTANTE commands are available instead from QGIS built-in Python console. That means that you can incorporate those command to your console work and connect SEXTANTE algorithms to all the other features (including methods from the QGIS API) available from there.
it: Non c'è una console di SEXTANTE in QGIS, ma tutti i comandi di SEXTANTE sono disponibili invece dalla console Python interna presente in QGIS. Ciò significa che è possibile incorporare quei comandi nella console di lavoro e connettere gli algoritmi di SEXTANTE a tutte le altre funzioni (compresi i metodi derivanti dalle API di QGIS) da lì disponibili.

en: The code that you can execute from the Python console, even if it does call any SEXTANTE method, can be converted into a new SEXTANTE algorithm that you can later call from the toolbox, the graphical modeler or any other SEXTANTE component, just like you do with any other SEXTANTE algorithm. In fact, some algorithms that you can find in the toolbox, like all the ones in the :guilabel:`mmqgis` group, are simple scripts.
it: Il codice che è possibile eseguire dalla console Python, anche se chiama un qualsiasi modulo di SEXTANTE, può essere convertito in un nuovo algoritmo di SEXTANTE che in seguito sarà possibile chiamare dalla finestra degli strumenti, il modellatore grafico o qualsiasi altro componente di SEXTANTE, proprio come si fa con qualunque algoritmo di SEXTANTE. Infatti, alcuni algoritmi che si possono trovare nella casella degli strumenti, come tutti quelli del gruppo :guilabel:`mmqgis`, sono semplici script.

en: In this chapter we will see how to use SEXTANTE from the QGIS Python console, and also how to write your own algorithms using Python.
it: In questo capitolo si spiegherà come utilizzare SEXTANTE dalla console Python di QGIS ed anche come scrivere un algoritmo in Python.

en: Calling SEXTANTE from the Python console
it: Chiamata di SEXTANTE dalla console Python

en: The first thing you have to do is to import the SEXTANTE functions with the following line:
it: La prima cosa da fare è importare le funzioni di SEXTANTE con la seguente istruzione:

en: Now, there is basically just one (interesting) thing you can do with SEXTANTE from the console: to execute an algorithm. That is done using the ``runalg()`` method, which takes the name of the algorithm to execute as its first parameter, and then a variable number of additional parameter depending on the requirements of the algorithm. So the first thing you need to know is the name of the algorithm to execute. That is not the name you see in the toolbox, but rather a unique command–line name. To find the right name for your algorithm, you can use the ``algslist()`` method. Type the following line in you console:
it: Fondamentalmente, c'è solo una cosa (interessante) che si può fare con SEXTANTE dalla console: eseguire un algoritmo. Ciò viene fatto usando il comando `` runalg () `` , che prende il nome dell'algoritmo da eseguire come primo parametro, e poi un numero variabile di parametri aggiuntivi che dipendono da ciò che è richiesto dall'algoritmo. Quindi la prima cosa da sapere è il nome dell'algoritmo da eseguire. Questo non è il nome che è riportato nella finestra degli strumenti, ma un nome univoco da richiamare nella da riga di comando. Per trovare il nome corretto dell'algoritmo, è possibile utilizzare il comando  `` algslist () ``. Digitare la seguente istruzione:

en: You will see something like this.
it: Il risultato dovrebbe essere.

en: That's a list of all the available algorithms, alphabetically ordered, along with their corresponding command-line names.
it: Questa è la lista di tutti gli algoritmi disponibili in ordine alfabetico, con il corrispondente nome da utilizzare nella riga di comando.

en: You can use a string as a parameter for this method. Instead of returning the full list of algorithm, it will only display those that include that string. If, for instance, you are looking for an algorithm to calculate slope from a DEM, type ``alglist("slope")`` to get the following result:
it: È possibile utilizzare una stringa come parametro per questo comando. Invece di restituire l'elenco completo degli algoritmi, verranno visualizzati solo quelli che includono tale stringa. Se, per esempio, si sta cercando un algoritmo per calcolare la pendenza da un DEM, si digiti  ``alglist ("slope") " per ottenere il seguente risultato:

en: This result might change depending on the algorithms you have available.
it: Il risultato potrebbe cambiare a seconda degli algoritmi che sono disponibili.

en: It is easier now to find the algorithm you are looking for and its command-line name, in this case ``saga:slopeaspectcurvature``.
it: È più facile ora trovare l'algoritmo che si sta cercando e il suo nome da utilizzare nella riga di comando, in questo caso `` saga: slopeaspectcurvature ``.

en: Once you know the command-line name of the algorithm, the next thing to do is to know the right syntax to execute it. That means knowing which parameters are needed and the order in which they have to be passed when calling the ``runalg()`` method. SEXTANTE has a method to describe an algorithm in detail, which can be used to get a list of the parameters that an algorithms require and the outputs that it will generate. To do it, you can use the ``alghelp(name_of_the_algorithm)`` method. Use the command-line name of the algorithm, not the full descriptive name.
it: Una volta che si conosce il nome dell'algoritmo da utilizzare nella riga di comando, la prossima cosa da fare è conoscere la giusta sintassi per eseguirlo. Ciò significa conoscere quali sono i parametri necessari e l'ordine in cui essi devono essere dichiarati quando si esegue il comando `` runalg () `` . SEXTANTE ha un comando per descrivere un algoritmo in dettaglio, che può essere usato per ottenere un elenco dei parametri che un algoritmo richiede e gli output che genererà. È possibile utilizzare il comando  `` alghelp (nome_algoritmo) ``. Utilizzare il nome dell'algoritmo nella riga di comando, non il nome descrittivo completo.

en: Calling the method with ``saga:slopeaspectcurvature`` as parameter, you get the following description.
it: Chiamando la funzione ``saga:slopeaspectcurvature`` come parametro, si otterrà la seguente descrizione.

en: Now you have everything you need to run any algorithm. As we have already mentioned, there is only one single command to execute algorithms: ``runalg()``. Its syntax is as follows:
it: Ora si ha tutto il necessario per eseguire qualsiasi algoritmo. Come già accennato, vi è solo un unico comando per eseguire algoritmi: `` runalg () ``. La sua sintassi è la seguente:

en: The list of parameters and outputs to add depends on the algorithm you want to run, and is exactly the list that the ``alghelp()`` method gives you, in the same order as shown.
it: L'elenco dei parametri e degli output da aggiungere dipende dall'algoritmo che si desidera eseguire, ed è esattamente la lista che il comando `` alghelp () `` restituisce, nello stesso ordine, come mostrato.

en: Depending on the type of parameter, values are introduced differently. The next one is a quick review of how to introduce values for each type of input parameter
it: A seconda del tipo di parametro, i valori vengono introdotti in modo diverso. Di seguito, una rapida rassegna di come introdurre i valori per ciascun tipo di parametro di input

en: Raster Layer, Vector Layer or Table. Simply use a string with the name that identifies the data object to use (the name it has in the QGIS Table of Contents) or a filename (if the corresponding layer is not opened, it will be opened, but not added to the map canvas). If you have an instance of a QGIS object representing the layer, you can also pass it as parameter. If the input is optional and you do not want to use any data object, use ``None``.
it: Layer raster, layer vettoriale o tabella. Basta usare una stringa con il nome che identifica l'oggetto da utilizzare (il nome che ha nell'area di legenda di QGIS ) o il nome di un file (se il layer corrispondente non è aperto, sarà aperto, ma non aggiunto alla mappa ). Se si dispone di un'istanza di un oggetto di QGIS che rappresenta il layer, è anche possibile utilizzarla come parametro. Se l'input è opzionale e non si desidera utilizzare alcun dato, utilizzare ``None ``.

en: Selection. If an algorithm has a selection parameter, the value of that parameter should be entered using an integer value. To know the available options, you can use the ``algoptions`` command, as shown in the following example:
it: Selezione. Se un algoritmo ha un parametro di selezione, il valore di tale parametro deve essere inserito come valore intero. Per conoscere le opzioni disponibili, è possibile utilizzare il comando ``algoptions ``, come mostrato nel seguente esempio:

en: In this case, the algorithm has one of such such parameters, with 7 options. Notice that ordering is zero-based.
it: In questo caso, l'algoritmo ha uno di questi parametri con 7 opzioni, ordinate a partire da zero.

en: Multiple input. The value is a string with input descriptors separated by semicolons. As in the case of single layers or tables, each input descriptor can be the data object name, or its filepath.
it: Input multipli. Il valore è una stringa con i descrittori degli input separati da virgola. Come nel caso di singoli layer o tabelle, ogni descrittore di input ingresso può essere il nome dell'oggetto, o il suo percorso sul disco.

en: Table Field from XXX. Use a string with the name of the field to use. This parameter is case-sensitive.
it: Campo di una Tabella da XXX. Inserire una stringa con il nome del campo da utilizzare. Il parametro è sensibile alle lettere maiuscole

en: Fixed Table. Type the list of all table values separated by commas and enclosed between quotes. Values start on the upper row and go from left to right. You can also use a 2D array of value representing the table.
it: Tabella fissa. Digitare l'elenco di tutti i valori della tabella, separati da virgole e racchiusi tra virgolette. I valori iniziano dalla riga superiore e vanno da sinistra a destra. È inoltre possibile utilizzare una matrice 2D dei valori che rappresenta la tabella.

en: CRS. Enter the EPSG code number of the desired CRS.
it: Sistema di Riferimento per le Coordinate (Coordinate Reference System, CRS). Inserire il codice EPSG per indicare il sistema di riferimento desiderato.

en: Extent. You must use a string with ``xmin``, ``xmax``, ``ymin`` and ``ymax`` values separated by commas.
it: Estensione. È necessario utilizzare una stringa con i valori di ``xmin``, ``xmax``, ``ymin`` e ``ymax`` separati da virgole.

en: Boolean, file, string and numerical parameters do not need any additional explanations.
it: Parametri booleani, di file, di stringa e numerici non hanno bisogno di ulteriori spiegazioni.

en: Input parameters such as strings booleans or numerical values have default values. To use them, use ``None`` in the corresponding parameter entry.
it: I parametri di input, come stringhe o valori numerici o booleani hanno valori di default. Per utilizzarli, usare ``None ``nella voce del parametro corrispondente.

en: For output data objects, type the filepath to be used to save it, just as it is done from the toolbox. If you want to save the result to a temporary file, use ``None``. The extension of the file determines the file format. If you enter a file extension not included in the ones supported by the algorithm, the default file format for that output type will be used, and its corresponding extension appended to the given filepath.
it: Per per salvare i dati di output, digitare il percorso del file da utilizzare, così come viene fatto nella finestra degli strumenti. Se si desidera salvare il risultato in un file temporaneo, utilizzare ``None ``. L'estensione del file determina il formato del file. Se si immette un'estensione del file non inclusa tra quelle supportate dall'algoritmo, verrà utilizzato il formato di file predefinito per il tipo di output e sarà aggiunta al percorso del file specificato la sua estensione corrispondente .

en: Unlike when an algorithm is executed from the toolbox, outputs are not added to the map canvas if you execute that same algorithm from the Python console. If you want to add an output to it, you have to do it yourself after running the algorithm. To do so, you can use QGIS API commands, or, even easier, use one of the handy methods provided by SEXTANTE for such task.
it: A differenza di quando un algoritmo viene eseguito dalla finestra degli strumenti, se si esegue lo stesso algoritmo dalla console Python, gli output non vengono aggiunti alla vista mappa. Se si desidera aggiungere un output alla vista, bisogna farlo dopo l'esecuzione dell'algoritmo. Per fare ciò, è possibile utilizzare i comandi API QGIS, o, ancora più semplicemente, utilizzare uno dei comandi forniti da SEXTANTE per tale compito.

en: The ``runalg()`` method returns a dictionary with the output names (the ones shown in the algorithm description) as keys and the filepaths of those outputs as values. To add all the outputs generated by an algorithm, pass that dictionary to the ``loadFromAlg()`` method. You can also load an individual layer passing its filepath to the ``load()`` method.
it: Il comando `` runalg () `` restituisce un dizionario con i nomi di output (quelli indicati nella descrizione dell'algoritmo) come chiavi e i percorsi dei file di quegli output come valori. Per aggiungere tutti gli output generati da un algoritmo, si può utilizzare il comando `` loadFromAlg () `` che processa il dizionario. È anche possibile caricare un singolo layer passando il suo percorso del file al comando `` load() ``.

en: Creating scripts and running them from the toolbox
it: Creare script e lanciarli dalla finestra degli strumenti

en: You can create your own algorithms by writing the corresponding Python code and adding a few extra lines to supply additional information needed by SEXTANTE. You can find a :guilabel:`Create new script` under the tools group in the script algorithms block of the toolbox. Double click on it to open the script edition dialog. That's where you should type your code. Saving the script from there in the :file:`scripts` folder (the default one when you open the save file dialog), with :file:`.py` extension, will automatically create the corresponding algorithm.
it: È possibile creare i propri algoritmi, scrivendo il relativo codice Python e aggiungendo qualche riga in più per fornire ulteriori informazioni necessarie a SEXTANTE. Il comando :guilabel:`Create new script` si trova sotto il  gruppo strumenti nel blocco degli Script, nella finestra degli strumenti. Fare doppio clic su di esso per aprire la finestra di dialogo dell'editor di script. È lì che si deve digitare il codice. Salvando lo script nella cartella :file:`scripts` (è quella di default quando si apre la finestra di dialogo Salva file), con estensione :file:`.py` , automaticamente si creerà l'algoritmo corrispondente.

en: The name of the algorithm (the one you will see in the toolbox) is created from the filename, removing its extension and replacing low hyphens with blank spaces.
it: Il nome dell'algoritmo (quello si vedrà nella finestra degli strumenti) viene creato dal nome del file, rimuovendo la sua estensione e sostituendoi trattini bassi con spazi vuoti.

en: Let's have the following code, which calculates the Topographic Wetness Index (TWI) directly from a DEM
it: Ad esempio, quello seguente è il codice che calcola l'Indice di Umidità Topografica (Topographic Wetness Index, TWI) direttamente da un DEM

en: As you can see, it involves 3 algorithms, all of them coming from SAGA. The last one of them calculates de TWI, but it needs a slope layer and a flow accumulation layer. We do not have these ones, but since we have the DEM, we can calculate them calling the corresponding SAGA algorithms.
it: Come si può vedere, si tratta di tre algoritmi, tutti provenienti da SAGA. L'ultimo calcola il TWI, ma ha bisogno del layer dell'inclinazioe e del layer della flow accumulation. Non essendo disponibili direttamente ed avendo a disposizione il DEM, possono essere calcolati richiamando i corrispondenti algoritmi di SAGA.

en: The part of the code where this processing takes place is not difficult to understand if you have read the previous sections in this chapter. The first lines, however, need some additional explanation. They provide SEXTANTE the information it needs to turn your code into an algorithm that can be run from any of its components, like the toolbox or the graphical modeler.
it: La parte del codice in cui avviene questo processo non è difficile da capire, una volta lette le sezioni precedenti di questo capitolo. Le prime linee, tuttavia, hanno bisogno di qualche spiegazione aggiuntiva. Esse forniscono a SEXTANTE le informazioni di cui ha bisogno per trasformare il codice in un algoritmo che può essere eseguito da uno dei suoi componenti, come la finestra degli strumenti  o il modellatore grafico.

en: These lines start with a double Python comment symbol and have the following structure:
it: Queste linee iniziano con un doppio simbolo di commento Python ed hanno la seguente struttura:

en: Here is a list of all the parameter types that SEXTANTE supports in its scripts, their syntax and some examples.
it: Ecco un elenco di tutti i tipi di parametri che SEXTANTE supporta nei suoi scrpt, la loro sintassi ed alcuni esempi.

en: ``raster``. A raster layer
it: ``raster``. Un layer raster

en: ``vector``. A vector layer
it: ``vector``. Un layer vettoriale

en: ``table``. A table
it: ``table``. Una tabella

en: ``number``. A numerical value. A default value must be provided. For instance, ``depth=number 2.4``
it: ``number``. Un valore numerico. Deve essere indicato un valore di default. Ad esempio, ``depth=number 2.4``

en: ``string``. A text string. As in the case of numerical values, a default value must be added. For instance, ``name=string Victor``
it: ``string``. Una stringa di testo. Come nel caso dei valori numerici, deve essere indicato un valore di default. Ad esempio, ``name=string Victor````number``

en: ``boolean``. A boolean value. Add ``True`` or ``False`` after it to set the default value. For example, ``verbose=boolean True``
it: ``boolean``. Un valore booleano. Aggiungere ``True`` o ``False`` dopo di esso per indicare il valore di default. Ad esempio, ``verbose=boolean True``

en: ``multiple raster``. A set of input raster layers.
it: ``multiple raster``. Un insieme di layer raster di input.

en: ``multiple vector``. A set of input vector layers.
it:  ``multiple vector``. Un insieme di layer vettoriali di input.

en: ``field``. A field in the attributes table of a vector layer. The name of the layer has to be added after the ``field`` tag. For instance, if you have declared a vector input with ``mylayer=vector``, you could use ``myfield=field mylayer`` to add a field from that layer as parameter.
it: ``field``. Un campo nella tabella degli attributi di un layer vettoriale. Il nome del layer deve essere aggiunto dopo il tag ``field``.  Ad esempio, una volta dichiarato il layer vettoriale di input con ``mylayer=vector``, si può usare ``myfield=field mylayer`` per aggiungere come parametro un campo di quel layer.

en: ``folder``. A folder
it: ``folder``. Una cartella

en: ``file``. A filename
it: ``file``. Un nome di un file

en: The parameter name is the name that will be shown to the user when executing the algorithm, and also the variable name to use in the script code. The value entered by the user for that parameter will be assigned to a variable with that name.
it: Il nome del parametro è il nome che verrà mostrato all'utente durante l'esecuzione dell'algoritmo, ed è anche il nome della variabile da utilizzare nel codice dello script. Il valore immesso dall'utente per quel parametro sarà assegnato a una variabile con quel nome.

en: When showing the name of the parameter to the user, SEXTANTE will edit it to improve its appearance, replacing low hyphens with blankspaces. So, for instance, if you want the user to see a parameter named ``A numerical value``, you can use the variable name ``A_numerical_value``.
it: Quando mostra all'utente il nome del parametro, SEXTANTE lo modifica per migliorare il suo aspetto, sostituendo i trattini bassi con spazi vuoti. Così, per esempio, se si desidera che l'utente visualizzi un parametro denominato `` Un valore numerico``, è possibile utilizzare il nome della variabile `` Un_valore_numerico ``.

en: Layers and tables values are strings containing the filepath of the corresponding object. To turn them into a QGIS object, you can use the ``sextante.getObjectFromUri()`` function. Multiple inputs also have a string value, which contains the filepaths to all selected object, separated by semicolons.
it: I valori dei layer e delle tabelle sono stringhe contenenti il percorso del file dell'oggetto corrispondente. Per trasformarle in un oggetto di QGIS, è possibile utilizzare la funzione ``sextante.getObjectFromUri () `` funzione. Anche input multipli hanno un valore della stringa, che contiene il percorso di gli oggetti selezionati, separati da punto e virgola.

en: Outputs are defined in a similar manner, using the following tags:
it: Gli output sono definiti in maniera simile, usando i seguenti tag:

en: The value assigned to the output variables is always a string with a filepath. It will correspond to a temporary filepath in case the use has not entered any output filename.
it: Il valore assegnato alle variabili di otput è sempre una stringa con un percorso file. Esso corrisponde al percorso di un file temporaneo nel caso in cui l'utente non ha specificato alcun file di output.

en: When you declare an output, SEXTANTE will try to add it to QGIS once the algorithm is finished. That is the reason why, although the ``runalg()`` method does not load the layers it produces, the final TWI layer will be loaded, since it is saved to the file entered by the user, which is the value of the corresponding output.
it: Quando si dichiara un output, SEXTANTE cercherà di aggiungerlo QGIS una volta che l'algoritmo è finito. Questa è la ragione per cui, anche se il comando `` runalg () `` non carica i layer che produce, il layer finale del TWI verrà caricato, poiché è salvato nel file scelto dall'utente, che è il valore dell'output corrispondente.

en: Do not use the ``load()`` method in your script algorithms, but just when working with the console line. If a layer is created as output of an algorithm, it should be declared as such. Otherwise, you will not be able to properly use the algorithm in the modeler, since its syntax (as defined by the tags explained above) will not match what the algorithm really creates.
it: Non usare il comando `` load() `` negli algoritmi di script, ma solo quando si lavora con la linea di comando. Se un layer viene creato come output di un algoritmo, esso dovrebbe essere dichiarato come tale. In caso contrario,  l'algoritmo nel modellatore non potrà essere utilizzato correttamente, dal momento che la sua sintassi (come definita dai tag spiegato sopra) non corrisponde a ciò che l'algoritmo in realtà crea.

en: Hidden outputs (numbers and strings) do not have a value. Instead, it is you who has to assign a value to them. To do so, just set the value of a variable with the name you used to declare that output. For instance, if you have used this declaration,
it: Output nascosti (numeri e stringhe) non hanno un valore. È invece l'utente che deve assegnare loro un valore. Per farlo, è sufficiente impostare il valore di una variabile con il nome utilizzato per dichiarare quell'output. Per esempio, se è stata usata questa dichiarazione,

en: the following line will set the value of the output to 5:
it: la riga seguente imposterà il valore dell'output a 5:

en: In addition to the tags for parameters and outputs, you can also define the group under which the algorithm will be shown, using the ``group`` tag.
it: Oltre ai tag per i parametri e gli output, è anche possibile definire il gruppo in cui verrà mostrato l'algoritmo, utilizzando il tag `` group ``.

en: If you algorithm takes a long time to process, it is a good idea to inform the user. You have a global named ``progress`` available, with two available methods: ``setText(text)`` and ``setPercentage(percent)`` to modify the progress text and the progress bar.
it: Se l'algoritmo impiega molto tempo per elaborare, è una buona idea informare l'utente. Si dispone di due comandi globali denominati ``progress ``con due metodi disponibile : `` setText (testo) `` e `` setPercentage (percent) `` per modificare il testo e la barra di avanzamento.

en: Several examples are provided with SEXTANTE. Please, check them to see real examples of how to create algorithms using this feature of SEXTANTE. You can right-click on any script algorithm and select :guilabel:`Edit script` to edit its code or just to see it.
it: Con SEXTANTE sono forniti diversi esempi. Si prega di controllarli per vedere alcuni esempi reali di come creare algoritmi che utilizzano questa funzione di SEXTANTE. È possibile fare clic destro su un qualsiasi algoritmo di script e selezionare select :guilabel:`Edit script` per modificare il codice o solo per vederlo.

en: Documenting your scripts
it: Documentare gli script

en: As in the case of models, you can create additional documentation for your script, to explain what they do and how to use them. In the script editing dialog you will find a **[Edit script help]** button. Click on it and it will take you to the help editing dialog. Check the chapter about the graphical modeler to know more about this dialog and how to use it.
it: Come nel caso dei modelli, è possibile creare una documentazione aggiuntiva per gli script, per spiegare che cosa fanno e come usarli. Nella finestra di modifica dello script si trova un pulsante **[Edit script help]**. Fare clic su di esso e si aprirà una finestra di editing dell'help. Controllare il capitolo sul modellatore grafico per sapere di più su questa finestra di dialogo e come usarla.

en: Help files are saved in the same folder as the script itself, adding the :file:`.help` extension to the filename. Notice that you can edit your script's help before saving it for the first time. If you later close the script editing dialog without saving the script (i.e. you discard it), the help content you wrote will be lost. If your script was already saved and is associated to a filename, saving is done automatically.
it: I file della guida vengono salvati nella stessa cartella dello stesso script, aggiungendo l'estensione :file:`.help` al nome del file. Si noti che è possibile modificare la guida dello script prima di salvarlo per la prima volta. Se in seguito si chiude la finestra di modifica dello script senza salvare lo script (cioè la si scarta), il contenuto già scritto della guida verrà perso. Se lo script è già stato salvato ed è associato ad un nome di file, il salvataggio è fatto automaticamente.
