# Manuale di &okteta;

Friedrich
W. H.
Kossebau

    &Friedrich.Kossebau.email;

Alex
Richardson

    &Alex.Richardson.email;

Federico
Zenith

    zenith@chemeng.ntnu.no

Traduzione della documentazione
2008, 2010
&Friedrich.Kossebau;
&FDLNotice;
2010-01-12
0.4.0

&okteta; è un semplice editor dei dati grezzi di un file. Questo tipo di programma si chiama anche editor esadecimale o binario.

KDE
kdeutils
Okteta
vista
modifica
bit
byte
binario
ottale
esadecimale
editor esadecimale
dati grezzi

## Introduzione

&okteta; è un semplice editor dei dati grezzi di un file.

I dati sono visualizzati in due modi: come i valori numerici dei byte e come i caratteri loro assegnati. I valori e i caratteri possono essere visualizzati in due colonne (la visualizzazione normale degli editor esadecimali) o in righe con il valore sopra il carattere. Le modifiche possono essere effettuate sia sui valori che sui caratteri.

Oltre alle solite funzionalità di modifica, &okteta; include una piccola serie di strumenti, come una tabella che elenca le decodifiche in tipi di dati semplici e comuni, una che elenca tutti i byte possibili con i suoi equivalenti in caratteri e valori, una vista informativa con statistiche, un calcolatore di codici di controllo, strumenti per il filtraggio e l'estrazione di stringhe.

Tutte le modifiche ai dati caricati possono essere annullate o rifatte senza limiti.

## Fondamentali

### Avviare &okteta;

Scrivi ``okteta`` sulla riga di comando, o seleziona Editor esadecimale dal gruppo ApplicazioniAccessori nell'avviatore di applicazioni.

Sono disponibili le opzioni da riga di comando standard di &Qt; e &kde;, che possono essere elencate scrivendo ``okteta` `--help``.

Le opzioni da riga di comando specifiche a &okteta; sono:

`<&URL;>`: apri file dallo o dagli &URL; specificati

### Uso

La finestra principale di &okteta; ha i seguenti componenti: una barra dei menu, una barra degli strumenti, barra di stato, una o più barre laterali con strumenti, e la vista principale con le viste dei dati organizzate per schede.

Quando si apre un file o si crea un nuovo array di byte, i byte ivi contenuti vengono elencati di fila in righe con un certo numero di byte per riga. Sono visualizzati in due modi: come i valori numerici dei byte e come i caratteri loro assegnati. I valori e i caratteri possono essere visualizzati separati in due colonne o fianco a fianco con il valore sopra il carattere. Sul lato sinistro sono indicati gli scostamenti del primo byte di ogni riga.

La gestione è simile alla maggior parte degli editor di testo: i dati possono essere modificati, tagliati, copiati, incollati, trascinati più o meno come il testo in questi. Un cursore indica la posizione attuale. Premere il pulsante Ins fa passare tra le modalità di inserimento e sovrascrittura. La modalità di sovrascrittura è più rigorosa che negli editor di testo, e non permette nessuna operazione che cambi le dimensioni dell'array di byte.

Diversamente dagli editor di testo, i contenuti sono visualizzati in due modi. Per l'inserimento si può usare solo uno di questi. Ci sono due cursori collegati, mostrati per la visualizzazione dei valori e dei caratteri; il cursore della visualizzazione attiva lampeggia. Quando sono attivi i caratteri, li si può inserire come in un editor di testo. Quando sono attivi i valori, scrivere una numero farà aprire un editor minimo per inserire il resto del valore.

La finestra di ricerca permette all'utente di cercare una stringa specifica di byte, definibile come valori (esadecimale, decimale, ottale, binaria) o testo (codifica a 8 bit corrente o UTF-8).

Si possono aprire contemporaneamente più array di byte, ma solo uno può essere attivo. Usa il menu Finestre per selezionare quale array debba essere attivo.

## Strumenti

### Panoramica

&okteta; include alcuni strumenti, alcuni per analizzare e manipolare gli array di byte e altri con scopi più generali. Questi strumenti si possono attivare o disattivare dal menu Strumenti. Ogni strumento ha una piccola vista, che si aggancia in una delle barre laterali o si presenta come finestra a sé. Puoi agganciare, sganciare, ridisporre e anche impilare le viste degli strumenti col mouse, premendo il &LMB; sulla barra del titolo di una vista, spostandola dove vuoi e rilasciando il &LMB; per completare l'azione, altrimenti annullala premendo il tasto &Esc;.

