# 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, 2011 &Friedrich.Kossebau; e &Alex.Richardson;
&FDLNotice;
2011-10-13
0.8.0 (&kde; 4.8)

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

KDE &package; 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 Applicazioni Accessori 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 vettore 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 del vettore 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ù vettori di dati, ma solo uno può essere attivo. Usa il menu Finestre per selezionare quale vettore debba essere attivo.

## Strumenti

### Panoramica

&okteta; include alcuni strumenti, alcuni per analizzare e manipolare i vettori di dati 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 vettori di dati 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 vettore 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 i vettori 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 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.

Ci sono due file per ogni definizione di struttura: un file per la definizione vera e propria, e un file `.desktop` per i dati aggiuntivi (autore, versione, eccetera).

In quella cartella c'è una sottocartella 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 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 definizioni di strutture

Ci sono due modi diversi di creare definizioni di strutture. La prima è scrivere la definizione in &XML;, l'altra è usare JavaScript. L'approccio con JavaScript permette di creare strutture più complesse con funzionalità come per esempio la validazione della struttura. Usare &XML; dà meno opportunità, ma se ti serve solo una struttura statica potrebbe essere la cosa più facile. Se ti serve una struttura dinamica, per esempio in cui le lunghezze dei vettori dipendono da altri valori nella struttura, o la disposizione della struttura è diversa quando qualche valore membro cambia, dovrai scrivere la definizione della struttura in JavaScript. C'è un'eccezione a questa regola: se hai un array in cui la lunghezza deve essere esattamente la stessa di un altro valore nella struttura, puoi usare &XML;. Se invece è qualcosa come `lunghezza - 1` devi ancora usare JavaScript.

#### Formato dei file &XML; per le definizioni di strutture

Il file &XML; `.osd` ha un elemento radice: `<data>`, senza attributi. Dentro a questo elemento ci dev'essere uno dei seguenti elementi:

<primitive>

  Per creare un tipo di dati primitivo, come per esempio `int` e `float`. Questo elemento non accetta sottoelementi e può avere i seguenti attributi:

  type

    Il tipo di questo tipo primitivo. Deve essere uno dei seguenti:

    - `char` per un carattere ASCII a 8 bit

    - `int8, int16, int32, int64` per un intero con segno di quella dimensione

    - `uint8, uint16, uint32, uint64` per un intero senza segno di quella dimensione

    - `bool8, bool16, bool32, bool64` per un booleano senza segno (0 = falso, qualsiasi altro valore = vero) di quella dimensione

    - `float` per un numero a virgola mobile IEEE754 a 32 bit

    - `double` per un numero a virgola mobile IEEE754 a 64 bit

<bitfield>

  Per creare un campo di bit. Questo elemento non accetta sottoelementi e può avere i seguenti attributi:

  width

    Il numero di bit usati da questo campo. Deve essere tra 1 e 64.

  type

    Il tipo di questo campo di bit. Deve essere uno dei seguenti:

    - `unsigned` per un campo di bit dove il valore verrà interpretato come senza segno (valore tra 0 e 2larghezza - 1)

    - `signed` per un campo di bit dove il valore verrà interpretato come con segno (valore tra - 2larghezza - 1 e 2larghezza - 1 - 1)

    - `bool` per un campo di bit dove il valore verrà interpretato come un booleano

    Ricordati sempre di aggiungere dello spazio dopo un `<bitfield>`, perché altrimenti il prossimo elemento (tranne che per stringhe ed array, visto che questi aggiungono spazio automaticamente) comincerà nel mezzo di un byte. Ovviamente lo spazio non è necessario se desideri questo comportamento.

<enum>

  Per creare un tipo primitivo, ma in cui i valori siano visualizzati come membri di un'enumerazione, se possibile. Questo elemento non accetta nessun sottoelemento (servirà però un'etichetta `<enumDef>` nel file per farvi riferimento). Ha i seguenti attributi:

  enum

    L'enumerazione su cui si basa questo valore. Deve corrispondere all'attributo `name` delle etichette `<enumDef>` in questo file.

  type

    Il tipo dell'enumerazione. Vedi l'attributo omonimo di `<primitive>`. L'unica differenza è che `Double` e `Float` non hanno senso.

