# 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, modificare o installare definizioni di strutture, quindi ciò va fatto manualmente, come descritto nelle sezioni seguenti.

### Installare 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` 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`.

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 modifiche, 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, `.tgz`) contenente solo la sottocartella con il file `.osd` e il file `.desktop`. L'esempio nella sezione precedente sarebbe nella cartella `Esempio`. Se aderisci a questo formato, le versioni future dello strumento per le strutture permetteranno lo scaricamento e l'installazione automatici di queste definizioni.

### Creare le tue definizioni di strutture

#### 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;
              };

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"/>
                </struct>
              </data>

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

- Char
- Int8
- UInt8
- Int16
- UInt16
- Int32
- UInt32
- Int64
- UInt64
- Float
- Double
- Bool8
- Bool16
- Bool32
- Bool64

Il passo successivo è scrivere il file `.desktop` per i dati aggiuntivi, che è solo una serie di coppie chiave-valore. Dovrebbe avere il nome `semplice.desktop`. In questo esempio si può scrivere così:

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

              Name=Semplice struttura di prova
              Comment=Una struttura di prova molto semplice contenente solo due 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

Questi campi dovrebbero essere tutti abbastanza facili da capire, tranne `X-KDE-PluginInfo-Name`. Questo deve avere il nome del file `.osd` (senza il suffisso) come valore.

Adesso crea una sottocartella `semplice` come sopra descritto, copiaci i due file, e riavvia &okteta;.

#### 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 per i file PNG. Uno schema &XML; per descrivere la struttura del file `.osd` è disponibile qui. Se ti servono maggiori informazioni, non esitare a contattarmi a &Alex.Richardson.email;.