#### Analisi e manipolazione

Tabella dei byte

  La tabella elenca tutti i valori possibili dei byte, sia come caratteri che come valori numerici.

  Il valore selezionato può essere inserito alla posizione del cursore per un certo numero di byte. Questo si può fare usando il pulsante Ins o facendo doppio clic sulla riga nella tabella.

Filtro binario

  Il filtro effettua operazioni binarie sui byte selezionati. Dopo aver scelto l'operazione (ET, VEL, RUOTA...), gli eventuali parametri possono essere impostati nella casella sotto. Il filtro viene eseguito all'attivazione del pulsante Filtra.

Stringhe

  Questo strumento localizza le stringhe nei byte selezionati. Dopo aver scelto la lunghezza minima delle stringhe, queste vengono ricercate dopo aver usato il pulsante Estrai. L'elenco di stringhe visualizzate può venire ristretto inserendo un termine di filtro.

Statistiche

  Questo strumento genera un dato statistico dei byte selezionati: la frequenza di ogni byte nella selezione. Può essere calcolata con il pulsante Genera.

Codice di controllo

  Questo strumento calcola vari codici di controllo per i byte selezionati. Dopo aver scelto l'algoritmo e impostato il parametro, se ce n'è uno, la somma viene calcolata alla pressione del pulsante Calcola.

Tabella di decodifica

  La tabella visualizza i valori dei byte a partire dal cursore per alcuni tipi di dati comuni come numeri interi o a virgola mobile, ma anche UTF-8. Fare doppio clic in una riga della tabella apre un editor per modificare il valore.

Strutture

  Questo strumento permette di investigare e modificare array di byte basati su definizioni di strutture dell'utente. Per istruzioni dettagliate vedi .

#### Strumenti generali

Filesystem

  Questo strumento offre un selettore di file incorporato.

Documenti

  Questo strumento mostra tutti i file attualmente creati o caricati. I simboli indicano il file la cui vista è attiva e anche quali file hanno modifiche non salvate o la cui copia salvata è stata modificata da un altro programma.

Segnalibri

  Questo strumento può essere usato per gestire i segnalibri, in alternativa al menu Segnalibri.

  I segnalibri sono al momento temporanei e non vengono salvati se chiudi un array di byte o tutto il programma.

Informazioni sul file

  Questo strumento visualizza alcune informazioni sul file attuale, inclusi il tipo, il luogo di memorizzazione e le dimensioni.

### Strumento per le strutture

#### Generale

Lo strumento per le strutture permette di analizzare e modificare gli array di byte in base a definizioni di strutture dell'utente, che possono essere costituite da array, unioni, tipi primitivi ed enumerazioni.

Ha una propria finestra di configurazione, che si può raggiungere con il pulsante Impostazioni. Ci sono diverse opzioni configurabili, come lo stile con cui i valori sono visualizzati (decimale, esadecimale, o binario). Inoltre è possibile scegliere quali definizioni di strutture caricare e quali mostrare nella vista.

Le strutture sono definite in file di definizione di strutture di &okteta; (basati su &XML;, con estensione `.osd`). Inoltre, un file `.desktop` contiene dati aggiuntivi sul file di descrizione delle strutture, come autore, pagina Web e licenza.

Attualmente non c'è un supporto integrato per creare o modificare definizioni di strutture, quindi ciò va fatto manualmente, come descritto nelle sezioni seguenti.

#### Installare definizioni di strutture

##### Installare con le Novità

Il modo più facile di installare nuove definizioni di strutture è usare il supporto per le Novità incorporato in &okteta;. Per installare una struttura esistente apri la finestra delle impostazioni dello strumento per le strutture. Lì, seleziona la scheda Gestione delle strutture e premi il pulsante Prendi nuove strutture. La finestra che apparirà permette di installare e disinstallare strutture.

##### Installare manualmente definizioni di strutture

Lo strumento per le strutture cerca descrizioni di strutture nella sottocartella `share/apps/okteta/structures/` della cartella dei dati dei programmi dell'utente (la trovi con ``kde4-config` `--localprefix``). Potresti dover creare questa cartella se non ci sono ancora definizioni di strutture installate.

In quella sottocartella ce n'è un'altra per ogni definizione di struttura, contenente sia il file `.desktop` che il file `.osd` o `main.js` della definizione.

Per esempio, con la cartella di dati dei programmi `~/.kde` e una definizione di struttura chiamata Esempio, c'è la cartella `.kde/share/apps/okteta/structures/Esempio`, contenente un file `Esempio.desktop` e un file `Esempio.osd`.