<flags>

  È la stessa cosa che `<enum>` con la sola differenza che i valori sono rappresentati come un O logico sui bit di tutti i valori dell'enumerazione.

<struct>

  Per creare una struttura. Tutti gli altri elementi (incluso `<struct>`) possono esserne figli, e saranno parte della struttura risultante.

<union>

  Per creare un'unione. Sostanzialmente la stessa cosa di `<struct>`, tranne che tutti gli elementi figli partiranno dallo stesso scostamento. È utile per interpretare la stessa sequenza di byte in modi diversi.

<array>

  Per creare un array. Questo elemento accetta esattamente un figlio (il tipo di array su cui si basa), che può essere qualsiasi elemento, anche `<array>` stesso. Ha anche i seguenti attributi:

  length

    Il numero di elementi in questo array come numero decimale. In alternativa può anche essere una stringa corrispondente al nome di un `<primitive>`, `<enum>` o `<flags>` definito in precedenza. La lunghezza sarà in tal caso sempre uguale al valore di quell'elemento. Attualmente è limitata a 10000, perché array di maggiori dimensioni userebbero troppa memoria e rallenterebbero troppo lo strumento.

<string>

  Per creare una stringa in varie codifiche. Come impostazione predefinita ottieni una stringa terminata da NULL in stile C. È però possibile creare diversi tipi di stringa con i seguenti attributi:

  terminatedBy

    Questo attributo determina quale punto di codice Unicode conclude la stringa. Deve essere un numero esadecimale (facoltativamente con un `0x` iniziale). Quando la codifica è ASCII, solo i valori fino a `0x7f` hanno senso. Se né questo valore, né `maxCharCount` né `maxByteCount` sono impostati, si assume che sia 0 (stringa in stile C).

  maxCharCount

    Il numero massimo di caratteri di questa stringa. Se è impostato anche `terminatedBy`, il primo criterio a verificarsi termina la stringa. Questo è mutuamente esclusivo con `maxByteCount`.

  maxByteCount

    La lunghezza massima in byte di questa stringa. Se è impostato anche `terminatedBy`, il primo criterio a verificarsi termina la stringa. Questo è mutuamente esclusivo con `maxCharCount`. Con codifiche come `ASCII` è la stessa cosa di `maxCharCount`.

  type

    La codifica di questa stringa. Può essere una delle seguenti:

    - ASCII

    - LATIN-1

    - UTF-8

    - `UTF-16-LE` o `UTF-16-BE`. Se non viene dato né il suffisso `-LE` né `-BE`, si assume la codifica little endian.

    - `UTF-32-LE` o `UTF-32-BE`. Se non viene dato né il suffisso `-LE` né `-BE`, si assume la codifica little endian.

Ogni elemento accetta anche un attributo `name` che è poi visibile nella vista delle strutture.

#### Una definizione di struttura d'esempio in &XML; e in JavaScript

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

Il nostro file di dati aggiuntivi ha 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 semplice definizione di struttura &XML;

Per cominciare creiamo una definizione per una struttura di prova molto semplice, contenente solo tipo di dati integrali (un carattere, un intero a 32 bit, e un campo di 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` secondo il formato di file definito nella sezione precedente. Lo chiameremo `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++.

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 struttura semplice 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 vettore di byte...

  - Vuoto: ... come vettore 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 il vettore di byte nel file assegnato.

File Salva come...

  Salva il vettore di dati 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 il vettore di byte dal file.

&Ctrl;P File Stampa...

  Stampa il vettore di byte attuale.

File Permessi

  Imposta i permessi di modifica:

  Imposta a sola lettura

    Se impostato, non si possono effettuare modifiche al vettore di byte caricato.

&Ctrl;W File Chiudi

  Chiude il vettore di byte attuale.

File Chiudi tutto

  Chiude tutti i vettori di byte.

File Chiudi tutti gli altri

  Chiude tutti i vettori 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 l'intero vettore 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à di 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 linee

  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 vettore di byte. Ogni vettore di byte 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 vettore di byte o tutto il programma.

&Ctrl;B Segnalibri Aggiungi segnalibro

  Segna una posizione nel vettore di dati.

&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; e &Alex.Richardson; &Alex.Richardson.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;