##### Usare le strutture appena installate

Se hai installato una nuova definizione di struttura creando una tale sottocartella con i due file o li hai modificati, devi riavviare &okteta; e aprire la finestra di configurazione dello strumento per le strutture. Lì, seleziona la scheda Gestione delle strutture e assicurati che la definizione di struttura desiderata sia segnata. Usa quindi il pulsante Applica, passa alla scheda Strutture e assicurati che l'elemento desiderato sia elencato sul lato destro.

#### Condividere definizioni di strutture

Per le strutture comuni potresti non dover creare una tua definizione, ma riutilizzarne invece una già disponibile per esempio da kde-files.org.

Potresti anche voler condividere una tua definizione. Per farlo, crea un file d'archivio (per esempio un archivio tar compresso, `.tar.gz`) contenente solo la sottocartella con il file `.desktop` e il file di definizione della struttura. Nell'esempio nella sezione precedente sarebbe nella cartella `Esempio` con tutti i suoi contenuti. Usare questo formato per condividere le definizioni delle strutture permette di installarle da dentro &okteta; e non richiede l'installazione manuale.

#### Creare le tue definizioni di strutture

Ci sono due modi diversi di creare definizioni di strutture. Il primo è scrivere la definizione in &XML; e l'altro usando JavaScript. L'approccio con JavaScript permette di creare strutture più complesse, con funzionalità come la validazione della struttura. L'uso di &XML; dà meno funzionalità e probabilmente non verrà esteso in futuro; tuttavia, le strutture &XML; continueranno ad essere supportate, ma si raccomanda di usare JavaScript.

##### Il passo in comune ad entrambi gli approcci

Vanno creati due file per ogni definizione di struttura. Uno è un file `.desktop` per i dati aggiuntivi.Un file d'esempio potrebbe avere questo aspetto:

              [Desktop Entry]
              Encoding=UTF-8
              Icon=arrow-up
              Type=Service
              ServiceTypes=KPluginInfo

              Name=Semplice struttura di prova
              Comment=Struttura di prova molto semplice con due soli elementi

              X-KDE-PluginInfo-Author=Pinco Pallino
              X-KDE-PluginInfo-Email=pinco@pallino.it
              X-KDE-PluginInfo-Name=semplice
              X-KDE-PluginInfo-Version=1.0
              X-KDE-PluginInfo-Website=http://it.wiktionary.org/wiki/semplice
              X-KDE-PluginInfo-Category=structure
              X-KDE-PluginInfo-License=LGPL
              X-KDE-PluginInfo-EnabledByDefault=false

L'icona visualizzata in &okteta; per questa struttura può essere qualsiasi cosa che si può trovare eseguendo ``kdialog` `--geticon``, o il percorso a un'icona.

Questi campi dovrebbero essere tutti abbastanza facili da capire, tranne `X-KDE-PluginInfo-Name`: questo deve avere il nome della cartella contenente il file così come il nome del file `.desktop`. Quando si creano definizioni di strutture con &XML;, anche il nome del file `.osd` deve corrispondere.

In questo esempio avremmo una cartella di nome `semplice` contenente il file `semplice.desktop`. Quando si definiscono strutture in &XML;, la cartella conterrebbe anche un file di nome `semplice.osd`. Usando JavaScript, avremmo invece un file di nome `main.js`.

##### Una prima definizione di struttura

Per cominciare creiamo una definizione per una struttura di prova molto semplice, contenente solo tipo di dati integrali (un carattere e un intero a 32 bit). In C e C++ verrebbero espressi come:

              struct simple {
                char aChar;
                int anInt;
                bool bitFlag :1;
                unsigned padding :7;
              };

Il primo passo è scrivere il file `.osd`, che chiamiamo `semplice.osd`:

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name="semplice">
                  <primitive name="carattere" type="Char"/>
                  <primitive name="intero" type="Int32"/>
                  <bitfield name="bitFlag" type="bool" width="1"/>
                  <bitfield name="padding" type="unsigned" width="7"/>
                </struct>
              </data>

il che è abbastanza simile alla definizione in C o C++. L'attributo type di primitive può essere uno tra i seguenti:

- Char

- Int8, Int16, Int32 o Int64

- UInt8, UInt16, UInt32 o UInt64

- Bool8, Bool16, Bool32 o Bool64

- Float

- Double

Il campo bitfield (campo di bit) ha due attributi (oltre all'attributo del nome, name, che hanno tutti gli elementi): l'attributo width (ampiezza) dice a &okteta; quanti bit vengono usati da questo bitfield.

Ricorda sempre di aggiungere del padding (spaziatura), altrimenti il prossimo elemento primitive comincerà in mezzo a un byte. Ovviamente la spaziatura non è necessaria se è proprio questo comportamento che vuoi.

L'altro attributo è quello di tipo, che può essere `bool`, `unsigned` o `signed`.

Adesso crea una cartella `semplice` sotto la cartella di installazione delle strutture (rivedi come si installano manualmente le strutture), e copiaci i due file. Adesso puoi riavviare &okteta; e usare la nuova struttura.

##### La stessa struttura in JavaScript

Per implementare la struttura sopra in JavaScript, crea un file di nome `main.js` invece che `semplice.osd`. I contenuti di questo file dovrebbero essere:

            function init() {
              var structure = struct({
                aChar : char(),
                anInt : int32(),
                bitFlag : bitfield("bool", 1),
                padding : bitfield("unsigned", 7),
              })
              return structure;
            }

La struttura visualizzata da &okteta; è sempre il valore restituito dalla funzione `init`.

Le funzioni seguenti possono essere chiamate per creare un tipo primitivo:

- `char()`

- `int8()`, `int16()`, `int32()` o `int64()`

- `uint8()`, `uint16()`, `uint32()` o `uint64()`

- `bool8()`, `bool16()`, `bool32()` o `bool64()`

- `float()`

- `double()`

La funzione `bitfield` prende due argomenti, di cui il primo è una stringa che può essere `bool`, `signed` o `unsigned`. Il secondo è un intero che imposta l'ampiezza in bit.

##### Strutture più complesse

Adesso creiamo la definizione di una struttura più complessa, che chiameremo complessa e salveremo in un file di nome `complessa.osd`. Questa struttura conterrà due array (uno di lunghezza fissa e uno di lunghezza determinata durante l'esecuzione), oltre a una struttura annidata e un'unione.

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name="complessa">
                  <primitive name="dimensione" type="UInt8" />
                  <union name="unione">
                    <array name="quattroByte" length="4">
                      <primitive type="Int8" />
                    </array>
                  </union>
                  <struct name="annidata">
                    <array name="stringa" length="dimensione"> <!-- fa riferimento alla dimensione di cui sopra -->
                      <primitive type="Char" />
                    </array>
                  </struct>
                </struct>
              </data>

Ciò corrisponderebbe a quanto segue in pseudo C o C++:

    struct complessa {
                uint8_t dimensione;
                union unione {
                  int8_t quattroByte[4];
                };
                struct annidata {
                  char stringa[dimensione] // non è C++ valido, fa riferimento al valore della dimensione uint8
                };
              };

Ovviamente puoi far riferire array a lunghezza dinamica solo a campi che vengono prima di questi.

Adesso creiamo il file `complessa.desktop` come nell'esempio precedente (assicurati di impostare `X-KDE-PluginInfo-Name` correttamente) e facciamo lo stesso per installare i file.

##### Ulteriori informazioni

Alcune definizioni di strutture esemplificative si possono trovare qui, incluse per esempio le intestazioni dei file PNG e per i file ELF. Uno schema &XML; per descrivere la struttura del file `.osd` è disponibile qui. Se servono maggiori informazioni, non esitare a contattare &Alex.Richardson.email;.

## Voci dei menu

Nota che la maggior parte dei comandi dei menu hanno anche una scorciatoia da tastiera.

### Menu File

&Ctrl;N File Nuovo

  Crea un nuovo array di byte...

  - Vuoto: ... come un array vuoto.

  - Dagli appunti: ... dai contenuti attuali degli appunti.

  - Schema: ... con un certo schema.

  - Dati casuali: ... con dati casuali.

  - Sequenza: ... con tutti i byte da 0 a 255.

&Ctrl;O File Apri...

  Apre un file esistente.

File Apri recente

  Scegli da un elenco degli ultimi file aperti.

&Ctrl;S File Salva

  Salva l'array di byte nel file assegnato.

File Salva come...

  Salva l'array di byte su un altro file con un nuovo nome.

File Esporta

  Esporta i byte selezionati in un file...

  - Valori: ... codificati come valori di byte.

  - Testo semplice: ... codificati come caratteri.

  - Base64: ... codificati nel formato Base64.

  - Array C: ... definiti come un array nel linguaggio di programmazione C.

  - Vista in testo semplice: ... come nella vista dati con slittamento, valori di byte e caratteri.

F5 File Ricarica

  Scarta tutte le modifiche e ricarica l'array di byte dal file.

&Ctrl;P File Stampa...

  Stampa l'attuale array di byte.

File Permessi

  Imposta i permessi di modifica:

  Imposta a sola lettura

    Se impostato, non si possono effettuare modifiche all'array di byte caricato.

&Ctrl;W File Chiudi

  Chiude l'attuale array di byte.

File Chiudi tutto

  Chiude tutti gli array di byte.

File Chiudi tutti gli altri

  Chiude tutti gli array di byte tranne l'attuale.

&Ctrl;Q File Esci

  Chiude la finestra di &okteta;.

### Menu Modifica

Attualmente in &kde; 4.4 &klipper; non è in grado di visualizzare i dati copiati o tagliati del tipo application/octetstream. D'altra parte quasi nessun'altra applicazione lo può fare, perché sono semplicemente dati grezzi. Vedi anche il sottomenu Copia come.

&Ctrl;Z Modifica Annulla

  Annulla l'ultima azione.

&Ctrl;&Shift;Z Modifica Rifai

  Rifai l'ultima azione annullata.

&Ctrl;X Modifica Taglia

  Elimina i byte selezionati e copiali negli appunti.

&Ctrl;C Modifica Copia

  Copia i byte selezionati negli appunti.

&Ctrl;V Modifica Incolla

  Inserisci i byte tagliati o copiati dagli appunti.

Edit Copia come

  Copia i byte selezionati negli appunti...

  - Valori: ... codificati come valori di byte.

  - Testo semplice: ... codificati come caratteri.

  - Base64: ... codificati nel formato Base64.

  - Array C: ... definiti come un array nel linguaggio di programmazione C.

  - Vista in testo semplice: ... come nella vista dati con slittamento, valori di byte e caratteri.

Modifica Inserisci
  Inserisci schema...

    Inserisci una stringa di byte specificata al cursore.

    Le opzioni nella finestra permettono di specificare il numero di inserimento dello schema e il suo formato (esadecimale, decimale, ottale, binario, caratteri o UTF-8).

&Ctrl;A Modifica Seleziona tutto

  Seleziona tutto l'array di byte.

&Ctrl;&Shift;A Modifica Deseleziona

  Deseleziona la selezione attuale.

&Ctrl;E Modifica Seleziona intervallo...

  Apre una finestra incorporata per inserire l'intervallo da selezionare.

Ins Modifica Modalità di sovrascrittura

  Passa tra le modalità d'inserimento e sovrascrittura.

  La modalità di sovrascrittura è implementata in modo da essere molto severa: non è possibile cambiare le dimensioni dei dati, quindi non se ne possono aggiungere né rimuovere.

&Ctrl;F Modifica Trova...

  Trova uno schema specifico nel documento. Si possono cercare schemi esadecimali, decimali, ottali, binari o di testo.

  Le opzioni nella finestra di permettono di specificare il punto di partenza, la direzione e l'estensione della ricerca.

F3 Modifica Trova successivo

  Trova la prossima corrispondenza dello schema di ricerca.

  Se non è stato specificato uno schema, ne verrà mostrata la finestra.

&Shift;F3 Modifica Trova precedente

  Trova la corrispondenza precedente dello schema di ricerca.

  Se non è stato specificato uno schema, ne verrà mostrata la finestra.

&Ctrl;R Modifica Sostituisci...

  Sostituisci lo schema di ricerca con uno schema diverso.

&Ctrl;G Modifica Vai allo slittamento...

  Sposta il cursore a un certo slittamento.

### Menu Visualizza

&Ctrl;+ Visualizza Ingrandisci

  Aumenta le dimensioni dei caratteri.

&Ctrl;- Visualizza Rimpicciolisci

  Diminuisci le dimensioni dei caratteri.

Visualizza Mostra caratteri non stampabili

  Attiva o disattiva la visualizzazione dei caratteri non stampabili. Se la visualizzazione è disattivata, ai posti corrispondenti nella colonna dei caratteri verrà mostrato un carattere sostitutivo.

F11 Visualizza Mostra slittamento delle righe

  Attiva o disattiva la visualizzazione dello slittamento delle righe su un pannello a sinistra.

Visualizza Mostra valori o caratteri

  Seleziona quale interpretazione dei dati viene visualizzata. Le possibili sono:

  - Valori

  - Caratteri

  - Valori e caratteri

Visualizza Codifica dei valori

  Seleziona la codifica dei valori tra:

  - Esadecimale

  - Decimale

  - Ottale

  - Binario

Visualizza Codifica dei caratteri

  Seleziona la codifica dei caratteri dal sottomenu.

Visualizza Schema dinamico

  Imposta le regole per lo schema di visualizzazione dei dati. Questo definisce quanti byte visualizzare per riga, a seconda della larghezza della vista. Le regole possibili sono:

  - Disattivo: lo schema è fisso all'attuale numero di byte per riga e non viene adattato ai cambiamenti di dimensioni della vista.

  - Raggruppa solo gruppi di byte completi: mette il massimo possibile di byte per riga, fintanto che i gruppi di byte sono completi.

  - Attivo: come il precedente, ma permette anche gruppi non completi di byte.

Visualizza Modalità di visualizzazione

  Seleziona lo schema di vista tra:

  - Colonne: le interpretazioni a valori e a caratteri sono mostrate nello schema classico, con ciascuna in una colonna separata.

  - Righe: l'interpretazione a caratteri di un byte è mostrata direttamente sotto a quella a valori.

&Ctrl;&Shift;T Visualizza Dividi orizzontalmente

  Divide l'area di visualizzazione della vista attiva in due parti e aggiungi una copia della vista attuale nella nuova area inferiore.

&Ctrl;&Shift;L Visualizza Dividi verticalmente

  Divide l'area di visualizzazione della vista attiva in due parti e aggiungi una copia della vista attuale nella nuova area a destra.

&Ctrl;&Shift;R Visualizza Chiudi area della vista

  Chiudi l'area di visualizzazione della vista attiva.

&Ctrl;&Shift;F11 Visualizza Modalità a tutto schermo

  Attiva o disattiva la modalità a tutto schermo.

### Menu Finestre

Fornisce un elenco delle viste attuali. Seleziona la finestra attiva.

### Menu Segnalibri

Si possono impostare più segnalibri per ogni array di byte. Ogni array ha la sua serie di segnalibri, e la serie appropriata viene visualizzata in fondo al menu Segnalibri. Scegline uno dal menu per spostarci il cursore e la vista.

I segnalibri sono al momento temporanei e non vengono salvati se chiudi un array di byte o tutto il programma.

&Ctrl;B Segnalibri Aggiungi segnalibro

  Segna una posizione nell'array di byte.

&Ctrl;&Shift;B Segnalibri Rimuovi segnalibro

  Rimuovi il segnalibro attuale. Questo comando è disponibile solo se il cursore è a una posizione segnata.

Segnalibri Rimuovi tutti i segnalibri

  Pulisci l'elenco dei segnalibri.

&Alt;↑ Segnalibri Vai al segnalibro precedente

  Sposta il cursore al segnalibro precedente.

&Alt;↓ Segnalibri Vai al segnalibro successivo

  Sposta il cursore al prossimo segnalibro.

### Menu Strumenti

Fornisce un elenco di strumenti installati. Attiva o disattiva la visualizzazione di ogni strumento. Trovi una descrizione dettagliata di ogni strumento nella sezione Strumenti.

### Menu Impostazioni

Impostazioni Mostra la barra degli strumenti

  Attiva o disattiva la visualizzazione della barra degli strumenti sotto la barra dei menu.

Impostazioni Mostra la barra di stato

  Attiva o disattiva la visualizzazione della barra di stato.

Impostazioni Configura le scorciatoie...

  Cambia le scorciatoie delle azioni del programma.

Impostazioni Configura le barre degli strumenti...

  Controlla il contenuto della barra degli strumenti.

### Menu Aiuto

&help.menu.documentation;

### Barra degli strumenti

La barra degli strumenti contiene icone per i comandi seguenti:

Si comportano tutti identicamente al comando nei menu.

- Nuovo

- Apri

- Salva

- Reimposta

- Stampa

- Annulla

- Rifai

- Taglia

- Copia

- Incolla

- Trova

- Trova successivo

## Riconoscimenti e licenza

&okteta;

Copyright del programma 2006-2010 di &Friedrich.Kossebau; &Friedrich.Kossebau.email;

Copyright della documentazione 2008, 2010 di &Friedrich.Kossebau; &Friedrich.Kossebau.email;

Traduzione in italiano di Federico Zenith federico.zenith@member.fsf.org

&underFDL; &underGPL;

## Installazione

### Come ottenere &okteta;

&install.intro.documentation;

### Compilazione e installazione

&install.compile.documentation;

&documentation.index;